@warlock.js/ai-panoptic 4.3.0

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

@@ -0,0 +1,142 @@
+import { GEN_AI_ATTRIBUTES, toGenAiAttributes } from "../utils/gen-ai-attributes.mjs";
+
+//#region ../@warlock.js/ai-panoptic/src/exporters/otel/otel-exporter.ts
+const EXPORTER_NAME = "otel";
+const DEFAULT_TRACER_NAME = "@warlock.js/ai-panoptic";
+let OtelApi;
+let isModuleExists = null;
+let loadingPromise;
+const OTEL_INSTALL_INSTRUCTIONS = `
+The Panoptic OpenTelemetry exporter requires the @opentelemetry/api package.
+Install it with:
+
+  npm install @opentelemetry/api
+
+Or with your preferred package manager:
+
+  pnpm add @opentelemetry/api
+  yarn add @opentelemetry/api
+`.trim();
+/**
+* Settle the lazy import of `@opentelemetry/api` once, concurrency-safe.
+* A bare `catch` flips the flag to `false`; the curated install string
+* surfaces at use time so a missing SDK never throws a raw module
+* resolution error.
+*/
+function loadOtel() {
+	if (isModuleExists !== null) return Promise.resolve();
+	if (loadingPromise) return loadingPromise;
+	loadingPromise = (async () => {
+		try {
+			OtelApi = await import("@opentelemetry/api");
+			isModuleExists = true;
+		} catch {
+			isModuleExists = false;
+		}
+	})();
+	return loadingPromise;
+}
+/**
+* {@link ExporterContract} that maps Panoptic traces onto OpenTelemetry
+* spans following the GenAI semantic conventions (`gen_ai.*`
+* attributes). Lazily imports `@opentelemetry/api` so it stays an
+* OPTIONAL peer — importing this module never forces the SDK to be
+* installed, and a missing SDK surfaces as a curated "install this"
+* error on first `export`, not a boot-time stack trace.
+*
+* The exporter emits onto a `Tracer` you supply (or fetches one from the
+* globally registered provider). It never configures the SDK — wiring a
+* `TracerProvider`, processors, and span exporters is the host app's
+* job, exactly as with any other OTel instrumentation.
+*
+* Each {@link TraceSpan} becomes one OTel span with the source span's
+* start/end times and parent relationship reconstructed, so the emitted
+* tree matches the original execution tree.
+*
+* @example
+* // app already set up @opentelemetry/sdk-trace-base + a provider
+* collector.use(otelExporter({ tracerName: "my-app", system: "openai" }));
+*/
+function otelExporter(options = {}) {
+	loadOtel();
+	return {
+		name: EXPORTER_NAME,
+		async export(trace) {
+			await loadOtel();
+			if (!isModuleExists) throw new Error(OTEL_INSTALL_INSTRUCTIONS);
+			emitSpan(resolveTracer(options), trace.root, void 0, options);
+		}
+	};
+}
+/**
+* Resolve the `Tracer` spans are emitted on — the caller-supplied one,
+* or one fetched from the globally registered provider by name.
+*/
+function resolveTracer(options) {
+	if (options.tracer) return options.tracer;
+	return OtelApi.trace.getTracer(options.tracerName ?? DEFAULT_TRACER_NAME, options.tracerVersion);
+}
+/**
+* Recreate one {@link TraceSpan} (and its subtree) as OTel spans. The
+* span is started with the source `startedAt`, parented under
+* `parentContext` so the tree is preserved, annotated with GenAI
+* attributes, given the mapped status, and ended at `endedAt`. Children
+* recurse under this span's context.
+*/
+function emitSpan(tracer, span, parentContext, options) {
+	const startTime = toEpochMillis(span.startedAt);
+	const baseContext = parentContext ?? OtelApi.context.active();
+	const otelSpan = tracer.startSpan(span.name, { startTime }, baseContext);
+	applyAttributes(otelSpan, span, options);
+	applyStatus(otelSpan, span);
+	const childContext = OtelApi.trace.setSpan(baseContext, otelSpan);
+	for (const child of span.children) emitSpan(tracer, child, childContext, options);
+	otelSpan.end(toEpochMillis(span.endedAt));
+}
+/**
+* Set the GenAI + Warlock attributes on the OTel span, defaulting
+* `gen_ai.system` from the exporter options when the span carried none.
+*/
+function applyAttributes(otelSpan, span, options) {
+	const attributes = toGenAiAttributes(span);
+	if (options.system !== void 0 && attributes[GEN_AI_ATTRIBUTES.system] === void 0) attributes[GEN_AI_ATTRIBUTES.system] = options.system;
+	otelSpan.setAttributes(attributes);
+}
+/**
+* Map the Panoptic span status onto the OTel span status, recording the
+* normalized error as an exception event + ERROR status when present.
+*/
+function applyStatus(otelSpan, span) {
+	const codes = OtelApi.SpanStatusCode;
+	if (span.error) otelSpan.recordException({
+		name: span.error.type,
+		message: span.error.message,
+		stack: span.error.stack
+	});
+	if (span.status === "failed" || span.status === "cancelled") {
+		otelSpan.setStatus({
+			code: codes.ERROR,
+			message: span.error?.message
+		});
+		return;
+	}
+	if (span.status === "max-iterations" || span.status === "awaiting-input") {
+		otelSpan.setStatus({
+			code: codes.UNSET,
+			message: span.status === "max-iterations" ? "Run hit the iteration cap without an explicit end" : "Run is awaiting the next input turn"
+		});
+		return;
+	}
+	otelSpan.setStatus({ code: codes.OK });
+}
+/**
+* Convert an ISO-8601 timestamp to epoch milliseconds — the `TimeInput`
+* form OTel's `startSpan` / `Span.end` accept directly.
+*/
+function toEpochMillis(isoTimestamp) {
+	return new Date(isoTimestamp).getTime();
+}
+
+//#endregion
+export { otelExporter };
+//# sourceMappingURL=otel-exporter.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"otel-exporter.mjs","names":[],"sources":["../../../../../../../../@warlock.js/ai-panoptic/src/exporters/otel/otel-exporter.ts"],"sourcesContent":["import type {\n  Context,\n  Span,\n  SpanStatusCode as SpanStatusCodeEnum,\n  Tracer,\n} from \"@opentelemetry/api\";\nimport type { ExporterContract, Trace, TraceSpan } from \"../../contracts\";\nimport { toGenAiAttributes, GEN_AI_ATTRIBUTES } from \"../utils\";\nimport type { OtelExporterOptions } from \"./otel-exporter.type\";\n\nconst EXPORTER_NAME = \"otel\";\nconst DEFAULT_TRACER_NAME = \"@warlock.js/ai-panoptic\";\n\n// ============================================================\n// Lazily-loaded @opentelemetry/api (OPTIONAL peer)\n// ============================================================\n\nlet OtelApi: typeof import(\"@opentelemetry/api\");\nlet isModuleExists: boolean | null = null;\nlet loadingPromise: Promise<void> | undefined;\n\nconst OTEL_INSTALL_INSTRUCTIONS = `\nThe Panoptic OpenTelemetry exporter requires the @opentelemetry/api package.\nInstall it with:\n\n  npm install @opentelemetry/api\n\nOr with your preferred package manager:\n\n  pnpm add @opentelemetry/api\n  yarn add @opentelemetry/api\n`.trim();\n\n/**\n * Settle the lazy import of `@opentelemetry/api` once, concurrency-safe.\n * A bare `catch` flips the flag to `false`; the curated install string\n * surfaces at use time so a missing SDK never throws a raw module\n * resolution error.\n */\nfunction loadOtel(): Promise<void> {\n  if (isModuleExists !== null) {\n    return Promise.resolve();\n  }\n\n  if (loadingPromise) {\n    return loadingPromise;\n  }\n\n  loadingPromise = (async () => {\n    try {\n      OtelApi = await import(\"@opentelemetry/api\");\n      isModuleExists = true;\n    } catch {\n      isModuleExists = false;\n    }\n  })();\n\n  return loadingPromise;\n}\n\n/**\n * {@link ExporterContract} that maps Panoptic traces onto OpenTelemetry\n * spans following the GenAI semantic conventions (`gen_ai.*`\n * attributes). Lazily imports `@opentelemetry/api` so it stays an\n * OPTIONAL peer — importing this module never forces the SDK to be\n * installed, and a missing SDK surfaces as a curated \"install this\"\n * error on first `export`, not a boot-time stack trace.\n *\n * The exporter emits onto a `Tracer` you supply (or fetches one from the\n * globally registered provider). It never configures the SDK — wiring a\n * `TracerProvider`, processors, and span exporters is the host app's\n * job, exactly as with any other OTel instrumentation.\n *\n * Each {@link TraceSpan} becomes one OTel span with the source span's\n * start/end times and parent relationship reconstructed, so the emitted\n * tree matches the original execution tree.\n *\n * @example\n * // app already set up @opentelemetry/sdk-trace-base + a provider\n * collector.use(otelExporter({ tracerName: \"my-app\", system: \"openai\" }));\n */\nexport function otelExporter(options: OtelExporterOptions = {}): ExporterContract {\n  loadOtel();\n\n  return {\n    name: EXPORTER_NAME,\n    async export(trace: Trace): Promise<void> {\n      await loadOtel();\n\n      if (!isModuleExists) {\n        throw new Error(OTEL_INSTALL_INSTRUCTIONS);\n      }\n\n      const tracer = resolveTracer(options);\n      emitSpan(tracer, trace.root, undefined, options);\n    },\n  };\n}\n\n/**\n * Resolve the `Tracer` spans are emitted on — the caller-supplied one,\n * or one fetched from the globally registered provider by name.\n */\nfunction resolveTracer(options: OtelExporterOptions): Tracer {\n  if (options.tracer) {\n    return options.tracer;\n  }\n\n  return OtelApi.trace.getTracer(\n    options.tracerName ?? DEFAULT_TRACER_NAME,\n    options.tracerVersion,\n  );\n}\n\n/**\n * Recreate one {@link TraceSpan} (and its subtree) as OTel spans. The\n * span is started with the source `startedAt`, parented under\n * `parentContext` so the tree is preserved, annotated with GenAI\n * attributes, given the mapped status, and ended at `endedAt`. Children\n * recurse under this span's context.\n */\nfunction emitSpan(\n  tracer: Tracer,\n  span: TraceSpan,\n  parentContext: Context | undefined,\n  options: OtelExporterOptions,\n): void {\n  const startTime = toEpochMillis(span.startedAt);\n  const baseContext = parentContext ?? OtelApi.context.active();\n\n  const otelSpan = tracer.startSpan(span.name, { startTime }, baseContext);\n\n  applyAttributes(otelSpan, span, options);\n  applyStatus(otelSpan, span);\n\n  const childContext = OtelApi.trace.setSpan(baseContext, otelSpan);\n\n  for (const child of span.children) {\n    emitSpan(tracer, child, childContext, options);\n  }\n\n  otelSpan.end(toEpochMillis(span.endedAt));\n}\n\n/**\n * Set the GenAI + Warlock attributes on the OTel span, defaulting\n * `gen_ai.system` from the exporter options when the span carried none.\n */\nfunction applyAttributes(\n  otelSpan: Span,\n  span: TraceSpan,\n  options: OtelExporterOptions,\n): void {\n  const attributes = toGenAiAttributes(span);\n\n  if (options.system !== undefined && attributes[GEN_AI_ATTRIBUTES.system] === undefined) {\n    attributes[GEN_AI_ATTRIBUTES.system] = options.system;\n  }\n\n  otelSpan.setAttributes(attributes);\n}\n\n/**\n * Map the Panoptic span status onto the OTel span status, recording the\n * normalized error as an exception event + ERROR status when present.\n */\nfunction applyStatus(otelSpan: Span, span: TraceSpan): void {\n  const codes: typeof SpanStatusCodeEnum = OtelApi.SpanStatusCode;\n\n  if (span.error) {\n    otelSpan.recordException({\n      name: span.error.type,\n      message: span.error.message,\n      stack: span.error.stack,\n    });\n  }\n\n  if (span.status === \"failed\" || span.status === \"cancelled\") {\n    otelSpan.setStatus({\n      code: codes.ERROR,\n      message: span.error?.message,\n    });\n    return;\n  }\n\n  // A capped / paused run is neither a failure nor a clean success.\n  // Mapping it to OK would let a hit iteration cap read as a healthy\n  // run; leave the OTel status UNSET with a descriptive message so the\n  // outcome is visible without being miscounted as an error.\n  if (span.status === \"max-iterations\" || span.status === \"awaiting-input\") {\n    otelSpan.setStatus({\n      code: codes.UNSET,\n      message:\n        span.status === \"max-iterations\"\n          ? \"Run hit the iteration cap without an explicit end\"\n          : \"Run is awaiting the next input turn\",\n    });\n    return;\n  }\n\n  otelSpan.setStatus({ code: codes.OK });\n}\n\n/**\n * Convert an ISO-8601 timestamp to epoch milliseconds — the `TimeInput`\n * form OTel's `startSpan` / `Span.end` accept directly.\n */\nfunction toEpochMillis(isoTimestamp: string): number {\n  return new Date(isoTimestamp).getTime();\n}\n"],"mappings":";;;AAUA,MAAM,gBAAgB;AACtB,MAAM,sBAAsB;AAM5B,IAAI;AACJ,IAAI,iBAAiC;AACrC,IAAI;AAEJ,MAAM,4BAA4B;;;;;;;;;;EAUhC,KAAK;;;;;;;AAQP,SAAS,WAA0B;CACjC,IAAI,mBAAmB,MACrB,OAAO,QAAQ,QAAQ;CAGzB,IAAI,gBACF,OAAO;CAGT,kBAAkB,YAAY;EAC5B,IAAI;GACF,UAAU,MAAM,OAAO;GACvB,iBAAiB;EACnB,QAAQ;GACN,iBAAiB;EACnB;CACF,EAAC,CAAE;CAEH,OAAO;AACT;;;;;;;;;;;;;;;;;;;;;;AAuBA,SAAgB,aAAa,UAA+B,CAAC,GAAqB;CAChF,SAAS;CAET,OAAO;EACL,MAAM;EACN,MAAM,OAAO,OAA6B;GACxC,MAAM,SAAS;GAEf,IAAI,CAAC,gBACH,MAAM,IAAI,MAAM,yBAAyB;GAI3C,SADe,cAAc,OACf,GAAG,MAAM,MAAM,QAAW,OAAO;EACjD;CACF;AACF;;;;;AAMA,SAAS,cAAc,SAAsC;CAC3D,IAAI,QAAQ,QACV,OAAO,QAAQ;CAGjB,OAAO,QAAQ,MAAM,UACnB,QAAQ,cAAc,qBACtB,QAAQ,aACV;AACF;;;;;;;;AASA,SAAS,SACP,QACA,MACA,eACA,SACM;CACN,MAAM,YAAY,cAAc,KAAK,SAAS;CAC9C,MAAM,cAAc,iBAAiB,QAAQ,QAAQ,OAAO;CAE5D,MAAM,WAAW,OAAO,UAAU,KAAK,MAAM,EAAE,UAAU,GAAG,WAAW;CAEvE,gBAAgB,UAAU,MAAM,OAAO;CACvC,YAAY,UAAU,IAAI;CAE1B,MAAM,eAAe,QAAQ,MAAM,QAAQ,aAAa,QAAQ;CAEhE,KAAK,MAAM,SAAS,KAAK,UACvB,SAAS,QAAQ,OAAO,cAAc,OAAO;CAG/C,SAAS,IAAI,cAAc,KAAK,OAAO,CAAC;AAC1C;;;;;AAMA,SAAS,gBACP,UACA,MACA,SACM;CACN,MAAM,aAAa,kBAAkB,IAAI;CAEzC,IAAI,QAAQ,WAAW,UAAa,WAAW,kBAAkB,YAAY,QAC3E,WAAW,kBAAkB,UAAU,QAAQ;CAGjD,SAAS,cAAc,UAAU;AACnC;;;;;AAMA,SAAS,YAAY,UAAgB,MAAuB;CAC1D,MAAM,QAAmC,QAAQ;CAEjD,IAAI,KAAK,OACP,SAAS,gBAAgB;EACvB,MAAM,KAAK,MAAM;EACjB,SAAS,KAAK,MAAM;EACpB,OAAO,KAAK,MAAM;CACpB,CAAC;CAGH,IAAI,KAAK,WAAW,YAAY,KAAK,WAAW,aAAa;EAC3D,SAAS,UAAU;GACjB,MAAM,MAAM;GACZ,SAAS,KAAK,OAAO;EACvB,CAAC;EACD;CACF;CAMA,IAAI,KAAK,WAAW,oBAAoB,KAAK,WAAW,kBAAkB;EACxE,SAAS,UAAU;GACjB,MAAM,MAAM;GACZ,SACE,KAAK,WAAW,mBACZ,sDACA;EACR,CAAC;EACD;CACF;CAEA,SAAS,UAAU,EAAE,MAAM,MAAM,GAAG,CAAC;AACvC;;;;;AAMA,SAAS,cAAc,cAA8B;CACnD,OAAO,IAAI,KAAK,YAAY,CAAC,CAAC,QAAQ;AACxC"}

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

