agent-inspect 6.31.6 → 6.31.7

package/packages/core/dist/exporters.mjs

@@ -1,4 +1,4 @@
-import { buildRunWhatSummary, renderRunWhat, renderTimeline, buildRunTimeline } from './chunk-EXGQLMVB.mjs';
+import { buildRunWhatSummary, renderRunWhat, renderTimeline, buildRunTimeline } from './chunk-7YYS742B.mjs';
 import { summarizeObservedOutcomes, extractOutcomesFromTraceEvents, renderObservedOutcomesMarkdown, renderObservedOutcomesHtml } from './chunk-N5PZAI6Q.mjs';
 import { escapeHtml, flattenTree, safeString, compactAttributes, stableJson, escapeMarkdown, zeroKinds } from './chunk-CAWPF22J.mjs';
 export { compactAttributes, escapeHtml, escapeMarkdown, flattenTree, safeString, stableJson, summarizeTree } from './chunk-CAWPF22J.mjs';
@@ -808,6 +808,10 @@ function exportOpenInference(tree, options) {
     warnings
   };
 }
+var OTLP_STATUS_CODE_UNSET = 0;
+var OTLP_STATUS_CODE_OK = 1;
+var OTLP_STATUS_CODE_ERROR = 2;
+var OTLP_SPAN_KIND_INTERNAL = 1;
 function hexFrom2(seed, byteLen) {
   return crypto.createHash("sha256").update(seed, "utf8").digest("hex").slice(0, byteLen * 2);
 }
