@tangle-network/traces 0.23.1 → 1.0.1

package/dist/analyst-model-call-JVUOYZ5V.js

@@ -0,0 +1,20 @@
+import {
+  ANALYST_MAX_OUTPUT_TOKENS,
+  UnservableModelError,
+  analysisEngineFromEnv,
+  bridgeVersion,
+  createAnalystModelOwner,
+  missingAskRequirements
+} from "./chunk-GLUDGUGJ.js";
+import {
+  DEFAULT_ANALYST_MODEL
+} from "./chunk-O52XK7OB.js";
+export {
+  ANALYST_MAX_OUTPUT_TOKENS,
+  DEFAULT_ANALYST_MODEL,
+  UnservableModelError,
+  analysisEngineFromEnv,
+  bridgeVersion,
+  createAnalystModelOwner,
+  missingAskRequirements
+};

package/dist/ask-2KF4KSPB.js

@@ -0,0 +1,39 @@
+import {
+  createTraceQuestionCorpus,
+  engineCallReservationFloorUsd,
+  isBridgeMismatchError,
+  loadTraceQuestionsFile,
+  normalizeTraceQuestions,
+  renderTraceQuestionInstructions,
+  renderTraceQuestionPrompt,
+  renderTraceQuestionsReport,
+  runTraceQuestions,
+  traceCitationsInText,
+  writeTraceQuestionsArtifacts
+} from "./chunk-QUHUMZ4W.js";
+import "./chunk-PYH3PL3N.js";
+import {
+  DEFAULT_ASK_CONCURRENCY,
+  MAX_TRACE_QUESTION_CHARS
+} from "./chunk-O52XK7OB.js";
+import "./chunk-2XXABIRL.js";
+import "./chunk-WF7PTDCZ.js";
+import "./chunk-7USMM4MA.js";
+import "./chunk-UQSAGXPH.js";
+import "./chunk-CQ6UYZG6.js";
+import "./chunk-DU534HAX.js";
+export {
+  DEFAULT_ASK_CONCURRENCY,
+  MAX_TRACE_QUESTION_CHARS,
+  createTraceQuestionCorpus,
+  engineCallReservationFloorUsd,
+  isBridgeMismatchError,
+  loadTraceQuestionsFile,
+  normalizeTraceQuestions,
+  renderTraceQuestionInstructions,
+  renderTraceQuestionPrompt,
+  renderTraceQuestionsReport,
+  runTraceQuestions,
+  traceCitationsInText,
+  writeTraceQuestionsArtifacts
+};

package/dist/check-YF6ZHPGG.js

