@tangle-network/traces 0.23.1 → 1.0.1

package/dist/chunk-DU534HAX.js

@@ -0,0 +1,263 @@
+// src/adapters/tool-io.ts
+import { createHash as createHash2 } from "crypto";
+
+// src/source-location.ts
+import { createHash } from "crypto";
+import { resolve } from "path";
+var SOURCE_ATTRIBUTE_PREFIX = "traces.source_record.";
+var locations = /* @__PURE__ */ new WeakMap();
+function sourceFileId(path) {
+  return createHash("sha256").update(resolve(path)).digest("hex");
+}
+function pointerPart(value) {
+  return value.replaceAll("~", "~0").replaceAll("/", "~1");
+}
+function locateSourceObjects(value, path, bytes, offset = 0) {
+  if (!value || typeof value !== "object") return;
+  const record = {
+    sourceId: sourceFileId(path),
+    recordOffset: offset,
+    recordBytes: bytes.length,
+    recordSha256: createHash("sha256").update(bytes).digest("hex")
+  };
+  const pending = [{ value, pointer: "#" }];
+  while (pending.length > 0) {
+    const current = pending.pop();
+    locations.set(current.value, { ...record, fieldLocator: current.pointer });
+    for (const [key, child] of Object.entries(current.value)) {
+      if (child && typeof child === "object") {
+        pending.push({ value: child, pointer: `${current.pointer}/${pointerPart(key)}` });
+      }
+    }
+  }
+}
+function sourceOf(value, ...fields) {
+  if (!value || typeof value !== "object") return void 0;
+  const location = locations.get(value);
+  return location ? {
+    ...location,
+    fieldLocator: `${location.fieldLocator}${fields.map((field) => `/${pointerPart(field)}`).join("")}`
+  } : void 0;
+}
+function textSources(value, field) {
+  if (!value || typeof value !== "object") return void 0;
+  const content = value[field];
+  if (typeof content === "string") return sourceOf(value, field);
+  if (!Array.isArray(content)) return void 0;
+  return content.flatMap((block, index) => {
+    if (typeof block === "string") {
+      const ref2 = sourceOf(value, field, String(index));
+      return ref2 ? [ref2] : [];
+    }
+    if (!block || typeof block !== "object" || typeof block.text !== "string") return [];
+    if (block.type !== void 0 && !["text", "input_text", "output_text"].includes(block.type)) return [];
+    const ref = sourceOf(block, "text");
+    return ref ? [ref] : [];
+  });
+}
+function sourceAttributes(attribute, sources) {
+  const refs = sources === void 0 ? [] : Array.isArray(sources) ? sources : [sources];
+  return refs.length === 0 ? {} : { [`${SOURCE_ATTRIBUTE_PREFIX}${attribute}`]: JSON.stringify(refs) };
+}
+function appendSourceAttributes(attributes, attribute, sources) {
+  const key = `${SOURCE_ATTRIBUTE_PREFIX}${attribute}`;
+  const added = sourceAttributes(attribute, sources)[key];
+  if (typeof added !== "string") return;
+  const prior = attributes[key];
+  const refs = typeof prior === "string" ? JSON.parse(prior) : [];
+  const known = new Set(refs.map((ref) => JSON.stringify(ref)));
+  for (const ref of JSON.parse(added)) {
+    if (!known.has(JSON.stringify(ref))) {
+      refs.push(ref);
+      known.add(JSON.stringify(ref));
+    }
+  }
+  attributes[key] = JSON.stringify(refs);
+}
+function stripSourceAttributes(attributes) {
+  return Object.fromEntries(Object.entries(attributes).filter(([key]) => !key.startsWith(SOURCE_ATTRIBUTE_PREFIX)));
+}
+
+// src/adapters/tool-io.ts
+var TOOL_IO_VALUE_MAX_BYTES = 16 * 1024;
+var TOOL_CALL_LEVEL_ATTR = "traces.tool_call.level";
+var INNER_TOOL_CALL_LEVEL = "inner";
+function isInnerToolCall(attributes) {
+  return attributes[TOOL_CALL_LEVEL_ATTR] === INNER_TOOL_CALL_LEVEL;
+}
+var TOOL_IO_SIDES = ["input", "output"];
+var LEGACY_TRUNCATION_MARKER = /\n\[truncated (\d+) bytes; sha256=[a-f0-9]{64}\]$/;
+var COUNTED_TRUNCATION_MARKER = /\n\[truncated \d+ bytes\]$/;
+var TRUNCATION_MARKER = /\n\[truncated\]$/;
+function canonicalJson(value) {
+  const sort = (item) => {
+    if (Array.isArray(item)) return item.map(sort);
+    if (!item || typeof item !== "object") return item;
+    return Object.fromEntries(
+      Object.entries(item).filter(([, entry]) => entry !== void 0).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([key, entry]) => [key, sort(entry)])
+    );
+  };
+  const json = JSON.stringify(sort(value));
+  if (json === void 0) throw new TypeError("tool I/O value is not JSON-serializable");
+  return json;
+}
+function serialize(value) {
+  if (value === void 0) return void 0;
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+      try {
+        return { value: canonicalJson(JSON.parse(trimmed)), mimeType: "application/json" };
+      } catch {
+      }
+    }
+    return { value, mimeType: "text/plain" };
+  }
+  return { value: canonicalJson(value), mimeType: "application/json" };
+}
+function utf8Prefix(value, maxBytes) {
+  let bytes = 0;
+  let end = 0;
+  for (const char of value) {
+    const charBytes = Buffer.byteLength(char);
+    if (bytes + charBytes > maxBytes) break;
+    bytes += charBytes;
+    end += char.length;
+  }
+  return Buffer.from(value.slice(0, end), "utf8").toString("utf8");
+}
+function truncatedValue(value, bytes) {
+  const longestMarker = `
+[truncated ${bytes} bytes]`;
+  const prefix = utf8Prefix(value, TOOL_IO_VALUE_MAX_BYTES - Buffer.byteLength(longestMarker));
+  const omittedBytes = bytes - Buffer.byteLength(prefix);
+  return `${prefix}
+[truncated ${omittedBytes} bytes]`;
+}
+function boundedString(value) {
+  if (value.length <= TOOL_IO_VALUE_MAX_BYTES / 4) return value;
+  const bytes = Buffer.byteLength(value);
+  return bytes > TOOL_IO_VALUE_MAX_BYTES ? truncatedValue(value, bytes) : value;
+}
+function valueAttributes(side, raw) {
+  const serialized = serialize(raw);
+  if (!serialized) return {};
+  const bytes = Buffer.byteLength(serialized.value);
+  const sha256 = createHash2("sha256").update(serialized.value).digest("hex");
+  const truncated = bytes > TOOL_IO_VALUE_MAX_BYTES;
+  const value = truncated ? truncatedValue(serialized.value, bytes) : serialized.value;
+  return {
+    [`${side}.value`]: value,
+    [`${side}.mime_type`]: serialized.mimeType,
+    [`traces.${side}.bytes`]: bytes,
+    [`traces.${side}.sha256`]: sha256,
+    [`traces.${side}.truncated`]: truncated
+  };
+}
+function toolIoAttributes(io) {
+  return {
+    ...valueAttributes("input", io.input),
+    ...valueAttributes("output", io.output),
+    ...io.input === void 0 ? {} : sourceAttributes("input.value", io.inputSource),
+    ...io.output === void 0 ? {} : sourceAttributes("output.value", io.outputSource),
+    ...io.argsCaptured === void 0 ? {} : { "tool.args_captured": io.argsCaptured }
+  };
+}
+function toolArgumentsFromAttributes(attributes) {
+  const declared = attributes["tool.args_captured"];
+  const explicit = typeof declared === "boolean" ? declared : declared === "true" ? true : declared === "false" ? false : void 0;
+  const argsCaptured = explicit ?? attributes["input.value"] !== void 0;
+  return {
+    args: argsCaptured ? attributes["input.value"] : void 0,
+    argsCaptured
+  };
+}
+function normalizeToolIoAttributes(attributes) {
+  for (const side of TOOL_IO_SIDES) {
+    const valueKey = `${side}.value`;
+    const mimeKey = `${side}.mime_type`;
+    const bytesKey = `traces.${side}.bytes`;
+    const digestKey = `traces.${side}.sha256`;
+    const truncatedKey = `traces.${side}.truncated`;
+    const rawValue = attributes[valueKey];
+    if (typeof rawValue !== "string") {
+      delete attributes[mimeKey];
+      delete attributes[bytesKey];
+      delete attributes[digestKey];
+      delete attributes[truncatedKey];
+      continue;
+    }
+    let value = rawValue.replace(LEGACY_TRUNCATION_MARKER, "\n[truncated]").replace(COUNTED_TRUNCATION_MARKER, "\n[truncated]");
+    let truncated = TRUNCATION_MARKER.test(value);
+    const unboundedBytes = Buffer.byteLength(value);
+    if (unboundedBytes > TOOL_IO_VALUE_MAX_BYTES) {
+      value = truncatedValue(value, unboundedBytes);
+      truncated = true;
+    }
+    attributes[valueKey] = value;
+    attributes[bytesKey] = Buffer.byteLength(value);
+    attributes[digestKey] = createHash2("sha256").update(value).digest("hex");
+    attributes[truncatedKey] = truncated;
+  }
+}
+function recordToolOutput(toolSpan, output, source) {
+  if (!toolSpan) return;
+  if (output === void 0) return;
+  delete toolSpan.attributes[`${SOURCE_ATTRIBUTE_PREFIX}output.value`];
+  Object.assign(toolSpan.attributes, valueAttributes("output", output));
+  Object.assign(toolSpan.attributes, sourceAttributes("output.value", source));
+}
+
+// src/time.ts
+function parseIsoToEpochMs(ts) {
+  if (typeof ts !== "string" || ts.trim().length === 0) {
+    throw new TypeError("timestamp must be a non-empty string");
+  }
+  const value = ts.trim();
+  const n = /^\d+$/.test(value) ? Number(value) : Date.parse(value);
+  if (!Number.isFinite(n) || !Number.isFinite(new Date(n).getTime())) {
+    throw new TypeError(`invalid timestamp: ${ts}`);
+  }
+  return n;
+}
+function parseSince(value) {
+  return parseTimeBound(value, "--since");
+}
+function relativeBoundMs(value) {
+  const m = value.match(/^(\d+)\s*([mhd])$/i);
+  if (!m) return void 0;
+  const unit = m[2].toLowerCase();
+  return Number(m[1]) * (unit === "m" ? 6e4 : unit === "h" ? 36e5 : 864e5);
+}
+function parseTimeBound(value, flag) {
+  const relative = relativeBoundMs(value);
+  if (relative !== void 0) return Date.now() - relative;
+  const t = Date.parse(value);
+  if (Number.isNaN(t)) throw new Error(`${flag}: expected 30m / 2h / 7d or an ISO date, got "${value}"`);
+  return t;
+}
+
+export {
+  SOURCE_ATTRIBUTE_PREFIX,
+  sourceFileId,
+  locateSourceObjects,
+  sourceOf,
+  textSources,
+  sourceAttributes,
+  appendSourceAttributes,
+  stripSourceAttributes,
+  TOOL_IO_VALUE_MAX_BYTES,
+  TOOL_CALL_LEVEL_ATTR,
+  INNER_TOOL_CALL_LEVEL,
+  isInnerToolCall,
+  canonicalJson,
+  boundedString,
+  toolIoAttributes,
+  toolArgumentsFromAttributes,
+  normalizeToolIoAttributes,
+  recordToolOutput,
+  parseIsoToEpochMs,
+  parseSince,
+  relativeBoundMs,
+  parseTimeBound
+};