@warlock.js/ai-panoptic 4.4.0 → 4.5.0

package/esm/dashboard/trace-filter.d.mts

@@ -0,0 +1,187 @@
+import { Trace, TraceSpan } from "../contracts/trace.type.mjs";
+import { ReportStatus, ReportType } from "@warlock.js/ai";
+
+//#region ../@warlock.js/ai-panoptic/src/dashboard/trace-filter.d.ts
+/**
+ * Client-side trace-list filter criteria. The dashboard polls the full
+ * trace list every 2s and narrows it in the browser with these — search
+ * box, filter chips, and the errors-only header toggle all feed one
+ * {@link TraceFilter}. Kept as a pure, framework-free module so the exact
+ * matching rules are unit-tested here and the inlined dashboard JS in
+ * {@link import("./ui.html").dashboardHtml} mirrors them 1:1.
+ *
+ * Every field is optional — an absent field is "don't care". An empty
+ * filter therefore matches every trace.
+ */
+type TraceFilter = {
+  /**
+   * Free-text needle matched case-insensitively against a trace's root
+   * span name and session id. Whitespace-trimmed; an empty/blank string
+   * is treated as absent.
+   */
+  text?: string;
+  /**
+   * Restrict to these terminal statuses (root span status). Empty array
+   * is treated as "don't care" (matches every status).
+   */
+  statuses?: ReportStatus[];
+  /**
+   * Restrict to these executable types (root span type). Empty array is
+   * treated as "don't care".
+   */
+  types?: ReportType[];
+  /**
+   * Exact session-id chip. When set, only traces whose `sessionId`
+   * equals this value match. Distinct from {@link TraceFilter.text},
+   * which is a fuzzy substring across name + session.
+   */
+  sessionId?: string;
+  /**
+   * Exact prompt chip — a `name@version` key (see {@link tracePromptKey}).
+   * When set, only traces whose root span resolved that exact named prompt
+   * version match. Mirrors {@link TraceFilter.sessionId} but over the
+   * prompt-version-linkage attributes the collector stamps on agent spans.
+   */
+  promptKey?: string;
+  /**
+   * Errors-only header toggle. When `true`, only `failed` / `cancelled`
+   * traces match — independent of (and intersected with) `statuses`.
+   */
+  errorsOnly?: boolean;
+};
+/**
+ * The `name@version` prompt key a trace falls under, read from its root
+ * span's prompt-version-linkage attributes (`agent.promptName` /
+ * `agent.promptVersion`). Returns `undefined` when the run carried no named
+ * prompt (raw-string / anonymous / no prompt), so callers can bucket those
+ * under a synthetic "no prompt" key or skip them.
+ *
+ * The version is included so two runs of the same prompt name at different
+ * versions are distinct keys — that is the whole point of the linkage: to
+ * group / filter by the *exact* prompt revision that produced a run.
+ */
+declare function tracePromptKey(trace: Trace): string | undefined;
+/**
+ * Does a single trace pass the given filter? Pure predicate — all
+ * conditions are ANDed; an unset field never excludes. Used by
+ * {@link filterTraces} and mirrored by the dashboard's inlined JS.
+ */
+declare function matchesFilter(trace: Trace, filter: TraceFilter): boolean;
+/** Narrow a trace list to those matching the filter, order preserved. */
+declare function filterTraces(traces: Trace[], filter: TraceFilter): Trace[];
+/**
+ * The grouping key a trace falls under when the list is grouped by
+ * session. Traces without a `sessionId` collapse into one synthetic
+ * "(no session)" bucket so they remain visible.
+ */
+declare const NO_SESSION_KEY = "(no session)";
+/** One session bucket — its key plus the traces under it, order preserved. */
+type SessionGroup = {
+  /** The `sessionId`, or {@link NO_SESSION_KEY} for sessionless traces. */sessionId: string; /** Traces in this group, in the order they appeared in the input. */
+  traces: Trace[];
+};
+/**
+ * Group an (already filtered, newest-first) trace list by session id,
+ * preserving first-seen order of both the groups and the traces within
+ * each. Sessionless traces bucket under {@link NO_SESSION_KEY}.
+ */
+declare function groupBySession(traces: Trace[]): SessionGroup[];
+/**
+ * The grouping key a trace falls under when the list is grouped by prompt
+ * version. Runs that resolved no named prompt collapse into one synthetic
+ * "(no prompt)" bucket so they remain visible.
+ */
+declare const NO_PROMPT_KEY = "(no prompt)";
+/** One prompt-version bucket — its `name@version` key plus its traces. */
+type PromptGroup = {
+  /** The `name@version` key, or {@link NO_PROMPT_KEY} for unlinked traces. */promptKey: string; /** Traces in this group, in the order they appeared in the input. */
+  traces: Trace[];
+};
+/**
+ * Group an (already filtered, newest-first) trace list by prompt version —
+ * the `name@version` key {@link tracePromptKey} derives from each run's
+ * prompt-version-linkage attributes. Preserves first-seen order of both the
+ * groups and the traces within each. Runs with no named prompt bucket under
+ * {@link NO_PROMPT_KEY}.
+ *
+ * The dashboard offers this as a second group-by dimension beside session,
+ * so a reviewer can see every run of "support@2" together and compare its
+ * cost / failure rate against "support@3".
+ */
+declare function groupByPrompt(traces: Trace[]): PromptGroup[];
+/**
+ * The grouping key a trace falls under when the list is grouped by root
+ * type. `root.type` is always present, so this is only a defensive
+ * fallback for a malformed trace with no typed root.
+ */
+declare const NO_TYPE_KEY = "(no type)";
+/** One root-type bucket — its type discriminator plus its traces. */
+type TypeGroup = {
+  /** The root span's `type` (e.g. `agent` / `workflow` / `planner`), or {@link NO_TYPE_KEY}. */type: string; /** Traces in this group, in the order they appeared in the input. */
+  traces: Trace[];
+};
+/**
+ * Group an (already filtered, newest-first) trace list by root type —
+ * the `agent` / `workflow` / `supervisor` / `orchestrator` / `planner` /
+ * `tool` / `batch` / `callback` discriminator on each trace's root span.
+ * Preserves first-seen order of both the groups and the traces within each.
+ *
+ * The dashboard offers this as the coarsest group-by dimension beside
+ * session and prompt: when a benchmark floods the flat list with hundreds
+ * of one primitive (e.g. standalone `agent` runs), this collapses them
+ * behind a per-type header so the structural primitives (the lone planner,
+ * the team, the supervisors) are one click away instead of a scroll past.
+ */
+declare function groupByType(traces: Trace[]): TypeGroup[];
+/** One row of the per-type aggregate-stats panel. */
+type TypeStat = {
+  /** Root type discriminator, or {@link NO_TYPE_KEY}. */type: string; /** Number of traces of this type. */
+  count: number; /** Traces whose status is `failed` / `cancelled`. */
+  failed: number; /** `failed / count` in `[0, 1]`. */
+  failRate: number; /** Median (p50) root duration in ms. */
+  p50: number; /** p95 root duration in ms. */
+  p95: number; /** Summed `usage.total` tokens across the bucket. */
+  tokens: number; /** Summed per-trace USD cost across the bucket. */
+  cost: number;
+};
+/**
+ * Nearest-rank percentile of `values` at `p` (0–100). Returns 0 for an
+ * empty input and sorts a copy so the caller's array is left untouched.
+ */
+declare function percentile(values: number[], p: number): number;
+/**
+ * One trace's total USD cost: its explicit root-usage cost when priced,
+ * else the rollup of its subtree. Mirrors the dashboard's `traceCost` so the
+ * stats panel and the trace rows agree to the cent.
+ */
+declare function traceCost(trace: Trace): number;
+/**
+ * Aggregate an (already filtered) trace list into one {@link TypeStat} row
+ * per root type — count, failure rate, p50/p95 latency, total tokens, total
+ * cost — preserving first-seen type order. Powers the dashboard's per-type
+ * stats panel; computed over the same filtered list the trace view shows, so
+ * the panel always reflects the active filters.
+ */
+declare function aggregateByType(traces: Trace[]): TypeStat[];
+/**
+ * Rollup-aware subtree cost: a node's own cost when it carries one
+ * (it already rolls up its trips), otherwise the sum of its children.
+ * Avoids double-counting wrapper nodes (workflow/supervisor roots carry
+ * tokens but no cost). Mirrors the dashboard's `rollupCost`.
+ */
+declare function rollupCost(span: TraceSpan): number;
+/**
+ * Heatmap intensity in `[0, 1]` for a node's `rollupCost` relative to the
+ * trace's most-expensive node. The dashboard tints each tree node's left
+ * accent by this. `max <= 0` (a free trace) yields `0` for every node so
+ * the heatmap simply stays cold rather than dividing by zero.
+ */
+declare function heatIntensity(nodeCost: number, maxCost: number): number;
+/**
+ * The largest single-node {@link rollupCost} anywhere in a span tree —
+ * the denominator for {@link heatIntensity}. Walks the whole subtree.
+ */
+declare function maxNodeCost(root: TraceSpan): number;
+//#endregion
+export { NO_PROMPT_KEY, NO_SESSION_KEY, NO_TYPE_KEY, PromptGroup, SessionGroup, TraceFilter, TypeGroup, TypeStat, aggregateByType, filterTraces, groupByPrompt, groupBySession, groupByType, heatIntensity, matchesFilter, maxNodeCost, percentile, rollupCost, traceCost, tracePromptKey };
+//# sourceMappingURL=trace-filter.d.mts.map