@@ -0,0 +1,322 @@
+import {
+  formatVerdict
+} from "./chunk-4VKPN432.js";
+import {
+  redactSpans
+} from "./chunk-RZL5GAWH.js";
+import {
+  parseIsoToEpochMs,
+  toolArgumentsFromAttributes
+} from "./chunk-DU534HAX.js";
+
+// src/check.ts
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { join } from "path";
+import {
+  compileTraceContractSpec,
+  evaluateTraceContract,
+  explainTraceContract,
+  lintTraceContractSpec
+} from "@tangle-network/agent-eval";
+var CONFORMANCE = "conformance";
+var CHECK_EXIT = Object.freeze({
+  pass: 0,
+  fail: 1,
+  /** A rule or verdict could not run, the contract is malformed, or the trace is unreadable or ambiguous. */
+  couldNotDecide: 2
+});
+var AmbiguousTraceInputError = class extends Error {
+  name = "AmbiguousTraceInputError";
+};
+var ContractFileError = class extends Error {
+  name = "ContractFileError";
+};
+async function loadContract(path) {
+  let text;
+  try {
+    text = await readFile(path, "utf8");
+  } catch (error) {
+    throw new ContractFileError(`cannot read contract ${path}: ${errorText(error)}`);
+  }
+  let json;
+  try {
+    json = JSON.parse(text);
+  } catch (error) {
+    throw new ContractFileError(`contract ${path} is not JSON: ${errorText(error)}`);
+  }
+  try {
+    const findings = lintTraceContractSpec(json);
+    const errors = findings.filter((f) => f.level === "error");
+    if (errors.length > 0) {
+      throw new ContractFileError(
+        `contract ${path} contradicts itself:
+${errors.map((f) => `  ${f.path}: ${f.message} [${f.code}]`).join("\n")}`
+      );
+    }
+    return {
+      path,
+      contract: compileTraceContractSpec(json),
+      warnings: findings.map((f) => `${f.path}: ${f.message} [${f.code}]`)
+    };
+  } catch (error) {
+    if (error instanceof ContractFileError) throw error;
+    throw new ContractFileError(`contract ${path}: ${errorText(error)}`);
+  }
+}
+function contractSpansFromOtlp(spans) {
+  return spans.map((span) => {
+    const startedAt = epochMs(span.start_time);
+    const endedAt = epochMs(span.end_time);
+    const args = toolArgumentsFromAttributes(span.attributes);
+    const truncated = span.attributes["traces.input.truncated"] === true;
+    return {
+      spanId: span.span_id,
+      parentSpanId: span.parent_span_id,
+      name: span.name,
+      ...startedAt === void 0 ? {} : { startedAt },
+      ...endedAt === void 0 ? {} : { endedAt },
+      ...span.status.code === "ERROR" ? { status: "error" } : span.status.code === "OK" ? { status: "ok" } : {},
+      // A truncated argument capture is not the call's arguments.
+      ...args.argsCaptured && !truncated ? { args: args.args } : { argsCaptured: false },
+      attributes: span.attributes
+    };
+  });
+}
+function epochMs(value) {
+  try {
+    return parseIsoToEpochMs(value);
+  } catch {
+    return void 0;
+  }
+}
+function groupByTrace(spans) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const span of spans) {
+    const list = groups.get(span.trace_id) ?? [];
+    list.push(span);
+    groups.set(span.trace_id, list);
+  }
+  return [...groups].map(([traceId, list]) => ({ traceId, spans: list }));
+}
+async function runCheck(contract, spans, opts = {}) {
+  const traces = [];
+  for (const group of groupByTrace(spans)) {
+    const verdict = evaluateTraceContract(contract, contractSpansFromOtlp(group.spans));
+    const check = { traceId: group.traceId, spanCount: group.spans.length, verdict };
+    if (verdict.status !== "pass" && opts.evidenceRoot !== void 0) {
+      check.evidenceDir = await writeEvidence(opts.evidenceRoot, contract, group.traceId, group.spans, verdict);
+    }
+    traces.push(check);
+  }
+  const status = traces.some((t) => t.verdict.status === "error") ? "error" : traces.every((t) => t.verdict.status === "pass") ? "pass" : "fail";
+  const exitCode = status === "pass" ? CHECK_EXIT.pass : status === "fail" ? CHECK_EXIT.fail : CHECK_EXIT.couldNotDecide;
+  return { contract: contract.name, status, exitCode, traces };
+}
+async function writeEvidence(root, contract, traceId, spans, verdict) {
+  const dir = join(root, `${safeName(contract.name)}-${safeName(traceId).slice(0, 40)}`);
+  await mkdir(dir, { recursive: true });
+  const cited = new Set(verdict.violations.map((v) => v.spanId).filter((id) => id !== void 0));
+  const redacted = redactSpans(spans.filter((s) => cited.has(s.span_id)));
+  await writeFile(join(dir, "verdict.json"), `${JSON.stringify({ traceId, verdict }, null, 2)}
+`);
+  await writeFile(join(dir, "contract.json"), `${JSON.stringify(contract, null, 2)}
+`);
+  await writeFile(join(dir, "explain.txt"), `${explainTraceContract(contract)}
+`);
+  await writeFile(join(dir, "cited-spans.jsonl"), redacted.spans.map((s) => JSON.stringify(s)).join("\n") + (redacted.spans.length ? "\n" : ""));
+  return dir;
+}
+function safeName(value) {
+  return value.replace(/[^A-Za-z0-9._-]+/g, "_");
+}
+function ruleLines(verdict) {
+  const branchPassed = /* @__PURE__ */ new Map();
+  for (const e of verdict.ruleExecutions) {
+    if (e.alternative === void 0) continue;
+    branchPassed.set(e.alternative, (branchPassed.get(e.alternative) ?? true) && e.status === "pass");
+  }
+  const anyBranchPassed = [...branchPassed.values()].some(Boolean);
+  return verdict.ruleExecutions.map((e) => {
+    const rule = e.alternative ? `${e.alternative}/${e.rule}` : e.rule;
+    const status = e.alternative && anyBranchPassed && !branchPassed.get(e.alternative) ? "skipped" : e.status;
+    return {
+      rule,
+      status,
+      ...e.error === void 0 ? {} : { error: e.error },
+      details: verdict.violations.filter((x) => x.rule === rule).map((x) => x.detail)
+    };
+  });
+}
+function renderCheckText(report) {
+  const lines = [];
+  for (const t of report.traces) {
+    const v = t.verdict;
+    lines.push(`${v.status.toUpperCase()}  contract ${report.contract}  trace ${t.traceId}  (${t.spanCount} spans, ${v.notes})`);
+    for (const r of ruleLines(v)) {
+      lines.push(`  ${r.status.padEnd(7)} ${r.rule}${r.error ? `  ${r.error}` : ""}`);
+      if (r.status === "fail") for (const detail of r.details.slice(0, 5)) lines.push(`          ${detail}`);
+    }
+    if (t.evidenceDir) lines.push(`  evidence \u2192 ${t.evidenceDir}`);
+  }
+  return lines.join("\n");
+}
+function contractSuites(report) {
+  return report.traces.map((t) => {
+    const rules = ruleLines(t.verdict);
+    const count = (status) => rules.filter((r) => r.status === status).length;
+    const cases = rules.map((r) => {
+      const open = `    <testcase classname="${xml(report.contract)}" name="${xml(r.rule)}">`;
+      if (r.status === "pass") return `${open}</testcase>`;
+      if (r.status === "skipped") return `${open}
+      <skipped message="another alternative passed"/>
+    </testcase>`;
+      if (r.status === "error") {
+        return `${open}
+      <error message="${xml(r.error ?? "rule could not be evaluated")}"/>
+    </testcase>`;
+      }
+      return `${open}
+      <failure message="${xml(r.details[0] ?? "rule failed")}">${xml(r.details.join("\n"))}</failure>
+    </testcase>`;
+    });
+    return [
+      `  <testsuite name="${xml(`${report.contract} @ ${t.traceId}`)}" tests="${rules.length}" failures="${count("fail")}" errors="${count("error")}" skipped="${count("skipped")}">`,
+      ...cases,
+      "  </testsuite>"
+    ].join("\n");
+  });
+}
+function renderGithubAnnotations(report) {
+  const lines = [];
+  for (const t of report.traces) {
+    for (const r of ruleLines(t.verdict)) {
+      if (r.status === "pass" || r.status === "skipped") continue;
+      const detail = r.status === "error" ? `could not be evaluated: ${r.error ?? "unknown"}` : r.details.join("\n");
+      lines.push(`::error title=${ghProperty(`${report.contract}: ${r.rule}`)}::${ghData(`trace ${t.traceId}: ${detail}`)}`);
+    }
+  }
+  return lines.join("\n");
+}
+function contractGate(report) {
+  return { gate: "contract", status: report.status === "error" ? "unknown" : report.status, report };
+}
+function conformanceGate(subject, validation, text) {
+  return { gate: "conformance", status: validation.ok ? "pass" : "fail", subject, validation, text };
+}
+function shareSafeGate(verdict) {
+  const status = verdict.status === "UNSAFE" ? "fail" : verdict.status === "UNKNOWN" ? "unknown" : "pass";
+  return { gate: "share-safe", status, verdict };
+}
+function combineGates(gates) {
+  const status = gates.some((gate) => gate.status === "fail") ? "fail" : gates.some((gate) => gate.status === "unknown") ? "unknown" : "pass";
+  const exitCode = status === "pass" ? CHECK_EXIT.pass : status === "fail" ? CHECK_EXIT.fail : CHECK_EXIT.couldNotDecide;
+  return { status, exitCode, gates };
+}
+async function writeGateEvidence(root, verdict) {
+  for (const gate of verdict.gates) {
+    if (gate.status === "pass" || gate.gate === "contract") continue;
+    await mkdir(root, { recursive: true });
+    if (gate.gate === "conformance") await writeFile(join(root, "conformance.md"), `${gate.text}
+`);
+    else await writeFile(join(root, "share-safe.json"), `${JSON.stringify(gate.verdict, null, 2)}
+`);
+  }
+}
+var CONFORMANCE_EXPLAINED = [
+  "conformance: whether the input can be read as a trace at all, and which analyses its spans can support.",
+  "  fail  not one entry could be read as a span (an empty export, or every line unreadable)",
+  "  pass  spans were read; each capability a field they lack costs is listed with what it empties"
+].join("\n");
+function renderVerdictText(verdict) {
+  return verdict.gates.map((gate) => {
+    if (gate.gate === "contract") return renderCheckText(gate.report);
+    if (gate.gate === "conformance") return gate.text;
+    return formatVerdict(gate.verdict);
+  }).join("\n\n");
+}
+function renderVerdictJUnit(verdict) {
+  const suites = verdict.gates.flatMap((gate) => {
+    if (gate.gate === "contract") return contractSuites(gate.report);
+    if (gate.gate === "conformance") {
+      const readable = gate.validation.ok ? '    <testcase classname="conformance" name="readable"></testcase>' : `    <testcase classname="conformance" name="readable">
+      <failure message="not one entry could be read as a span"/>
+    </testcase>`;
+      const capabilities = gate.validation.capabilities.map((capability) => capability.available ? `    <testcase classname="conformance" name="${xml(capability.name)}"></testcase>` : `    <testcase classname="conformance" name="${xml(capability.name)}">
+      <skipped message="${xml(capability.reason ?? "unavailable")}"/>
+    </testcase>`);
+      const unavailable = gate.validation.capabilities.filter((capability) => !capability.available).length;
+      return [[
+        `  <testsuite name="${xml(`conformance @ ${gate.subject}`)}" tests="${capabilities.length + 1}" failures="${gate.validation.ok ? 0 : 1}" errors="0" skipped="${unavailable}">`,
+        readable,
+        ...capabilities,
+        "  </testsuite>"
+      ].join("\n")];
+    }
+    const result = gate.verdict;
+    const findings = result.findings.map((finding) => `${finding.severity} ${finding.category}/${finding.detector} x${finding.count} at ${finding.paths.join(", ")}`);
+    const body = gate.status === "fail" ? `
+      <failure message="${xml(`${result.status}: ${findings[0] ?? ""}`)}">${xml(findings.join("\n"))}</failure>
+    ` : gate.status === "unknown" ? `
+      <error message="${xml(`UNKNOWN: ${result.unreadable[0] ?? "part of the input could not be read"}`)}">${xml(result.unreadable.join("\n"))}</error>
+    ` : findings.length > 0 ? `
+      <system-out>${xml(findings.join("\n"))}</system-out>
+    ` : "";
+    return [[
+      `  <testsuite name="${xml(`share-safe @ ${result.target}`)}" tests="1" failures="${gate.status === "fail" ? 1 : 0}" errors="${gate.status === "unknown" ? 1 : 0}" skipped="0">`,
+      `    <testcase classname="share-safe" name="${xml(result.target)}">${body}</testcase>`,
+      "  </testsuite>"
+    ].join("\n")];
+  });
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<testsuites name="traces check">
+${suites.join("\n")}
+</testsuites>
+`;
+}
+function renderVerdictGithub(verdict) {
+  const lines = [];
+  for (const gate of verdict.gates) {
+    if (gate.gate === "contract") {
+      const annotations = renderGithubAnnotations(gate.report);
+      if (annotations) lines.push(annotations);
+    } else if (gate.gate === "conformance") {
+      if (!gate.validation.ok) lines.push(`::error title=${ghProperty("conformance")}::${ghData(`${gate.subject}: not one entry could be read as a span`)}`);
+    } else {
+      const result = gate.verdict;
+      for (const finding of result.findings) {
+        const kind = finding.severity === "error" ? "error" : "warning";
+        lines.push(`::${kind} title=${ghProperty(`share-safe: ${finding.category}/${finding.detector}`)}::${ghData(`${result.target}: x${finding.count} at ${finding.paths.join(", ")}`)}`);
+      }
+      for (const entry of result.unreadable) lines.push(`::error title=${ghProperty("share-safe: unreadable")}::${ghData(entry)}`);
+    }
+  }
+  return lines.join("\n");
+}
+function xml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F]/g, "");
+}
+function ghData(value) {
+  return value.replace(/%/g, "%25").replace(/\r/g, "%0D").replace(/\n/g, "%0A");
+}
+function ghProperty(value) {
+  return ghData(value).replace(/:/g, "%3A").replace(/,/g, "%2C");
+}
+function errorText(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+export {
+  AmbiguousTraceInputError,
+  CHECK_EXIT,
+  CONFORMANCE,
+  CONFORMANCE_EXPLAINED,
+  combineGates,
+  conformanceGate,
+  contractGate,
+  loadContract,
+  renderVerdictGithub,
+  renderVerdictJUnit,
+  renderVerdictText,
+  runCheck,
+  shareSafeGate,
+  writeGateEvidence
+};

package/dist/chunk-2XXABIRL.js

@@ -0,0 +1,25 @@
+import {
+  iterSerializedSpans
+} from "./chunk-CQ6UYZG6.js";
+
+// src/analysis-store.ts
+import { otlpTextToTraceAnalysisStore } from "@tangle-network/agent-eval/traces";
+var DETERMINISTIC_PER_CALL_CEILING = 512 * 1024 * 1024;
+function openAgenticTraceStore(spans) {
+  return otlpTextToTraceAnalysisStore(spans instanceof Uint8Array ? spans : exportBytes(spans));
+}
+function openDeterministicTraceStore(spans) {
+  const bytes = spans instanceof Uint8Array ? spans : exportBytes(spans);
+  return otlpTextToTraceAnalysisStore(bytes, { perCallByteCeiling: DETERMINISTIC_PER_CALL_CEILING });
+}
+function exportBytes(spans) {
+  const lines = [];
+  for (const line of iterSerializedSpans(spans)) lines.push(Buffer.from(line, "utf8"));
+  return Buffer.concat(lines);
+}
+
+export {
+  openAgenticTraceStore,
+  openDeterministicTraceStore,
+  exportBytes
+};

package/dist/chunk-4VKPN432.js

@@ -0,0 +1,138 @@
+// src/verify-safe.ts
+import { lstat, readdir, readFile } from "fs/promises";
+import { basename, extname, join, relative } from "path";
+import {
+  assessShareSafety,
+  classifyKey,
+  combineVerdicts
+} from "@tangle-network/agent-eval/traces";
+var PROFILE = "share";
+var JSON_LINES = /* @__PURE__ */ new Set([".jsonl", ".ndjson"]);
+async function verifySafe(target, options = {}) {
+  const assess = (value) => assessShareSafety(numbersAreNotContent(value), { profile: PROFILE, knownSecrets: options.knownSecrets });
+  const verdicts = [];
+  const unreadable = [];
+  const files = await listFiles(target, unreadable);
+  for (const file of files) {
+    const label = relative(target, file) || basename(file);
+    let bytes;
+    try {
+      bytes = await readFile(file);
+    } catch (error) {
+      unreadable.push(`${label}: ${error instanceof Error ? error.message : String(error)}`);
+      continue;
+    }
+    const text = decodeUtf8(bytes);
+    if (text === void 0) {
+      unreadable.push(`${label}: not UTF-8 text`);
+      continue;
+    }
+    const extension = extname(file).toLowerCase();
+    if (JSON_LINES.has(extension)) {
+      text.split("\n").forEach((line, index) => {
+        if (!line.trim()) return;
+        const parsed = parseJson(line);
+        if (parsed === void 0) unreadable.push(`${label}:${index + 1}: not JSON`);
+        else verdicts.push(located(assess(parsed.value), `${label}:${index + 1}`));
+      });
+    } else if (extension === ".json") {
+      const parsed = parseJson(text);
+      if (parsed === void 0) unreadable.push(`${label}: not JSON`);
+      else verdicts.push(located(assess(parsed.value), label));
+    } else {
+      verdicts.push(located(assess(text), label));
+    }
+  }
+  if (files.length === 0 && unreadable.length === 0) unreadable.push(`${target}: no files to check`);
+  return { ...combineVerdicts(PROFILE, verdicts, unreadable), target, files: files.length };
+}
+function onlyNumbers(value) {
+  if (value === null || typeof value === "number" || typeof value === "boolean") return true;
+  if (Array.isArray(value)) return value.every(onlyNumbers);
+  if (typeof value === "object") return Object.values(value).every(onlyNumbers);
+  return false;
+}
+function noFlaggedKeys(value) {
+  if (Array.isArray(value)) return value.every(noFlaggedKeys);
+  if (value === null || typeof value !== "object") return true;
+  return Object.entries(value).every(([key, item]) => {
+    const category = classifyKey(key);
+    return (category === void 0 || category === "raw-content") && noFlaggedKeys(item);
+  });
+}
+function numbersAreNotContent(value) {
+  if (Array.isArray(value)) return value.map(numbersAreNotContent);
+  if (value === null || typeof value !== "object") return value;
+  const out = {};
+  for (const [key, item] of Object.entries(value)) {
+    out[key] = classifyKey(key) === "raw-content" && item !== null && typeof item === "object" && onlyNumbers(item) && noFlaggedKeys(item) ? 0 : numbersAreNotContent(item);
+  }
+  return out;
+}
+async function listFiles(target, unreadable) {
+  let stat;
+  try {
+    stat = await lstat(target);
+  } catch (error) {
+    unreadable.push(`${target}: ${error instanceof Error ? error.message : String(error)}`);
+    return [];
+  }
+  if (stat.isFile()) return [target];
+  if (!stat.isDirectory()) {
+    unreadable.push(`${target}: not a regular file or directory`);
+    return [];
+  }
+  const out = [];
+  const walk = async (dir) => {
+    for (const entry of (await readdir(dir, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name))) {
+      const path = join(dir, entry.name);
+      if (entry.isDirectory()) await walk(path);
+      else if (entry.isFile()) out.push(path);
+      else unreadable.push(`${relative(target, path)}: not a regular file`);
+    }
+  };
+  await walk(target);
+  return out;
+}
+function decodeUtf8(bytes) {
+  if (bytes.includes(0)) return void 0;
+  try {
+    return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  } catch {
+    return void 0;
+  }
+}
+function parseJson(text) {
+  try {
+    return { value: JSON.parse(text) };
+  } catch {
+    return void 0;
+  }
+}
+function located(verdict, where) {
+  return {
+    ...verdict,
+    findings: verdict.findings.map((finding) => ({
+      ...finding,
+      paths: finding.paths.map((path) => `${where}#${path}`)
+    })),
+    unreadable: verdict.unreadable.map((entry) => `${where}#${entry}`)
+  };
+}
+function formatVerdict(result) {
+  const lines = [`${result.status}  ${result.target} (${result.files} file(s), share profile)`];
+  for (const finding of result.findings) {
+    lines.push(
+      `  ${finding.severity.padEnd(7)} ${finding.category}/${finding.detector} x${finding.count}  ${finding.paths.join(", ")}`
+    );
+  }
+  for (const entry of result.unreadable) lines.push(`  unread  ${entry}`);
+  if (result.status === "UNSAFE") lines.push("Refuse to share: remove what each finding names, then run traces check <path> --share-safe again.");
+  if (result.status === "UNKNOWN") lines.push("Refuse to share: part of the input could not be read, so its safety is unknown.");
+  return lines.join("\n");
+}
+
+export {
+  verifySafe,
+  formatVerdict
+};

