@warlock.js/ai-panoptic 4.3.0 → 4.4.0

package/esm/collector/report-to-span.d.mts

@@ -1,4 +1,5 @@
 import { TraceSpan } from "../contracts/trace.type.mjs";
+import { ContentCaptureOptions } from "./content-capture.type.mjs";
 import { BaseReport } from "@warlock.js/ai";
 
 //#region ../@warlock.js/ai-panoptic/src/collector/report-to-span.d.ts
@@ -17,6 +18,12 @@ import { BaseReport } from "@warlock.js/ai";
  * identity, tool trip index) is routed into the optional `attributes`
  * bag via {@link extractSpanAttributes}.
  *
+ * When {@link ContentCaptureOptions.captureContent} is set, the raw
+ * prompt/response (agents) and args/result (tools) are additionally
+ * copied onto `span.input` / `span.output` — off by default because
+ * payloads are large and often sensitive. A {@link ContentRedactor} can
+ * mask each value first.
+ *
  * No external lookup is needed — a `BaseReport` already carries
  * everything a span requires, so a collector can flatten a tree without
  * consulting any other source.
@@ -25,7 +32,7 @@ import { BaseReport } from "@warlock.js/ai";
  * const root = reportToSpan(result.report);
  * console.log(root.spanId, root.traceId, root.children.length);
  */
-declare function reportToSpan(report: BaseReport): TraceSpan;
+declare function reportToSpan(report: BaseReport, options?: ContentCaptureOptions): TraceSpan;
 //#endregion
 export { reportToSpan };
 //# sourceMappingURL=report-to-span.d.mts.map

package/esm/collector/report-to-span.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"report-to-span.d.mts","names":[],"sources":["../../../../../../../@warlock.js/ai-panoptic/src/collector/report-to-span.ts"],"mappings":";;;;;;AA4BA;;;;;;;;AAA2D;;;;;;;;;;;;;iBAA3C,YAAA,CAAa,MAAA,EAAQ,UAAA,GAAa,SAAS"}
+{"version":3,"file":"report-to-span.d.mts","names":[],"sources":["../../../../../../../@warlock.js/ai-panoptic/src/collector/report-to-span.ts"],"mappings":";;;;;;;AAmCA;;;;;;;;;;;;;;AAA4F;;;;;;;;;;;;;iBAA5E,YAAA,CAAa,MAAA,EAAQ,UAAA,EAAY,OAAA,GAAU,qBAAA,GAAwB,SAAA"}

package/esm/collector/report-to-span.mjs

@@ -17,6 +17,12 @@ import { extractSpanAttributes } from "./extract-span-attributes.mjs";
 * identity, tool trip index) is routed into the optional `attributes`
 * bag via {@link extractSpanAttributes}.
 *
+* When {@link ContentCaptureOptions.captureContent} is set, the raw
+* prompt/response (agents) and args/result (tools) are additionally
+* copied onto `span.input` / `span.output` — off by default because
+* payloads are large and often sensitive. A {@link ContentRedactor} can
+* mask each value first.
+*
 * No external lookup is needed — a `BaseReport` already carries
 * everything a span requires, so a collector can flatten a tree without
 * consulting any other source.
@@ -25,7 +31,7 @@ import { extractSpanAttributes } from "./extract-span-attributes.mjs";
 * const root = reportToSpan(result.report);
 * console.log(root.spanId, root.traceId, root.children.length);
 */