@@ -0,0 +1,39 @@
+import { Tracer } from "@opentelemetry/api";
+
+//#region ../@warlock.js/ai-panoptic/src/exporters/otel/otel-exporter.type.d.ts
+/**
+ * Options for {@link otelExporter}.
+ *
+ * The exporter never owns a `TracerProvider` — wiring the SDK
+ * (`@opentelemetry/sdk-trace-base`, exporters, processors) is the host
+ * app's job. Pass either a ready {@link Tracer} or a name and let the
+ * exporter fetch one from the globally registered provider via
+ * `trace.getTracer(name)`.
+ */
+type OtelExporterOptions = {
+  /**
+   * A `Tracer` to emit spans on. When omitted, the exporter lazily calls
+   * `trace.getTracer(tracerName, tracerVersion)` against the globally
+   * registered provider, so it works with whatever SDK the app set up.
+   */
+  tracer?: Tracer;
+  /**
+   * Instrumentation-scope name passed to `trace.getTracer` when `tracer`
+   * is not supplied. Defaults to `"@warlock.js/ai-panoptic"`.
+   */
+  tracerName?: string;
+  /**
+   * Instrumentation-scope version passed alongside `tracerName`.
+   * Optional.
+   */
+  tracerVersion?: string;
+  /**
+   * Value of the `gen_ai.system` attribute set on every span when the
+   * span itself didn't carry one (e.g. `"openai"`, `"anthropic"`).
+   * Optional — omitted when neither this nor the span supplies it.
+   */
+  system?: string;
+};
+//#endregion
+export { OtelExporterOptions };
+//# sourceMappingURL=otel-exporter.type.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"otel-exporter.type.d.mts","names":[],"sources":["../../../../../../../../@warlock.js/ai-panoptic/src/exporters/otel/otel-exporter.type.ts"],"mappings":";;;;;AAWA;;;;;;;KAAY,mBAAA;EAsBV;;AAAM;;;EAhBN,MAAA,GAAS,MAAM;;;;;EAKf,UAAA;;;;;EAKA,aAAA;;;;;;EAMA,MAAA;AAAA"}

