@warlock.js/ai-panoptic 5.31.0 → 5.33.0

package/CHANGELOG.md

@@ -4,6 +4,24 @@ All notable changes to `@warlock.js/ai-panoptic` are documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/). `@warlock.js/*` packages are released in lockstep — every package shares the same version number, so a version below may list only the changes that affected this package.
 
+## 5.33.0 - 2026-10-19
+
+### Added
+
+- `subscribeTraces(listener)` and `TraceListener` for process-local adapters observing finalized traces from every built-in collector before exporter dispatch, with isolated listener failures and independent teardown.
+- Optional `Trace.requestId` and exact `TraceQuery.requestId` filters for both in-memory and cache-backed query/aggregate APIs.
+- Content-free retry-attempt timings, provider cache-hit and truncated-trip counts, agent compaction decisions and provider compaction-block counts on trace attributes, surfaced by the devtools AI panel.
+
+## 5.32.0 - 2026-10-18
+
+### Changed
+
+- Pin the package development compiler to TypeScript 7.0.2 and use explicit Node types and source roots with supported module resolution.
+
+### Fixed
+
+- Use the canonical usage rollup for trace aggregates, retaining hosted-tool counters and historical request fees alongside cache lifetime and mixed-provider cache semantics.
+
 ## 5.31.0 - 2026-10-18
 
 ### Fixed

package/cjs/index.cjs