@@ -820,7 +824,19 @@ function stringAttr(key, value) {
   return { key, value: { stringValue: value } };
 }
 function intAttr(key, value) {
-  return { key, value: { intValue: String(value) } };
+  return { key, value: { intValue: String(Math.trunc(value)) } };
+}
+function doubleAttr(key, value) {
+  return { key, value: { doubleValue: value } };
+}
+function boolAttr(key, value) {
+  return { key, value: { boolValue: value } };
+}
+function numberAttr(key, value) {
+  if (Number.isFinite(value) && !Number.isInteger(value)) {
+    return doubleAttr(key, value);
+  }
+  return intAttr(key, value);
 }
 function genAiOperationName(kind) {
   switch (kind) {
@@ -834,10 +850,27 @@ function genAiOperationName(kind) {
       return void 0;
   }
 }
+function resolveSpanTimes(ev) {
+  const startedAtMs = typeof ev.attributes?.startedAtMs === "number" && Number.isFinite(ev.attributes.startedAtMs) ? ev.attributes.startedAtMs : void 0;
+  const endedAtMs = typeof ev.attributes?.endedAtMs === "number" && Number.isFinite(ev.attributes.endedAtMs) ? ev.attributes.endedAtMs : void 0;
+  const startMs = startedAtMs ?? ev.timestamp;
+  const startNs = String(unixNano2(startMs));
+  if (endedAtMs !== void 0) {
+    return { startNs, endNs: String(unixNano2(endedAtMs)) };
+  }
+  if (ev.durationMs !== void 0 && Number.isFinite(ev.durationMs)) {
+    return {
+      startNs,
+      endNs: String(unixNano2(startMs) + unixNano2(ev.durationMs))
+    };
+  }
+  return { startNs };
+}
 function exportOtlpJson(tree, options) {
   const warnings = [
     "OTLP JSON export uses OTel GenAI-aligned attributes where applicable; experimental until verified against specific collectors.",
-    "Not OTLP gRPC/protobuf \u2014 JSON mapping only. Generated locally; no network upload."
+    "Not OTLP gRPC/protobuf \u2014 JSON mapping only. Generated locally; no network upload.",
+    "Status and span kind use OTLP numeric enums (StatusCode 0/1/2, SpanKind INTERNAL=1)."
   ];
   const traceId = hexFrom2(`trace:${tree.runId}`, 16);
   const includeAttributes = options?.includeAttributes ?? false;
@@ -849,11 +882,7 @@ function exportOtlpJson(tree, options) {
     const ev = n.event;
     const spanId = hexFrom2(`${tree.runId}:${ev.eventId}`, 8);
     const parentSpanId = ev.parentId ? hexFrom2(`${tree.runId}:${ev.parentId}`, 8) : void 0;
-    const startNs = String(unixNano2(ev.timestamp));
-    let endNs;
-    if (ev.durationMs !== void 0 && Number.isFinite(ev.durationMs)) {
-      endNs = String(unixNano2(ev.timestamp) + unixNano2(ev.durationMs));
-    }
+    const { startNs, endNs } = resolveSpanTimes(ev);
     const attrs = [
       stringAttr("agent_inspect.kind", ev.kind),
       stringAttr("agent_inspect.confidence", ev.confidence),
@@ -883,29 +912,28 @@ function exportOtlpJson(tree, options) {
     if (includeAttributes && meta && typeof meta === "object") {
       for (const [k, v] of Object.entries(meta)) {
         if (k === "tokens" || k === "model") continue;
-        if (typeof v === "string" || typeof v === "number" || typeof v === "boolean") {
-          attrs.push(
-            stringAttr(
-              `agent_inspect.preview.${k}`,
-              typeof v === "string" ? v.slice(0, maxLen) : String(v)
-            )
-          );
+        if (typeof v === "string") {
+          attrs.push(stringAttr(`agent_inspect.preview.${k}`, v.slice(0, maxLen)));
+        } else if (typeof v === "number" && Number.isFinite(v)) {
+          attrs.push(numberAttr(`agent_inspect.preview.${k}`, v));
+        } else if (typeof v === "boolean") {
+          attrs.push(boolAttr(`agent_inspect.preview.${k}`, v));
         }
       }
     }
-    let statusCode = "STATUS_CODE_UNSET";
+    let statusCode = OTLP_STATUS_CODE_UNSET;
     let statusMessage;
     if (ev.status === "error") {
-      statusCode = "STATUS_CODE_ERROR";
+      statusCode = OTLP_STATUS_CODE_ERROR;
       statusMessage = meta && typeof meta.error === "object" && meta.error !== null ? String(meta.error.message ?? "error").slice(0, maxLen) : "error";
     } else if (ev.status === "ok") {
-      statusCode = "STATUS_CODE_OK";
+      statusCode = OTLP_STATUS_CODE_OK;
     }
     const spanJson = {
       traceId,
       spanId,
       name: ev.name,
-      kind: "SPAN_KIND_INTERNAL",
+      kind: OTLP_SPAN_KIND_INTERNAL,
       startTimeUnixNano: startNs,
       attributes: attrs,
       status: {
@@ -947,6 +975,136 @@ function exportOtlpJson(tree, options) {
 
 // packages/core/src/exporters/validation.ts
 var EXPERIMENTAL = "Experimental compatibility export \u2014 verify against your target tooling before relying on it.";
+function pushPath(errors, path, message) {
+  errors.push(`${path}: ${message}`);
+}
+function isRecord2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function validateOtlpJson(content) {
+  const errors = [];
+  const warnings = [
+    EXPERIMENTAL,
+    "OTLP JSON mapping uses OTel GenAI-aligned attributes where applicable; collectors may require transformation.",
+    "protocol-valid \u2260 profile-complete \u2260 fixture-complete \u2014 nested path diagnostics report protocol shape only."
+  ];
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    pushPath(errors, "$", "OTLP JSON export is not valid JSON");
+    return { ok: false, format: "otlp-json", errors, warnings };
+  }
+  if (!isRecord2(parsed)) {
+    pushPath(errors, "$", "OTLP JSON export must be an object");
+    return { ok: false, format: "otlp-json", errors, warnings };
+  }
+  if (!Array.isArray(parsed.resourceSpans)) {
+    pushPath(errors, "$.resourceSpans", "must be an array");
+    return { ok: false, format: "otlp-json", errors, warnings };
+  }
+  parsed.resourceSpans.forEach((resourceSpan, rsi) => {
+    const rsPath = `$.resourceSpans[${rsi}]`;
+    if (!isRecord2(resourceSpan)) {
+      pushPath(errors, rsPath, "must be an object");
+      return;
+    }
+    if (!Array.isArray(resourceSpan.scopeSpans)) {
+      pushPath(errors, `${rsPath}.scopeSpans`, "must be an array");
+      return;
+    }
+    resourceSpan.scopeSpans.forEach((scopeSpan, ssi) => {
+      const ssPath = `${rsPath}.scopeSpans[${ssi}]`;
+      if (!isRecord2(scopeSpan)) {
+        pushPath(errors, ssPath, "must be an object");
+        return;
+      }
+      if (!Array.isArray(scopeSpan.spans)) {
+        pushPath(errors, `${ssPath}.spans`, "must be an array");
+        return;
+      }
+      scopeSpan.spans.forEach((span, spi) => {
+        const spanPath = `${ssPath}.spans[${spi}]`;
+        if (!isRecord2(span)) {
+          pushPath(errors, spanPath, "must be an object");
+          return;
+        }
+        if (typeof span.traceId !== "string" || span.traceId.length === 0) {
+          pushPath(errors, `${spanPath}.traceId`, "must be a non-empty string");
+        }
+        if (typeof span.spanId !== "string" || span.spanId.length === 0) {
+          pushPath(errors, `${spanPath}.spanId`, "must be a non-empty string");
+        }
+        if (typeof span.name !== "string") {
+          pushPath(errors, `${spanPath}.name`, "must be a string");
+        }
+        if (typeof span.startTimeUnixNano !== "string" || !/^\d+$/.test(span.startTimeUnixNano)) {
+          pushPath(
+            errors,
+            `${spanPath}.startTimeUnixNano`,
+            "must be a decimal-string 64-bit integer"
+          );
+        }
+        if (span.endTimeUnixNano !== void 0 && (typeof span.endTimeUnixNano !== "string" || !/^\d+$/.test(span.endTimeUnixNano))) {
+          pushPath(
+            errors,
+            `${spanPath}.endTimeUnixNano`,
+            "must be a decimal-string 64-bit integer when present"
+          );
+        }
+        if (typeof span.kind === "number") {
+          if (!Number.isInteger(span.kind)) {
+            pushPath(errors, `${spanPath}.kind`, "must be an integer SpanKind enum");
+          }
+        } else if (typeof span.kind === "string") {
+          warnings.push(
+            `${spanPath}.kind: string SpanKind enum is legacy; prefer numeric (INTERNAL=1)`
+          );
+        } else if (span.kind !== void 0) {
+          pushPath(
+            errors,
+            `${spanPath}.kind`,
+            "must be numeric SpanKind or historical string enum"
+          );
+        }
+        if (!isRecord2(span.status)) {
+          pushPath(errors, `${spanPath}.status`, "must be an object");
+        } else {
+          const code = span.status.code;
+          if (typeof code === "number") {
+            if (![0, 1, 2].includes(code)) {
+              pushPath(
+                errors,
+                `${spanPath}.status.code`,
+                "must be numeric StatusCode 0 (UNSET), 1 (OK), or 2 (ERROR)"
+              );
+            }
+          } else if (typeof code === "string") {
+            const upper = code.toUpperCase();
+            if (upper !== "STATUS_CODE_UNSET" && upper !== "STATUS_CODE_OK" && upper !== "STATUS_CODE_ERROR" && upper !== "UNSET" && upper !== "OK" && upper !== "ERROR" && !/^[012]$/.test(code.trim())) {
+              pushPath(
+                errors,
+                `${spanPath}.status.code`,
+                "unrecognized StatusCode string"
+              );
+            } else {
+              warnings.push(
+                `${spanPath}.status.code: string StatusCode is legacy; prefer numeric 0/1/2`
+              );
+            }
+          } else {
+            pushPath(
+              errors,
+              `${spanPath}.status.code`,
+              "must be numeric StatusCode 0/1/2 or historical string enum"
+            );
+          }
+        }
+      });
+    });
+  });
+  return { ok: errors.length === 0, format: "otlp-json", errors, warnings };
+}
 function validateExportContent(format, content) {
   const errors = [];
   const warnings = [EXPERIMENTAL];
@@ -992,25 +1150,7 @@ function validateExportContent(format, content) {
     return { ok: errors.length === 0, format, errors, warnings };
   }
   if (format === "otlp-json") {
-    let parsed;
-    try {
-      parsed = JSON.parse(content);
-    } catch {
-      errors.push("OTLP JSON export is not valid JSON");
-      return { ok: false, format, errors, warnings };
-    }
-    if (!parsed || typeof parsed !== "object") {
-      errors.push("OTLP JSON export must be an object");
-      return { ok: false, format, errors, warnings };
-    }
-    const o = parsed;
-    if (!Array.isArray(o.resourceSpans)) {
-      errors.push("OTLP JSON export must include resourceSpans array");
-    }
-    warnings.push(
-      "OTLP JSON mapping uses OTel GenAI-aligned attributes where applicable; collectors may require transformation."
-    );
-    return { ok: errors.length === 0, format, errors, warnings };
+    return validateOtlpJson(content);
   }
   errors.push(`Unsupported export format`);
   return { ok: false, format, errors, warnings };