package/esm/exporters/utils/gen-ai-attributes.d.mts

@@ -0,0 +1,65 @@
+import { TraceSpan } from "../../contracts/trace.type.mjs";
+//#region ../@warlock.js/ai-panoptic/src/exporters/utils/gen-ai-attributes.d.ts
+/**
+ * Subset of the OpenTelemetry GenAI semantic-convention attribute keys
+ * Panoptic emits. Kept as a named constant map (not inline string
+ * literals scattered through the mapper) so the convention names live in
+ * one place and a convention bump is a single edit.
+ *
+ * @see https://opentelemetry.io/docs/specs/semconv/gen-ai/
+ */
+declare const GEN_AI_ATTRIBUTES: {
+  readonly operationName: "gen_ai.operation.name";
+  readonly system: "gen_ai.system";
+  readonly requestModel: "gen_ai.request.model";
+  readonly responseModel: "gen_ai.response.model";
+  readonly usageInputTokens: "gen_ai.usage.input_tokens";
+  readonly usageOutputTokens: "gen_ai.usage.output_tokens";
+  readonly conversationId: "gen_ai.conversation.id";
+};
+/**
+ * Panoptic-specific attribute keys that have no GenAI-convention
+ * equivalent. Namespaced under `warlock.*` so they never collide with a
+ * future `gen_ai.*` key the spec might add.
+ */
+declare const WARLOCK_ATTRIBUTES: {
+  readonly reportType: "warlock.report.type";
+  readonly version: "warlock.version";
+  readonly durationMs: "warlock.duration_ms";
+  readonly totalTokens: "gen_ai.usage.total_tokens";
+  readonly cachedTokens: "gen_ai.usage.cached_tokens";
+  readonly reasoningTokens: "gen_ai.usage.reasoning_tokens";
+  readonly costUsd: "warlock.cost.usd";
+};
+/**
+ * Span attribute values an OpenTelemetry / Langfuse backend accepts.
+ * GenAI attributes are scalars; the framework's free-form
+ * `TraceSpan.attributes` may also carry these.
+ */
+type AttributeValue = string | number | boolean;
+/**
+ * Project a {@link TraceSpan} onto the OpenTelemetry GenAI
+ * semantic-convention attribute set.
+ *
+ * The vendor-neutral {@link TraceSpan} carries identity, timing, status,
+ * and rolled-up `usage` as first-class fields; model identity and other
+ * provider detail live in the free-form `attributes` bag the collector
+ * populated. This mapper folds both into a flat `gen_ai.*` /
+ * `warlock.*` attribute map ready to set on an OTel span or hand to a
+ * Langfuse generation.
+ *
+ * - `gen_ai.operation.name` / `gen_ai.system` / `gen_ai.request.model`
+ *   are forwarded from the span's `attributes` when the collector set
+ *   them; never invented here.
+ * - Token counts come from the span's typed `usage` rollup.
+ * - The free-form `attributes` are merged last so an explicit collector
+ *   value wins over a derived one.
+ *
+ * @example
+ * const attributes = toGenAiAttributes(span);
+ * // { "gen_ai.usage.input_tokens": 150, "gen_ai.usage.output_tokens": 320, ... }
+ */
+declare function toGenAiAttributes(span: TraceSpan): Record<string, AttributeValue>;
+//#endregion
+export { AttributeValue, GEN_AI_ATTRIBUTES, WARLOCK_ATTRIBUTES, toGenAiAttributes };
+//# sourceMappingURL=gen-ai-attributes.d.mts.map

