@mastra/react 0.0.0-studio-cli-20260504022012 → 0.0.0-sugared-octave-20261030170102

package/dist/hooks/metrics/index.js

@@ -0,0 +1,973 @@
+import { n as useMastraClient } from "../../mastra-client-context-DQ5z_ze9.js";
+import { t as getOrCreate } from "../../map-5-4U5rwA.js";
+import { useMemo, useRef } from "react";
+import { useQuery } from "@tanstack/react-query";
+// src/hooks/metrics/metrics-query-filters.ts
+const DEFAULT_WINDOW_MS = 864e5;
+const PRESET_MS = {
+	"24h": DEFAULT_WINDOW_MS,
+	"3d": 2592e5,
+	"7d": 6048e5,
+	"14d": 12096e5,
+	"30d": 2592e6
+};
+function buildTimestamp(preset, customRange, anchor) {
+	if (preset !== "custom") {
+		const ms = PRESET_MS[preset] ?? DEFAULT_WINDOW_MS;
+		return {
+			start: new Date(anchor - ms),
+			end: new Date(anchor)
+		};
+	}
+	return {
+		start: customRange?.from ?? /* @__PURE__ */ new Date(anchor - DEFAULT_WINDOW_MS),
+		end: customRange?.to ?? new Date(anchor)
+	};
+}
+/**
+* Compose a ready-to-use metrics filter object from a date window and a
+* dimensional filter. Pass the result to the metrics hooks.
+*
+* Stability guarantees (important for react-query):
+*   - `timestamp` is frozen at the moment the inputs change and does NOT update
+*     on every render. Otherwise each render would mint a new `new Date()` and
+*     every metrics query would re-fetch on every keystroke.
+*   - `filters` and `filterKey` are referentially stable while inputs are
+*     unchanged, so `queryKey` hashing is cheap and caches hit.
+*/
+function useMetricsQueryFilters({ datePreset, customRange, dimensionalFilter, dimensionalFilterKey }) {
+	const anchorRef = useRef(null);
+	const windowKey = datePreset === "custom" ? `custom:${customRange?.from?.getTime() ?? ""}:${customRange?.to?.getTime() ?? ""}` : `preset:${datePreset}`;
+	if (!anchorRef.current || anchorRef.current.key !== windowKey) anchorRef.current = {
+		key: windowKey,
+		anchor: Date.now()
+	};
+	const anchor = anchorRef.current.anchor;
+	const timestamp = useMemo(() => buildTimestamp(datePreset, customRange, anchor), [
+		datePreset,
+		customRange,
+		anchor
+	]);
+	return {
+		datePreset,
+		customRange,
+		timestamp,
+		filters: useMemo(() => ({
+			timestamp,
+			...dimensionalFilter
+		}), [timestamp, dimensionalFilterKey]),
+		dimensionalFilter,
+		filterKey: useMemo(() => `${windowKey}|${dimensionalFilterKey}`, [windowKey, dimensionalFilterKey])
+	};
+}
+// src/hooks/shared/date-format.ts
+function toDate(value) {
+	if (value == null) return void 0;
+	const date = value instanceof Date ? value : new Date(value);
+	return Number.isNaN(date.getTime()) ? void 0 : date;
+}
+const PRESET_OPTIONS = {
+	time: {
+		hour: "numeric",
+		minute: "2-digit"
+	},
+	"time-seconds": {
+		hour: "numeric",
+		minute: "2-digit",
+		second: "2-digit"
+	},
+	"date-time": {
+		month: "short",
+		day: "numeric",
+		year: "numeric",
+		hour: "numeric",
+		minute: "2-digit"
+	},
+	"date-time-seconds": {
+		month: "short",
+		day: "numeric",
+		year: "numeric",
+		hour: "numeric",
+		minute: "2-digit",
+		second: "2-digit"
+	},
+	"day-time-seconds": {
+		month: "short",
+		day: "numeric",
+		hour: "numeric",
+		minute: "2-digit",
+		second: "2-digit"
+	},
+	calendar: {
+		year: "numeric",
+		month: "numeric",
+		day: "numeric",
+		calendar: "gregory",
+		numberingSystem: "latn"
+	},
+	dayMonth: {
+		month: "short",
+		day: "numeric"
+	},
+	dayMonthYear: {
+		month: "short",
+		day: "numeric",
+		year: "numeric"
+	},
+	precise: {
+		month: "short",
+		day: "numeric",
+		year: "numeric",
+		hour: "numeric",
+		minute: "2-digit",
+		second: "2-digit",
+		fractionalSecondDigits: 3
+	},
+	timePrecise: {
+		hour: "numeric",
+		minute: "2-digit",
+		second: "2-digit",
+		fractionalSecondDigits: 3
+	}
+};
+const formatters = /* @__PURE__ */ new Map();
+function getFormatter(key, locale, timeZone) {
+	const cacheKey = `${locale ?? ""}|${timeZone ?? ""}|${key}`;
+	let formatter = formatters.get(cacheKey);
+	if (!formatter) {
+		formatter = new Intl.DateTimeFormat(locale, {
+			...PRESET_OPTIONS[key],
+			timeZone
+		});
+		formatters.set(cacheKey, formatter);
+	}
+	return formatter;
+}
+function calendarDate(date, timeZone) {
+	const parts = getFormatter("calendar", "en-US", timeZone).formatToParts(date);
+	return {
+		year: parts.find((part) => part.type === "year")?.value,
+		month: parts.find((part) => part.type === "month")?.value,
+		day: parts.find((part) => part.type === "day")?.value
+	};
+}
+/** Short absolute date without time: `Sep 24` this year, `Sep 24, 2025` otherwise. */
+function formatShortDate(value, { locale, now, timeZone } = {}) {
+	const date = toDate(value);
+	if (!date) return void 0;
+	const reference = new Date(now ?? Date.now());
+	return getFormatter(calendarDate(date, timeZone).year === calendarDate(reference, timeZone).year ? "dayMonth" : "dayMonthYear", locale, timeZone).format(date);
+}
+const LONG_RELATIVE_UNITS = [
+	["year", 31536e3],
+	["month", 2592e3],
+	["week", 604800],
+	["day", 86400],
+	["hour", 3600],
+	["minute", 60]
+];
+const relativeFormatters = /* @__PURE__ */ new Map();
+function getRelativeFormatter(locale) {
+	const key = locale ?? "";
+	let formatter = relativeFormatters.get(key);
+	if (!formatter) {
+		formatter = new Intl.RelativeTimeFormat(locale, { numeric: "auto" });
+		relativeFormatters.set(key, formatter);
+	}
+	return formatter;
+}
+/**
+* Uses the browser locale unless `locale` is given.
+* - `date`: date only; omits the year when it matches `now` in the requested timezone
+* - `date-time`: date, year and time to minutes, including historical dates
+* - `date-time-seconds`: date, year and time to seconds
+* - `day-time-seconds`: month, day and time to seconds, without the year
+* - `time`: time to minutes, without a date
+* - `time-seconds`: time to seconds, without a date
+* - `relative-time`: short relative label; delegates to `date` at seven days
+*/
+function formatDate(value, preset, options = {}) {
+	const date = toDate(value);
+	if (!date) return void 0;
+	const { locale, now, timeZone } = options;
+	if (preset === "relative-time") {
+		const diff = date.getTime() - new Date(now ?? Date.now()).getTime();
+		const abs = Math.abs(diff);
+		if (abs < 5e3) return "just now";
+		const match = [
+			{
+				limit: 6e4,
+				size: 1e3,
+				unit: "s"
+			},
+			{
+				limit: 36e5,
+				size: 6e4,
+				unit: "m"
+			},
+			{
+				limit: 864e5,
+				size: 36e5,
+				unit: "h"
+			},
+			{
+				limit: 6048e5,
+				size: 864e5,
+				unit: "d"
+			}
+		].find(({ limit }) => abs < limit);
+		if (!match) return formatDate(date, "date", options);
+		const label = `${Math.floor(abs / match.size)}${match.unit}`;
+		return diff < 0 ? `${label} ago` : `in ${label}`;
+	}
+	if (preset === "relative-long") {
+		const seconds = (date.getTime() - new Date(now ?? Date.now()).getTime()) / 1e3;
+		const [unit, size] = LONG_RELATIVE_UNITS.find(([, size]) => Math.abs(seconds) >= size) ?? ["second", 1];
+		return getRelativeFormatter(locale).format(Math.round(seconds / size), unit);
+	}
+	if (preset === "date") return formatShortDate(date, options);
+	return getFormatter(preset, locale, timeZone).format(date);
+}
+// src/hooks/metrics/metrics-interval.ts
+const HOURLY_MAX_RANGE_MS = 1728e5;
+/** Hourly buckets up to 48h, daily buckets beyond, so long ranges stay readable. */
+function chooseMetricsInterval({ start, end }) {
+	return end.getTime() - start.getTime() <= HOURLY_MAX_RANGE_MS ? "1h" : "1d";
+}
+function formatMetricsBucketLabel(ts, interval) {
+	if (interval === "1h") return formatDate(ts, "time") ?? "";
+	return formatShortDate(ts) ?? "";
+}
+// src/hooks/metrics/use-active-resources-kpi-metrics.tsx
+/** Active Resources — number of distinct resource IDs observed in agent runs.
+*  Uses approximate `count_distinct` (HyperLogLog on ClickHouse,
+*  `approx_count_distinct` on DuckDB) so the query stays fast even on
+*  tens of millions of rows. */
+function useActiveResourcesKpiMetrics(params) {
+	const client = useMastraClient();
+	const { filters, filterKey, queryOptions } = params;
+	return useQuery({
+		queryKey: [
+			"metrics",
+			"active-resources-kpi",
+			filterKey
+		],
+		queryFn: () => client.getMetricAggregate({
+			name: ["mastra_agent_duration_ms"],
+			aggregation: "count_distinct",
+			distinctColumn: "resourceId",
+			filters,
+			comparePeriod: "previous_period"
+		}),
+		...queryOptions
+	});
+}
+// src/hooks/metrics/use-active-threads-kpi-metrics.tsx
+/** Active Threads — number of distinct thread IDs observed in agent runs.
+*  Uses approximate `count_distinct` (HyperLogLog on ClickHouse,
+*  `approx_count_distinct` on DuckDB) so the query stays fast even on
+*  tens of millions of rows. */
+function useActiveThreadsKpiMetrics(params) {
+	const client = useMastraClient();
+	const { filters, filterKey, queryOptions } = params;
+	return useQuery({
+		queryKey: [
+			"metrics",
+			"active-threads-kpi",
+			filterKey
+		],
+		queryFn: () => client.getMetricAggregate({
+			name: ["mastra_agent_duration_ms"],
+			aggregation: "count_distinct",
+			distinctColumn: "threadId",
+			filters,
+			comparePeriod: "previous_period"
+		}),
+		...queryOptions
+	});
+}
+// src/hooks/metrics/use-agent-runs-kpi-metrics.tsx
+/** Total Agent Runs — count of agent duration metric observations */
+function useAgentRunsKpiMetrics(params) {
+	const client = useMastraClient();
+	const { filters, filterKey, queryOptions } = params;
+	return useQuery({
+		queryKey: [
+			"metrics",
+			"agent-runs-kpi",
+			filterKey
+		],
+		queryFn: () => client.getMetricAggregate({
+			name: ["mastra_agent_duration_ms"],
+			aggregation: "count",
+			filters,
+			comparePeriod: "previous_period"
+		}),
+		...queryOptions
+	});
+}
+// src/hooks/metrics/use-latency-metrics.tsx
+async function fetchPercentiles(client, metricName, filters, interval) {
+	const res = await client.getMetricPercentiles({
+		name: metricName,
+		percentiles: [.5, .95],
+		interval,
+		filters
+	});
+	const p50Series = res.series.find((s) => s.percentile === .5);
+	const p95Series = res.series.find((s) => s.percentile === .95);
+	if (!p50Series || !p95Series) return [];
+	const p95Map = new Map(p95Series.points.map((p) => [new Date(p.timestamp).getTime(), p.value]));
+	return p50Series.points.map((p) => {
+		const ts = new Date(p.timestamp);
+		const tsMs = ts.getTime();
+		return {
+			time: formatMetricsBucketLabel(ts, interval),
+			tsMs,
+			p50: Math.round(p.value),
+			p95: Math.round(p95Map.get(tsMs) ?? 0)
+		};
+	});
+}
+function useLatencyMetrics(params) {
+	const client = useMastraClient();
+	const { timestamp, filters, filterKey, queryOptions } = params;
+	const interval = chooseMetricsInterval(timestamp);
+	return useQuery({
+		queryKey: [
+			"metrics",
+			"latency",
+			filterKey,
+			interval
+		],
+		queryFn: async () => {
+			const [agentData, workflowData, toolData] = await Promise.all([
+				fetchPercentiles(client, "mastra_agent_duration_ms", filters, interval),
+				fetchPercentiles(client, "mastra_workflow_duration_ms", filters, interval),
+				fetchPercentiles(client, "mastra_tool_duration_ms", filters, interval)
+			]);
+			return {
+				agentData,
+				workflowData,
+				toolData,
+				interval
+			};
+		},
+		...queryOptions
+	});
+}
+// src/hooks/metrics/use-model-cost-kpi-metrics.tsx
+function useModelCostKpiMetrics(params) {
+	const client = useMastraClient();
+	const { filters, filterKey, queryOptions } = params;
+	return useQuery({
+		queryKey: [
+			"metrics",
+			"model-cost-kpi",
+			filterKey
+		],
+		queryFn: async () => {
+			const res = await client.getMetricAggregate({
+				name: ["mastra_model_total_input_tokens", "mastra_model_total_output_tokens"],
+				aggregation: "sum",
+				filters,
+				comparePeriod: "previous_period"
+			});
+			return {
+				cost: res.estimatedCost ?? null,
+				costUnit: res.costUnit ?? null,
+				previousCost: res.previousEstimatedCost ?? null,
+				costChangePercent: res.costChangePercent ?? null
+			};
+		},
+		...queryOptions
+	});
+}
+// src/hooks/shared/cost.ts
+const compactNumber = new Intl.NumberFormat("en-US", {
+	notation: "compact",
+	maximumSignificantDigits: 3
+});
+const fullNumber = new Intl.NumberFormat("en-US");
+const currencyCodes = new Set(Intl.supportedValuesOf("currency"));
+function isCurrency(code) {
+	return code !== void 0 && currencyCodes.has(code.toUpperCase());
+}
+function money(currency, options) {
+	return new Intl.NumberFormat("en-US", {
+		style: "currency",
+		currency,
+		...options
+	});
+}
+function formatCompactNumber(value, { currency } = {}) {
+	if (!isCurrency(currency)) return compactNumber.format(value);
+	const size = Math.abs(value);
+	if (size < 100) return formatFullNumber(value, { currency });
+	if (size < 1e3) return money(currency, { maximumFractionDigits: 0 }).format(value);
+	return money(currency, {
+		notation: "compact",
+		maximumSignificantDigits: 3
+	}).format(value);
+}
+function formatFullNumber(value, { currency } = {}) {
+	if (!isCurrency(currency)) return fullNumber.format(value);
+	const formatter = money(currency, {});
+	const smallestUnit = 10 ** -(formatter.resolvedOptions().maximumFractionDigits ?? 2);
+	if (value !== 0 && Math.abs(value) < smallestUnit) return `${value < 0 ? "-" : ""}<${formatter.format(smallestUnit)}`;
+	return formatter.format(value);
+}
+// src/hooks/metrics/use-model-usage-cost-metrics.tsx
+function useModelUsageCostMetrics(params) {
+	const client = useMastraClient();
+	const { filters, filterKey, queryOptions } = params;
+	return useQuery({
+		queryKey: [
+			"metrics",
+			"model-usage-cost",
+			filterKey
+		],
+		queryFn: async () => {
+			const [inputRes, outputRes, cacheReadRes, cacheWriteRes] = await Promise.all([
+				"mastra_model_total_input_tokens",
+				"mastra_model_total_output_tokens",
+				"mastra_model_input_cache_read_tokens",
+				"mastra_model_input_cache_write_tokens"
+			].map((name) => client.getMetricBreakdown({
+				name: [name],
+				groupBy: ["model", "provider"],
+				aggregation: "sum",
+				orderDirection: "DESC",
+				filters
+			})));
+			if (!inputRes || !outputRes || !cacheReadRes || !cacheWriteRes) return [];
+			const modelMap = /* @__PURE__ */ new Map();
+			const ensureModel = (dimensions) => {
+				const model = dimensions.model ?? "unknown";
+				const provider = dimensions.provider ?? void 0;
+				return getOrCreate(modelMap, `${model}\u0000${provider ?? ""}`, () => ({
+					model,
+					provider,
+					input: 0,
+					output: 0,
+					cacheRead: 0,
+					cacheWrite: 0,
+					cost: null,
+					costUnit: null
+				}));
+			};
+			const addCost = (entry, group) => {
+				if (group.estimatedCost != null) {
+					entry.cost = (entry.cost ?? 0) + group.estimatedCost;
+					if (group.costUnit) entry.costUnit = group.costUnit;
+				}
+			};
+			for (const group of inputRes.groups) {
+				const entry = ensureModel(group.dimensions);
+				entry.input = group.value;
+				addCost(entry, group);
+			}
+			for (const group of outputRes.groups) {
+				const entry = ensureModel(group.dimensions);
+				entry.output = group.value;
+				addCost(entry, group);
+			}
+			for (const group of cacheReadRes.groups) {
+				const entry = ensureModel(group.dimensions);
+				entry.cacheRead = group.value;
+			}
+			for (const group of cacheWriteRes.groups) {
+				const entry = ensureModel(group.dimensions);
+				entry.cacheWrite = group.value;
+			}
+			return Array.from(modelMap.values()).map((vals) => ({
+				model: vals.model,
+				...vals.provider ? { provider: vals.provider } : {},
+				input: formatCompactNumber(vals.input),
+				output: formatCompactNumber(vals.output),
+				cacheRead: formatCompactNumber(vals.cacheRead),
+				cacheWrite: formatCompactNumber(vals.cacheWrite),
+				cost: vals.cost,
+				costUnit: vals.costUnit
+			})).sort((a, b) => a.model.localeCompare(b.model) || (a.provider ?? "").localeCompare(b.provider ?? ""));
+		},
+		...queryOptions
+	});
+}
+// src/hooks/metrics/use-scores-metrics.tsx
+function useScoresMetrics(params) {
+	const client = useMastraClient();
+	const { datePreset, customRange, timestamp, queryOptions } = params;
+	return useQuery({
+		queryKey: [
+			"metrics",
+			"scores-card",
+			datePreset,
+			customRange
+		],
+		queryFn: async () => {
+			const filters = { timestamp: {
+				start: timestamp.start,
+				end: timestamp.end
+			} };
+			const scorersMap = await client.listScorers();
+			const scorerIds = Object.keys(scorersMap ?? {});
+			if (scorerIds.length === 0) return {
+				summaryData: [],
+				overTimeData: [],
+				scorerNames: [],
+				avgScore: null
+			};
+			const summaryData = (await Promise.all(scorerIds.map(async (scorerId) => {
+				const [avg, min, max, count] = await Promise.all([
+					client.getScoreAggregate({
+						scorerId,
+						aggregation: "avg",
+						filters
+					}),
+					client.getScoreAggregate({
+						scorerId,
+						aggregation: "min",
+						filters
+					}),
+					client.getScoreAggregate({
+						scorerId,
+						aggregation: "max",
+						filters
+					}),
+					client.getScoreAggregate({
+						scorerId,
+						aggregation: "count",
+						filters
+					})
+				]);
+				return {
+					scorer: scorerId,
+					avg: avg.value ?? 0,
+					min: min.value ?? 0,
+					max: max.value ?? 0,
+					count: count.value ?? 0
+				};
+			}))).filter((s) => s.count > 0);
+			const scorerNames = summaryData.map((s) => s.scorer);
+			if (summaryData.length === 0) return {
+				summaryData: [],
+				overTimeData: [],
+				scorerNames: [],
+				avgScore: null
+			};
+			const totalWeighted = summaryData.reduce((s, d) => s + d.avg * d.count, 0);
+			const totalCount = summaryData.reduce((s, d) => s + d.count, 0);
+			const avgScore = totalCount ? Math.round(totalWeighted / totalCount * 100) / 100 : 0;
+			const interval = "1h";
+			const timeSeriesResults = await Promise.all(scorerNames.map((scorerId) => client.getScoreTimeSeries({
+				scorerId,
+				interval,
+				aggregation: "avg",
+				filters
+			})));
+			const hourBuckets = /* @__PURE__ */ new Map();
+			for (let i = 0; i < scorerNames.length; i++) {
+				const scorerId = scorerNames[i];
+				const series = timeSeriesResults[i]?.series ?? [];
+				for (const s of series) for (const point of s.points) {
+					const ts = new Date(point.timestamp);
+					const hourKey = ts.getHours() * 60 + ts.getMinutes();
+					const scorerMap = getOrCreate(hourBuckets, hourKey, () => /* @__PURE__ */ new Map());
+					const acc = getOrCreate(scorerMap, scorerId, () => ({
+						sum: 0,
+						count: 0
+					}));
+					acc.sum += point.value;
+					acc.count += 1;
+				}
+			}
+			return {
+				summaryData,
+				overTimeData: Array.from(hourBuckets.entries()).sort(([a], [b]) => a - b).map(([hourKey, scorerMap]) => {
+					const point = { time: formatDate(new Date(2e3, 0, 1, Math.floor(hourKey / 60), hourKey % 60), "time") ?? "" };
+					for (const [scorerId, acc] of scorerMap) point[scorerId] = +(acc.sum / acc.count).toFixed(2);
+					return point;
+				}),
+				scorerNames,
+				avgScore
+			};
+		},
+		...queryOptions
+	});
+}
+// src/hooks/metrics/use-token-usage-by-agent-metrics.tsx
+function useTokenUsageByAgentMetrics(params) {
+	const client = useMastraClient();
+	const { filters, filterKey, queryOptions } = params;
+	return useQuery({
+		queryKey: [
+			"metrics",
+			"token-usage-by-agent",
+			filterKey
+		],
+		queryFn: async () => {
+			const breakdownBase = {
+				groupBy: ["entityName"],
+				aggregation: "sum",
+				orderDirection: "DESC",
+				filters
+			};
+			const [inputRes, outputRes] = await Promise.all([client.getMetricBreakdown({
+				...breakdownBase,
+				name: ["mastra_model_total_input_tokens"]
+			}), client.getMetricBreakdown({
+				...breakdownBase,
+				name: ["mastra_model_total_output_tokens"]
+			})]);
+			const agentMap = /* @__PURE__ */ new Map();
+			const ensure = (name) => getOrCreate(agentMap, name, () => ({
+				input: 0,
+				output: 0,
+				cost: null,
+				costUnit: null
+			}));
+			const addCost = (entry, group) => {
+				if (group.estimatedCost != null) {
+					entry.cost = (entry.cost ?? 0) + group.estimatedCost;
+					if (group.costUnit) entry.costUnit = group.costUnit;
+				}
+			};
+			for (const group of inputRes.groups) {
+				const entry = ensure(group.dimensions.entityName ?? "unknown");
+				entry.input = group.value;
+				addCost(entry, group);
+			}
+			for (const group of outputRes.groups) {
+				const entry = ensure(group.dimensions.entityName ?? "unknown");
+				entry.output = group.value;
+				addCost(entry, group);
+			}
+			return Array.from(agentMap.entries()).map(([name, vals]) => ({
+				name,
+				input: vals.input,
+				output: vals.output,
+				total: vals.input + vals.output,
+				cost: vals.cost,
+				costUnit: vals.costUnit
+			})).sort((a, b) => b.total - a.total);
+		},
+		...queryOptions
+	});
+}
+// src/hooks/metrics/use-token-usage-timeseries.tsx
+function addSeriesPoints(pointMap, series, key) {
+	for (const point of series?.points ?? []) {
+		const tsMs = new Date(point.timestamp).getTime();
+		if (!Number.isFinite(tsMs)) continue;
+		const existing = pointMap.get(tsMs) ?? {
+			tsMs,
+			input: 0,
+			output: 0,
+			cost: null,
+			costUnits: /* @__PURE__ */ new Set(),
+			hasUnknownCostUnit: false
+		};
+		existing[key] += point.value;
+		if (point.estimatedCost != null) {
+			existing.cost = (existing.cost ?? 0) + point.estimatedCost;
+			if (series?.costUnit) existing.costUnits.add(series.costUnit);
+			else existing.hasUnknownCostUnit = true;
+		}
+		pointMap.set(tsMs, existing);
+	}
+}
+function toCostUnit(entry) {
+	if (entry.cost == null || entry.hasUnknownCostUnit || entry.costUnits.size !== 1) return null;
+	return [...entry.costUnits][0] ?? null;
+}
+function useTokenUsageTimeSeries(params) {
+	const client = useMastraClient();
+	const { timestamp, filters, filterKey, queryOptions } = params;
+	const interval = chooseMetricsInterval(timestamp);
+	return useQuery({
+		queryKey: [
+			"metrics",
+			"token-usage-timeseries",
+			filterKey,
+			interval
+		],
+		queryFn: async () => {
+			const [inputRes, outputRes] = await Promise.all([client.getMetricTimeSeries({
+				name: ["mastra_model_total_input_tokens"],
+				interval,
+				aggregation: "sum",
+				filters
+			}), client.getMetricTimeSeries({
+				name: ["mastra_model_total_output_tokens"],
+				interval,
+				aggregation: "sum",
+				filters
+			})]);
+			const pointMap = /* @__PURE__ */ new Map();
+			addSeriesPoints(pointMap, inputRes.series[0], "input");
+			addSeriesPoints(pointMap, outputRes.series[0], "output");
+			return {
+				data: Array.from(pointMap.values()).sort((a, b) => a.tsMs - b.tsMs).map((point) => {
+					return {
+						time: formatMetricsBucketLabel(new Date(point.tsMs), interval),
+						tsMs: point.tsMs,
+						input: point.input,
+						output: point.output,
+						total: point.input + point.output,
+						cost: point.cost,
+						costUnit: toCostUnit(point)
+					};
+				}),
+				interval
+			};
+		},
+		...queryOptions
+	});
+}
+// src/hooks/metrics/use-top-active-threads-metrics.tsx
+const TOP_N$1 = 20;
+/** Top Active Threads — the threads with the most agent runs in the selected
+*  range. Server-side TopK (`ORDER BY value DESC LIMIT 20`) is required so the
+*  query never returns the full thread set when cardinality is in the millions.
+*
+*  Tokens + cost are joined in from parallel breakdowns on the same `threadId`
+*  grouping so we don't need any new backend aggregation support. */
+function useTopActiveThreadsMetrics(params) {
+	const client = useMastraClient();
+	const { filters, filterKey, queryOptions } = params;
+	return useQuery({
+		queryKey: [
+			"metrics",
+			"top-active-threads",
+			filterKey
+		],
+		queryFn: async () => {
+			const breakdownBase = {
+				groupBy: ["threadId", "resourceId"],
+				orderDirection: "DESC",
+				filters
+			};
+			const [runsRes, inputRes, outputRes] = await Promise.all([
+				client.getMetricBreakdown({
+					...breakdownBase,
+					name: ["mastra_agent_duration_ms"],
+					aggregation: "count",
+					limit: TOP_N$1
+				}),
+				client.getMetricBreakdown({
+					...breakdownBase,
+					name: ["mastra_model_total_input_tokens"],
+					aggregation: "sum",
+					limit: TOP_N$1
+				}),
+				client.getMetricBreakdown({
+					...breakdownBase,
+					name: ["mastra_model_total_output_tokens"],
+					aggregation: "sum",
+					limit: TOP_N$1
+				})
+			]);
+			const byThread = /* @__PURE__ */ new Map();
+			const ensure = (threadId) => getOrCreate(byThread, threadId, () => ({
+				tokens: 0,
+				cost: null,
+				costUnit: null
+			}));
+			const foldTokens = (groups) => {
+				for (const group of groups) {
+					const threadId = group.dimensions.threadId;
+					if (!threadId) continue;
+					const entry = ensure(threadId);
+					entry.tokens += group.value;
+					if (group.estimatedCost != null) {
+						entry.cost = (entry.cost ?? 0) + group.estimatedCost;
+						if (group.costUnit) entry.costUnit = group.costUnit;
+					}
+				}
+			};
+			foldTokens(inputRes.groups);
+			foldTokens(outputRes.groups);
+			return runsRes.groups.filter((group) => !!group.dimensions.threadId).map((group) => {
+				const threadId = group.dimensions.threadId;
+				const extra = byThread.get(threadId);
+				return {
+					threadId,
+					resourceId: group.dimensions.resourceId ?? null,
+					runs: group.value,
+					tokens: extra?.tokens ?? 0,
+					cost: extra?.cost ?? null,
+					costUnit: extra?.costUnit ?? null
+				};
+			});
+		},
+		...queryOptions
+	});
+}
+// src/hooks/metrics/use-top-resources-by-threads-metrics.tsx
+const TOP_N = 20;
+/** Top Resources by Thread Count — the resources with the most distinct threads
+*  in the selected range. Uses `count_distinct(threadId)` per `resourceId`,
+*  with server-side TopK (`ORDER BY value DESC LIMIT 20`).
+*
+*  Tokens + cost are joined in from parallel breakdowns on `resourceId` so the
+*  table can show cost/usage without a separate backend aggregation. */
+function useTopResourcesByThreadsMetrics(params) {
+	const client = useMastraClient();
+	const { filters, filterKey, queryOptions } = params;
+	return useQuery({
+		queryKey: [
+			"metrics",
+			"top-resources-by-threads",
+			filterKey
+		],
+		queryFn: async () => {
+			const breakdownBase = {
+				groupBy: ["resourceId"],
+				orderDirection: "DESC",
+				filters
+			};
+			const [threadsRes, inputRes, outputRes] = await Promise.all([
+				client.getMetricBreakdown({
+					...breakdownBase,
+					name: ["mastra_agent_duration_ms"],
+					aggregation: "count_distinct",
+					distinctColumn: "threadId",
+					limit: TOP_N
+				}),
+				client.getMetricBreakdown({
+					...breakdownBase,
+					name: ["mastra_model_total_input_tokens"],
+					aggregation: "sum",
+					limit: TOP_N
+				}),
+				client.getMetricBreakdown({
+					...breakdownBase,
+					name: ["mastra_model_total_output_tokens"],
+					aggregation: "sum",
+					limit: TOP_N
+				})
+			]);
+			const byResource = /* @__PURE__ */ new Map();
+			const ensure = (resourceId) => getOrCreate(byResource, resourceId, () => ({
+				tokens: 0,
+				cost: null,
+				costUnit: null
+			}));
+			const foldTokens = (groups) => {
+				for (const group of groups) {
+					const resourceId = group.dimensions.resourceId;
+					if (!resourceId) continue;
+					const entry = ensure(resourceId);
+					entry.tokens += group.value;
+					if (group.estimatedCost != null) {
+						entry.cost = (entry.cost ?? 0) + group.estimatedCost;
+						if (group.costUnit) entry.costUnit = group.costUnit;
+					}
+				}
+			};
+			foldTokens(inputRes.groups);
+			foldTokens(outputRes.groups);
+			return threadsRes.groups.filter((group) => !!group.dimensions.resourceId).map((group) => {
+				const resourceId = group.dimensions.resourceId;
+				const extra = byResource.get(resourceId);
+				return {
+					resourceId,
+					threadCount: group.value,
+					tokens: extra?.tokens ?? 0,
+					cost: extra?.cost ?? null,
+					costUnit: extra?.costUnit ?? null
+				};
+			});
+		},
+		...queryOptions
+	});
+}
+// src/hooks/metrics/use-total-tokens-kpi-metrics.tsx
+function useTotalTokensKpiMetrics(params) {
+	const client = useMastraClient();
+	const { filters, filterKey, queryOptions } = params;
+	return useQuery({
+		queryKey: [
+			"metrics",
+			"total-tokens-kpi",
+			filterKey
+		],
+		queryFn: async () => {
+			const [input, output] = await Promise.all([client.getMetricAggregate({
+				name: ["mastra_model_total_input_tokens"],
+				aggregation: "sum",
+				filters,
+				comparePeriod: "previous_period"
+			}), client.getMetricAggregate({
+				name: ["mastra_model_total_output_tokens"],
+				aggregation: "sum",
+				filters,
+				comparePeriod: "previous_period"
+			})]);
+			const hasCurrent = input.value != null || output.value != null;
+			const hasPrevious = input.previousValue != null || output.previousValue != null;
+			const value = (input.value ?? 0) + (output.value ?? 0);
+			const previousValue = (input.previousValue ?? 0) + (output.previousValue ?? 0);
+			const changePercent = hasPrevious && previousValue > 0 ? (value - previousValue) / previousValue * 100 : null;
+			return {
+				value: hasCurrent ? value : null,
+				previousValue: hasPrevious ? previousValue : null,
+				changePercent
+			};
+		},
+		...queryOptions
+	});
+}
+// src/hooks/metrics/use-trace-volume-metrics.tsx
+async function fetchVolume(client, metricName, filters) {
+	const res = await client.getMetricBreakdown({
+		name: [metricName],
+		groupBy: ["entityName", "status"],
+		aggregation: "count",
+		orderDirection: "DESC",
+		filters
+	});
+	const map = /* @__PURE__ */ new Map();
+	for (const group of res.groups) {
+		const name = group.dimensions.entityName ?? "unknown";
+		const status = group.dimensions.status ?? "ok";
+		const entry = getOrCreate(map, name, () => ({
+			completed: 0,
+			errors: 0
+		}));
+		if (status === "error") entry.errors += group.value;
+		else entry.completed += group.value;
+	}
+	return Array.from(map.entries()).map(([name, vals]) => ({
+		name,
+		...vals
+	})).sort((a, b) => b.completed + b.errors - (a.completed + a.errors));
+}
+function useTraceVolumeMetrics(params) {
+	const client = useMastraClient();
+	const { filters, filterKey, queryOptions } = params;
+	return useQuery({
+		queryKey: [
+			"metrics",
+			"trace-volume",
+			filterKey
+		],
+		queryFn: async () => {
+			const [agentData, workflowData, toolData] = await Promise.all([
+				fetchVolume(client, "mastra_agent_duration_ms", filters),
+				fetchVolume(client, "mastra_workflow_duration_ms", filters),
+				fetchVolume(client, "mastra_tool_duration_ms", filters)
+			]);
+			return {
+				agentData,
+				workflowData,
+				toolData
+			};
+		},
+		...queryOptions
+	});
+}
+export { chooseMetricsInterval, formatMetricsBucketLabel, useActiveResourcesKpiMetrics, useActiveThreadsKpiMetrics, useAgentRunsKpiMetrics, useLatencyMetrics, useMetricsQueryFilters, useModelCostKpiMetrics, useModelUsageCostMetrics, useScoresMetrics, useTokenUsageByAgentMetrics, useTokenUsageTimeSeries, useTopActiveThreadsMetrics, useTopResourcesByThreadsMetrics, useTotalTokensKpiMetrics, useTraceVolumeMetrics };
+
+//# sourceMappingURL=index.js.map