-function reportToSpan(report) {
+function reportToSpan(report, options) {
 	const span = {
 		spanId: report.runId,
 		traceId: report.rootRunId,
@@ -36,7 +42,7 @@ function reportToSpan(report) {
 		endedAt: report.endedAt,
 		duration: report.duration,
 		usage: report.usage,
-		children: report.children.map(reportToSpan)
+		children: report.children.map((child) => reportToSpan(child, options))
 	};
 	if (report.parentRunId !== void 0) span.parentSpanId = report.parentRunId;
 	if (report.sessionId !== void 0) span.sessionId = report.sessionId;
@@ -45,8 +51,66 @@ function reportToSpan(report) {
 	if (error !== void 0) span.error = error;
 	const attributes = extractSpanAttributes(report);
 	if (attributes !== void 0) span.attributes = attributes;
+	if (options?.captureContent) captureContent(span, report, options.redactContent);
 	return span;
 }
+/**
+* Copy the node's raw content onto `span.input` / `span.output`.
+*
+* - Tools carry the call arguments + return value directly on the report
+*   (`ToolCall.input` / `ToolCall.output`).
+* - Agents carry a `trips[]` history; the first trip's `input` is the
+*   real user prompt, and the last NON-EMPTY trip `output` is the final
+*   response text. (A failed / max-trips run can end on a trip whose
+*   `output` is `""` or tool-call-only, so we scan back for the last one
+*   that carried text rather than surfacing an empty string. Intermediate
+*   trips also store a `"[tool results]"` placeholder upstream.)
+*
+* Each value is passed through the optional {@link ContentRedactor};
+* a redactor returning `undefined` drops the field.
+*/
+function captureContent(span, report, redact) {
+	const node = report;
+	let input;
+	let output;
+	if (report.type === "tool") {
+		input = node.input;
+		output = node.output;
+	} else if (Array.isArray(node.trips) && node.trips.length > 0) {
+		input = node.trips[0]?.input;
+		output = lastNonEmptyOutput(node.trips);
+	}
+	if (input !== void 0) {
+		const value = redact ? redact(input, {
+			name: span.name,
+			type: span.type,
+			field: "input"
+		}) : input;
+		if (value !== void 0) span.input = value;
+	}
+	if (output !== void 0) {
+		const value = redact ? redact(output, {
+			name: span.name,
+			type: span.type,
+			field: "output"
+		}) : output;
+		if (value !== void 0) span.output = value;
+	}
+}
+/**
+* The last trip output that actually carries text — the agent's final
+* response on the happy path. A failed or max-trips run can end on a trip
+* whose `output` is `""` or tool-call-only, so we scan backwards for the
+* last trip that produced text rather than blindly taking the final trip
+* (which would surface an empty string). Returns `undefined` when no trip
+* produced any output.
+*/
+function lastNonEmptyOutput(trips) {
+	for (let i = trips.length - 1; i >= 0; i -= 1) {
+		const out = trips[i]?.output;
+		if (typeof out === "string" ? out.length > 0 : out !== void 0) return out;
+	}
+}
 
 //#endregion
 export { reportToSpan };

package/esm/collector/report-to-span.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"report-to-span.mjs","names":[],"sources":["../../../../../../../@warlock.js/ai-panoptic/src/collector/report-to-span.ts"],"sourcesContent":["import type { BaseReport } from \"@warlock.js/ai\";\nimport type { TraceSpan } from \"../contracts/trace.type\";\nimport { extractSpanAttributes } from \"./extract-span-attributes\";\nimport { normalizeError } from \"./normalize-error\";\n\n/**\n * Project one {@link BaseReport} node — and its entire subtree — into a\n * {@link TraceSpan}. Pure and recursive: identity, timing, status, and\n * the rolled-up `usage` map across 1:1 from the report; lineage maps\n * `runId → spanId`, `parentRunId → parentSpanId`, `rootRunId → traceId`;\n * children recurse in invocation order so the span tree mirrors the\n * report tree exactly.\n *\n * The error is normalized to the JSON-safe {@link\n * import(\"../contracts/trace.type\").TraceSpanError} shape only when the\n * node carried one (failed / cancelled). Primitive-specific detail that\n * has no first-class span field (trip / step / iteration counts, model\n * identity, tool trip index) is routed into the optional `attributes`\n * bag via {@link extractSpanAttributes}.\n *\n * No external lookup is needed — a `BaseReport` already carries\n * everything a span requires, so a collector can flatten a tree without\n * consulting any other source.\n *\n * @example\n * const root = reportToSpan(result.report);\n * console.log(root.spanId, root.traceId, root.children.length);\n */\nexport function reportToSpan(report: BaseReport): TraceSpan {\n  const span: TraceSpan = {\n    spanId: report.runId,\n    traceId: report.rootRunId,\n    name: report.name,\n    type: report.type,\n    status: report.status,\n    startedAt: report.startedAt,\n    endedAt: report.endedAt,\n    duration: report.duration,\n    usage: report.usage,\n    children: report.children.map(reportToSpan),\n  };\n\n  if (report.parentRunId !== undefined) {\n    span.parentSpanId = report.parentRunId;\n  }\n\n  if (report.sessionId !== undefined) {\n    span.sessionId = report.sessionId;\n  }\n\n  if (report.version !== undefined) {\n    span.version = report.version;\n  }\n\n  const error = normalizeError((report as { error?: unknown }).error);\n  if (error !== undefined) {\n    span.error = error;\n  }\n\n  const attributes = extractSpanAttributes(report);\n  if (attributes !== undefined) {\n    span.attributes = attributes;\n  }\n\n  return span;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,SAAgB,aAAa,QAA+B;CAC1D,MAAM,OAAkB;EACtB,QAAQ,OAAO;EACf,SAAS,OAAO;EAChB,MAAM,OAAO;EACb,MAAM,OAAO;EACb,QAAQ,OAAO;EACf,WAAW,OAAO;EAClB,SAAS,OAAO;EAChB,UAAU,OAAO;EACjB,OAAO,OAAO;EACd,UAAU,OAAO,SAAS,IAAI,YAAY;CAC5C;CAEA,IAAI,OAAO,gBAAgB,QACzB,KAAK,eAAe,OAAO;CAG7B,IAAI,OAAO,cAAc,QACvB,KAAK,YAAY,OAAO;CAG1B,IAAI,OAAO,YAAY,QACrB,KAAK,UAAU,OAAO;CAGxB,MAAM,QAAQ,eAAgB,OAA+B,KAAK;CAClE,IAAI,UAAU,QACZ,KAAK,QAAQ;CAGf,MAAM,aAAa,sBAAsB,MAAM;CAC/C,IAAI,eAAe,QACjB,KAAK,aAAa;CAGpB,OAAO;AACT"}
+{"version":3,"file":"report-to-span.mjs","names":[],"sources":["../../../../../../../@warlock.js/ai-panoptic/src/collector/report-to-span.ts"],"sourcesContent":["import type { BaseReport } from \"@warlock.js/ai\";\nimport type { TraceSpan } from \"../contracts/trace.type\";\nimport type { ContentCaptureOptions, ContentRedactor } from \"./content-capture.type\";\nimport { extractSpanAttributes } from \"./extract-span-attributes\";\nimport { normalizeError } from \"./normalize-error\";\n\n/**\n * Project one {@link BaseReport} node — and its entire subtree — into a\n * {@link TraceSpan}. Pure and recursive: identity, timing, status, and\n * the rolled-up `usage` map across 1:1 from the report; lineage maps\n * `runId → spanId`, `parentRunId → parentSpanId`, `rootRunId → traceId`;\n * children recurse in invocation order so the span tree mirrors the\n * report tree exactly.\n *\n * The error is normalized to the JSON-safe {@link\n * import(\"../contracts/trace.type\").TraceSpanError} shape only when the\n * node carried one (failed / cancelled). Primitive-specific detail that\n * has no first-class span field (trip / step / iteration counts, model\n * identity, tool trip index) is routed into the optional `attributes`\n * bag via {@link extractSpanAttributes}.\n *\n * When {@link ContentCaptureOptions.captureContent} is set, the raw\n * prompt/response (agents) and args/result (tools) are additionally\n * copied onto `span.input` / `span.output` — off by default because\n * payloads are large and often sensitive. A {@link ContentRedactor} can\n * mask each value first.\n *\n * No external lookup is needed — a `BaseReport` already carries\n * everything a span requires, so a collector can flatten a tree without\n * consulting any other source.\n *\n * @example\n * const root = reportToSpan(result.report);\n * console.log(root.spanId, root.traceId, root.children.length);\n */\nexport function reportToSpan(report: BaseReport, options?: ContentCaptureOptions): TraceSpan {\n  const span: TraceSpan = {\n    spanId: report.runId,\n    traceId: report.rootRunId,\n    name: report.name,\n    type: report.type,\n    status: report.status,\n    startedAt: report.startedAt,\n    endedAt: report.endedAt,\n    duration: report.duration,\n    usage: report.usage,\n    children: report.children.map((child) => reportToSpan(child, options)),\n  };\n\n  if (report.parentRunId !== undefined) {\n    span.parentSpanId = report.parentRunId;\n  }\n\n  if (report.sessionId !== undefined) {\n    span.sessionId = report.sessionId;\n  }\n\n  if (report.version !== undefined) {\n    span.version = report.version;\n  }\n\n  const error = normalizeError((report as { error?: unknown }).error);\n  if (error !== undefined) {\n    span.error = error;\n  }\n\n  const attributes = extractSpanAttributes(report);\n  if (attributes !== undefined) {\n    span.attributes = attributes;\n  }\n\n  if (options?.captureContent) {\n    captureContent(span, report, options.redactContent);\n  }\n\n  return span;\n}\n\n/** Per-primitive content fields read off a widened report node. */\ntype ContentReport = {\n  input?: unknown;\n  output?: unknown;\n  trips?: Array<{ input?: unknown; output?: unknown }>;\n};\n\n/**\n * Copy the node's raw content onto `span.input` / `span.output`.\n *\n * - Tools carry the call arguments + return value directly on the report\n *   (`ToolCall.input` / `ToolCall.output`).\n * - Agents carry a `trips[]` history; the first trip's `input` is the\n *   real user prompt, and the last NON-EMPTY trip `output` is the final\n *   response text. (A failed / max-trips run can end on a trip whose\n *   `output` is `\"\"` or tool-call-only, so we scan back for the last one\n *   that carried text rather than surfacing an empty string. Intermediate\n *   trips also store a `\"[tool results]\"` placeholder upstream.)\n *\n * Each value is passed through the optional {@link ContentRedactor};\n * a redactor returning `undefined` drops the field.\n */\nfunction captureContent(span: TraceSpan, report: BaseReport, redact?: ContentRedactor): void {\n  const node = report as BaseReport & ContentReport;\n\n  let input: unknown;\n  let output: unknown;\n\n  if (report.type === \"tool\") {\n    input = node.input;\n    output = node.output;\n  } else if (Array.isArray(node.trips) && node.trips.length > 0) {\n    input = node.trips[0]?.input;\n    output = lastNonEmptyOutput(node.trips);\n  }\n\n  if (input !== undefined) {\n    const value = redact ? redact(input, { name: span.name, type: span.type, field: \"input\" }) : input;\n    if (value !== undefined) {\n      span.input = value;\n    }\n  }\n\n  if (output !== undefined) {\n    const value = redact ? redact(output, { name: span.name, type: span.type, field: \"output\" }) : output;\n    if (value !== undefined) {\n      span.output = value;\n    }\n  }\n}\n\n/**\n * The last trip output that actually carries text — the agent's final\n * response on the happy path. A failed or max-trips run can end on a trip\n * whose `output` is `\"\"` or tool-call-only, so we scan backwards for the\n * last trip that produced text rather than blindly taking the final trip\n * (which would surface an empty string). Returns `undefined` when no trip\n * produced any output.\n */\nfunction lastNonEmptyOutput(trips: Array<{ output?: unknown }>): unknown {\n  for (let i = trips.length - 1; i >= 0; i -= 1) {\n    const out = trips[i]?.output;\n    const hasText = typeof out === \"string\" ? out.length > 0 : out !== undefined;\n\n    if (hasText) {\n      return out;\n    }\n  }\n\n  return undefined;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCA,SAAgB,aAAa,QAAoB,SAA4C;CAC3F,MAAM,OAAkB;EACtB,QAAQ,OAAO;EACf,SAAS,OAAO;EAChB,MAAM,OAAO;EACb,MAAM,OAAO;EACb,QAAQ,OAAO;EACf,WAAW,OAAO;EAClB,SAAS,OAAO;EAChB,UAAU,OAAO;EACjB,OAAO,OAAO;EACd,UAAU,OAAO,SAAS,KAAK,UAAU,aAAa,OAAO,OAAO,CAAC;CACvE;CAEA,IAAI,OAAO,gBAAgB,QACzB,KAAK,eAAe,OAAO;CAG7B,IAAI,OAAO,cAAc,QACvB,KAAK,YAAY,OAAO;CAG1B,IAAI,OAAO,YAAY,QACrB,KAAK,UAAU,OAAO;CAGxB,MAAM,QAAQ,eAAgB,OAA+B,KAAK;CAClE,IAAI,UAAU,QACZ,KAAK,QAAQ;CAGf,MAAM,aAAa,sBAAsB,MAAM;CAC/C,IAAI,eAAe,QACjB,KAAK,aAAa;CAGpB,IAAI,SAAS,gBACX,eAAe,MAAM,QAAQ,QAAQ,aAAa;CAGpD,OAAO;AACT;;;;;;;;;;;;;;;;AAwBA,SAAS,eAAe,MAAiB,QAAoB,QAAgC;CAC3F,MAAM,OAAO;CAEb,IAAI;CACJ,IAAI;CAEJ,IAAI,OAAO,SAAS,QAAQ;EAC1B,QAAQ,KAAK;EACb,SAAS,KAAK;CAChB,OAAO,IAAI,MAAM,QAAQ,KAAK,KAAK,KAAK,KAAK,MAAM,SAAS,GAAG;EAC7D,QAAQ,KAAK,MAAM,EAAE,EAAE;EACvB,SAAS,mBAAmB,KAAK,KAAK;CACxC;CAEA,IAAI,UAAU,QAAW;EACvB,MAAM,QAAQ,SAAS,OAAO,OAAO;GAAE,MAAM,KAAK;GAAM,MAAM,KAAK;GAAM,OAAO;EAAQ,CAAC,IAAI;EAC7F,IAAI,UAAU,QACZ,KAAK,QAAQ;CAEjB;CAEA,IAAI,WAAW,QAAW;EACxB,MAAM,QAAQ,SAAS,OAAO,QAAQ;GAAE,MAAM,KAAK;GAAM,MAAM,KAAK;GAAM,OAAO;EAAS,CAAC,IAAI;EAC/F,IAAI,UAAU,QACZ,KAAK,SAAS;CAElB;AACF;;;;;;;;;AAUA,SAAS,mBAAmB,OAA6C;CACvE,KAAK,IAAI,IAAI,MAAM,SAAS,GAAG,KAAK,GAAG,KAAK,GAAG;EAC7C,MAAM,MAAM,MAAM,EAAE,EAAE;EAGtB,IAFgB,OAAO,QAAQ,WAAW,IAAI,SAAS,IAAI,QAAQ,QAGjE,OAAO;CAEX;AAGF"}

package/esm/collector/report-to-trace.d.mts

@@ -1,4 +1,5 @@
 import { Trace } from "../contracts/trace.type.mjs";
+import { ContentCaptureOptions } from "./content-capture.type.mjs";
 import { BaseReport } from "@warlock.js/ai";
 
 //#region ../@warlock.js/ai-panoptic/src/collector/report-to-trace.d.ts
@@ -29,7 +30,7 @@ import { BaseReport } from "@warlock.js/ai";
  * const trace = reportToTrace(result.report, result.error);
  * console.log(trace.traceId, trace.usage.total, trace.duration);
  */
-declare function reportToTrace(report: BaseReport, rootError?: unknown): Trace;
+declare function reportToTrace(report: BaseReport, rootError?: unknown, options?: ContentCaptureOptions): Trace;
 //#endregion
 export { reportToTrace };
 //# sourceMappingURL=report-to-trace.d.mts.map

package/esm/collector/report-to-trace.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"report-to-trace.d.mts","names":[],"sources":["../../../../../../../@warlock.js/ai-panoptic/src/collector/report-to-trace.ts"],"mappings":";;;;;;AAgCA;;;;;;;;;AAA6E;;;;;;;;;;;;;;;;iBAA7D,aAAA,CAAc,MAAA,EAAQ,UAAA,EAAY,SAAA,aAAsB,KAAK"}
+{"version":3,"file":"report-to-trace.d.mts","names":[],"sources":["../../../../../../../@warlock.js/ai-panoptic/src/collector/report-to-trace.ts"],"mappings":";;;;;;;AAiCA;;;;;;;;;;;;;;;AAIQ;;;;;;;;;;iBAJQ,aAAA,CACd,MAAA,EAAQ,UAAA,EACR,SAAA,YACA,OAAA,GAAU,qBAAA,GACT,KAAA"}

package/esm/collector/report-to-trace.mjs

@@ -29,8 +29,8 @@ import { reportToSpan } from "./report-to-span.mjs";
 * const trace = reportToTrace(result.report, result.error);
 * console.log(trace.traceId, trace.usage.total, trace.duration);
 */
-function reportToTrace(report, rootError) {
-	const root = reportToSpan(report);
+function reportToTrace(report, rootError, options) {
+	const root = reportToSpan(report, options);
 	if (root.error === void 0) {
 		const error = normalizeError(rootError);
 		if (error !== void 0) root.error = error;

package/esm/collector/report-to-trace.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"report-to-trace.mjs","names":[],"sources":["../../../../../../../@warlock.js/ai-panoptic/src/collector/report-to-trace.ts"],"sourcesContent":["import type { BaseReport } from \"@warlock.js/ai\";\nimport type { Trace } from \"../contracts/trace.type\";\nimport { normalizeError } from \"./normalize-error\";\nimport { reportToSpan } from \"./report-to-span\";\n\n/**\n * Project an outermost {@link BaseReport} (one whole `.execute()` /\n * `.invoke()` run) into a {@link Trace} — the root {@link\n * import(\"../contracts/trace.type\").TraceSpan} plus the trace-wide\n * rollups exporters need without re-walking the tree.\n *\n * The trace-level identity and rollups all read off the root span the\n * projection already built (`traceId`, `usage`, timing), so the trace\n * envelope never disagrees with its own root. `reportSchemaVersion` is\n * mirrored from the root report when present (it is stamped only on\n * root nodes upstream) so exporters can branch on the source shape.\n *\n * Pure — the same input always yields the same trace. The collector\n * exposes this as `toTrace` so callers can inspect the normalized shape\n * without dispatching to exporters.\n *\n * The optional `rootError` threads the failing run's envelope error\n * (`BaseResult.error`) onto the root span. The error lives on the result\n * envelope, never on the `BaseReport` tree, so without this a failed root\n * would export `status` with no error type/message. Applied only when the\n * root span carries none of its own; the subtree projection stays pure\n * (each child surfaces its own report-level error, if any).\n *\n * @example\n * const trace = reportToTrace(result.report, result.error);\n * console.log(trace.traceId, trace.usage.total, trace.duration);\n */\nexport function reportToTrace(report: BaseReport, rootError?: unknown): Trace {\n  const root = reportToSpan(report);\n\n  if (root.error === undefined) {\n    const error = normalizeError(rootError);\n\n    if (error !== undefined) {\n      root.error = error;\n    }\n  }\n\n  const trace: Trace = {\n    traceId: root.traceId,\n    root,\n    startedAt: root.startedAt,\n    endedAt: root.endedAt,\n    duration: root.duration,\n    usage: root.usage,\n  };\n\n  if (root.sessionId !== undefined) {\n    trace.sessionId = root.sessionId;\n  }\n\n  if (report.reportSchemaVersion !== undefined) {\n    trace.reportSchemaVersion = report.reportSchemaVersion;\n  }\n\n  return trace;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,SAAgB,cAAc,QAAoB,WAA4B;CAC5E,MAAM,OAAO,aAAa,MAAM;CAEhC,IAAI,KAAK,UAAU,QAAW;EAC5B,MAAM,QAAQ,eAAe,SAAS;EAEtC,IAAI,UAAU,QACZ,KAAK,QAAQ;CAEjB;CAEA,MAAM,QAAe;EACnB,SAAS,KAAK;EACd;EACA,WAAW,KAAK;EAChB,SAAS,KAAK;EACd,UAAU,KAAK;EACf,OAAO,KAAK;CACd;CAEA,IAAI,KAAK,cAAc,QACrB,MAAM,YAAY,KAAK;CAGzB,IAAI,OAAO,wBAAwB,QACjC,MAAM,sBAAsB,OAAO;CAGrC,OAAO;AACT"}
+{"version":3,"file":"report-to-trace.mjs","names":[],"sources":["../../../../../../../@warlock.js/ai-panoptic/src/collector/report-to-trace.ts"],"sourcesContent":["import type { BaseReport } from \"@warlock.js/ai\";\nimport type { Trace } from \"../contracts/trace.type\";\nimport type { ContentCaptureOptions } from \"./content-capture.type\";\nimport { normalizeError } from \"./normalize-error\";\nimport { reportToSpan } from \"./report-to-span\";\n\n/**\n * Project an outermost {@link BaseReport} (one whole `.execute()` /\n * `.invoke()` run) into a {@link Trace} — the root {@link\n * import(\"../contracts/trace.type\").TraceSpan} plus the trace-wide\n * rollups exporters need without re-walking the tree.\n *\n * The trace-level identity and rollups all read off the root span the\n * projection already built (`traceId`, `usage`, timing), so the trace\n * envelope never disagrees with its own root. `reportSchemaVersion` is\n * mirrored from the root report when present (it is stamped only on\n * root nodes upstream) so exporters can branch on the source shape.\n *\n * Pure — the same input always yields the same trace. The collector\n * exposes this as `toTrace` so callers can inspect the normalized shape\n * without dispatching to exporters.\n *\n * The optional `rootError` threads the failing run's envelope error\n * (`BaseResult.error`) onto the root span. The error lives on the result\n * envelope, never on the `BaseReport` tree, so without this a failed root\n * would export `status` with no error type/message. Applied only when the\n * root span carries none of its own; the subtree projection stays pure\n * (each child surfaces its own report-level error, if any).\n *\n * @example\n * const trace = reportToTrace(result.report, result.error);\n * console.log(trace.traceId, trace.usage.total, trace.duration);\n */\nexport function reportToTrace(\n  report: BaseReport,\n  rootError?: unknown,\n  options?: ContentCaptureOptions,\n): Trace {\n  const root = reportToSpan(report, options);\n\n  if (root.error === undefined) {\n    const error = normalizeError(rootError);\n\n    if (error !== undefined) {\n      root.error = error;\n    }\n  }\n\n  const trace: Trace = {\n    traceId: root.traceId,\n    root,\n    startedAt: root.startedAt,\n    endedAt: root.endedAt,\n    duration: root.duration,\n    usage: root.usage,\n  };\n\n  if (root.sessionId !== undefined) {\n    trace.sessionId = root.sessionId;\n  }\n\n  if (report.reportSchemaVersion !== undefined) {\n    trace.reportSchemaVersion = report.reportSchemaVersion;\n  }\n\n  return trace;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCA,SAAgB,cACd,QACA,WACA,SACO;CACP,MAAM,OAAO,aAAa,QAAQ,OAAO;CAEzC,IAAI,KAAK,UAAU,QAAW;EAC5B,MAAM,QAAQ,eAAe,SAAS;EAEtC,IAAI,UAAU,QACZ,KAAK,QAAQ;CAEjB;CAEA,MAAM,QAAe;EACnB,SAAS,KAAK;EACd;EACA,WAAW,KAAK;EAChB,SAAS,KAAK;EACd,UAAU,KAAK;EACf,OAAO,KAAK;CACd;CAEA,IAAI,KAAK,cAAc,QACrB,MAAM,YAAY,KAAK;CAGzB,IAAI,OAAO,wBAAwB,QACjC,MAAM,sBAAsB,OAAO;CAGrC,OAAO;AACT"}

package/esm/contracts/trace.type.d.mts

@@ -13,7 +13,9 @@ import { ReportStatus, ReportType, Usage } from "@warlock.js/ai";
  * about — identity (`spanId` / `parentSpanId` / `traceId`), timing
  * (`startedAt` / `endedAt` / `duration`), outcome (`status` / `error`),
  * and cost (`usage`) — so a collector can flatten a `BaseReport` tree
- * into spans without consulting any other source.
+ * into spans without consulting any other source. Raw content — prompts,
+ * responses, and tool payloads — is captured onto `input` / `output`
+ * only when the collector opts in via `captureContent` (off by default).
  *
  * @example
  * const root: TraceSpan = {
@@ -75,10 +77,27 @@ type TraceSpan = {
   /**
    * Free-form attribute bag forwarded verbatim onto the backend span
    * (OTel attributes, Langfuse metadata). Collectors populate this with
-   * primitive-specific detail (trip index, step name, tool args digest)
-   * that has no first-class field here. Absent when empty.
+   * primitive-specific metadata (trip / step / iteration counts, model
+   * identity, the tool's originating trip index) that has no first-class
+   * field here. Raw prompts / completions / tool payloads do NOT live
+   * here — they go on {@link TraceSpan.input} / {@link TraceSpan.output}
+   * under content capture. Absent when empty.
    */
   attributes?: Record<string, unknown>;
+  /**
+   * Captured input for this node — an agent's first-trip prompt or a
+   * tool's call arguments — present ONLY when the collector ran with
+   * content capture enabled (`captureContent`), off by default because
+   * payloads are large and often sensitive. Typed `unknown`: agent
+   * prompts are strings, tool args are the validated argument value.
+   */
+  input?: unknown;
+  /**
+   * Captured output for this node — an agent's final response text or a
+   * tool's return value — present only under content capture (see
+   * {@link TraceSpan.input}).
+   */
+  output?: unknown;
   /**
    * Child spans, mirroring `BaseReport.children` in invocation order.
    * Empty for leaf spans (pure tools). Exporters that emit a flat

package/esm/contracts/trace.type.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"trace.type.d.mts","names":[],"sources":["../../../../../../../@warlock.js/ai-panoptic/src/contracts/trace.type.ts"],"mappings":";;;;;AA8BA;;;;;;;;;;;;;;;;;;;;;;;;;;KAAY,SAAA;EAiDF;;;;EA5CR,MAAA;EAyDmB;AAAA;AAQrB;;EA5DE,YAAA;EA4DwB;;;;;AAMnB;EA3DL,OAAA;EAoEe;;;;;EA9Df,SAAA,WAoEM;EAlEN,IAAA;EAsEA;;;;;EAhEA,OAAA,WA0EmB;EAxEnB,IAAA,EAAM,UAAA;EAEN,MAAA,EAAQ,YAAA;EAER,SAAA;EAEA,OAAA;EAEA,QAAA;EAEA,KAAA,EAAO,KAAA;;;;;;EAMP,KAAA,GAAQ,cAAA;;;;;;;EAOR,UAAA,GAAa,MAAA;;;;;;EAMb,QAAA,EAAU,SAAA;AAAA;;;;;;KAQA,cAAA;6EAEV,IAAA;EAEA,OAAA;EAEA,KAAA;AAAA;;;;;;;KASU,KAAA;mEAEV,OAAA;EAEA,SAAA;EAEA,IAAA,EAAM,SAAA;EAEN,SAAA;EAEA,OAAA;EAEA,QAAA;EAEA,KAAA,EAAO,KAAK;;;;;;EAMZ,mBAAA;AAAA"}
+{"version":3,"file":"trace.type.d.mts","names":[],"sources":["../../../../../../../@warlock.js/ai-panoptic/src/contracts/trace.type.ts"],"mappings":";;;;;AAgCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAAY,SAAA;EA2DG;;;;EAtDb,MAAA;EA0EmB;AAAA;AAQrB;;EA7EE,YAAA;EA6EwB;;;;;AAMnB;EA5EL,OAAA;EAqFe;;;;;EA/Ef,SAAA,WAqFM;EAnFN,IAAA;EAuFA;;;;;EAjFA,OAAA,WA2FmB;EAzFnB,IAAA,EAAM,UAAA;EAEN,MAAA,EAAQ,YAAA;EAER,SAAA;EAEA,OAAA;EAEA,QAAA;EAEA,KAAA,EAAO,KAAA;;;;;;EAMP,KAAA,GAAQ,cAAA;;;;;;;;;;EAUR,UAAA,GAAa,MAAA;;;;;;;;EAQb,KAAA;;;;;;EAMA,MAAA;;;;;;EAMA,QAAA,EAAU,SAAA;AAAA;;;;;;KAQA,cAAA;6EAEV,IAAA;EAEA,OAAA;EAEA,KAAA;AAAA;;;;;;;KASU,KAAA;mEAEV,OAAA;EAEA,SAAA;EAEA,IAAA,EAAM,SAAA;EAEN,SAAA;EAEA,OAAA;EAEA,QAAA;EAEA,KAAA,EAAO,KAAK;;;;;;EAMZ,mBAAA;AAAA"}

package/esm/exporters/console/console-exporter.d.mts

@@ -8,9 +8,10 @@ import { ConsoleExporterOptions } from "./console-exporter.type.mjs";
  * as the reference implementation of the contract.
  *
  * By default it prints one summary line per completed trace. Set
- * `tree: true` to print the full indented span tree, and
- * `streaming: true` to also print each span the moment it finalizes
- * (via the optional `exportSpan` hook).
+ * `tree: true` to print the full indented span tree, `io: true` to also
+ * print each span's captured `input` / `output` (needs the collector's
+ * `captureContent`), and `streaming: true` to print each span the moment
+ * it finalizes (via the optional `exportSpan` hook).
  *
  * @example
  * collector.use(consoleExporter());
@@ -18,6 +19,13 @@ import { ConsoleExporterOptions } from "./console-exporter.type.mjs";
  *
  * @example
  * collector.use(consoleExporter({ tree: true }));
+ *
+ * @example
+ * // Full content trace — prompts, responses, and tool I/O:
+ * const observe = panoptic({
+ *   captureContent: true,
+ *   exporters: [consoleExporter({ tree: true, io: true })],
+ * });
  */
 declare function consoleExporter(options?: ConsoleExporterOptions): ExporterContract;
 //#endregion

package/esm/exporters/console/console-exporter.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"console-exporter.d.mts","names":[],"sources":["../../../../../../../../@warlock.js/ai-panoptic/src/exporters/console/console-exporter.ts"],"mappings":";;;;;;;AAwBA;;;;;;;;AAAuF;;;;;;iBAAvE,eAAA,CAAgB,OAAA,GAAS,sBAAA,GAA8B,gBAAgB"}
+{"version":3,"file":"console-exporter.d.mts","names":[],"sources":["../../../../../../../../@warlock.js/ai-panoptic/src/exporters/console/console-exporter.ts"],"mappings":";;;;;;;AAiCA;;;;;;;;AAAuF;;;;;;;;;;;;;;iBAAvE,eAAA,CAAgB,OAAA,GAAS,sBAAA,GAA8B,gBAAgB"}

package/esm/exporters/console/console-exporter.mjs

@@ -1,4 +1,5 @@
 import { walkSpans } from "../utils/walk-spans.mjs";
+import { formatSpanIO } from "./format-span-io.mjs";
 import { formatSpanLine } from "./format-span-line.mjs";
 
 //#region ../@warlock.js/ai-panoptic/src/exporters/console/console-exporter.ts
@@ -9,9 +10,10 @@ const EXPORTER_NAME = "console";
 * as the reference implementation of the contract.
 *
 * By default it prints one summary line per completed trace. Set
-* `tree: true` to print the full indented span tree, and
-* `streaming: true` to also print each span the moment it finalizes
-* (via the optional `exportSpan` hook).
+* `tree: true` to print the full indented span tree, `io: true` to also
+* print each span's captured `input` / `output` (needs the collector's
+* `captureContent`), and `streaming: true` to print each span the moment
+* it finalizes (via the optional `exportSpan` hook).
 *
 * @example
 * collector.use(consoleExporter());
@@ -19,36 +21,52 @@ const EXPORTER_NAME = "console";
 *
 * @example
 * collector.use(consoleExporter({ tree: true }));
+*
+* @example
+* // Full content trace — prompts, responses, and tool I/O:
+* const observe = panoptic({
+*   captureContent: true,
+*   exporters: [consoleExporter({ tree: true, io: true })],
+* });
 */
 function consoleExporter(options = {}) {
 	const sink = options.console ?? console;
 	const tree = options.tree ?? false;
+	const io = options.io ?? false;
+	const ioMaxChars = options.ioMaxChars;
 	const exporter = {
 		name: EXPORTER_NAME,
 		export(trace) {
-			writeTrace(sink, trace, tree);
+			writeTrace(sink, trace, tree, io, ioMaxChars);
 		}
 	};
 	if (options.streaming) exporter.exportSpan = (span) => {
 		sink.log(formatSpanLine(span));
+		if (io) for (const line of formatSpanIO(span, 0, ioMaxChars)) sink.log(line);
 	};
 	return exporter;
 }
 /**
 * Write a completed trace — either a single root summary line or the
-* full indented tree. Failed traces are routed to `console.error` so
-* they surface at the right severity in log aggregators.
+* full indented tree, each span optionally followed by its captured
+* `input` / `output`. Failed / cancelled spans route to `console.error`
+* so they surface at the right severity in log aggregators.
 */
-function writeTrace(sink, trace, tree) {
+function writeTrace(sink, trace, tree, io, ioMaxChars) {
 	if (!tree) {
-		const line = formatSpanLine(trace.root);
-		writeAtSeverity(sink, trace.root.status, line);
+		writeSpan(sink, trace.root, 0, io, ioMaxChars);
 		return;
 	}
-	for (const span of walkSpans(trace.root)) {
-		const line = formatSpanLine(span, spanDepth(trace.root, span.spanId));
-		writeAtSeverity(sink, span.status, line);
-	}
+	for (const span of walkSpans(trace.root)) writeSpan(sink, span, spanDepth(trace.root, span.spanId), io, ioMaxChars);
+}
+/**
+* Write one span's line and — when `io` is on — its captured content,
+* all routed at the span's own severity so a failed span keeps its
+* content beside it in the error stream.
+*/
+function writeSpan(sink, span, depth, io, ioMaxChars) {
+	writeAtSeverity(sink, span.status, formatSpanLine(span, depth));
+	if (io) for (const line of formatSpanIO(span, depth, ioMaxChars)) writeAtSeverity(sink, span.status, line);
 }
 /**
 * Route a line to `error` when the span failed/cancelled, otherwise to

package/esm/exporters/console/console-exporter.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"console-exporter.mjs","names":[],"sources":["../../../../../../../../@warlock.js/ai-panoptic/src/exporters/console/console-exporter.ts"],"sourcesContent":["import type { ExporterContract, Trace, TraceSpan } from \"../../contracts\";\nimport { walkSpans } from \"../utils\";\nimport type { ConsoleExporterOptions, ConsoleLike } from \"./console-exporter.type\";\nimport { formatSpanLine } from \"./format-span-line\";\n\nconst EXPORTER_NAME = \"console\";\n\n/**\n * Zero-dependency {@link ExporterContract} that prints traces to a\n * console-like sink. The simplest exporter — useful in development and\n * as the reference implementation of the contract.\n *\n * By default it prints one summary line per completed trace. Set\n * `tree: true` to print the full indented span tree, and\n * `streaming: true` to also print each span the moment it finalizes\n * (via the optional `exportSpan` hook).\n *\n * @example\n * collector.use(consoleExporter());\n * // ok workflow \"checkout\" — 2103ms, 1820 tok, $0.0094\n *\n * @example\n * collector.use(consoleExporter({ tree: true }));\n */\nexport function consoleExporter(options: ConsoleExporterOptions = {}): ExporterContract {\n  const sink: ConsoleLike = options.console ?? console;\n  const tree = options.tree ?? false;\n\n  const exporter: ExporterContract = {\n    name: EXPORTER_NAME,\n    export(trace: Trace): void {\n      writeTrace(sink, trace, tree);\n    },\n  };\n\n  if (options.streaming) {\n    exporter.exportSpan = (span: TraceSpan): void => {\n      sink.log(formatSpanLine(span));\n    };\n  }\n\n  return exporter;\n}\n\n/**\n * Write a completed trace — either a single root summary line or the\n * full indented tree. Failed traces are routed to `console.error` so\n * they surface at the right severity in log aggregators.\n */\nfunction writeTrace(sink: ConsoleLike, trace: Trace, tree: boolean): void {\n  if (!tree) {\n    const line = formatSpanLine(trace.root);\n    writeAtSeverity(sink, trace.root.status, line);\n    return;\n  }\n\n  for (const span of walkSpans(trace.root)) {\n    const depth = spanDepth(trace.root, span.spanId);\n    const line = formatSpanLine(span, depth);\n    writeAtSeverity(sink, span.status, line);\n  }\n}\n\n/**\n * Route a line to `error` when the span failed/cancelled, otherwise to\n * `log`. Keeps healthy traces out of the error stream.\n */\nfunction writeAtSeverity(sink: ConsoleLike, status: TraceSpan[\"status\"], line: string): void {\n  if (status === \"failed\" || status === \"cancelled\") {\n    sink.error(line);\n    return;\n  }\n\n  sink.log(line);\n}\n\n/**\n * Depth of `targetSpanId` below `root` for indentation. Walks the tree\n * once; returns 0 when the span is the root or not found.\n */\nfunction spanDepth(root: TraceSpan, targetSpanId: string, depth = 0): number {\n  if (root.spanId === targetSpanId) {\n    return depth;\n  }\n\n  for (const child of root.children) {\n    const found = spanDepth(child, targetSpanId, depth + 1);\n\n    if (found > 0) {\n      return found;\n    }\n  }\n\n  return 0;\n}\n"],"mappings":";;;;AAKA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;AAmBtB,SAAgB,gBAAgB,UAAkC,CAAC,GAAqB;CACtF,MAAM,OAAoB,QAAQ,WAAW;CAC7C,MAAM,OAAO,QAAQ,QAAQ;CAE7B,MAAM,WAA6B;EACjC,MAAM;EACN,OAAO,OAAoB;GACzB,WAAW,MAAM,OAAO,IAAI;EAC9B;CACF;CAEA,IAAI,QAAQ,WACV,SAAS,cAAc,SAA0B;EAC/C,KAAK,IAAI,eAAe,IAAI,CAAC;CAC/B;CAGF,OAAO;AACT;;;;;;AAOA,SAAS,WAAW,MAAmB,OAAc,MAAqB;CACxE,IAAI,CAAC,MAAM;EACT,MAAM,OAAO,eAAe,MAAM,IAAI;EACtC,gBAAgB,MAAM,MAAM,KAAK,QAAQ,IAAI;EAC7C;CACF;CAEA,KAAK,MAAM,QAAQ,UAAU,MAAM,IAAI,GAAG;EAExC,MAAM,OAAO,eAAe,MADd,UAAU,MAAM,MAAM,KAAK,MACH,CAAC;EACvC,gBAAgB,MAAM,KAAK,QAAQ,IAAI;CACzC;AACF;;;;;AAMA,SAAS,gBAAgB,MAAmB,QAA6B,MAAoB;CAC3F,IAAI,WAAW,YAAY,WAAW,aAAa;EACjD,KAAK,MAAM,IAAI;EACf;CACF;CAEA,KAAK,IAAI,IAAI;AACf;;;;;AAMA,SAAS,UAAU,MAAiB,cAAsB,QAAQ,GAAW;CAC3E,IAAI,KAAK,WAAW,cAClB,OAAO;CAGT,KAAK,MAAM,SAAS,KAAK,UAAU;EACjC,MAAM,QAAQ,UAAU,OAAO,cAAc,QAAQ,CAAC;EAEtD,IAAI,QAAQ,GACV,OAAO;CAEX;CAEA,OAAO;AACT"}
+{"version":3,"file":"console-exporter.mjs","names":[],"sources":["../../../../../../../../@warlock.js/ai-panoptic/src/exporters/console/console-exporter.ts"],"sourcesContent":["import type { ExporterContract, Trace, TraceSpan } from \"../../contracts\";\nimport { walkSpans } from \"../utils\";\nimport type { ConsoleExporterOptions, ConsoleLike } from \"./console-exporter.type\";\nimport { formatSpanIO } from \"./format-span-io\";\nimport { formatSpanLine } from \"./format-span-line\";\n\nconst EXPORTER_NAME = \"console\";\n\n/**\n * Zero-dependency {@link ExporterContract} that prints traces to a\n * console-like sink. The simplest exporter — useful in development and\n * as the reference implementation of the contract.\n *\n * By default it prints one summary line per completed trace. Set\n * `tree: true` to print the full indented span tree, `io: true` to also\n * print each span's captured `input` / `output` (needs the collector's\n * `captureContent`), and `streaming: true` to print each span the moment\n * it finalizes (via the optional `exportSpan` hook).\n *\n * @example\n * collector.use(consoleExporter());\n * // ok workflow \"checkout\" — 2103ms, 1820 tok, $0.0094\n *\n * @example\n * collector.use(consoleExporter({ tree: true }));\n *\n * @example\n * // Full content trace — prompts, responses, and tool I/O:\n * const observe = panoptic({\n *   captureContent: true,\n *   exporters: [consoleExporter({ tree: true, io: true })],\n * });\n */\nexport function consoleExporter(options: ConsoleExporterOptions = {}): ExporterContract {\n  const sink: ConsoleLike = options.console ?? console;\n  const tree = options.tree ?? false;\n  const io = options.io ?? false;\n  const ioMaxChars = options.ioMaxChars;\n\n  const exporter: ExporterContract = {\n    name: EXPORTER_NAME,\n    export(trace: Trace): void {\n      writeTrace(sink, trace, tree, io, ioMaxChars);\n    },\n  };\n\n  if (options.streaming) {\n    exporter.exportSpan = (span: TraceSpan): void => {\n      sink.log(formatSpanLine(span));\n\n      if (io) {\n        for (const line of formatSpanIO(span, 0, ioMaxChars)) {\n          sink.log(line);\n        }\n      }\n    };\n  }\n\n  return exporter;\n}\n\n/**\n * Write a completed trace — either a single root summary line or the\n * full indented tree, each span optionally followed by its captured\n * `input` / `output`. Failed / cancelled spans route to `console.error`\n * so they surface at the right severity in log aggregators.\n */\nfunction writeTrace(\n  sink: ConsoleLike,\n  trace: Trace,\n  tree: boolean,\n  io: boolean,\n  ioMaxChars: number | undefined,\n): void {\n  if (!tree) {\n    writeSpan(sink, trace.root, 0, io, ioMaxChars);\n    return;\n  }\n\n  for (const span of walkSpans(trace.root)) {\n    const depth = spanDepth(trace.root, span.spanId);\n    writeSpan(sink, span, depth, io, ioMaxChars);\n  }\n}\n\n/**\n * Write one span's line and — when `io` is on — its captured content,\n * all routed at the span's own severity so a failed span keeps its\n * content beside it in the error stream.\n */\nfunction writeSpan(\n  sink: ConsoleLike,\n  span: TraceSpan,\n  depth: number,\n  io: boolean,\n  ioMaxChars: number | undefined,\n): void {\n  writeAtSeverity(sink, span.status, formatSpanLine(span, depth));\n\n  if (io) {\n    for (const line of formatSpanIO(span, depth, ioMaxChars)) {\n      writeAtSeverity(sink, span.status, line);\n    }\n  }\n}\n\n/**\n * Route a line to `error` when the span failed/cancelled, otherwise to\n * `log`. Keeps healthy traces out of the error stream.\n */\nfunction writeAtSeverity(sink: ConsoleLike, status: TraceSpan[\"status\"], line: string): void {\n  if (status === \"failed\" || status === \"cancelled\") {\n    sink.error(line);\n    return;\n  }\n\n  sink.log(line);\n}\n\n/**\n * Depth of `targetSpanId` below `root` for indentation. Walks the tree\n * once; returns 0 when the span is the root or not found.\n */\nfunction spanDepth(root: TraceSpan, targetSpanId: string, depth = 0): number {\n  if (root.spanId === targetSpanId) {\n    return depth;\n  }\n\n  for (const child of root.children) {\n    const found = spanDepth(child, targetSpanId, depth + 1);\n\n    if (found > 0) {\n      return found;\n    }\n  }\n\n  return 0;\n}\n"],"mappings":";;;;;AAMA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BtB,SAAgB,gBAAgB,UAAkC,CAAC,GAAqB;CACtF,MAAM,OAAoB,QAAQ,WAAW;CAC7C,MAAM,OAAO,QAAQ,QAAQ;CAC7B,MAAM,KAAK,QAAQ,MAAM;CACzB,MAAM,aAAa,QAAQ;CAE3B,MAAM,WAA6B;EACjC,MAAM;EACN,OAAO,OAAoB;GACzB,WAAW,MAAM,OAAO,MAAM,IAAI,UAAU;EAC9C;CACF;CAEA,IAAI,QAAQ,WACV,SAAS,cAAc,SAA0B;EAC/C,KAAK,IAAI,eAAe,IAAI,CAAC;EAE7B,IAAI,IACF,KAAK,MAAM,QAAQ,aAAa,MAAM,GAAG,UAAU,GACjD,KAAK,IAAI,IAAI;CAGnB;CAGF,OAAO;AACT;;;;;;;AAQA,SAAS,WACP,MACA,OACA,MACA,IACA,YACM;CACN,IAAI,CAAC,MAAM;EACT,UAAU,MAAM,MAAM,MAAM,GAAG,IAAI,UAAU;EAC7C;CACF;CAEA,KAAK,MAAM,QAAQ,UAAU,MAAM,IAAI,GAErC,UAAU,MAAM,MADF,UAAU,MAAM,MAAM,KAAK,MACf,GAAG,IAAI,UAAU;AAE/C;;;;;;AAOA,SAAS,UACP,MACA,MACA,OACA,IACA,YACM;CACN,gBAAgB,MAAM,KAAK,QAAQ,eAAe,MAAM,KAAK,CAAC;CAE9D,IAAI,IACF,KAAK,MAAM,QAAQ,aAAa,MAAM,OAAO,UAAU,GACrD,gBAAgB,MAAM,KAAK,QAAQ,IAAI;AAG7C;;;;;AAMA,SAAS,gBAAgB,MAAmB,QAA6B,MAAoB;CAC3F,IAAI,WAAW,YAAY,WAAW,aAAa;EACjD,KAAK,MAAM,IAAI;EACf;CACF;CAEA,KAAK,IAAI,IAAI;AACf;;;;;AAMA,SAAS,UAAU,MAAiB,cAAsB,QAAQ,GAAW;CAC3E,IAAI,KAAK,WAAW,cAClB,OAAO;CAGT,KAAK,MAAM,SAAS,KAAK,UAAU;EACjC,MAAM,QAAQ,UAAU,OAAO,cAAc,QAAQ,CAAC;EAEtD,IAAI,QAAQ,GACV,OAAO;CAEX;CAEA,OAAO;AACT"}

package/esm/exporters/console/console-exporter.type.d.mts

@@ -30,6 +30,21 @@ type ConsoleExporterOptions = {
    * present, so leaving this off omits the method entirely.
    */
   streaming?: boolean;
+  /**
+   * Also print each span's captured content — `TraceSpan.input` /
+   * `output` — as extra indented `in:` / `out:` lines beneath the span.
+   * Defaults to `false`. Requires the collector to run with content
+   * capture (`captureContent`); without it spans carry no content and
+   * this is a no-op.
+   */
+  io?: boolean;
+  /**
+   * Max characters of captured content shown per `in:` / `out:` line
+   * before truncation — only when {@link ConsoleExporterOptions.io} is on.
+   * Defaults to `500`. Raise it for fuller payloads, or use the file
+   * exporter for untruncated content.
+   */
+  ioMaxChars?: number;
 };
 //#endregion
 export { ConsoleExporterOptions, ConsoleLike };

package/esm/exporters/console/console-exporter.type.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"console-exporter.type.d.mts","names":[],"sources":["../../../../../../../../@warlock.js/ai-panoptic/src/exporters/console/console-exporter.type.ts"],"mappings":";;AAMA;;;;;KAAY,WAAA;EACV,GAAA,IAAO,IAAA;EACP,KAAA,IAAS,IAAA;AAAA;AAAI;AAMf;;AANe,KAMH,sBAAA;EAKW;;;;EAArB,OAAA,GAAU,WAAW;EAYZ;AAAA;;;;EANT,IAAA;;;;;;EAMA,SAAA;AAAA"}
+{"version":3,"file":"console-exporter.type.d.mts","names":[],"sources":["../../../../../../../../@warlock.js/ai-panoptic/src/exporters/console/console-exporter.type.ts"],"mappings":";;AAMA;;;;;KAAY,WAAA;EACV,GAAA,IAAO,IAAA;EACP,KAAA,IAAS,IAAA;AAAA;AAAI;AAMf;;AANe,KAMH,sBAAA;EAKW;;;;EAArB,OAAA,GAAU,WAAW;EAoBrB;;;AAOU;;EArBV,IAAA;;;;;;EAMA,SAAA;;;;;;;;EAQA,EAAA;;;;;;;EAOA,UAAA;AAAA"}

package/esm/exporters/console/format-span-io.d.mts

@@ -0,0 +1,27 @@
+import { TraceSpan } from "../../contracts/trace.type.mjs";
+//#region ../@warlock.js/ai-panoptic/src/exporters/console/format-span-io.d.ts
+/**
+ * Render a span's captured content ({@link TraceSpan.input} /
+ * {@link TraceSpan.output}) as extra indented console lines, one level
+ * below the span's own line:
+ *
+ * ```text
+ *   ok agent "market-research" — 1794ms, 224 tok, $0.0008
+ *       in:  Research the market for Acme Coffee Roasters …
+ *       out: Demand is steady; specialty buyers skew premium …
+ * ```
+ *
+ * Returns `[]` when the span carries no content — capture disabled, or a
+ * composite node with no own I/O. Each value is stringified (JSON for
+ * non-strings), whitespace-collapsed to stay scannable, and truncated to
+ * `maxChars` (default {@link DEFAULT_IO_MAX_CHARS}) with an ellipsis. Use
+ * the file exporter for the full, untruncated payload.
+ *
+ * @example
+ * formatSpanIO(toolSpan, 1);
+ * // ['    in:  {"query":"specialty coffee demand"}', '    out: {"results":[…]}']
+ */
+declare function formatSpanIO(span: TraceSpan, depth?: number, maxChars?: number): string[];
+//#endregion
+export { formatSpanIO };
+//# sourceMappingURL=format-span-io.d.mts.map

package/esm/exporters/console/format-span-io.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format-span-io.d.mts","names":[],"sources":["../../../../../../../../@warlock.js/ai-panoptic/src/exporters/console/format-span-io.ts"],"mappings":";;;;;AA0BA;;;;;;;;;AAAwF;;;;;;;;;iBAAxE,YAAA,CAAa,IAAA,EAAM,SAAS,EAAE,KAAA,WAAW,QAAA"}

package/esm/exporters/console/format-span-io.mjs

@@ -0,0 +1,52 @@
+//#region ../@warlock.js/ai-panoptic/src/exporters/console/format-span-io.ts
+/** Default cap on how many characters of captured content a console line shows. */
+const DEFAULT_IO_MAX_CHARS = 500;
+/**
+* Render a span's captured content ({@link TraceSpan.input} /
+* {@link TraceSpan.output}) as extra indented console lines, one level
+* below the span's own line:
+*
+* ```text
+*   ok agent "market-research" — 1794ms, 224 tok, $0.0008
+*       in:  Research the market for Acme Coffee Roasters …
+*       out: Demand is steady; specialty buyers skew premium …
+* ```
+*
+* Returns `[]` when the span carries no content — capture disabled, or a
+* composite node with no own I/O. Each value is stringified (JSON for
+* non-strings), whitespace-collapsed to stay scannable, and truncated to
+* `maxChars` (default {@link DEFAULT_IO_MAX_CHARS}) with an ellipsis. Use
+* the file exporter for the full, untruncated payload.
+*
+* @example
+* formatSpanIO(toolSpan, 1);
+* // ['    in:  {"query":"specialty coffee demand"}', '    out: {"results":[…]}']
+*/
+function formatSpanIO(span, depth = 0, maxChars = DEFAULT_IO_MAX_CHARS) {
+	const lines = [];
+	const indent = "  ".repeat(depth + 1);
+	if (span.input !== void 0) lines.push(`${indent}in:  ${preview(span.input, maxChars)}`);
+	if (span.output !== void 0) lines.push(`${indent}out: ${preview(span.output, maxChars)}`);
+	return lines;
+}
+/**
+* One-line, length-capped preview of a captured value. Strings pass
+* through; everything else is JSON-stringified (falling back to
+* `String()` on a circular / unstringifiable value). Internal whitespace
+* is collapsed so the preview never breaks the tree layout.
+*/
+function preview(value, maxChars) {
+	const collapsed = (typeof value === "string" ? value : stringify(value)).replace(/\s+/g, " ").trim();
+	return collapsed.length > maxChars ? `${collapsed.slice(0, maxChars)}…` : collapsed;
+}
+function stringify(value) {
+	try {
+		return JSON.stringify(value) ?? String(value);
+	} catch {
+		return String(value);
+	}
+}
+
+//#endregion
+export { formatSpanIO };
+//# sourceMappingURL=format-span-io.mjs.map

package/esm/exporters/console/format-span-io.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"format-span-io.mjs","names":[],"sources":["../../../../../../../../@warlock.js/ai-panoptic/src/exporters/console/format-span-io.ts"],"sourcesContent":["import type { TraceSpan } from \"../../contracts\";\n\n/** Default cap on how many characters of captured content a console line shows. */\nconst DEFAULT_IO_MAX_CHARS = 500;\n\n/**\n * Render a span's captured content ({@link TraceSpan.input} /\n * {@link TraceSpan.output}) as extra indented console lines, one level\n * below the span's own line:\n *\n * ```text\n *   ok agent \"market-research\" — 1794ms, 224 tok, $0.0008\n *       in:  Research the market for Acme Coffee Roasters …\n *       out: Demand is steady; specialty buyers skew premium …\n * ```\n *\n * Returns `[]` when the span carries no content — capture disabled, or a\n * composite node with no own I/O. Each value is stringified (JSON for\n * non-strings), whitespace-collapsed to stay scannable, and truncated to\n * `maxChars` (default {@link DEFAULT_IO_MAX_CHARS}) with an ellipsis. Use\n * the file exporter for the full, untruncated payload.\n *\n * @example\n * formatSpanIO(toolSpan, 1);\n * // ['    in:  {\"query\":\"specialty coffee demand\"}', '    out: {\"results\":[…]}']\n */\nexport function formatSpanIO(span: TraceSpan, depth = 0, maxChars = DEFAULT_IO_MAX_CHARS): string[] {\n  const lines: string[] = [];\n  const indent = \"  \".repeat(depth + 1);\n\n  if (span.input !== undefined) {\n    lines.push(`${indent}in:  ${preview(span.input, maxChars)}`);\n  }\n\n  if (span.output !== undefined) {\n    lines.push(`${indent}out: ${preview(span.output, maxChars)}`);\n  }\n\n  return lines;\n}\n\n/**\n * One-line, length-capped preview of a captured value. Strings pass\n * through; everything else is JSON-stringified (falling back to\n * `String()` on a circular / unstringifiable value). Internal whitespace\n * is collapsed so the preview never breaks the tree layout.\n */\nfunction preview(value: unknown, maxChars: number): string {\n  const text = typeof value === \"string\" ? value : stringify(value);\n  const collapsed = text.replace(/\\s+/g, \" \").trim();\n\n  return collapsed.length > maxChars ? `${collapsed.slice(0, maxChars)}…` : collapsed;\n}\n\nfunction stringify(value: unknown): string {\n  try {\n    return JSON.stringify(value) ?? String(value);\n  } catch {\n    return String(value);\n  }\n}\n"],"mappings":";;AAGA,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;AAuB7B,SAAgB,aAAa,MAAiB,QAAQ,GAAG,WAAW,sBAAgC;CAClG,MAAM,QAAkB,CAAC;CACzB,MAAM,SAAS,KAAK,OAAO,QAAQ,CAAC;CAEpC,IAAI,KAAK,UAAU,QACjB,MAAM,KAAK,GAAG,OAAO,OAAO,QAAQ,KAAK,OAAO,QAAQ,GAAG;CAG7D,IAAI,KAAK,WAAW,QAClB,MAAM,KAAK,GAAG,OAAO,OAAO,QAAQ,KAAK,QAAQ,QAAQ,GAAG;CAG9D,OAAO;AACT;;;;;;;AAQA,SAAS,QAAQ,OAAgB,UAA0B;CAEzD,MAAM,aADO,OAAO,UAAU,WAAW,QAAQ,UAAU,KAAK,EAC1C,CAAC,QAAQ,QAAQ,GAAG,CAAC,CAAC,KAAK;CAEjD,OAAO,UAAU,SAAS,WAAW,GAAG,UAAU,MAAM,GAAG,QAAQ,EAAE,KAAK;AAC5E;AAEA,SAAS,UAAU,OAAwB;CACzC,IAAI;EACF,OAAO,KAAK,UAAU,KAAK,KAAK,OAAO,KAAK;CAC9C,QAAQ;EACN,OAAO,OAAO,KAAK;CACrB;AACF"}

package/esm/exporters/console/index.d.mts

@@ -1,3 +1,4 @@
 import { ConsoleExporterOptions, ConsoleLike } from "./console-exporter.type.mjs";
 import { consoleExporter } from "./console-exporter.mjs";
-import { formatSpanLine } from "./format-span-line.mjs";
+import { formatSpanLine } from "./format-span-line.mjs";
+import { formatSpanIO } from "./format-span-io.mjs";

package/esm/exporters/index.d.mts

@@ -1,6 +1,7 @@
 import { ConsoleExporterOptions, ConsoleLike } from "./console/console-exporter.type.mjs";
 import { consoleExporter } from "./console/console-exporter.mjs";
 import { formatSpanLine } from "./console/format-span-line.mjs";
+import { formatSpanIO } from "./console/format-span-io.mjs";
 import { FileExporterOptions, TraceRecord } from "./file/file-exporter.type.mjs";
 import { fileExporter } from "./file/file-exporter.mjs";
 import { LangfuseClientLike, LangfuseExporterOptions, LangfuseObservationBody, LangfuseObservationEndBody, LangfuseObservationLevel, LangfuseObservationLike, LangfuseTraceBody, LangfuseTraceLike, LangfuseUsageBody } from "./langfuse/langfuse-exporter.type.mjs";

package/esm/exporters/index.mjs

@@ -1,6 +1,7 @@
 import { walkSpans } from "./utils/walk-spans.mjs";
 import { totalCostUsd } from "./utils/total-cost.mjs";
 import { GEN_AI_ATTRIBUTES, WARLOCK_ATTRIBUTES, toGenAiAttributes } from "./utils/gen-ai-attributes.mjs";
+import { formatSpanIO } from "./console/format-span-io.mjs";
 import { formatSpanLine } from "./console/format-span-line.mjs";
 import { consoleExporter } from "./console/console-exporter.mjs";
 import { fileExporter } from "./file/file-exporter.mjs";

package/esm/exporters/langfuse/langfuse-exporter.d.mts

@@ -9,12 +9,16 @@ import { LangfuseExporterOptions } from "./langfuse-exporter.type.mjs";
  * installed, and a missing SDK surfaces as a curated "install this"
  * error when the exporter first needs to build a client.
  *
- * The root {@link TraceSpan} becomes a Langfuse trace; each descendant
- * becomes a nested observation — a `generation` when it produced tokens
- * (LLM-backed agents, supervisors), otherwise a plain `span` (tools,
- * callbacks). Timing, status, version, and rolled-up `usage` are mapped
- * 1:1; the rest of the GenAI attributes ride along as observation
- * metadata.
+ * The root {@link TraceSpan} becomes a Langfuse trace AND its top
+ * observation (so the root execution's own tokens are metered, not just
+ * its children's); every node is an observation — a `generation` when it
+ * metered its OWN tokens (LLM-backed agents, supervisors), otherwise a
+ * plain `span` (tools, callbacks, and composite nodes whose tokens came
+ * only from children). Timing, status, and version map 1:1; each
+ * generation reports its own token usage (rolled-up minus children) so
+ * the trace total isn't double-counted; non-usage GenAI attributes ride
+ * along as metadata, and captured content (under `captureContent`)
+ * surfaces as native `input` / `output`.
  *
  * @example
  * collector.use(langfuseExporter({ publicKey: "pk-...", secretKey: "sk-..." }));

package/esm/exporters/langfuse/langfuse-exporter.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"langfuse-exporter.d.mts","names":[],"sources":["../../../../../../../../@warlock.js/ai-panoptic/src/exporters/langfuse/langfuse-exporter.ts"],"mappings":";;;;;;;AA+EA;;;;;;;;AAAoF;;;;;;;;iBAApE,gBAAA,CAAiB,OAAA,EAAS,uBAAA,GAA0B,gBAAgB"}
+{"version":3,"file":"langfuse-exporter.d.mts","names":[],"sources":["../../../../../../../../@warlock.js/ai-panoptic/src/exporters/langfuse/langfuse-exporter.ts"],"mappings":";;;;;;;AAoFA;;;;;;;;AAAoF;;;;;;;;;;;;iBAApE,gBAAA,CAAiB,OAAA,EAAS,uBAAA,GAA0B,gBAAgB"}