agent-inspect 6.31.7 → 6.31.9

package/packages/core/dist/exporters.mjs

@@ -740,11 +740,13 @@ function exportOpenInference(tree, options) {
       endNs = startNs + unixNano(ev.durationMs);
     }
     const { openInferenceKind } = mapInspectKindToOI(ev.kind, warnings);
+    const meta = ev.attributes;
+    const originalSource = typeof meta?.originalSourceType === "string" && meta.originalSourceType.trim() !== "" ? meta.originalSourceType.trim() : ev.source.type;
     const attrs = {
       "openinference.span.kind": openInferenceKind,
       "agent_inspect.kind": ev.kind,
       "agent_inspect.confidence": ev.confidence,
-      "agent_inspect.source.type": ev.source.type,
+      "agent_inspect.source.type": originalSource,
       "agent_inspect.run_id": tree.runId,
       "agent_inspect.event_id": ev.eventId,
       "agent_inspect.status": ev.status ?? "unset"
@@ -752,9 +754,9 @@ function exportOpenInference(tree, options) {
     if (ev.durationMs !== void 0) {
       attrs["agent_inspect.duration_ms"] = ev.durationMs;
     }
-    const meta = ev.attributes;
-    if (meta?.model !== void 0 && typeof meta.model === "string") {
-      attrs["llm.model_name"] = meta.model;
+    const requestModel = (typeof meta?.model === "string" && meta.model.trim() !== "" ? meta.model : void 0) ?? (typeof meta?.modelId === "string" && meta.modelId.trim() !== "" ? meta.modelId : void 0);
+    if (requestModel !== void 0) {
+      attrs["llm.model_name"] = requestModel;
     }
     const tokens = meta?.tokens;
     if (tokens && typeof tokens === "object" && tokens !== null) {
@@ -764,8 +766,9 @@ function exportOpenInference(tree, options) {
       if (typeof outp === "number") attrs["llm.token_count.completion"] = outp;
     }
     if (includeAttributes && meta && typeof meta === "object") {
+      const skipKeys = /* @__PURE__ */ new Set(["tokens", "model", "modelId", "originalSourceType"]);
       for (const [k, v] of Object.entries(meta)) {
-        if (k === "tokens" || k === "model") continue;
+        if (skipKeys.has(k)) continue;
         if (v !== void 0 && v !== null && typeof v !== "object") {
           attrs[`agent_inspect.preview.${k}`] = typeof v === "string" ? v.slice(0, maxLen) : v;
         }
@@ -883,24 +886,33 @@ function exportOtlpJson(tree, options) {
     const spanId = hexFrom2(`${tree.runId}:${ev.eventId}`, 8);
     const parentSpanId = ev.parentId ? hexFrom2(`${tree.runId}:${ev.parentId}`, 8) : void 0;
     const { startNs, endNs } = resolveSpanTimes(ev);
+    const meta = ev.attributes;
+    const originalSource = typeof meta?.originalSourceType === "string" && meta.originalSourceType.trim() !== "" ? meta.originalSourceType.trim() : ev.source.type;
     const attrs = [
       stringAttr("agent_inspect.kind", ev.kind),
       stringAttr("agent_inspect.confidence", ev.confidence),
-      stringAttr("agent_inspect.source.type", ev.source.type),
+      stringAttr("agent_inspect.source.type", originalSource),
       stringAttr("agent_inspect.run_id", tree.runId),
       stringAttr("agent_inspect.event_id", ev.eventId),
       stringAttr("agent_inspect.status", ev.status ?? "unset")
     ];
     if (ev.durationMs !== void 0) {
-      attrs.push(intAttr("agent_inspect.duration_ms", ev.durationMs));
+      attrs.push(numberAttr("agent_inspect.duration_ms", ev.durationMs));
     }
     const op = genAiOperationName(ev.kind);
     if (op !== void 0) {
       attrs.push(stringAttr("gen_ai.operation.name", op));
     }
-    const meta = ev.attributes;
-    if (meta?.model !== void 0 && typeof meta.model === "string") {
-      attrs.push(stringAttr("gen_ai.request.model", meta.model.slice(0, maxLen)));
+    const requestModel = (typeof meta?.model === "string" && meta.model.trim() !== "" ? meta.model : void 0) ?? (typeof meta?.modelId === "string" && meta.modelId.trim() !== "" ? meta.modelId : void 0);
+    if (requestModel !== void 0) {
+      attrs.push(stringAttr("gen_ai.request.model", requestModel.slice(0, maxLen)));
+    }
+    const responseModel = typeof meta?.responseModelId === "string" && meta.responseModelId.trim() !== "" ? meta.responseModelId : typeof meta?.responseModel === "string" && meta.responseModel.trim() !== "" ? meta.responseModel : void 0;
+    if (responseModel !== void 0) {
+      attrs.push(stringAttr("gen_ai.response.model", responseModel.slice(0, maxLen)));
+    }
+    if (typeof meta?.provider === "string" && meta.provider.trim() !== "") {
+      attrs.push(stringAttr("gen_ai.provider.name", meta.provider.slice(0, maxLen)));
     }
     const tokens = meta?.tokens;
     if (tokens && typeof tokens === "object" && tokens !== null) {
@@ -910,8 +922,17 @@ function exportOtlpJson(tree, options) {
       if (typeof outp === "number") attrs.push(intAttr("gen_ai.usage.output_tokens", outp));
     }
     if (includeAttributes && meta && typeof meta === "object") {
+      const skipKeys = /* @__PURE__ */ new Set([
+        "tokens",
+        "model",
+        "modelId",
+        "responseModel",
+        "responseModelId",
+        "provider",
+        "originalSourceType"
+      ]);
       for (const [k, v] of Object.entries(meta)) {
-        if (k === "tokens" || k === "model") continue;
+        if (skipKeys.has(k)) continue;
         if (typeof v === "string") {
           attrs.push(stringAttr(`agent_inspect.preview.${k}`, v.slice(0, maxLen)));
         } else if (typeof v === "number" && Number.isFinite(v)) {
@@ -981,12 +1002,42 @@ function pushPath(errors, path, message) {
 function isRecord2(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
+function isHexId(value, byteLen) {
+  return typeof value === "string" && new RegExp(`^[0-9a-fA-F]{${byteLen * 2}}$`).test(value);
+}
+function validateAnyValue(errors, path, value) {
+  if (!isRecord2(value)) {
+    pushPath(errors, path, "must be an AnyValue object");
+    return;
+  }
+  const variants = [
+    "stringValue",
+    "boolValue",
+    "intValue",
+    "doubleValue",
+    "bytesValue",
+    "arrayValue",
+    "kvlistValue"
+  ].filter((key) => value[key] !== void 0);
+  if (variants.length !== 1) {
+    pushPath(
+      errors,
+      path,
+      `AnyValue must set exactly one variant (found ${variants.length}: ${variants.join(",")})`
+    );
+  }
+  if (value.intValue !== void 0) {
+    if (typeof value.intValue !== "string" || !/^-?\d+$/.test(value.intValue)) {
+      pushPath(errors, `${path}.intValue`, "must be a decimal integer string");
+    }
+  }
+}
 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."
+    "producer-profile checks IDs, timing, and AnyValue shape; historical string enums are reader-compat warnings only."
   ];
   let parsed;
   try {
@@ -1029,11 +1080,26 @@ function validateOtlpJson(content) {
           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 (!isHexId(span.traceId, 16)) {
+          pushPath(
+            errors,
+            `${spanPath}.traceId`,
+            "must be a 32-char hex trace id (16 bytes)"
+          );
+        }
+        if (!isHexId(span.spanId, 8)) {
+          pushPath(
+            errors,
+            `${spanPath}.spanId`,
+            "must be a 16-char hex span id (8 bytes)"
+          );
         }
-        if (typeof span.spanId !== "string" || span.spanId.length === 0) {
-          pushPath(errors, `${spanPath}.spanId`, "must be a non-empty string");
+        if (span.parentSpanId !== void 0 && !isHexId(span.parentSpanId, 8)) {
+          pushPath(
+            errors,
+            `${spanPath}.parentSpanId`,
+            "must be a 16-char hex span id when present"
+          );
         }
         if (typeof span.name !== "string") {
           pushPath(errors, `${spanPath}.name`, "must be a string");
@@ -1052,13 +1118,39 @@ function validateOtlpJson(content) {
             "must be a decimal-string 64-bit integer when present"
           );
         }
+        if (typeof span.startTimeUnixNano === "string" && /^\d+$/.test(span.startTimeUnixNano) && typeof span.endTimeUnixNano === "string" && /^\d+$/.test(span.endTimeUnixNano)) {
+          try {
+            if (BigInt(span.endTimeUnixNano) < BigInt(span.startTimeUnixNano)) {
+              pushPath(
+                errors,
+                `${spanPath}.endTimeUnixNano`,
+                "must be >= startTimeUnixNano"
+              );
+            }
+          } catch {
+            pushPath(errors, `${spanPath}.endTimeUnixNano`, "out of integer range");
+          }
+        }
+        if (Array.isArray(span.attributes)) {
+          span.attributes.forEach((attr, ai) => {
+            const attrPath = `${spanPath}.attributes[${ai}]`;
+            if (!isRecord2(attr)) {
+              pushPath(errors, attrPath, "must be an object");
+              return;
+            }
+            if (typeof attr.key !== "string") {
+              pushPath(errors, `${attrPath}.key`, "must be a string");
+            }
+            validateAnyValue(errors, `${attrPath}.value`, attr.value);
+          });
+        }
         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)`
+            `${spanPath}.kind: string SpanKind is historical reader-compat only; producer wire format uses numeric enums`
           );
         } else if (span.kind !== void 0) {
           pushPath(
@@ -1089,7 +1181,7 @@ function validateOtlpJson(content) {
               );
             } else {
               warnings.push(
-                `${spanPath}.status.code: string StatusCode is legacy; prefer numeric 0/1/2`
+                `${spanPath}.status.code: string StatusCode is historical reader-compat only; producer wire format uses numeric 0/1/2`
               );
             }
           } else {