@tangle-network/agent-eval 0.72.3 → 0.73.0

package/dist/{chunk-JHA3ZGSO.js → chunk-XGNCBAVZ.js}

@@ -1323,6 +1323,330 @@ function padTraceId(id) {
   return cleaned.slice(0, 32).padEnd(32, "0");
 }
 
+// src/trace/store-to-otlp.ts
+import { readdirSync, readFileSync, statSync, writeFileSync } from "fs";
+import { join } from "path";
+function convertTraceStoresToOtlp(source, outPath, opts = {}) {
+  const sources = Array.isArray(source) ? [...source] : typeof source === "string" ? [{ root: source, layout: "celled" }] : [source];
+  const defaultServiceName = opts.serviceName ?? "agent-eval";
+  const resourceAttributes = opts.resourceAttributes ?? (() => ({}));
+  const runAttributes = opts.runAttributes ?? (() => ({}));
+  const lines = [];
+  let spanCount = 0;
+  let runCount = 0;
+  let cellCount = 0;
+  let cellErrorCount = 0;
+  for (const src of sources) {
+    const serviceName = src.serviceName ?? defaultServiceName;
+    const cellDirs = src.layout === "flat" ? [{ label: "<root>", dir: src.root }] : listCells(src.root).map((name) => ({ label: name, dir: join(src.root, name) }));
+    for (const cell of cellDirs) {
+      try {
+        const result = projectCell({
+          cellDir: cell.dir,
+          serviceName,
+          resourceAttributes,
+          runAttributes
+        });
+        for (const line of result.lines) lines.push(line);
+        spanCount += result.spanCount;
+        runCount += result.runCount;
+        cellCount += 1;
+      } catch (err) {
+        console.warn(
+          `[traces-to-otlp] cell ${cell.label} (${cell.dir}) skipped: ${err instanceof Error ? err.message : String(err)}`
+        );
+        cellErrorCount += 1;
+      }
+    }
+  }
+  writeFileSync(outPath, lines.join("\n") + (lines.length > 0 ? "\n" : ""));
+  return { spanCount, runCount, cellCount, cellErrorCount };
+}
+function projectCell(args) {
+  const { cellDir, serviceName, resourceAttributes, runAttributes } = args;
+  const lines = [];
+  let runCount = 0;
+  let spanCount = 0;
+  const runs = readMergedShards(cellDir, "runs", "runId");
+  const spans = readMergedShards(cellDir, "spans", "spanId");
+  const events = readShards(cellDir, "events");
+  const runByRunId = /* @__PURE__ */ new Map();
+  for (const r of runs) runByRunId.set(r.runId, r);
+  const spanBySpanId = /* @__PURE__ */ new Map();
+  for (const s of spans) spanBySpanId.set(s.spanId, s);
+  const eventsBySpanId = /* @__PURE__ */ new Map();
+  for (const e of events) {
+    if (e.kind === "state_mutation" && e.payload && typeof e.payload === "object") {
+      const entity = e.payload.entity;
+      if (entity === "run") {
+        const run = e.payload.run;
+        if (run?.runId) runByRunId.set(run.runId, run);
+        continue;
+      }
+      if (entity === "run.update") {
+        const patch = e.payload.patch;
+        if (patch && e.runId) {
+          const prior = runByRunId.get(e.runId);
+          if (prior) runByRunId.set(e.runId, { ...prior, ...patch });
+        }
+        continue;
+      }
+      if (entity === "span") {
+        const span = e.payload.span;
+        if (span?.spanId) spanBySpanId.set(span.spanId, span);
+        continue;
+      }
+      if (entity === "span.update") {
+        const spanId = e.payload.spanId;
+        const patch = e.payload.patch;
+        if (spanId && patch) {
+          const prior = spanBySpanId.get(spanId);
+          if (prior) spanBySpanId.set(spanId, { ...prior, ...patch });
+        }
+        continue;
+      }
+    }
+    if (!e.spanId) continue;
+    const arr = eventsBySpanId.get(e.spanId) ?? [];
+    arr.push(e);
+    eventsBySpanId.set(e.spanId, arr);
+  }
+  for (const run of runByRunId.values()) {
+    const traceId = padTraceId2(run.runId);
+    const agentName = run.variantId ?? run.scenarioId;
+    const sharedResource = {
+      attributes: {
+        "service.name": serviceName,
+        "agent.name": agentName,
+        "run.id": run.runId,
+        "run.status": run.status,
+        ...resourceAttributes(run)
+      }
+    };
+    const runSpanId = padSpanId3(`run-${run.runId}`);
+    const runStart = msToIso(run.startedAt);
+    const runEnd = msToIso(run.endedAt ?? run.startedAt);
+    const runStatus = run.outcome?.failureClass && run.outcome.failureClass !== "success" ? "STATUS_CODE_ERROR" : "STATUS_CODE_OK";
+    const runAttrs = {
+      "openinference.span.kind": "AGENT",
+      "agent.name": agentName,
+      "agent.workflow.name": serviceName,
+      ...runAttributes(run)
+    };
+    lines.push(
+      JSON.stringify(
+        toLine({
+          traceId,
+          spanId: runSpanId,
+          parentSpanId: "",
+          name: `run.${agentName}`,
+          kind: "SPAN_KIND_INTERNAL",
+          startTime: runStart,
+          endTime: runEnd,
+          statusCode: runStatus,
+          statusMessage: run.outcome?.notes ?? "",
+          resource: sharedResource,
+          attributes: runAttrs
+        })
+      )
+    );
+    runCount += 1;
+    for (const span of spanBySpanId.values()) {
+      if (span.runId !== run.runId) continue;
+      const spanAttrs = spanToAttributes(span, eventsBySpanId.get(span.spanId) ?? []);
+      const statusCode = span.status === "error" ? "STATUS_CODE_ERROR" : "STATUS_CODE_OK";
+      lines.push(
+        JSON.stringify(
+          toLine({
+            traceId,
+            spanId: padSpanId3(span.spanId),
+            parentSpanId: span.parentSpanId ? padSpanId3(span.parentSpanId) : runSpanId,
+            name: span.name,
+            kind: spanKindToOtlpKind(span.kind),
+            startTime: msToIso(span.startedAt),
+            endTime: msToIso(span.endedAt ?? span.startedAt),
+            statusCode,
+            statusMessage: span.error ?? "",
+            resource: sharedResource,
+            attributes: spanAttrs
+          })
+        )
+      );
+      spanCount += 1;
+    }
+  }
+  return { lines, runCount, spanCount };
+}
+function listCells(root) {
+  try {
+    return readdirSync(root, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort();
+  } catch {
+    return [];
+  }
+}
+function readShards(cellDir, name) {
+  let entries;
+  try {
+    entries = readdirSync(cellDir);
+  } catch {
+    return [];
+  }
+  const shards = entries.filter((f) => (f === `${name}.ndjson` || f.startsWith(`${name}.`)) && f.endsWith(".ndjson")).map((f) => ({ file: f, path: join(cellDir, f) })).map((s) => {
+    let mtime = 0;
+    try {
+      mtime = statSync(s.path).mtimeMs;
+    } catch {
+    }
+    return { ...s, mtime };
+  }).sort((a, b) => a.mtime - b.mtime || a.file.localeCompare(b.file));
+  const rows = [];
+  for (const shard of shards) {
+    let text;
+    try {
+      text = readFileSync(shard.path, "utf-8");
+    } catch {
+      continue;
+    }
+    for (const line of text.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        rows.push(JSON.parse(trimmed));
+      } catch {
+      }
+    }
+  }
+  return rows;
+}
+function readMergedShards(cellDir, name, idKey) {
+  const rows = readShards(cellDir, name);
+  const byId = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const id = row[idKey];
+    if (!id) continue;
+    const prior = byId.get(id);
+    if (prior && row._update) {
+      byId.set(id, { ...prior, ...row, _update: void 0 });
+    } else {
+      byId.set(id, row);
+    }
+  }
+  return [...byId.values()];
+}
+function spanToAttributes(span, events) {
+  const attrs = {
+    "openinference.span.kind": spanKindToOpenInferenceKind(span.kind)
+  };
+  if (span.kind === "llm") {
+    attrs["llm.model_name"] = span.model;
+    if (span.inputTokens !== void 0) attrs["llm.token_count.prompt"] = span.inputTokens;
+    if (span.outputTokens !== void 0) attrs["llm.token_count.completion"] = span.outputTokens;
+    if (span.costUsd !== void 0) attrs["llm.cost_usd"] = span.costUsd;
+    if (span.finishReason) attrs["llm.finish_reason"] = span.finishReason;
+    if (Array.isArray(span.messages)) {
+      attrs["llm.input_messages"] = JSON.stringify(span.messages.slice(-6));
+    }
+    if (typeof span.output === "string") {
+      attrs["llm.output_messages"] = JSON.stringify([{ role: "assistant", content: span.output }]);
+    }
+  } else if (span.kind === "tool") {
+    attrs["tool.name"] = span.toolName;
+    if (span.latencyMs !== void 0) attrs["tool.latency_ms"] = span.latencyMs;
+    attrs["input.value"] = safeStringify(span.args);
+    if (span.result !== void 0) attrs["output.value"] = safeStringify(span.result);
+  } else if (span.kind === "judge") {
+    attrs["judge.id"] = span.judgeId;
+    attrs["judge.dimension"] = span.dimension;
+    attrs["judge.score"] = span.score;
+    attrs["judge.target_span_id"] = span.targetSpanId;
+  }
+  if (span.attributes) {
+    for (const [k, v] of Object.entries(span.attributes)) {
+      attrs[`agent_eval.${k}`] = v;
+    }
+  }
+  if (events.length > 0) {
+    attrs["agent_eval.event_count"] = events.length;
+    attrs["agent_eval.event_kinds"] = JSON.stringify(events.map((e) => e.kind));
+  }
+  return attrs;
+}
+function spanKindToOtlpKind(kind) {
+  switch (kind) {
+    case "llm":
+      return "SPAN_KIND_CLIENT";
+    case "retrieval":
+      return "SPAN_KIND_CLIENT";
+    default:
+      return "SPAN_KIND_INTERNAL";
+  }
+}
+function spanKindToOpenInferenceKind(kind) {
+  switch (kind) {
+    case "llm":
+      return "LLM";
+    case "tool":
+      return "TOOL";
+    case "retrieval":
+      return "CHAIN";
+    case "judge":
+      return "GUARDRAIL";
+    case "sandbox":
+      return "CHAIN";
+    case "agent":
+      return "AGENT";
+    default:
+      return "SPAN";
+  }
+}
+function toLine(args) {
+  return {
+    trace_id: args.traceId,
+    span_id: args.spanId,
+    parent_span_id: args.parentSpanId,
+    name: args.name,
+    kind: args.kind,
+    start_time: args.startTime,
+    end_time: args.endTime,
+    status: { code: args.statusCode, message: args.statusMessage },
+    resource: args.resource,
+    attributes: args.attributes
+  };
+}
+function msToIso(ms) {
+  if (!Number.isFinite(ms) || ms <= 0) return (/* @__PURE__ */ new Date(0)).toISOString();
+  return new Date(ms).toISOString();
+}
+function padSpanId3(id) {
+  const cleaned = id.replace(/[^a-f0-9]/gi, "").toLowerCase();
+  if (cleaned.length >= 16) return cleaned.slice(0, 16);
+  return foldTo16Hex(id);
+}
+function padTraceId2(id) {
+  const cleaned = id.replace(/[^a-f0-9]/gi, "").toLowerCase();
+  if (cleaned.length >= 32) return cleaned.slice(0, 32);
+  return foldTo32Hex(id);
+}
+function foldTo16Hex(s) {
+  let h1 = 2166136261;
+  for (const ch of s) {
+    h1 ^= ch.charCodeAt(0);
+    h1 = Math.imul(h1, 16777619) >>> 0;
+  }
+  const part = h1.toString(16).padStart(8, "0");
+  return (part + part).slice(0, 16);
+}
+function foldTo32Hex(s) {
+  return foldTo16Hex(s) + foldTo16Hex(`${s}::trace`).slice(0, 16);
+}
+function safeStringify(value) {
+  try {
+    return typeof value === "string" ? value : JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+
 // src/replay.ts
 var ReplayCacheMissError = class extends ReplayError {
   constructor(url, requestKey2, message) {
@@ -1488,9 +1812,10 @@ export {
   otelRunCompleteHook,
   createOtelTracingStore,
   createOtelExporter,
+  convertTraceStoresToOtlp,
   ReplayCacheMissError,
   ReplayCache,
   createReplayFetch,
   iterateRawCalls
 };
-//# sourceMappingURL=chunk-JHA3ZGSO.js.map
+//# sourceMappingURL=chunk-XGNCBAVZ.js.map