@mastra/react 1.12.0-alpha.9 → 1.12.0

package/dist/hooks/traces/index.js

@@ -1,8 +1,8 @@
 import { n as useMastraClient } from "../../mastra-client-context-Bx_g84YB.js";
 import { t as useInView } from "../../use-in-view-C9sYPGRm.js";
-import { t as getOrCreate } from "../../map-CDv4fbu4.js";
 import { n as is403ForbiddenError } from "../../query-utils-D1NgFnWU.js";
 import { t as getFeedbackRefetchInterval } from "../../feedback-refetch-interval-DLHzQoVV.js";
+import { t as getOrCreate } from "../../map-CDv4fbu4.js";
 import { MastraClient, MastraClientError } from "@mastra/client-js";
 import { useEffect, useMemo, useRef, useState } from "react";
 import { keepPreviousData, queryOptions, skipToken, useInfiniteQuery, useMutation, useQueries, useQuery, useQueryClient } from "@tanstack/react-query";
@@ -18,7 +18,7 @@ import { EntityType } from "@mastra/core/observability";
 * through to the store's discovery refresh. Matching the server TTL keeps the
 * client from asking more often than the answer can change.
 */
-const DISCOVERY_STALE_TIME = 300 * 1e3;
+const DISCOVERY_STALE_TIME = 3e5;
 //#endregion
 //#region src/hooks/traces/use-branch.ts
 /**
@@ -135,7 +135,7 @@ const useServiceNames = ({ queryOptions } = {}) => {
 };
 //#endregion
 //#region src/hooks/traces/use-span-detail.ts
-const IMMUTABLE_CACHE_TIME$1 = 1e3 * 60 * 60 * 24 * 30;
+const IMMUTABLE_CACHE_TIME$1 = 2592e6;
 /**
 * Does not guard on empty ids; pass `queryOptions: { enabled }` to skip the fetch.
 */
@@ -200,7 +200,7 @@ function useThreadHasOtherTraces({ threadId, queryOptions }) {
 }
 //#endregion
 //#region src/hooks/traces/use-trace-light-spans.ts
-const IMMUTABLE_CACHE_TIME = 1e3 * 60 * 60 * 24 * 30;
+const IMMUTABLE_CACHE_TIME = 2592e6;
 /**
 * Does not guard on empty ids; pass `queryOptions: { enabled }` to skip the fetch.
 */
