@agent-inspect/mcp-server 6.12.0 → 6.12.2

package/dist/{chunk-YSGVFUHF.mjs → chunk-J72IWHQK.mjs}

@@ -669,12 +669,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);
   }
@@ -2567,6 +2567,238 @@ function diffRuns(left, right, options) {
   return table;
 })();
 
+// packages/core/src/checks/logical-events.ts
+function isRecord6(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 = {
+    ...isRecord6(complete.attributes) ? complete.attributes : {},
+    ...isRecord6(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)) {
+        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)
+  };
+}
+
 // packages/core/src/checks/index.ts
 var SEVERITY_RANK = {
   error: 0,
@@ -2619,7 +2851,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",
@@ -2695,10 +2931,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]),
@@ -2863,7 +3102,10 @@ function failFinding(ruleId, message, evidence, expected, actual, meta) {
     ...meta?.action !== void 0 ? { action: meta.action } : {}
   };
 }
-function isRecord6(value) {
+function semanticEvents(context) {
+  return context.logicalEvents ?? context.events;
+}
+function isRecord7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function normalizedKey(value) {
@@ -2894,7 +3136,7 @@ function pushValueEntries(entries, event, value, path16, key, depth = 0) {
     }
     return;
   }
-  if (!isRecord6(value)) return;
+  if (!isRecord7(value)) return;
   for (const nestedKey of Object.keys(value).sort((a, b) => a.localeCompare(b))) {
     pushValueEntries(
       entries,
@@ -2976,7 +3218,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(
@@ -3144,7 +3386,7 @@ function createSafetyOversizedAttributeRule(options) {
               )
             );
           }
-          if (isRecord6(entry.value) && options.maxObjectKeys !== void 0 && Object.keys(entry.value).length > options.maxObjectKeys) {
+          if (isRecord7(entry.value) && options.maxObjectKeys !== void 0 && Object.keys(entry.value).length > options.maxObjectKeys) {
             findings.push(
               failFinding(
                 "safety.oversizedAttribute",
@@ -3233,14 +3475,14 @@ function runTraceChecks(input, options = {}) {
 }
 
 // packages/core/src/persisted/token-usage.ts
-function isRecord7(value) {
+function isRecord8(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 (!isRecord7(value)) return void 0;
+  if (!isRecord8(value)) return void 0;
   const input = nonNegativeFinite(value.input);
   const output = nonNegativeFinite(value.output);
   const suppliedTotal = nonNegativeFinite(value.total);
@@ -4009,7 +4251,7 @@ function persistedEventsForParsedTrace(parsed) {
     sourceName: "agent-inspect-jsonl-reader"
   });
 }
-function isRecord8(value) {
+function isRecord9(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isNonEmptyString3(value) {
@@ -4024,13 +4266,13 @@ function readStringField(record, keys) {
 }
 function readRecordField(record, key) {
   const value = record[key];
-  return isRecord8(value) ? value : void 0;
+  return isRecord9(value) ? value : void 0;
 }
 function parseJsonDocument(content) {
   return JSON.parse(content);
 }
 function looksLikeOpenInferenceSpan(value) {
-  if (!isRecord8(value)) return false;
+  if (!isRecord9(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);
 }
@@ -4055,7 +4297,7 @@ function extractOpenInferenceDocument(root) {
       unsupportedFields
     };
   }
-  if (!isRecord8(root)) return void 0;
+  if (!isRecord9(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;
@@ -4195,7 +4437,7 @@ function summarizeAttributeValue(value) {
   if (Array.isArray(value)) {
     return { type: "array", length: value.length };
   }
-  if (isRecord8(value)) {
+  if (isRecord9(value)) {
     return { type: "object", keyCount: Object.keys(value).length };
   }
   if (value === null) {
@@ -4282,7 +4524,7 @@ function mapOpenInferenceKind(span, attributes, pathPrefix) {
   }
 }
 function mapOpenInferenceStatus(status) {
-  if (!isRecord8(status)) return void 0;
+  if (!isRecord9(status)) return void 0;
   const rawCode = status.code;
   if (typeof rawCode !== "string") return void 0;
   switch (rawCode.toUpperCase()) {
@@ -4382,7 +4624,7 @@ function mapOpenInferenceSpan(span, index, version) {
   warnings.push(...kindWarnings);
   const status = mapOpenInferenceStatus(span.status);
   const tokenUsage = readOpenInferenceTokenUsage(rawAttributes);
-  const errorMessage = isRecord8(span.status) && typeof span.status.message === "string" ? span.status.message : void 0;
+  const errorMessage = isRecord9(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,
@@ -4528,7 +4770,7 @@ var openInferenceJsonReader = {
   }
 };
 function parseOtlpAnyValue(value, field, warnings, unsupportedFields) {
-  if (!isRecord8(value)) {
+  if (!isRecord9(value)) {
     unsupportedFields.push(field);
     warnings.push({
       code: "otlp_attribute_value_invalid",
@@ -4550,15 +4792,15 @@ function parseOtlpAnyValue(value, field, warnings, unsupportedFields) {
   if (typeof value.doubleValue === "number" && Number.isFinite(value.doubleValue)) {
     return value.doubleValue;
   }
-  if (isRecord8(value.arrayValue) && Array.isArray(value.arrayValue.values)) {
+  if (isRecord9(value.arrayValue) && Array.isArray(value.arrayValue.values)) {
     return value.arrayValue.values.map(
       (item, index) => parseOtlpAnyValue(item, `${field}.arrayValue.values[${index}]`, warnings, unsupportedFields)
     );
   }
-  if (isRecord8(value.kvlistValue) && Array.isArray(value.kvlistValue.values)) {
+  if (isRecord9(value.kvlistValue) && Array.isArray(value.kvlistValue.values)) {
     const out = {};
     for (const [index, item] of value.kvlistValue.values.entries()) {
-      if (!isRecord8(item) || typeof item.key !== "string") {
+      if (!isRecord9(item) || typeof item.key !== "string") {
         unsupportedFields.push(`${field}.kvlistValue.values[${index}]`);
         continue;
       }
@@ -4609,7 +4851,7 @@ function parseOtlpAttributes(value, pathPrefix) {
   }
   for (const [index, item] of value.entries()) {
     const field = `${pathPrefix}[${index}]`;
-    if (!isRecord8(item) || typeof item.key !== "string") {
+    if (!isRecord9(item) || typeof item.key !== "string") {
       unsupportedFields.push(field);
       warnings.push({
         code: "otlp_attribute_invalid",
@@ -4632,16 +4874,16 @@ function parseOtlpAttributes(value, pathPrefix) {
   return { attributes, warnings, unsupportedFields };
 }
 function looksLikeOtlpSpan(value) {
-  return isRecord8(value) && readStringField(value, ["traceId"]) !== void 0 && readStringField(value, ["spanId"]) !== void 0 && readStringField(value, ["name"]) !== void 0;
+  return isRecord9(value) && readStringField(value, ["traceId"]) !== void 0 && readStringField(value, ["spanId"]) !== void 0 && readStringField(value, ["name"]) !== void 0;
 }
 function extractOtlpDocument(root) {
-  if (!isRecord8(root) || !Array.isArray(root.resourceSpans)) return void 0;
+  if (!isRecord9(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 (!isRecord8(resourceSpan)) {
+    if (!isRecord9(resourceSpan)) {
       unsupportedFields.push(resourcePath);
       continue;
     }
@@ -4664,7 +4906,7 @@ function extractOtlpDocument(root) {
     }
     for (const [scopeIndex, scopeSpan] of resourceSpan.scopeSpans.entries()) {
       const scopePath = `${resourcePath}.scopeSpans[${scopeIndex}]`;
-      if (!isRecord8(scopeSpan)) {
+      if (!isRecord9(scopeSpan)) {
         unsupportedFields.push(scopePath);
         continue;
       }
@@ -4731,7 +4973,7 @@ function extractOtlpDocument(root) {
   };
 }
 function mapOtlpStatus(status) {
-  if (!isRecord8(status)) return void 0;
+  if (!isRecord9(status)) return void 0;
   const rawCode = status.code;
   if (typeof rawCode !== "string") return void 0;
   switch (rawCode.toUpperCase()) {
@@ -4831,7 +5073,7 @@ function mapOtlpEvents(value, pathPrefix) {
   const events = [];
   for (const [index, event] of value.entries()) {
     const eventPath = `${pathPrefix}[${index}]`;
-    if (!isRecord8(event)) {
+    if (!isRecord9(event)) {
       unsupportedFields.push(eventPath);
       continue;
     }
@@ -4969,7 +5211,7 @@ function mapOtlpSpan(context) {
   warnings.push(...kindWarnings);
   const status = mapOtlpStatus(span.status);
   const tokenUsage = readOtlpTokenUsage(parsedSpanAttributes.attributes);
-  const errorMessage = isRecord8(span.status) && typeof span.status.message === "string" ? span.status.message : void 0;
+  const errorMessage = isRecord9(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,
@@ -5315,7 +5557,7 @@ function openTrace(input, options = {}) {
 var EXPORT_PAYLOAD_VERSION = "0.1.2";
 
 // packages/core/src/exporters/redact-export.ts
-function isRecord9(value) {
+function isRecord10(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function deepClone(value) {
@@ -5389,7 +5631,7 @@ function redactEventAttributes(attrs, redactor, maxMetadataValueLength, maxPrevi
     0
   );
   const err = bounded.error;
-  if (isRecord9(err) && typeof err.message === "string") {
+  if (isRecord10(err) && typeof err.message === "string") {
     bounded.error = {
       ...err,
       message: truncateStringForProfile(
@@ -6051,7 +6293,7 @@ var STRICT_PROFILE_EXTRA_KEYS2 = [
   "retrieval",
   "query"
 ];
-function isRecord10(value) {
+function isRecord11(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function toKey2(key) {
@@ -6416,7 +6658,7 @@ var Redactor2 = class {
       });
       return out;
     }
-    if (isRecord10(value)) {
+    if (isRecord11(value)) {
       if (state.seen.has(value)) return state.seen.get(value);
       const out = {};
       state.seen.set(value, out);
@@ -7237,5 +7479,5 @@ async function runReadOnlyMcpServer(options = {}) {
 }
 
 export { MCP_MAX_REQUEST_BYTES, MCP_PROTOCOL_VERSION, READ_ONLY_TOOLS, callReadOnlyTool, createMcpServerContext, handleMcpProtocolLine, runReadOnlyMcpServer };
-//# sourceMappingURL=chunk-YSGVFUHF.mjs.map
-//# sourceMappingURL=chunk-YSGVFUHF.mjs.map
+//# sourceMappingURL=chunk-J72IWHQK.mjs.map
+//# sourceMappingURL=chunk-J72IWHQK.mjs.map