package/dist/chunk-6GOG5KIK.js

@@ -0,0 +1,53 @@
+import {
+  ATTR,
+  SESSION_CWD_ATTR,
+  SUBAGENT_SPAWN_TASK_ATTR,
+  SUBAGENT_TASK_ATTR
+} from "./chunk-UQSAGXPH.js";
+import {
+  SOURCE_ATTRIBUTE_PREFIX
+} from "./chunk-DU534HAX.js";
+
+// src/metadata-only.ts
+import { isContentAttribute } from "@tangle-network/agent-eval/diagnosis";
+var PAYLOAD_DERIVED = /^(?:input|output)\.mime_type$|^traces\.(?:input|output)\.(?:bytes|sha256|truncated)$/i;
+var WITHHELD = /* @__PURE__ */ new Set([
+  "tool.args_captured",
+  "cwd",
+  SESSION_CWD_ATTR,
+  ATTR.CWD,
+  ATTR.ENVIRONMENT_CWD,
+  ATTR.SESSION_FILE,
+  ATTR.CORRUPTION_SOURCE_PATH,
+  ATTR.SUBJECT_KEY,
+  ATTR.GIT_REPOSITORY,
+  ATTR.GIT_BRANCH,
+  ATTR.GIT_BRANCH_NAME,
+  SUBAGENT_TASK_ATTR,
+  SUBAGENT_SPAWN_TASK_ATTR
+]);
+function isMetadataAttribute(key, value) {
+  return !(isContentAttribute(key) || PAYLOAD_DERIVED.test(key) || WITHHELD.has(key) || key.startsWith(SOURCE_ATTRIBUTE_PREFIX) || value !== null && typeof value === "object");
+}
+function metadataOnly(spans) {
+  const dropped = /* @__PURE__ */ new Set();
+  const keep = (attributes) => {
+    const kept = {};
+    for (const [key, value] of Object.entries(attributes)) {
+      if (isMetadataAttribute(key, value)) kept[key] = value;
+      else dropped.add(key);
+    }
+    return kept;
+  };
+  const out = spans.map((span) => {
+    if (span.status.message) dropped.add("status.message");
+    const links = span.links?.map((link) => link.attributes ? { ...link, attributes: keep(link.attributes) } : link);
+    return { ...span, attributes: keep(span.attributes), status: { code: span.status.code }, ...links ? { links } : {} };
+  });
+  return { spans: out, dropped: [...dropped].sort() };
+}
+
+export {
+  isMetadataAttribute,
+  metadataOnly
+};