@@ -319,6 +319,8 @@ function useTraceOrBranchSpans({ traceId, anchorSpanId, listMode, depth, queryOp
 //#endregion
 //#region src/hooks/traces/use-trace-query.ts
 const TRACE_QUERY_PER_PAGE = 25;
+/** Max traces per delta request; the server caps `limit` at 100. */
+const TRACE_QUERY_DELTA_LIMIT = 100;
 function getTraceQueryNextPageParam(lastPage) {
 	return lastPage?.page.next ?? void 0;
 }
@@ -368,16 +370,101 @@ function selectLegacyTraceQueryTraces(data) {
 function getLegacyTraceQueryNextPageParam(lastPage) {
 	return lastPage.pagination?.hasMore ? lastPage.pagination.page + 1 : void 0;
 }
+/** Cache key of `useTraceQuery`'s trace-query list. Pass the same `query` and `limit` to share it. */
+const traceQueryKey = (query, limit = 25) => [
+	"trace-query",
+	query,
+	limit
+];
+function traceSortValue(trace, field) {
+	if (field === "timeToFirstChunkMs") return trace.timeToFirstChunkMs ?? null;
+	const value = trace[field];
+	return value == null ? null : Date.parse(value);
+}
+/** Mirrors the server's keyset order: empty values last in both directions, ties by ascending `traceId`. */
+function compareTraces(orderBy) {
+	return (a, b) => {
+		const va = traceSortValue(a, orderBy.field);
+		const vb = traceSortValue(b, orderBy.field);
+		if (va !== vb) {
+			if (va === null) return 1;
+			if (vb === null) return -1;
+			return orderBy.direction === "asc" ? va - vb : vb - va;
+		}
+		return a.traceId < b.traceId ? -1 : a.traceId > b.traceId ? 1 : 0;
+	};
+}
+/**
+* Merges delta-polled traces into the pages of a `useTraceQuery` list, without mutating `data`.
+* A trace already on a page is replaced in place when its sort value is unchanged; otherwise it is
+* removed and placed again like a new trace (sorting by `endedAt`, a running trace moves once it
+* ends). A new trace goes into the first page whose last row sorts after it; when no loaded page does, it is
+* appended to the last page if that is the end of the list, and skipped otherwise, since keyset
+* pagination returns it once the user scrolls there. Page cursors are kept as they are, and `data`
+* itself is returned when nothing changed.
+*/
+function mergeTraceQueryDelta(data, traces, orderBy) {
+	if (traces.length === 0 || data.pages.length === 0) return data;
+	const incoming = new Map(traces.map((trace) => [trace.traceId, trace]));
+	const rows = data.pages.map((page) => page.traces);
+	const changed = /* @__PURE__ */ new Set();
+	const write = (pageIndex, next) => {
+		rows[pageIndex] = next;
+		changed.add(pageIndex);
+	};
+	const sortBy = orderBy?.[0] ?? {
+		field: "startedAt",
+		direction: "desc"
+	};
+	const compare = compareTraces(sortBy);
+	const replacedInPlace = /* @__PURE__ */ new Set();
+	rows.forEach((pageRows, pageIndex) => {
+		if (!pageRows.some((row) => incoming.has(row.traceId))) return;
+		const next = [];
+		for (const row of pageRows) {
+			const update = incoming.get(row.traceId);
+			if (!update) next.push(row);
+			else if (traceSortValue(update, sortBy.field) === traceSortValue(row, sortBy.field)) {
+				next.push(update);
+				replacedInPlace.add(row.traceId);
+			}
+		}
+		write(pageIndex, next);
+	});
+	for (const traceId of replacedInPlace) incoming.delete(traceId);
+	const lastIndex = rows.length - 1;
+	for (const trace of incoming.values()) {
+		let pageIndex = rows.findIndex((pageRows) => {
+			const last = pageRows[pageRows.length - 1];
+			return last !== void 0 && compare(trace, last) < 0;
+		});
+		if (pageIndex === -1) {
+			if (data.pages[lastIndex].page.next !== null) continue;
+			pageIndex = lastIndex;
+		}
+		const pageRows = rows[pageIndex];
+		const at = pageRows.findIndex((row) => compare(trace, row) < 0);
+		write(pageIndex, at === -1 ? [...pageRows, trace] : [
+			...pageRows.slice(0, at),
+			trace,
+			...pageRows.slice(at)
+		]);
+	}
+	if (changed.size === 0) return data;
+	return {
+		...data,
+		pages: data.pages.map((page, pageIndex) => changed.has(pageIndex) ? {
+			...page,
+			traces: rows[pageIndex]
+		} : page)
+	};
+}
 /** Queries traces with cursor pagination and viewport-driven loading. */
 function useTraceQuery({ query, limit = 25, enabled = true, withQueryTrace = true, legacyFilters, queryOptions }) {
 	const client = useMastraClient();
 	const { inView, setRef: setEndOfListElement } = useInView();
 	const queryResult = useInfiniteQuery({
-		queryKey: [
-			"trace-query",
-			query,
-			limit
-		],
+		queryKey: traceQueryKey(query, limit),
 		queryFn: query ? async ({ pageParam }) => {
 			const response = await new MastraClient({
 				...client.options,
@@ -455,6 +542,90 @@ function useTraceQuery({ query, limit = 25, enabled = true, withQueryTrace = tru
 		setEndOfListElement
 	};
 }
+function omitOrderBy({ orderBy: _orderBy, ...rest }) {
+	return rest;
+}
+/** Request timeouts and rate limits clear up on their own, unlike the other 4xx refusals. */
+const TRANSIENT_CLIENT_ERROR_STATUSES = /* @__PURE__ */ new Set([408, 429]);
+/** The server refused the request or does not support delta polling; polling again cannot change that. */
+function isRejectedDeltaRequest(error) {
+	if (!(error instanceof MastraClientError) || TRANSIENT_CLIENT_ERROR_STATUSES.has(error.status)) return false;
+	return error.status >= 400 && error.status < 500 || error.status === 501;
+}
+const isCursorConflict = (error) => error instanceof MastraClientError && error.status === 409;
+/**
+* Polls `queryTraces({ mode: 'delta' })` and merges new or updated traces into the list of a
+* `useTraceQuery` rendered with the same `query` and `limit`. The first request only establishes
+* the server cursor; each later poll drains every batch since that cursor. A cursor conflict (409)
+* starts over with a new cursor. A poll that returns while the list is loading a page, or before
+* the list has loaded at all, keeps its cursor and asks again on the next poll.
+*
+* The cursor is keyed on the query without `orderBy` (delta polls cannot sort) and on `limit`, so
+* re-sorting the list keeps polling from the same cursor, and lists with different page sizes each
+* get their own cursor.
+*
+* Requires the `deltaPolling` capability (see `useTraceQueryDeltaPollingAvailable`). The list's
+* `timeRange.to` must not move between polls, so a live list needs a `to` in the future.
+*
+* Known limitation: the cursor is established in parallel with the list's first page, so a trace
+* that completes between the first page's read and the cursor can be missed until the list is
+* refetched. Traces returned by both are merged by `traceId`.
+*/
+function useTraceQueryLatest({ query, limit = 25, enabled = true, refetchInterval = false, queryOptions }) {
+	const client = useMastraClient();
+	const queryClient = useQueryClient();
+	const deltaQuery = query && omitOrderBy(query);
+	const queryKey = [
+		"trace-query-latest",
+		deltaQuery,
+		limit
+	];
+	return useQuery({
+		queryKey,
+		queryFn: query && deltaQuery ? async () => {
+			const mastra = new MastraClient({
+				...client.options,
+				retries: 0
+			});
+			const bootstrap = async () => {
+				return { deltaCursor: (await mastra.queryTraces({
+					...deltaQuery,
+					mode: "delta"
+				})).deltaCursor };
+			};
+			const previous = queryClient.getQueryData(queryKey);
+			if (!previous) return bootstrap();
+			const traces = [];
+			let deltaCursor = previous.deltaCursor;
+			try {
+				for (let hasMore = true; hasMore;) {
+					const response = await mastra.queryTraces({
+						...deltaQuery,
+						mode: "delta",
+						after: deltaCursor,
+						limit: 100
+					});
+					traces.push(...response.traces);
+					deltaCursor = response.deltaCursor;
+					hasMore = response.delta.hasMore;
+				}
+			} catch (error) {
+				if (isCursorConflict(error)) return bootstrap();
+				throw error;
+			}
+			const listKey = traceQueryKey(query, limit);
+			const listState = queryClient.getQueryState(listKey);
+			if (!listState?.data || listState.fetchStatus === "fetching") return previous;
+			queryClient.setQueryData(listKey, (data) => data ? mergeTraceQueryDelta(data, traces, query.orderBy) : data);
+			return { deltaCursor };
+		} : skipToken,
+		retry: false,
+		refetchInterval: (q) => isRejectedDeltaRequest(q.state.error) ? false : refetchInterval,
+		refetchIntervalInBackground: false,
+		enabled: enabled && !!query,
+		...queryOptions
+	});
+}
 //#endregion
 //#region src/hooks/traces/use-trace-usage.ts
 const INPUT_TOKEN_METRIC = "mastra_model_total_input_tokens";
@@ -551,7 +722,7 @@ const DEFAULT_POLLING_CONFIG = {
 	deltaLimit: 100,
 	pageModeRefetchIntervalMs: 1e4,
 	page0StatusRefreshIntervalMs: 6e4,
-	idleGuardThresholdMs: 15 * 6e4,
+	idleGuardThresholdMs: 9e5,
 	minRefetchSpinMs: 400,
 	deltaHighlightMs: 1e3
 };
@@ -1129,6 +1300,6 @@ function useTraceColumnPreferencesStorageKey() {
 	return `mastra:traces:columns:${client.options.baseUrl || (typeof window === "undefined" ? "local" : window.location.origin || "local")}:${client.options.apiPrefix ?? "/api"}`;
 }
 //#endregion
-export { DISCOVERY_STALE_TIME, ROOT_ENTITY_TYPES, TRACES_PER_PAGE, TRACE_QUERY_PER_PAGE, createTraceQueryValuesResolver, getLegacyTraceQueryNextPageParam, getTraceQueryNextPageParam, getTracesNextPageParam, lightSpanToTraceQueryTrace, mergeDeltaIntoPage0, refreshPage0Rows, selectLegacyTraceQueryTraces, selectTraceQueryTraces, selectUniqueTraces, shouldPinLightList, shouldResetAfterIdle, traceQueryFieldsQueryKey, traceSpansQueryOptions, useBranch, useCreateFeedback, useDeleteFeedback, useEntityNames, useEnvironments, useFetchTraceSpans, useServiceNames, useSpanDetail, useSpanFeedback, useTags, useThreadHasOtherTraces, useTraceColumnPreferencesStorageKey, useTraceFeedback, useTraceLightSpans, useTraceMetadataFilterFields, useTraceOrBranchSpans, useTraceQuery, useTraceSpans, useTraceSpansQueries, useTraceUsage, useTraces };
+export { DISCOVERY_STALE_TIME, ROOT_ENTITY_TYPES, TRACES_PER_PAGE, TRACE_QUERY_DELTA_LIMIT, TRACE_QUERY_PER_PAGE, createTraceQueryValuesResolver, getLegacyTraceQueryNextPageParam, getTraceQueryNextPageParam, getTracesNextPageParam, lightSpanToTraceQueryTrace, mergeDeltaIntoPage0, mergeTraceQueryDelta, refreshPage0Rows, selectLegacyTraceQueryTraces, selectTraceQueryTraces, selectUniqueTraces, shouldPinLightList, shouldResetAfterIdle, traceQueryFieldsQueryKey, traceQueryKey, traceSpansQueryOptions, useBranch, useCreateFeedback, useDeleteFeedback, useEntityNames, useEnvironments, useFetchTraceSpans, useServiceNames, useSpanDetail, useSpanFeedback, useTags, useThreadHasOtherTraces, useTraceColumnPreferencesStorageKey, useTraceFeedback, useTraceLightSpans, useTraceMetadataFilterFields, useTraceOrBranchSpans, useTraceQuery, useTraceQueryLatest, useTraceSpans, useTraceSpansQueries, useTraceUsage, useTraces };
 
 //# sourceMappingURL=index.js.map