package/esm/exporters/utils/gen-ai-attributes.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gen-ai-attributes.d.mts","names":[],"sources":["../../../../../../../../@warlock.js/ai-panoptic/src/exporters/utils/gen-ai-attributes.ts"],"mappings":";;;;;AAWA;;;;;cAAa,iBAAA;EAAA;;;;;;;;;;;;;cAeA,kBAAA;EAAA;;;;;;;;;;AAea;AAwB1B;;KAxBY,cAAA;;;;;;;;;;;AAwBqE;;;;;;;;;;;;iBAAjE,iBAAA,CAAkB,IAAA,EAAM,SAAA,GAAY,MAAA,SAAe,cAAA"}

package/esm/exporters/utils/gen-ai-attributes.mjs

@@ -0,0 +1,88 @@
+import { totalCostUsd } from "./total-cost.mjs";
+
+//#region ../@warlock.js/ai-panoptic/src/exporters/utils/gen-ai-attributes.ts
+/**
+* Subset of the OpenTelemetry GenAI semantic-convention attribute keys
+* Panoptic emits. Kept as a named constant map (not inline string
+* literals scattered through the mapper) so the convention names live in
+* one place and a convention bump is a single edit.
+*
+* @see https://opentelemetry.io/docs/specs/semconv/gen-ai/
+*/
+const GEN_AI_ATTRIBUTES = {
+	operationName: "gen_ai.operation.name",
+	system: "gen_ai.system",
+	requestModel: "gen_ai.request.model",
+	responseModel: "gen_ai.response.model",
+	usageInputTokens: "gen_ai.usage.input_tokens",
+	usageOutputTokens: "gen_ai.usage.output_tokens",
+	conversationId: "gen_ai.conversation.id"
+};
+/**
+* Panoptic-specific attribute keys that have no GenAI-convention
+* equivalent. Namespaced under `warlock.*` so they never collide with a
+* future `gen_ai.*` key the spec might add.
+*/
+const WARLOCK_ATTRIBUTES = {
+	reportType: "warlock.report.type",
+	version: "warlock.version",
+	durationMs: "warlock.duration_ms",
+	totalTokens: "gen_ai.usage.total_tokens",
+	cachedTokens: "gen_ai.usage.cached_tokens",
+	reasoningTokens: "gen_ai.usage.reasoning_tokens",
+	costUsd: "warlock.cost.usd"
+};
+/**
+* Project a {@link TraceSpan} onto the OpenTelemetry GenAI
+* semantic-convention attribute set.
+*
+* The vendor-neutral {@link TraceSpan} carries identity, timing, status,
+* and rolled-up `usage` as first-class fields; model identity and other
+* provider detail live in the free-form `attributes` bag the collector
+* populated. This mapper folds both into a flat `gen_ai.*` /
+* `warlock.*` attribute map ready to set on an OTel span or hand to a
+* Langfuse generation.
+*
+* - `gen_ai.operation.name` / `gen_ai.system` / `gen_ai.request.model`
+*   are forwarded from the span's `attributes` when the collector set
+*   them; never invented here.
+* - Token counts come from the span's typed `usage` rollup.
+* - The free-form `attributes` are merged last so an explicit collector
+*   value wins over a derived one.
+*
+* @example
+* const attributes = toGenAiAttributes(span);
+* // { "gen_ai.usage.input_tokens": 150, "gen_ai.usage.output_tokens": 320, ... }
+*/
+function toGenAiAttributes(span) {
+	const attributes = {
+		[WARLOCK_ATTRIBUTES.reportType]: span.type,
+		[WARLOCK_ATTRIBUTES.durationMs]: span.duration,
+		[WARLOCK_ATTRIBUTES.totalTokens]: span.usage.total,
+		[GEN_AI_ATTRIBUTES.usageInputTokens]: span.usage.input,
+		[GEN_AI_ATTRIBUTES.usageOutputTokens]: span.usage.output
+	};
+	if (span.version !== void 0) attributes[WARLOCK_ATTRIBUTES.version] = span.version;
+	if (span.sessionId !== void 0) attributes[GEN_AI_ATTRIBUTES.conversationId] = span.sessionId;
+	if (span.usage.cachedTokens !== void 0) attributes[WARLOCK_ATTRIBUTES.cachedTokens] = span.usage.cachedTokens;
+	if (span.usage.reasoningTokens !== void 0) attributes[WARLOCK_ATTRIBUTES.reasoningTokens] = span.usage.reasoningTokens;
+	const cost = totalCostUsd(span.usage);
+	if (cost !== void 0) attributes[WARLOCK_ATTRIBUTES.costUsd] = cost;
+	mergeScalarAttributes(attributes, span.attributes);
+	return attributes;
+}
+/**
+* Copy the scalar entries of a free-form attribute bag onto the target
+* map. Non-scalar values (objects, arrays, functions) are skipped — OTel
+* and Langfuse attribute values must be primitives, and the collector's
+* bag may legitimately hold nested digests that don't belong on a span
+* attribute. Explicit collector values overwrite derived ones.
+*/
+function mergeScalarAttributes(target, source) {
+	if (!source) return;
+	for (const [key, value] of Object.entries(source)) if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") target[key] = value;
+}
+
+//#endregion
+export { GEN_AI_ATTRIBUTES, WARLOCK_ATTRIBUTES, toGenAiAttributes };
+//# sourceMappingURL=gen-ai-attributes.mjs.map