package/esm/dashboard/trace-filter.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trace-filter.d.mts","names":[],"sources":["../../../../../../../@warlock.js/ai-panoptic/src/dashboard/trace-filter.ts"],"mappings":";;;;;;AAcA;;;;;;;;;KAAY,WAAA;EA6BV;;;AAKU;AAyBZ;EArDE,IAAA;;;AAqDyC;AAwB3C;EAxEE,QAAA,GAAW,YAAA;;;;;EAKX,KAAA,GAAQ,UAAU;EAmEwB;;AAAmB;AA2C/D;;EAxGE,SAAA;EAwGmC;;;;;;EAjGnC,SAAA;EAiGoD;;;;EA5FpD,UAAA;AAAA;;;;AAqGyB;AAG3B;;;;;;;iBA/EgB,cAAA,CAAe,KAAY,EAAL,KAAK;AAmF5B;AAQf;;;;AARe,iBA3DC,aAAA,CAAc,KAAA,EAAO,KAAA,EAAO,MAAA,EAAQ,WAAW;;iBA2C/C,YAAA,CAAa,MAAA,EAAQ,KAAA,IAAS,MAAA,EAAQ,WAAA,GAAc,KAAA;;AAwBP;AAyB7D;;;cAxCa,cAAA;AAwCa;AAAA,KArCd,YAAA;EAwCW,yEAtCrB,SAAA,UA0Ca;EAxCb,MAAA,EAAQ,KAAK;AAAA;;;AAwCA;AAcf;;iBA9CgB,cAAA,CAAe,MAAA,EAAQ,KAAA,KAAU,YAAY;;;;;;cAyBhD,aAAA;AA8Cb;AAAA,KA3CY,WAAA;8EAEV,SAAA,UAyCsB;EAvCtB,MAAA,EAAQ,KAAK;AAAA;;;;;;;AA8CA;AAef;;;;iBA/CgB,aAAA,CAAc,MAAA,EAAQ,KAAA,KAAU,WAAW;;;;AA+CJ;AAqBvD;cA3Ca,WAAA;;KAGD,SAAA;EA0CV,8FAxCA,IAAA,UA4CA;EA1CA,MAAA,EAAQ,KAAK;AAAA;;;;;AAoDT;AAON;;;;AAAsD;AAiBtD;;iBA7DgB,WAAA,CAAY,MAAA,EAAQ,KAAA,KAAU,SAAS;;KAqB3C,QAAA;EAoDI,uDAlDd,IAAA;EAEA,KAAA,UAgDsC;EA9CtC,MAAA,UA8CgD;EA5ChD,QAAA,UA4CwD;EA1CxD,GAAA,UAiHwB;EA/GxB,GAAA,UA+G+B;EA7G/B,MAAA,UAiIc;EA/Hd,IAAA;AAAA;;AA+H6D;AAc/D;;iBAtIgB,UAAA,CAAW,MAAA,YAAkB,CAAS;;AAsIX;;;;iBArH3B,SAAA,CAAU,KAAY,EAAL,KAAK;;;;;;;;iBAYtB,eAAA,CAAgB,MAAA,EAAQ,KAAA,KAAU,QAAQ;;;;;;;iBAuE1C,UAAA,CAAW,IAAe,EAAT,SAAS;;;;;;;iBAoB1B,aAAA,CAAc,QAAA,UAAkB,OAAe;;;;;iBAc/C,WAAA,CAAY,IAAe,EAAT,SAAS"}

