@tangle-network/agent-eval 0.56.0 → 0.57.0

package/dist/{chunk-MAOZCN36.js → chunk-5GLYP2IQ.js}

@@ -2,6 +2,10 @@ import {
   canonicalize,
   hashJson
 } from "./chunk-VSMTAMNK.js";
+import {
+  defaultProviderRedactor,
+  providerFromBaseUrl
+} from "./chunk-PC4UYEBM.js";
 import {
   NotFoundError,
   ReplayError
@@ -1282,6 +1286,86 @@ ${JSON.stringify(
 Use the trace tools. Do not invent facts. Cite task ids. Separate customer-facing claims from internal harness/model findings.`;
 }
 
+// src/trace-analyst/otlp-flatten.ts
+var DEFAULT_KIND_MAP = {
+  0: "SPAN_KIND_UNSPECIFIED",
+  1: "SPAN_KIND_INTERNAL",
+  2: "SPAN_KIND_SERVER",
+  3: "SPAN_KIND_CLIENT",
+  4: "SPAN_KIND_PRODUCER",
+  5: "SPAN_KIND_CONSUMER"
+};
+var STATUS_MAP = {
+  0: "STATUS_CODE_UNSET",
+  1: "STATUS_CODE_OK",
+  2: "STATUS_CODE_ERROR"
+};
+function attrValue(v) {
+  if (v.stringValue !== void 0) return v.stringValue;
+  if (v.intValue !== void 0) return Number(v.intValue);
+  if (v.doubleValue !== void 0) return v.doubleValue;
+  if (v.boolValue !== void 0) return v.boolValue;
+  return "";
+}
+function attrsToRecord(attrs) {
+  const out = {};
+  for (const a of attrs) out[a.key] = attrValue(a.value);
+  return out;
+}
+function nanoToIso(nano) {
+  const ms = Number(nano) / 1e6;
+  return Number.isFinite(ms) ? new Date(ms).toISOString() : (/* @__PURE__ */ new Date(0)).toISOString();
+}
+function applyOpenInference(attrs) {
+  if ("llm.model" in attrs && !("llm.model_name" in attrs)) {
+    attrs["llm.model_name"] = attrs["llm.model"];
+  }
+  if ("tool.name" in attrs && !("inference.tool.name" in attrs)) {
+    attrs["inference.tool.name"] = attrs["tool.name"];
+  }
+  if ("span.kind" in attrs && !("openinference.span.kind" in attrs)) {
+    attrs["openinference.span.kind"] = String(attrs["span.kind"]).toUpperCase();
+  }
+}
+function flattenOtlpExportToNdjson(otlpExport, opts = {}) {
+  const vocab = opts.attributeVocabulary ?? "openinference";
+  const kindMap = { ...DEFAULT_KIND_MAP, ...opts.kindMap };
+  const lines = [];
+  for (const rs of otlpExport.resourceSpans ?? []) {
+    const resource = { attributes: attrsToRecord(rs.resource?.attributes ?? []) };
+    for (const scope of rs.scopeSpans ?? []) {
+      for (const span of scope.spans ?? []) {
+        const attributes = attrsToRecord(span.attributes ?? []);
+        if (vocab === "openinference") applyOpenInference(attributes);
+        const line = {
+          trace_id: span.traceId,
+          span_id: span.spanId,
+          parent_span_id: span.parentSpanId ?? null,
+          name: span.name,
+          kind: kindMap[span.kind] ?? "SPAN_KIND_UNSPECIFIED",
+          start_time: nanoToIso(span.startTimeUnixNano),
+          end_time: nanoToIso(span.endTimeUnixNano),
+          status: {
+            code: STATUS_MAP[span.status?.code ?? 0] ?? "STATUS_CODE_UNSET",
+            ...span.status?.message ? { message: span.status.message } : {}
+          },
+          resource,
+          attributes
+        };
+        if (span.events && span.events.length > 0) {
+          line.events = span.events.map((e) => ({
+            name: e.name,
+            timeUnixNano: e.timeUnixNano,
+            ...e.attributes ? { attributes: attrsToRecord(e.attributes) } : {}
+          }));
+        }
+        lines.push(line);
+      }
+    }
+  }
+  return lines;
+}
+
 // src/trace/store.ts
 var InMemoryTraceStore = class {
   runs = /* @__PURE__ */ new Map();
@@ -1509,6 +1593,126 @@ var FileSystemTraceStore = class {
   }
 };
 
+// src/trace/capture-fetch.ts
+var DEFAULT_BODY_CAP = 2 * 1024 * 1024;
+function headersToRecord(headers) {
+  if (!headers) return void 0;
+  const out = {};
+  headers.forEach((value, key) => {
+    out[key.toLowerCase()] = value;
+  });
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function parseMaybeJson(text) {
+  if (text.length === 0) return void 0;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+async function readRequestBody(input, init) {
+  if (typeof init?.body === "string") return parseMaybeJson(init.body);
+  if (init?.body != null) return void 0;
+  if (input instanceof Request) {
+    try {
+      return parseMaybeJson(await input.clone().text());
+    } catch {
+      return void 0;
+    }
+  }
+  return void 0;
+}
+function endpointFromUrl(url, baseUrl) {
+  const normalisedBase = baseUrl.replace(/\/+$/, "");
+  if (url.startsWith(normalisedBase)) return url.slice(normalisedBase.length) || "/";
+  try {
+    return new URL(url).pathname;
+  } catch {
+    return url;
+  }
+}
+function captureFetchToRawSink(fetch2, sink, ctx, opts = {}) {
+  const provider = ctx.provider ?? providerFromBaseUrl(ctx.baseUrl);
+  const redactor = opts.redactor ?? defaultProviderRedactor;
+  const bodyCap = opts.responseBodyByteCap ?? DEFAULT_BODY_CAP;
+  let warned = false;
+  const baseEvent = (direction, endpoint) => ({
+    eventId: crypto.randomUUID(),
+    runId: ctx.runId,
+    spanId: ctx.spanId,
+    provider,
+    model: ctx.model,
+    endpoint,
+    baseUrl: ctx.baseUrl,
+    attemptIndex: 0,
+    // retries are re-invocations one layer up; documented in 0.x
+    direction,
+    timestamp: Date.now(),
+    redactedFields: []
+  });
+  const record = async (event) => {
+    try {
+      await sink.record(redactor(event));
+    } catch (err) {
+      if (opts.failClosed) throw err;
+      if (!warned) {
+        warned = true;
+        console.warn(
+          `captureFetchToRawSink: sink.record failed (capture is best-effort) \u2014 ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+  };
+  return async (input, init) => {
+    const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+    const method = (init?.method ?? (input instanceof Request ? input.method : "GET")).toUpperCase();
+    const endpoint = endpointFromUrl(url, ctx.baseUrl);
+    const reqHeaders = new Headers(
+      init?.headers ?? (input instanceof Request ? input.headers : void 0)
+    );
+    await record({
+      ...baseEvent("request", endpoint),
+      requestHeaders: { ...headersToRecord(reqHeaders), "x-http-method": method },
+      requestBody: await readRequestBody(input, init)
+    });
+    const start = Date.now();
+    let response;
+    try {
+      response = await fetch2(input, init);
+    } catch (err) {
+      await record({
+        ...baseEvent("error", endpoint),
+        durationMs: Date.now() - start,
+        errorMessage: err instanceof Error ? err.message : String(err)
+      });
+      throw err;
+    }
+    let responseBody;
+    const redactedFields = [];
+    try {
+      const raw = await response.clone().text();
+      if (raw.length > bodyCap) {
+        responseBody = raw.slice(0, bodyCap);
+        redactedFields.push("body_truncated");
+      } else {
+        responseBody = parseMaybeJson(raw);
+      }
+    } catch {
+      responseBody = void 0;
+    }
+    await record({
+      ...baseEvent("response", endpoint),
+      durationMs: Date.now() - start,
+      statusCode: response.status,
+      responseHeaders: headersToRecord(response.headers),
+      responseBody,
+      redactedFields
+    });
+    return response;
+  };
+}
+
 // src/trace/otel.ts
 var OTEL_AGENT_EVAL_SCOPE = { name: "@tangle-network/agent-eval", version: "0.3.0" };
 async function exportRunAsOtlp(store, runId, resourceAttrs = {}) {
@@ -1996,8 +2200,10 @@ export {
   scoreTraceInsightReadiness,
   defaultTraceInsightPanel,
   buildTraceInsightPrompt,
+  flattenOtlpExportToNdjson,
   InMemoryTraceStore,
   FileSystemTraceStore,
+  captureFetchToRawSink,
   OTEL_AGENT_EVAL_SCOPE,
   exportRunAsOtlp,
   otelRunCompleteHook,
@@ -2008,4 +2214,4 @@ export {
   createReplayFetch,
   iterateRawCalls
 };
-//# sourceMappingURL=chunk-MAOZCN36.js.map
+//# sourceMappingURL=chunk-5GLYP2IQ.js.map