package/esm/exporters/utils/gen-ai-attributes.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"gen-ai-attributes.mjs","names":[],"sources":["../../../../../../../../@warlock.js/ai-panoptic/src/exporters/utils/gen-ai-attributes.ts"],"sourcesContent":["import type { TraceSpan } from \"../../contracts\";\nimport { totalCostUsd } from \"./total-cost\";\n\n/**\n * Subset of the OpenTelemetry GenAI semantic-convention attribute keys\n * Panoptic emits. Kept as a named constant map (not inline string\n * literals scattered through the mapper) so the convention names live in\n * one place and a convention bump is a single edit.\n *\n * @see https://opentelemetry.io/docs/specs/semconv/gen-ai/\n */\nexport const GEN_AI_ATTRIBUTES = {\n  operationName: \"gen_ai.operation.name\",\n  system: \"gen_ai.system\",\n  requestModel: \"gen_ai.request.model\",\n  responseModel: \"gen_ai.response.model\",\n  usageInputTokens: \"gen_ai.usage.input_tokens\",\n  usageOutputTokens: \"gen_ai.usage.output_tokens\",\n  conversationId: \"gen_ai.conversation.id\",\n} as const;\n\n/**\n * Panoptic-specific attribute keys that have no GenAI-convention\n * equivalent. Namespaced under `warlock.*` so they never collide with a\n * future `gen_ai.*` key the spec might add.\n */\nexport const WARLOCK_ATTRIBUTES = {\n  reportType: \"warlock.report.type\",\n  version: \"warlock.version\",\n  durationMs: \"warlock.duration_ms\",\n  totalTokens: \"gen_ai.usage.total_tokens\",\n  cachedTokens: \"gen_ai.usage.cached_tokens\",\n  reasoningTokens: \"gen_ai.usage.reasoning_tokens\",\n  costUsd: \"warlock.cost.usd\",\n} as const;\n\n/**\n * Span attribute values an OpenTelemetry / Langfuse backend accepts.\n * GenAI attributes are scalars; the framework's free-form\n * `TraceSpan.attributes` may also carry these.\n */\nexport type AttributeValue = string | number | boolean;\n\n/**\n * Project a {@link TraceSpan} onto the OpenTelemetry GenAI\n * semantic-convention attribute set.\n *\n * The vendor-neutral {@link TraceSpan} carries identity, timing, status,\n * and rolled-up `usage` as first-class fields; model identity and other\n * provider detail live in the free-form `attributes` bag the collector\n * populated. This mapper folds both into a flat `gen_ai.*` /\n * `warlock.*` attribute map ready to set on an OTel span or hand to a\n * Langfuse generation.\n *\n * - `gen_ai.operation.name` / `gen_ai.system` / `gen_ai.request.model`\n *   are forwarded from the span's `attributes` when the collector set\n *   them; never invented here.\n * - Token counts come from the span's typed `usage` rollup.\n * - The free-form `attributes` are merged last so an explicit collector\n *   value wins over a derived one.\n *\n * @example\n * const attributes = toGenAiAttributes(span);\n * // { \"gen_ai.usage.input_tokens\": 150, \"gen_ai.usage.output_tokens\": 320, ... }\n */\nexport function toGenAiAttributes(span: TraceSpan): Record<string, AttributeValue> {\n  const attributes: Record<string, AttributeValue> = {\n    [WARLOCK_ATTRIBUTES.reportType]: span.type,\n    [WARLOCK_ATTRIBUTES.durationMs]: span.duration,\n    [WARLOCK_ATTRIBUTES.totalTokens]: span.usage.total,\n    [GEN_AI_ATTRIBUTES.usageInputTokens]: span.usage.input,\n    [GEN_AI_ATTRIBUTES.usageOutputTokens]: span.usage.output,\n  };\n\n  if (span.version !== undefined) {\n    attributes[WARLOCK_ATTRIBUTES.version] = span.version;\n  }\n\n  if (span.sessionId !== undefined) {\n    attributes[GEN_AI_ATTRIBUTES.conversationId] = span.sessionId;\n  }\n\n  if (span.usage.cachedTokens !== undefined) {\n    attributes[WARLOCK_ATTRIBUTES.cachedTokens] = span.usage.cachedTokens;\n  }\n\n  if (span.usage.reasoningTokens !== undefined) {\n    attributes[WARLOCK_ATTRIBUTES.reasoningTokens] = span.usage.reasoningTokens;\n  }\n\n  const cost = totalCostUsd(span.usage);\n\n  if (cost !== undefined) {\n    attributes[WARLOCK_ATTRIBUTES.costUsd] = cost;\n  }\n\n  mergeScalarAttributes(attributes, span.attributes);\n\n  return attributes;\n}\n\n/**\n * Copy the scalar entries of a free-form attribute bag onto the target\n * map. Non-scalar values (objects, arrays, functions) are skipped — OTel\n * and Langfuse attribute values must be primitives, and the collector's\n * bag may legitimately hold nested digests that don't belong on a span\n * attribute. Explicit collector values overwrite derived ones.\n */\nfunction mergeScalarAttributes(\n  target: Record<string, AttributeValue>,\n  source: Record<string, unknown> | undefined,\n): void {\n  if (!source) {\n    return;\n  }\n\n  for (const [key, value] of Object.entries(source)) {\n    if (typeof value === \"string\" || typeof value === \"number\" || typeof value === \"boolean\") {\n      target[key] = value;\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;AAWA,MAAa,oBAAoB;CAC/B,eAAe;CACf,QAAQ;CACR,cAAc;CACd,eAAe;CACf,kBAAkB;CAClB,mBAAmB;CACnB,gBAAgB;AAClB;;;;;;AAOA,MAAa,qBAAqB;CAChC,YAAY;CACZ,SAAS;CACT,YAAY;CACZ,aAAa;CACb,cAAc;CACd,iBAAiB;CACjB,SAAS;AACX;;;;;;;;;;;;;;;;;;;;;;;AA+BA,SAAgB,kBAAkB,MAAiD;CACjF,MAAM,aAA6C;GAChD,mBAAmB,aAAa,KAAK;GACrC,mBAAmB,aAAa,KAAK;GACrC,mBAAmB,cAAc,KAAK,MAAM;GAC5C,kBAAkB,mBAAmB,KAAK,MAAM;GAChD,kBAAkB,oBAAoB,KAAK,MAAM;CACpD;CAEA,IAAI,KAAK,YAAY,QACnB,WAAW,mBAAmB,WAAW,KAAK;CAGhD,IAAI,KAAK,cAAc,QACrB,WAAW,kBAAkB,kBAAkB,KAAK;CAGtD,IAAI,KAAK,MAAM,iBAAiB,QAC9B,WAAW,mBAAmB,gBAAgB,KAAK,MAAM;CAG3D,IAAI,KAAK,MAAM,oBAAoB,QACjC,WAAW,mBAAmB,mBAAmB,KAAK,MAAM;CAG9D,MAAM,OAAO,aAAa,KAAK,KAAK;CAEpC,IAAI,SAAS,QACX,WAAW,mBAAmB,WAAW;CAG3C,sBAAsB,YAAY,KAAK,UAAU;CAEjD,OAAO;AACT;;;;;;;;AASA,SAAS,sBACP,QACA,QACM;CACN,IAAI,CAAC,QACH;CAGF,KAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,MAAM,GAC9C,IAAI,OAAO,UAAU,YAAY,OAAO,UAAU,YAAY,OAAO,UAAU,WAC7E,OAAO,OAAO;AAGpB"}

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