package/esm/dashboard/trace-filter.mjs

@@ -0,0 +1,270 @@
+//#region ../@warlock.js/ai-panoptic/src/dashboard/trace-filter.ts
+/** Statuses the errors-only toggle keeps. */
+const ERROR_STATUSES = ["failed", "cancelled"];
+/**
+* Span-attribute keys the collector stamps with prompt-version linkage when
+* an agent ran against a *named* `ai.prompts` builder. Read here (not
+* imported) so this pure module stays decoupled from the collector.
+*/
+const PROMPT_NAME_ATTR = "agent.promptName";
+const PROMPT_VERSION_ATTR = "agent.promptVersion";
+/**
+* The `name@version` prompt key a trace falls under, read from its root
+* span's prompt-version-linkage attributes (`agent.promptName` /
+* `agent.promptVersion`). Returns `undefined` when the run carried no named
+* prompt (raw-string / anonymous / no prompt), so callers can bucket those
+* under a synthetic "no prompt" key or skip them.
+*
+* The version is included so two runs of the same prompt name at different
+* versions are distinct keys — that is the whole point of the linkage: to
+* group / filter by the *exact* prompt revision that produced a run.
+*/
+function tracePromptKey(trace) {
+	const attributes = trace.root.attributes;
+	if (attributes === void 0) return;
+	const name = attributes[PROMPT_NAME_ATTR];
+	if (typeof name !== "string" || name.length === 0) return;
+	const version = attributes[PROMPT_VERSION_ATTR];
+	return `${name}@${typeof version === "string" && version.length > 0 ? version : "1"}`;
+}
+/**
+* Does a single trace pass the given filter? Pure predicate — all
+* conditions are ANDed; an unset field never excludes. Used by
+* {@link filterTraces} and mirrored by the dashboard's inlined JS.
+*/
+function matchesFilter(trace, filter) {
+	const root = trace.root;
+	if (filter.errorsOnly === true && !ERROR_STATUSES.includes(root.status)) return false;
+	if (filter.statuses !== void 0 && filter.statuses.length > 0) {
+		if (!filter.statuses.includes(root.status)) return false;
+	}
+	if (filter.types !== void 0 && filter.types.length > 0) {
+		if (!filter.types.includes(root.type)) return false;
+	}
+	if (filter.sessionId !== void 0 && filter.sessionId.length > 0) {
+		if (trace.sessionId !== filter.sessionId) return false;
+	}
+	if (filter.promptKey !== void 0 && filter.promptKey.length > 0) {
+		if (tracePromptKey(trace) !== filter.promptKey) return false;
+	}
+	const text = filter.text?.trim().toLowerCase();
+	if (text !== void 0 && text.length > 0) {
+		if (!`${root.name} ${trace.sessionId ?? ""}`.toLowerCase().includes(text)) return false;
+	}
+	return true;
+}
+/** Narrow a trace list to those matching the filter, order preserved. */
+function filterTraces(traces, filter) {
+	return traces.filter((trace) => matchesFilter(trace, filter));
+}
+/**
+* The grouping key a trace falls under when the list is grouped by
+* session. Traces without a `sessionId` collapse into one synthetic
+* "(no session)" bucket so they remain visible.
+*/
+const NO_SESSION_KEY = "(no session)";
+/**
+* Group an (already filtered, newest-first) trace list by session id,
+* preserving first-seen order of both the groups and the traces within
+* each. Sessionless traces bucket under {@link NO_SESSION_KEY}.
+*/
+function groupBySession(traces) {
+	const order = [];
+	const byKey = /* @__PURE__ */ new Map();
+	for (const trace of traces) {
+		const key = trace.sessionId ?? "(no session)";
+		let bucket = byKey.get(key);
+		if (bucket === void 0) {
+			bucket = [];
+			byKey.set(key, bucket);
+			order.push(key);
+		}
+		bucket.push(trace);
+	}
+	return order.map((sessionId) => ({
+		sessionId,
+		traces: byKey.get(sessionId) ?? []
+	}));
+}
+/**
+* The grouping key a trace falls under when the list is grouped by prompt
+* version. Runs that resolved no named prompt collapse into one synthetic
+* "(no prompt)" bucket so they remain visible.
+*/
+const NO_PROMPT_KEY = "(no prompt)";
+/**
+* Group an (already filtered, newest-first) trace list by prompt version —
+* the `name@version` key {@link tracePromptKey} derives from each run's
+* prompt-version-linkage attributes. Preserves first-seen order of both the
+* groups and the traces within each. Runs with no named prompt bucket under
+* {@link NO_PROMPT_KEY}.
+*
+* The dashboard offers this as a second group-by dimension beside session,
+* so a reviewer can see every run of "support@2" together and compare its
+* cost / failure rate against "support@3".
+*/
+function groupByPrompt(traces) {
+	const order = [];
+	const byKey = /* @__PURE__ */ new Map();
+	for (const trace of traces) {
+		const key = tracePromptKey(trace) ?? "(no prompt)";
+		let bucket = byKey.get(key);
+		if (bucket === void 0) {
+			bucket = [];
+			byKey.set(key, bucket);
+			order.push(key);
+		}
+		bucket.push(trace);
+	}
+	return order.map((promptKey) => ({
+		promptKey,
+		traces: byKey.get(promptKey) ?? []
+	}));
+}
+/**
+* The grouping key a trace falls under when the list is grouped by root
+* type. `root.type` is always present, so this is only a defensive
+* fallback for a malformed trace with no typed root.
+*/
+const NO_TYPE_KEY = "(no type)";
+/**
+* Group an (already filtered, newest-first) trace list by root type —
+* the `agent` / `workflow` / `supervisor` / `orchestrator` / `planner` /
+* `tool` / `batch` / `callback` discriminator on each trace's root span.
+* Preserves first-seen order of both the groups and the traces within each.
+*
+* The dashboard offers this as the coarsest group-by dimension beside
+* session and prompt: when a benchmark floods the flat list with hundreds
+* of one primitive (e.g. standalone `agent` runs), this collapses them
+* behind a per-type header so the structural primitives (the lone planner,
+* the team, the supervisors) are one click away instead of a scroll past.
+*/
+function groupByType(traces) {
+	const order = [];
+	const byKey = /* @__PURE__ */ new Map();
+	for (const trace of traces) {
+		const key = trace.root.type || "(no type)";
+		let bucket = byKey.get(key);
+		if (bucket === void 0) {
+			bucket = [];
+			byKey.set(key, bucket);
+			order.push(key);
+		}
+		bucket.push(trace);
+	}
+	return order.map((type) => ({
+		type,
+		traces: byKey.get(type) ?? []
+	}));
+}
+/**
+* Nearest-rank percentile of `values` at `p` (0–100). Returns 0 for an
+* empty input and sorts a copy so the caller's array is left untouched.
+*/
+function percentile(values, p) {
+	if (values.length === 0) return 0;
+	const sorted = values.slice().sort((a, b) => a - b);
+	const rank = Math.ceil(p / 100 * sorted.length) - 1;
+	return sorted[Math.min(Math.max(rank, 0), sorted.length - 1)];
+}
+/**
+* One trace's total USD cost: its explicit root-usage cost when priced,
+* else the rollup of its subtree. Mirrors the dashboard's `traceCost` so the
+* stats panel and the trace rows agree to the cent.
+*/
+function traceCost(trace) {
+	const own = costSumObj(trace.usage.cost);
+	return own > 0 ? own : rollupCost(trace.root);
+}
+/**
+* Aggregate an (already filtered) trace list into one {@link TypeStat} row
+* per root type — count, failure rate, p50/p95 latency, total tokens, total
+* cost — preserving first-seen type order. Powers the dashboard's per-type
+* stats panel; computed over the same filtered list the trace view shows, so
+* the panel always reflects the active filters.
+*/
+function aggregateByType(traces) {
+	const order = [];
+	const byKey = /* @__PURE__ */ new Map();
+	for (const trace of traces) {
+		const key = trace.root.type || "(no type)";
+		let bucket = byKey.get(key);
+		if (bucket === void 0) {
+			bucket = [];
+			byKey.set(key, bucket);
+			order.push(key);
+		}
+		bucket.push(trace);
+	}
+	return order.map((type) => {
+		const bucket = byKey.get(type) ?? [];
+		const durations = bucket.map((trace) => trace.duration);
+		let failed = 0;
+		let tokens = 0;
+		let cost = 0;
+		for (const trace of bucket) {
+			if (ERROR_STATUSES.includes(trace.root.status)) failed += 1;
+			tokens += trace.usage.total ?? 0;
+			cost += traceCost(trace);
+		}
+		return {
+			type,
+			count: bucket.length,
+			failed,
+			failRate: bucket.length > 0 ? failed / bucket.length : 0,
+			p50: percentile(durations, 50),
+			p95: percentile(durations, 95),
+			tokens,
+			cost
+		};
+	});
+}
+/**
+* Sum every priced lane of a usage cost object into one USD number.
+* Mirrors the dashboard's `costSumObj` so heatmap intensities computed
+* here match what the page renders.
+*/
+function costSumObj(cost) {
+	if (cost === void 0) return 0;
+	return (cost.input ?? 0) + (cost.output ?? 0) + (cost.cachedInput ?? 0) + (cost.cachedOutput ?? 0) + (cost.reasoning ?? 0);
+}
+/**
+* Rollup-aware subtree cost: a node's own cost when it carries one
+* (it already rolls up its trips), otherwise the sum of its children.
+* Avoids double-counting wrapper nodes (workflow/supervisor roots carry
+* tokens but no cost). Mirrors the dashboard's `rollupCost`.
+*/
+function rollupCost(span) {
+	const own = costSumObj(span.usage.cost);
+	if (own > 0) return own;
+	let sum = 0;
+	for (const child of span.children) sum += rollupCost(child);
+	return sum;
+}
+/**
+* Heatmap intensity in `[0, 1]` for a node's `rollupCost` relative to the
+* trace's most-expensive node. The dashboard tints each tree node's left
+* accent by this. `max <= 0` (a free trace) yields `0` for every node so
+* the heatmap simply stays cold rather than dividing by zero.
+*/
+function heatIntensity(nodeCost, maxCost) {
+	if (maxCost <= 0 || nodeCost <= 0) return 0;
+	const ratio = nodeCost / maxCost;
+	return ratio > 1 ? 1 : ratio;
+}
+/**
+* The largest single-node {@link rollupCost} anywhere in a span tree —
+* the denominator for {@link heatIntensity}. Walks the whole subtree.
+*/
+function maxNodeCost(root) {
+	let max = rollupCost(root);
+	for (const child of root.children) {
+		const childMax = maxNodeCost(child);
+		if (childMax > max) max = childMax;
+	}
+	return max;
+}
+
+//#endregion
+export { NO_PROMPT_KEY, NO_SESSION_KEY, NO_TYPE_KEY, aggregateByType, filterTraces, groupByPrompt, groupBySession, groupByType, heatIntensity, matchesFilter, maxNodeCost, percentile, rollupCost, traceCost, tracePromptKey };
+//# sourceMappingURL=trace-filter.mjs.map