@@ -99,7 +99,16 @@ function pickString(value) {
 function extractSpanAttributes(report) {
 	const extensions = report;
 	const attributes = {};
-	if (report.attempts !== void 0 && report.attempts.length > 0) attributes["retries"] = report.attempts.length;
+	if (report.attempts !== void 0 && report.attempts.length > 0) {
+		attributes["retries"] = report.attempts.length;
+		attributes["retry.attempts"] = report.attempts.map((attempt) => ({
+			index: attempt.index,
+			startedAt: attempt.startedAt,
+			endedAt: attempt.endedAt,
+			duration: attempt.duration,
+			status: attempt.status
+		}));
+	}
 	switch (report.type) {
 		case "agent":
 			addAgentAttributes(attributes, extensions);
@@ -114,16 +123,31 @@ function extractSpanAttributes(report) {
 		case "orchestrator":
 			addOrchestratorAttributes(attributes, extensions);
 			break;
-		case "tool":
-			addToolAttributes(attributes, extensions);
-			break;
-		default: break;
+		case "tool": addToolAttributes(attributes, extensions);
 	}
 	if (Object.keys(attributes).length === 0) return;
 	return attributes;
 }
 function addAgentAttributes(attributes, extensions) {
-	if (Array.isArray(extensions.trips)) attributes["agent.trips"] = extensions.trips.length;
+	if (Array.isArray(extensions.trips)) {
+		attributes["agent.trips"] = extensions.trips.length;
+		if (extensions.trips.some((trip) => trip.usage?.cachedTokens !== void 0)) attributes["agent.cacheHits"] = extensions.trips.filter((trip) => (trip.usage?.cachedTokens ?? 0) > 0).length;
+		const truncatedTrips = extensions.trips.filter((trip) => trip.finishReason === "length" || trip.finishReason === "context_exceeded").length;
+		if (truncatedTrips > 0) attributes["agent.truncatedTrips"] = truncatedTrips;
+		const providerCompactions = extensions.trips.reduce((count, trip) => count + (trip.blocks?.filter((block) => block.type === "compaction").length ?? 0), 0);
+		if (providerCompactions > 0) attributes["agent.providerCompactions"] = providerCompactions;
+	}
+	if (extensions.compactions?.length) attributes["agent.compactions"] = extensions.compactions.map((record) => ({
+		type: record.type,
+		tripIndex: record.tripIndex,
+		inputTokens: record.inputTokens,
+		counting: record.counting,
+		reason: record.reason,
+		...record.compaction ? {
+			replacesFromIndex: record.compaction.replacesFromIndex,
+			replacesToIndex: record.compaction.replacesToIndex
+		} : {}
+	}));
 	if (extensions.model?.name !== void 0) attributes["agent.model.name"] = extensions.model.name;
 	if (extensions.model?.provider !== void 0) attributes["agent.model.provider"] = extensions.model.provider;
 	if (extensions.promptName !== void 0) attributes["agent.promptName"] = extensions.promptName;
@@ -334,6 +358,30 @@ function reportToTrace(report, rootError, options) {
 	return trace;
 }
 
+//#endregion
+//#region ../../packages/ai-panoptic/src/collector/trace-subscriptions.ts
+const listeners = /* @__PURE__ */ new Set();
+/**
+* Subscribe to traces from every built-in collector in this process, including
+* collectors created before subscribing. No replay or retention. Called before
+* exporter dispatch, so adapters can read request-local context synchronously.
+* Listener failures are isolated; async listeners are not awaited. The returned
+* disposer removes only this subscription. Does not enable flow observation.
+*/
+function subscribeTraces(listener) {
+	const subscription = (trace) => listener(trace);
+	listeners.add(subscription);
+	return () => {
+		listeners.delete(subscription);
+	};
+}
+/** Internal collector notification; pure toTrace projections never publish. */
+function publishTrace(trace) {
+	for (const listener of listeners) try {
+		Promise.resolve(listener(trace)).catch(() => {});
+	} catch {}
+}
+
 //#endregion
 //#region ../../packages/ai-panoptic/src/collector/collector.ts
 /**
@@ -385,6 +433,7 @@ var Collector = class {
 	}
 	async collect(report, rootError) {
 		const trace = this.toTrace(report, rootError);
+		publishTrace(trace);
 		await this.dispatch(trace);
 	}
 	async flush() {
@@ -475,6 +524,7 @@ function createCollector(options = {}) {
 */
 function matchTrace(trace, filter) {
 	if (!filter) return true;
+	if (filter.requestId !== void 0 && trace.requestId !== filter.requestId) return false;
 	if (filter.traceId !== void 0 && trace.traceId !== filter.traceId) return false;
 	if (filter.sessionId !== void 0 && trace.sessionId !== filter.sessionId) return false;
 	if (filter.status !== void 0 && !statusMatches(trace.root.status, filter.status)) return false;
@@ -502,48 +552,14 @@ function toEpoch(bound) {
 
 //#endregion
 //#region ../../packages/ai-panoptic/src/store/sum-usage.ts
-/**
-* Fold a child {@link Usage} into a running accumulator. Token channels
-* (`input` / `output` / `total`) always sum; the optional cache /
-* reasoning channels (`cachedTokens` / `cacheWriteTokens` /
-* `reasoningTokens`) sum only when at least one side reported them, so
-* a provider that never meters a channel doesn't fabricate a `0` for
-* it. The `cost` breakdown is merged with the core framework's
-* {@link accumulateCost}, keeping cost-rollup semantics identical to a
-* native report tree — an unpriced contributor never erases a priced
-* one.
-*
-* Pure: returns a fresh `Usage`, never mutates either argument. Seed an
-* aggregation with {@link emptyUsage}.
-*
-* @example
-* let total = emptyUsage();
-* for (const trace of traces) {
-*   total = sumUsage(total, trace.usage);
-* }
-*/
+/** Return an independent all-channel usage rollup, preserving hosted-tool counters. */
 function sumUsage(accumulator, next) {
-	const merged = {
-		input: accumulator.input + next.input,
-		output: accumulator.output + next.output,
-		total: accumulator.total + next.total
-	};
-	const cachedTokens = sumOptional(accumulator.cachedTokens, next.cachedTokens);
-	if (cachedTokens !== void 0) merged.cachedTokens = cachedTokens;
-	const cacheWriteTokens = sumOptional(accumulator.cacheWriteTokens, next.cacheWriteTokens);
-	if (cacheWriteTokens !== void 0) merged.cacheWriteTokens = cacheWriteTokens;
-	const reasoningTokens = sumOptional(accumulator.reasoningTokens, next.reasoningTokens);
-	if (reasoningTokens !== void 0) merged.reasoningTokens = reasoningTokens;
-	const cost = (0, _warlock_js_ai.accumulateCost)(accumulator.cost, next.cost);
-	if (cost !== void 0) merged.cost = cost;
+	const merged = emptyUsage();
+	(0, _warlock_js_ai.mergeUsage)(merged, accumulator);
+	(0, _warlock_js_ai.mergeUsage)(merged, next);
 	return merged;
 }
-/**
-* A zero-valued {@link Usage} to seed an aggregation. Only the required
-* token channels are set; optional channels stay absent until a
-* contributor reports them, preserving the "never reported" vs
-* "reported as 0" distinction.
-*/
+/** Seed an aggregation without claiming any optional counter was reported. */
 function emptyUsage() {
 	return {
 		input: 0,
@@ -551,15 +567,6 @@ function emptyUsage() {
 		total: 0
 	};
 }
-/**
-* Add two optional token counts, treating either side's `undefined` as
-* zero — but return `undefined` when both are absent, so an unreported
-* channel stays unreported rather than collapsing to `0`.
-*/
-function sumOptional(accumulator, next) {
-	if (accumulator === void 0 && next === void 0) return;
-	return (accumulator ?? 0) + (next ?? 0);
-}
 
 //#endregion
 //#region ../../packages/ai-panoptic/src/store/cache-trace-store.ts
@@ -785,10 +792,7 @@ var CacheTraceStore = class {
 			case "incomplete":
 				aggregate.failed += 1;
 				break;
-			case "cancelled":
-				aggregate.cancelled += 1;
-				break;
-			default: break;
+			case "cancelled": aggregate.cancelled += 1;
 		}
 	}
 	/**
@@ -941,10 +945,7 @@ var InMemoryTraceStore = class {
 			case "incomplete":
 				aggregate.failed += 1;
 				break;
-			case "cancelled":
-				aggregate.cancelled += 1;
-				break;
-			default: break;
+			case "cancelled": aggregate.cancelled += 1;
 		}
 	}
 	/**
@@ -1535,7 +1536,7 @@ function ownUsage(span) {
 * rolled-up subtree totals next to an own-usage `usage` block. Cost is
 * omitted for the same reason; Langfuse prices the own tokens itself.
 */
-const LANGFUSE_METADATA_OMIT = new Set([
+const LANGFUSE_METADATA_OMIT = /* @__PURE__ */ new Set([
 	GEN_AI_ATTRIBUTES.usageInputTokens,
 	GEN_AI_ATTRIBUTES.usageOutputTokens,
 	WARLOCK_ATTRIBUTES.totalTokens,
@@ -1935,7 +1936,9 @@ function panoptic(options = {}) {
 * the caller (the dashboard route) is expected to catch.
 */
 async function evaluateSystemPrompt(systemPrompt, config, instructionsOverride) {
-	return (0, _warlock_js_ai.judgePromptBody)(systemPrompt, typeof config.model === "function" ? await config.model() : config.model, instructionsOverride?.trim() || config.instructions);
+	const model = typeof config.model === "function" ? await config.model() : config.model;
+	const instructions = instructionsOverride?.trim() || config.instructions;
+	return (0, _warlock_js_ai.judgePromptBody)(systemPrompt, model, instructions);
 }
 
 //#endregion
@@ -3524,7 +3527,7 @@ function encodeForInlineScript(value) {
 //#endregion
 //#region ../../packages/ai-panoptic/src/dashboard/serve.ts
 /** Hard cap on the evaluate route's request body — well beyond a real instructions string. */
-const MAX_EVALUATE_BODY_BYTES = 64 * 1024;
+const MAX_EVALUATE_BODY_BYTES = 65536;
 /**
 * Security response headers added to every dashboard response (S4):
 * block MIME-sniffing, framing, referrer leakage, and lock the page's
@@ -3806,13 +3809,14 @@ function dashboard(store, options = {}) {
 	const basePath = normalizeBasePath(options.basePath);
 	if (!isLoopbackHost(host) && !options.authToken) return Promise.reject(/* @__PURE__ */ new Error(`Panoptic dashboard: binding to a non-loopback host ("${host}") requires an \`authToken\` (the dashboard exposes raw prompt content). Pass \`authToken\`, or bind to 127.0.0.1.`));
 	const allowedHosts = (options.allowedHosts ?? defaultAllowedHosts(host)).map((h) => h.toLowerCase());
-	const server = (0, node_http.createServer)(createRequestHandler(store, {
+	const handler = createRequestHandler(store, {
 		basePath,
 		title,
 		authToken: options.authToken,
 		allowedHosts,
 		evaluate: options.evaluate
-	}));
+	});
+	const server = (0, node_http.createServer)(handler);
 	return new Promise((resolve, reject) => {
 		const onError = (error) => {
 			server.off("error", onError);
@@ -4293,6 +4297,7 @@ exports.percentile = percentile;
 exports.reportToSpan = reportToSpan;
 exports.reportToTrace = reportToTrace;
 exports.rollupCost = rollupCost;
+exports.subscribeTraces = subscribeTraces;
 exports.sumUsage = sumUsage;
 exports.toGenAiAttributes = toGenAiAttributes;
 exports.totalCostUsd = totalCostUsd;