@@ -0,0 +1,3 @@
+import { AttributeValue, GEN_AI_ATTRIBUTES, WARLOCK_ATTRIBUTES, toGenAiAttributes } from "./gen-ai-attributes.mjs";
+import { totalCostUsd } from "./total-cost.mjs";
+import { walkSpans } from "./walk-spans.mjs";

package/esm/exporters/utils/total-cost.d.mts

@@ -0,0 +1,20 @@
+import { Usage } from "@warlock.js/ai";
+
+//#region ../@warlock.js/ai-panoptic/src/exporters/utils/total-cost.d.ts
+/**
+ * Collapse a {@link Usage.cost} breakdown into a single USD scalar by
+ * summing every populated field. Mirrors the formula documented on
+ * `Usage.cost` (input + output + cachedInput + cachedOutput), and also
+ * folds in `reasoning` for forward-safety when a provider prices
+ * reasoning tokens as a separate channel. Returns `undefined` when no
+ * pricing was attached, so exporters can omit the cost attribute
+ * entirely rather than reporting a misleading `0`.
+ *
+ * @example
+ * totalCostUsd({ input: 1, output: 2, total: 3, cost: { input: 0.01, output: 0.04 } });
+ * // => 0.05
+ */
+declare function totalCostUsd(usage: Usage): number | undefined;
+//#endregion
+export { totalCostUsd };
+//# sourceMappingURL=total-cost.d.mts.map

package/esm/exporters/utils/total-cost.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"total-cost.d.mts","names":[],"sources":["../../../../../../../../@warlock.js/ai-panoptic/src/exporters/utils/total-cost.ts"],"mappings":";;;;;AAeA;;;;AAAyC;;;;;;;iBAAzB,YAAA,CAAa,KAAY,EAAL,KAAK"}

package/esm/exporters/utils/total-cost.mjs

@@ -0,0 +1,23 @@
+//#region ../@warlock.js/ai-panoptic/src/exporters/utils/total-cost.ts
+/**
+* Collapse a {@link Usage.cost} breakdown into a single USD scalar by
+* summing every populated field. Mirrors the formula documented on
+* `Usage.cost` (input + output + cachedInput + cachedOutput), and also
+* folds in `reasoning` for forward-safety when a provider prices
+* reasoning tokens as a separate channel. Returns `undefined` when no
+* pricing was attached, so exporters can omit the cost attribute
+* entirely rather than reporting a misleading `0`.
+*
+* @example
+* totalCostUsd({ input: 1, output: 2, total: 3, cost: { input: 0.01, output: 0.04 } });
+* // => 0.05
+*/
+function totalCostUsd(usage) {
+	const cost = usage.cost;
+	if (!cost) return;
+	return (cost.input ?? 0) + (cost.output ?? 0) + (cost.cachedInput ?? 0) + (cost.cachedOutput ?? 0) + (cost.reasoning ?? 0);
+}
+
+//#endregion
+export { totalCostUsd };
+//# sourceMappingURL=total-cost.mjs.map