package/esm/dashboard/trace-filter.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"trace-filter.mjs","names":[],"sources":["../../../../../../../@warlock.js/ai-panoptic/src/dashboard/trace-filter.ts"],"sourcesContent":["import type { ReportStatus, ReportType } from \"@warlock.js/ai\";\nimport type { Trace, TraceSpan } from \"../contracts/trace.type\";\n\n/**\n * Client-side trace-list filter criteria. The dashboard polls the full\n * trace list every 2s and narrows it in the browser with these — search\n * box, filter chips, and the errors-only header toggle all feed one\n * {@link TraceFilter}. Kept as a pure, framework-free module so the exact\n * matching rules are unit-tested here and the inlined dashboard JS in\n * {@link import(\"./ui.html\").dashboardHtml} mirrors them 1:1.\n *\n * Every field is optional — an absent field is \"don't care\". An empty\n * filter therefore matches every trace.\n */\nexport type TraceFilter = {\n  /**\n   * Free-text needle matched case-insensitively against a trace's root\n   * span name and session id. Whitespace-trimmed; an empty/blank string\n   * is treated as absent.\n   */\n  text?: string;\n  /**\n   * Restrict to these terminal statuses (root span status). Empty array\n   * is treated as \"don't care\" (matches every status).\n   */\n  statuses?: ReportStatus[];\n  /**\n   * Restrict to these executable types (root span type). Empty array is\n   * treated as \"don't care\".\n   */\n  types?: ReportType[];\n  /**\n   * Exact session-id chip. When set, only traces whose `sessionId`\n   * equals this value match. Distinct from {@link TraceFilter.text},\n   * which is a fuzzy substring across name + session.\n   */\n  sessionId?: string;\n  /**\n   * Exact prompt chip — a `name@version` key (see {@link tracePromptKey}).\n   * When set, only traces whose root span resolved that exact named prompt\n   * version match. Mirrors {@link TraceFilter.sessionId} but over the\n   * prompt-version-linkage attributes the collector stamps on agent spans.\n   */\n  promptKey?: string;\n  /**\n   * Errors-only header toggle. When `true`, only `failed` / `cancelled`\n   * traces match — independent of (and intersected with) `statuses`.\n   */\n  errorsOnly?: boolean;\n};\n\n/** Statuses the errors-only toggle keeps. */\nconst ERROR_STATUSES: readonly ReportStatus[] = [\"failed\", \"cancelled\"] as const;\n\n/**\n * Span-attribute keys the collector stamps with prompt-version linkage when\n * an agent ran against a *named* `ai.prompts` builder. Read here (not\n * imported) so this pure module stays decoupled from the collector.\n */\nconst PROMPT_NAME_ATTR = \"agent.promptName\";\nconst PROMPT_VERSION_ATTR = \"agent.promptVersion\";\n\n/**\n * The `name@version` prompt key a trace falls under, read from its root\n * span's prompt-version-linkage attributes (`agent.promptName` /\n * `agent.promptVersion`). Returns `undefined` when the run carried no named\n * prompt (raw-string / anonymous / no prompt), so callers can bucket those\n * under a synthetic \"no prompt\" key or skip them.\n *\n * The version is included so two runs of the same prompt name at different\n * versions are distinct keys — that is the whole point of the linkage: to\n * group / filter by the *exact* prompt revision that produced a run.\n */\nexport function tracePromptKey(trace: Trace): string | undefined {\n  const attributes = trace.root.attributes;\n\n  if (attributes === undefined) {\n    return undefined;\n  }\n\n  const name = attributes[PROMPT_NAME_ATTR];\n\n  if (typeof name !== \"string\" || name.length === 0) {\n    return undefined;\n  }\n\n  const version = attributes[PROMPT_VERSION_ATTR];\n  const versionLabel = typeof version === \"string\" && version.length > 0 ? version : \"1\";\n\n  return `${name}@${versionLabel}`;\n}\n\n/**\n * Does a single trace pass the given filter? Pure predicate — all\n * conditions are ANDed; an unset field never excludes. Used by\n * {@link filterTraces} and mirrored by the dashboard's inlined JS.\n */\nexport function matchesFilter(trace: Trace, filter: TraceFilter): boolean {\n  const root = trace.root;\n\n  if (filter.errorsOnly === true && !ERROR_STATUSES.includes(root.status)) {\n    return false;\n  }\n\n  if (filter.statuses !== undefined && filter.statuses.length > 0) {\n    if (!filter.statuses.includes(root.status)) {\n      return false;\n    }\n  }\n\n  if (filter.types !== undefined && filter.types.length > 0) {\n    if (!filter.types.includes(root.type)) {\n      return false;\n    }\n  }\n\n  if (filter.sessionId !== undefined && filter.sessionId.length > 0) {\n    if (trace.sessionId !== filter.sessionId) {\n      return false;\n    }\n  }\n\n  if (filter.promptKey !== undefined && filter.promptKey.length > 0) {\n    if (tracePromptKey(trace) !== filter.promptKey) {\n      return false;\n    }\n  }\n\n  const text = filter.text?.trim().toLowerCase();\n  if (text !== undefined && text.length > 0) {\n    const haystack = `${root.name} ${trace.sessionId ?? \"\"}`.toLowerCase();\n    if (!haystack.includes(text)) {\n      return false;\n    }\n  }\n\n  return true;\n}\n\n/** Narrow a trace list to those matching the filter, order preserved. */\nexport function filterTraces(traces: Trace[], filter: TraceFilter): Trace[] {\n  return traces.filter((trace) => matchesFilter(trace, filter));\n}\n\n/**\n * The grouping key a trace falls under when the list is grouped by\n * session. Traces without a `sessionId` collapse into one synthetic\n * \"(no session)\" bucket so they remain visible.\n */\nexport const NO_SESSION_KEY = \"(no session)\";\n\n/** One session bucket — its key plus the traces under it, order preserved. */\nexport type SessionGroup = {\n  /** The `sessionId`, or {@link NO_SESSION_KEY} for sessionless traces. */\n  sessionId: string;\n  /** Traces in this group, in the order they appeared in the input. */\n  traces: Trace[];\n};\n\n/**\n * Group an (already filtered, newest-first) trace list by session id,\n * preserving first-seen order of both the groups and the traces within\n * each. Sessionless traces bucket under {@link NO_SESSION_KEY}.\n */\nexport function groupBySession(traces: Trace[]): SessionGroup[] {\n  const order: string[] = [];\n  const byKey = new Map<string, Trace[]>();\n\n  for (const trace of traces) {\n    const key = trace.sessionId ?? NO_SESSION_KEY;\n    let bucket = byKey.get(key);\n\n    if (bucket === undefined) {\n      bucket = [];\n      byKey.set(key, bucket);\n      order.push(key);\n    }\n\n    bucket.push(trace);\n  }\n\n  return order.map((sessionId) => ({ sessionId, traces: byKey.get(sessionId) ?? [] }));\n}\n\n/**\n * The grouping key a trace falls under when the list is grouped by prompt\n * version. Runs that resolved no named prompt collapse into one synthetic\n * \"(no prompt)\" bucket so they remain visible.\n */\nexport const NO_PROMPT_KEY = \"(no prompt)\";\n\n/** One prompt-version bucket — its `name@version` key plus its traces. */\nexport type PromptGroup = {\n  /** The `name@version` key, or {@link NO_PROMPT_KEY} for unlinked traces. */\n  promptKey: string;\n  /** Traces in this group, in the order they appeared in the input. */\n  traces: Trace[];\n};\n\n/**\n * Group an (already filtered, newest-first) trace list by prompt version —\n * the `name@version` key {@link tracePromptKey} derives from each run's\n * prompt-version-linkage attributes. Preserves first-seen order of both the\n * groups and the traces within each. Runs with no named prompt bucket under\n * {@link NO_PROMPT_KEY}.\n *\n * The dashboard offers this as a second group-by dimension beside session,\n * so a reviewer can see every run of \"support@2\" together and compare its\n * cost / failure rate against \"support@3\".\n */\nexport function groupByPrompt(traces: Trace[]): PromptGroup[] {\n  const order: string[] = [];\n  const byKey = new Map<string, Trace[]>();\n\n  for (const trace of traces) {\n    const key = tracePromptKey(trace) ?? NO_PROMPT_KEY;\n    let bucket = byKey.get(key);\n\n    if (bucket === undefined) {\n      bucket = [];\n      byKey.set(key, bucket);\n      order.push(key);\n    }\n\n    bucket.push(trace);\n  }\n\n  return order.map((promptKey) => ({ promptKey, traces: byKey.get(promptKey) ?? [] }));\n}\n\n/**\n * The grouping key a trace falls under when the list is grouped by root\n * type. `root.type` is always present, so this is only a defensive\n * fallback for a malformed trace with no typed root.\n */\nexport const NO_TYPE_KEY = \"(no type)\";\n\n/** One root-type bucket — its type discriminator plus its traces. */\nexport type TypeGroup = {\n  /** The root span's `type` (e.g. `agent` / `workflow` / `planner`), or {@link NO_TYPE_KEY}. */\n  type: string;\n  /** Traces in this group, in the order they appeared in the input. */\n  traces: Trace[];\n};\n\n/**\n * Group an (already filtered, newest-first) trace list by root type —\n * the `agent` / `workflow` / `supervisor` / `orchestrator` / `planner` /\n * `tool` / `batch` / `callback` discriminator on each trace's root span.\n * Preserves first-seen order of both the groups and the traces within each.\n *\n * The dashboard offers this as the coarsest group-by dimension beside\n * session and prompt: when a benchmark floods the flat list with hundreds\n * of one primitive (e.g. standalone `agent` runs), this collapses them\n * behind a per-type header so the structural primitives (the lone planner,\n * the team, the supervisors) are one click away instead of a scroll past.\n */\nexport function groupByType(traces: Trace[]): TypeGroup[] {\n  const order: string[] = [];\n  const byKey = new Map<string, Trace[]>();\n\n  for (const trace of traces) {\n    const key = trace.root.type || NO_TYPE_KEY;\n    let bucket = byKey.get(key);\n\n    if (bucket === undefined) {\n      bucket = [];\n      byKey.set(key, bucket);\n      order.push(key);\n    }\n\n    bucket.push(trace);\n  }\n\n  return order.map((type) => ({ type, traces: byKey.get(type) ?? [] }));\n}\n\n/** One row of the per-type aggregate-stats panel. */\nexport type TypeStat = {\n  /** Root type discriminator, or {@link NO_TYPE_KEY}. */\n  type: string;\n  /** Number of traces of this type. */\n  count: number;\n  /** Traces whose status is `failed` / `cancelled`. */\n  failed: number;\n  /** `failed / count` in `[0, 1]`. */\n  failRate: number;\n  /** Median (p50) root duration in ms. */\n  p50: number;\n  /** p95 root duration in ms. */\n  p95: number;\n  /** Summed `usage.total` tokens across the bucket. */\n  tokens: number;\n  /** Summed per-trace USD cost across the bucket. */\n  cost: number;\n};\n\n/**\n * Nearest-rank percentile of `values` at `p` (0–100). Returns 0 for an\n * empty input and sorts a copy so the caller's array is left untouched.\n */\nexport function percentile(values: number[], p: number): number {\n  if (values.length === 0) {\n    return 0;\n  }\n\n  const sorted = values.slice().sort((a, b) => a - b);\n  const rank = Math.ceil((p / 100) * sorted.length) - 1;\n  const index = Math.min(Math.max(rank, 0), sorted.length - 1);\n\n  return sorted[index];\n}\n\n/**\n * One trace's total USD cost: its explicit root-usage cost when priced,\n * else the rollup of its subtree. Mirrors the dashboard's `traceCost` so the\n * stats panel and the trace rows agree to the cent.\n */\nexport function traceCost(trace: Trace): number {\n  const own = costSumObj(trace.usage.cost);\n  return own > 0 ? own : rollupCost(trace.root);\n}\n\n/**\n * Aggregate an (already filtered) trace list into one {@link TypeStat} row\n * per root type — count, failure rate, p50/p95 latency, total tokens, total\n * cost — preserving first-seen type order. Powers the dashboard's per-type\n * stats panel; computed over the same filtered list the trace view shows, so\n * the panel always reflects the active filters.\n */\nexport function aggregateByType(traces: Trace[]): TypeStat[] {\n  const order: string[] = [];\n  const byKey = new Map<string, Trace[]>();\n\n  for (const trace of traces) {\n    const key = trace.root.type || NO_TYPE_KEY;\n    let bucket = byKey.get(key);\n\n    if (bucket === undefined) {\n      bucket = [];\n      byKey.set(key, bucket);\n      order.push(key);\n    }\n\n    bucket.push(trace);\n  }\n\n  return order.map((type) => {\n    const bucket = byKey.get(type) ?? [];\n    const durations = bucket.map((trace) => trace.duration);\n    let failed = 0;\n    let tokens = 0;\n    let cost = 0;\n\n    for (const trace of bucket) {\n      if (ERROR_STATUSES.includes(trace.root.status)) {\n        failed += 1;\n      }\n\n      tokens += trace.usage.total ?? 0;\n      cost += traceCost(trace);\n    }\n\n    return {\n      type,\n      count: bucket.length,\n      failed,\n      failRate: bucket.length > 0 ? failed / bucket.length : 0,\n      p50: percentile(durations, 50),\n      p95: percentile(durations, 95),\n      tokens,\n      cost,\n    };\n  });\n}\n\n/**\n * Sum every priced lane of a usage cost object into one USD number.\n * Mirrors the dashboard's `costSumObj` so heatmap intensities computed\n * here match what the page renders.\n */\nfunction costSumObj(cost: TraceSpan[\"usage\"][\"cost\"]): number {\n  if (cost === undefined) {\n    return 0;\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\n/**\n * Rollup-aware subtree cost: a node's own cost when it carries one\n * (it already rolls up its trips), otherwise the sum of its children.\n * Avoids double-counting wrapper nodes (workflow/supervisor roots carry\n * tokens but no cost). Mirrors the dashboard's `rollupCost`.\n */\nexport function rollupCost(span: TraceSpan): number {\n  const own = costSumObj(span.usage.cost);\n  if (own > 0) {\n    return own;\n  }\n\n  let sum = 0;\n  for (const child of span.children) {\n    sum += rollupCost(child);\n  }\n\n  return sum;\n}\n\n/**\n * Heatmap intensity in `[0, 1]` for a node's `rollupCost` relative to the\n * trace's most-expensive node. The dashboard tints each tree node's left\n * accent by this. `max <= 0` (a free trace) yields `0` for every node so\n * the heatmap simply stays cold rather than dividing by zero.\n */\nexport function heatIntensity(nodeCost: number, maxCost: number): number {\n  if (maxCost <= 0 || nodeCost <= 0) {\n    return 0;\n  }\n\n  const ratio = nodeCost / maxCost;\n\n  return ratio > 1 ? 1 : ratio;\n}\n\n/**\n * The largest single-node {@link rollupCost} anywhere in a span tree —\n * the denominator for {@link heatIntensity}. Walks the whole subtree.\n */\nexport function maxNodeCost(root: TraceSpan): number {\n  let max = rollupCost(root);\n\n  for (const child of root.children) {\n    const childMax = maxNodeCost(child);\n    if (childMax > max) {\n      max = childMax;\n    }\n  }\n\n  return max;\n}\n"],"mappings":"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"}