package/esm/exporters/utils/total-cost.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"total-cost.mjs","names":[],"sources":["../../../../../../../../@warlock.js/ai-panoptic/src/exporters/utils/total-cost.ts"],"sourcesContent":["import type { Usage } from \"@warlock.js/ai\";\n\n/**\n * Collapse a {@link Usage.cost} breakdown into a single USD scalar by\n * summing every populated field. Mirrors the formula documented on\n * `Usage.cost` (input + output + cachedInput + cachedOutput), and also\n * folds in `reasoning` for forward-safety when a provider prices\n * reasoning tokens as a separate channel. Returns `undefined` when no\n * pricing was attached, so exporters can omit the cost attribute\n * entirely rather than reporting a misleading `0`.\n *\n * @example\n * totalCostUsd({ input: 1, output: 2, total: 3, cost: { input: 0.01, output: 0.04 } });\n * // => 0.05\n */\nexport function totalCostUsd(usage: Usage): number | undefined {\n  const cost = usage.cost;\n\n  if (!cost) {\n    return undefined;\n  }\n\n  return (\n    (cost.input ?? 0) +\n    (cost.output ?? 0) +\n    (cost.cachedInput ?? 0) +\n    (cost.cachedOutput ?? 0) +\n    (cost.reasoning ?? 0)\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;AAeA,SAAgB,aAAa,OAAkC;CAC7D,MAAM,OAAO,MAAM;CAEnB,IAAI,CAAC,MACH;CAGF,QACG,KAAK,SAAS,MACd,KAAK,UAAU,MACf,KAAK,eAAe,MACpB,KAAK,gBAAgB,MACrB,KAAK,aAAa;AAEvB"}

package/esm/exporters/utils/walk-spans.d.mts

@@ -0,0 +1,18 @@
+import { TraceSpan } from "../../contracts/trace.type.mjs";
+//#region ../@warlock.js/ai-panoptic/src/exporters/utils/walk-spans.d.ts
+/**
+ * Depth-first pre-order traversal of a {@link TraceSpan} tree, yielding
+ * the root first and then each descendant in `children` (invocation)
+ * order. Exporters that emit a flat span stream — OpenTelemetry, the
+ * console table — walk the tree once with this instead of re-writing the
+ * recursion in every exporter.
+ *
+ * @example
+ * for (const span of walkSpans(trace.root)) {
+ *   emit(span);
+ * }
+ */
+declare function walkSpans(root: TraceSpan): Generator<TraceSpan>;
+//#endregion
+export { walkSpans };
+//# sourceMappingURL=walk-spans.d.mts.map

package/esm/exporters/utils/walk-spans.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"walk-spans.d.mts","names":[],"sources":["../../../../../../../../@warlock.js/ai-panoptic/src/exporters/utils/walk-spans.ts"],"mappings":";;;;;AAcA;;;;;;;;;iBAAiB,SAAA,CAAU,IAAA,EAAM,SAAA,GAAY,SAAA,CAAU,SAAA"}

package/esm/exporters/utils/walk-spans.mjs

@@ -0,0 +1,21 @@
+//#region ../@warlock.js/ai-panoptic/src/exporters/utils/walk-spans.ts
+/**
+* Depth-first pre-order traversal of a {@link TraceSpan} tree, yielding
+* the root first and then each descendant in `children` (invocation)
+* order. Exporters that emit a flat span stream — OpenTelemetry, the
+* console table — walk the tree once with this instead of re-writing the
+* recursion in every exporter.
+*
+* @example
+* for (const span of walkSpans(trace.root)) {
+*   emit(span);
+* }
+*/
+function* walkSpans(root) {
+	yield root;
+	for (const child of root.children) yield* walkSpans(child);
+}
+
+//#endregion
+export { walkSpans };
+//# sourceMappingURL=walk-spans.mjs.map

package/esm/exporters/utils/walk-spans.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"walk-spans.mjs","names":[],"sources":["../../../../../../../../@warlock.js/ai-panoptic/src/exporters/utils/walk-spans.ts"],"sourcesContent":["import type { TraceSpan } from \"../../contracts\";\n\n/**\n * Depth-first pre-order traversal of a {@link TraceSpan} tree, yielding\n * the root first and then each descendant in `children` (invocation)\n * order. Exporters that emit a flat span stream — OpenTelemetry, the\n * console table — walk the tree once with this instead of re-writing the\n * recursion in every exporter.\n *\n * @example\n * for (const span of walkSpans(trace.root)) {\n *   emit(span);\n * }\n */\nexport function* walkSpans(root: TraceSpan): Generator<TraceSpan> {\n  yield root;\n\n  for (const child of root.children) {\n    yield* walkSpans(child);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;AAcA,UAAiB,UAAU,MAAuC;CAChE,MAAM;CAEN,KAAK,MAAM,SAAS,KAAK,UACvB,OAAO,UAAU,KAAK;AAE1B"}

package/esm/index.d.mts

@@ -0,0 +1,31 @@
+import { Trace, TraceSpan, TraceSpanError } from "./contracts/trace.type.mjs";
+import { ExporterContract } from "./contracts/exporter.contract.mjs";
+import { CollectorContract } from "./contracts/collector.contract.mjs";
+import { createCollector } from "./collector/collector.mjs";
+import { reportToTrace } from "./collector/report-to-trace.mjs";
+import { reportToSpan } from "./collector/report-to-span.mjs";
+import { extractSpanAttributes } from "./collector/extract-span-attributes.mjs";
+import { normalizeError } from "./collector/normalize-error.mjs";
+import { TraceAggregate } from "./store/trace-aggregate.type.mjs";
+import { TraceQuery } from "./store/trace-query.type.mjs";
+import { TraceStoreContract } from "./store/trace-store.contract.mjs";
+import { InMemoryTraceStoreOptions, createInMemoryTraceStore } from "./store/in-memory-trace-store.mjs";
+import { matchTrace } from "./store/match-trace.mjs";
+import { emptyUsage, sumUsage } from "./store/sum-usage.mjs";
+import { ConsoleExporterOptions, ConsoleLike } from "./exporters/console/console-exporter.type.mjs";
+import { consoleExporter } from "./exporters/console/console-exporter.mjs";
+import { formatSpanLine } from "./exporters/console/format-span-line.mjs";
+import { FileExporterOptions, TraceRecord } from "./exporters/file/file-exporter.type.mjs";
+import { fileExporter } from "./exporters/file/file-exporter.mjs";
+import { LangfuseClientLike, LangfuseExporterOptions, LangfuseObservationBody, LangfuseObservationEndBody, LangfuseObservationLevel, LangfuseObservationLike, LangfuseTraceBody, LangfuseTraceLike, LangfuseUsageBody } from "./exporters/langfuse/langfuse-exporter.type.mjs";
+import { langfuseExporter } from "./exporters/langfuse/langfuse-exporter.mjs";
+import { OtelExporterOptions } from "./exporters/otel/otel-exporter.type.mjs";
+import { otelExporter } from "./exporters/otel/otel-exporter.mjs";
+import { AttributeValue, GEN_AI_ATTRIBUTES, WARLOCK_ATTRIBUTES, toGenAiAttributes } from "./exporters/utils/gen-ai-attributes.mjs";
+import { totalCostUsd } from "./exporters/utils/total-cost.mjs";
+import { walkSpans } from "./exporters/utils/walk-spans.mjs";
+import { CompletedEventPayload, PanopticTarget } from "./panoptic/panoptic-target.type.mjs";
+import { Panoptic, PanopticOptions } from "./panoptic/panoptic.type.mjs";
+import { panoptic } from "./panoptic/panoptic.mjs";
+import { createPanopticMiddleware } from "./panoptic/panoptic-middleware.mjs";
+export { type AttributeValue, type CollectorContract, type CompletedEventPayload, type ConsoleExporterOptions, type ConsoleLike, type ExporterContract, type FileExporterOptions, GEN_AI_ATTRIBUTES, type InMemoryTraceStoreOptions, type LangfuseClientLike, type LangfuseExporterOptions, type LangfuseObservationBody, type LangfuseObservationEndBody, type LangfuseObservationLevel, type LangfuseObservationLike, type LangfuseTraceBody, type LangfuseTraceLike, type LangfuseUsageBody, type OtelExporterOptions, type Panoptic, type PanopticOptions, type PanopticTarget, type Trace, type TraceAggregate, type TraceQuery, type TraceRecord, type TraceSpan, type TraceSpanError, type TraceStoreContract, WARLOCK_ATTRIBUTES, consoleExporter, createCollector, createInMemoryTraceStore, createPanopticMiddleware, emptyUsage, extractSpanAttributes, fileExporter, formatSpanLine, langfuseExporter, matchTrace, normalizeError, otelExporter, panoptic, reportToSpan, reportToTrace, sumUsage, toGenAiAttributes, totalCostUsd, walkSpans };

package/esm/index.mjs

@@ -0,0 +1,22 @@
+import { walkSpans } from "./exporters/utils/walk-spans.mjs";
+import { normalizeError } from "./collector/normalize-error.mjs";
+import { extractSpanAttributes } from "./collector/extract-span-attributes.mjs";
+import { reportToSpan } from "./collector/report-to-span.mjs";
+import { reportToTrace } from "./collector/report-to-trace.mjs";
+import { createCollector } from "./collector/collector.mjs";
+import { matchTrace } from "./store/match-trace.mjs";
+import { emptyUsage, sumUsage } from "./store/sum-usage.mjs";
+import { createInMemoryTraceStore } from "./store/in-memory-trace-store.mjs";
+import "./store/index.mjs";
+import { totalCostUsd } from "./exporters/utils/total-cost.mjs";
+import { GEN_AI_ATTRIBUTES, WARLOCK_ATTRIBUTES, toGenAiAttributes } from "./exporters/utils/gen-ai-attributes.mjs";
+import { formatSpanLine } from "./exporters/console/format-span-line.mjs";
+import { consoleExporter } from "./exporters/console/console-exporter.mjs";
+import { fileExporter } from "./exporters/file/file-exporter.mjs";
+import { langfuseExporter } from "./exporters/langfuse/langfuse-exporter.mjs";
+import { otelExporter } from "./exporters/otel/otel-exporter.mjs";
+import "./exporters/index.mjs";
+import { createPanopticMiddleware } from "./panoptic/panoptic-middleware.mjs";
+import { panoptic } from "./panoptic/panoptic.mjs";
+
+export { GEN_AI_ATTRIBUTES, WARLOCK_ATTRIBUTES, consoleExporter, createCollector, createInMemoryTraceStore, createPanopticMiddleware, emptyUsage, extractSpanAttributes, fileExporter, formatSpanLine, langfuseExporter, matchTrace, normalizeError, otelExporter, panoptic, reportToSpan, reportToTrace, sumUsage, toGenAiAttributes, totalCostUsd, walkSpans };

package/esm/panoptic/index.d.mts

@@ -0,0 +1,4 @@
+import { CompletedEventPayload, PanopticTarget } from "./panoptic-target.type.mjs";
+import { Panoptic, PanopticOptions } from "./panoptic.type.mjs";
+import { panoptic } from "./panoptic.mjs";
+import { createPanopticMiddleware } from "./panoptic-middleware.mjs";

package/esm/panoptic/panoptic-middleware.d.mts

@@ -0,0 +1,38 @@
+import { CollectorContract } from "../contracts/collector.contract.mjs";
+import { AgentMiddleware } from "@warlock.js/ai";
+
+//#region ../@warlock.js/ai-panoptic/src/panoptic/panoptic-middleware.d.ts
+/**
+ * Build an {@link AgentMiddleware} that feeds a collector from the
+ * `execute`- and `supervisor`-level hooks. An alternative wiring to event
+ * subscription for apps that already compose cross-cutting concerns
+ * through the agent middleware pipeline (`[cache, budget, guardrail,
+ * observability]`). Declaring both hook maps lets a single middleware
+ * object work uniformly on agents (which fire the `execute` map) and
+ * supervisors (which fire the `supervisor` map) — registering it on a
+ * supervisor would otherwise install and collect nothing silently.
+ *
+ * Both terminal paths are covered on each surface:
+ * - `after` — fires on a run that produced a result. A run can complete
+ *   with `result.error` populated (the engine still calls `after`), so
+ *   the report AND the envelope error are collected; the error type and
+ *   message land on the root span.
+ * - `onError` — fires when the run threw before assembling a result. The
+ *   error carries the partial result's report on its envelope; when
+ *   present it is collected, with the error itself threaded onto the
+ *   root span so failed runs still produce a trace.
+ *
+ * The hooks never return a value, so they never mutate the agent's /
+ * supervisor's result. The `collect` call is fire-and-forget relative to
+ * the run — the collector isolates exporter failures internally, and we
+ * additionally swallow any rejection here so an observability fault can
+ * never surface on the run's hot path.
+ *
+ * @param collector - the collector traces are fed into.
+ * @param name - stable middleware name (kebab-case). Defaults to
+ *   `"panoptic"`.
+ */
+declare function createPanopticMiddleware(collector: CollectorContract, name?: string): AgentMiddleware;
+//#endregion
+export { createPanopticMiddleware };
+//# sourceMappingURL=panoptic-middleware.d.mts.map

package/esm/panoptic/panoptic-middleware.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"panoptic-middleware.d.mts","names":[],"sources":["../../../../../../../@warlock.js/ai-panoptic/src/panoptic/panoptic-middleware.ts"],"mappings":";;;;;;AAiCA;;;;;;;;;AAGkB;;;;;;;;;;;;;;;;;;;iBAHF,wBAAA,CACd,SAAA,EAAW,iBAAA,EACX,IAAA,YACC,eAAe"}