@mastra/playground-ui 66.1.0-alpha.2 → 67.0.0

package/dist/src/domains/spans/hooks/use-spans-list-source.d.ts

@@ -63,5 +63,8 @@ export declare function useSpansListSource({ query, rolling, autoRefetch, limit,
         errorPreview: string | null;
         timeToFirstChunkMs?: number | null | undefined;
         timeToFirstTokenMs?: number | null | undefined;
+        outcome?: string | null | undefined;
+        stopReason?: string | null | undefined;
+        stopReasonContext?: Record<string, unknown> | null | undefined;
     }[] | undefined;
 };

package/dist/src/domains/spans/span-filters.d.ts

@@ -1,14 +1,23 @@
 import type { TraceQueryScalarPredicate } from '@mastra/core/storage';
+import type { StreamingTimingSupport } from '../traces/trace-filters';
 import type { TraceFilterGroup, TraceFilterToken } from '../traces/trace-query-filters';
 import type { FilterBarField, FilterBarSuggestionsResolver } from '../../ds/components/FilterBar/types';
 /** Span query fields every store accepts. `startedAt`/`endedAt` are left to the time-range chip. */
-export declare const SPAN_CORE_FILTER_FIELD_IDS: readonly ['name', 'spanType', 'status', 'error', 'durationMs', 'timeToFirstChunkMs', 'entityType', 'entityId', 'entityName', 'entityVersionId', 'parentEntityVersionId', 'rootEntityVersionId', 'runId', 'sessionId', 'userId', 'organizationId'];
+export declare const SPAN_CORE_FILTER_FIELD_IDS: readonly ['name', 'spanType', 'status', 'error', 'durationMs', 'timeToFirstChunkMs', 'timeToFirstTokenMs', 'entityType', 'entityId', 'entityName', 'entityVersionId', 'parentEntityVersionId', 'rootEntityVersionId', 'runId', 'sessionId', 'userId', 'organizationId'];
 /** Span query fields the server only accepts when the store declares `spanQueryContextFields`. */
 export declare const SPAN_CONTEXT_FILTER_FIELD_IDS: readonly ['traceId', 'spanId', 'parentSpanId', 'threadId', 'resourceId', 'requestId', 'serviceName', 'experimentId', 'environment', 'executionSource', 'parentEntityType', 'parentEntityId', 'parentEntityName', 'rootEntityType', 'rootEntityId', 'rootEntityName'];
+/** Span query fields the server only accepts when the store declares `spanQueryOutcomeFields`. */
+export declare const SPAN_OUTCOME_FILTER_FIELD_IDS: readonly ['outcome', 'stopReason'];
+/** Span query fields the server only accepts when the store declares `spanQueryModelFields`. */
+export declare const SPAN_MODEL_FILTER_FIELD_IDS: readonly ['model', 'provider'];
 /** FilterBar fields for the spans page: only paths and operators `querySpans()` accepts. */
-export declare function createSpanFilterBarFields({ withContextFields, entityNames, environments, valueSuggestions, }: {
+export declare function createSpanFilterBarFields({ withContextFields, withTimeToFirstChunk, withTimeToFirstToken, withOutcomeFields, withModelFields, entityNames, environments, valueSuggestions, }: StreamingTimingSupport & {
     /** Offer the context fields. Only when the server declares `spanQueryContextFields`. */
     withContextFields: boolean;
+    /** Offer `outcome` and `stopReason`. Only when the server declares `spanQueryOutcomeFields`. */
+    withOutcomeFields?: boolean;
+    /** Offer `model` and `provider`. Only when the server declares `spanQueryModelFields`. */
+    withModelFields?: boolean;
     entityNames: readonly string[];
     environments: readonly string[];
     /** Builds a lazy value resolver for a span field. Absent → free text. */
@@ -16,9 +25,11 @@ export declare function createSpanFilterBarFields({ withContextFields, entityNam
 }): FilterBarField[];
 /**
  * The span query `where` for the filter bar's tokens and groups, or `undefined` when nothing applies.
- * Conditions the span query can't run (unknown fields, context fields without the capability,
- * unusable values) are left out instead of failing the request.
+ * Conditions the span query can't run (unknown fields, context, model or outcome fields or streaming timings without
+ * the capability, unusable values) are left out instead of failing the request.
  */
-export declare function buildSpanQueryWhere(tokens: TraceFilterToken[], groups: TraceFilterGroup[], { withContextFields }: {
+export declare function buildSpanQueryWhere(tokens: TraceFilterToken[], groups: TraceFilterGroup[], { withContextFields, withOutcomeFields, withModelFields, ...support }: StreamingTimingSupport & {
     withContextFields: boolean;
+    withOutcomeFields?: boolean;
+    withModelFields?: boolean;
 }): TraceQueryScalarPredicate | undefined;

package/dist/src/domains/threads/components/threads-explorer-body.d.ts

@@ -1,9 +1,12 @@
+import type { ObservabilityListUrlState } from '../../observability/hooks/use-observability-list-filters';
 export type ThreadsExplorerBodyProps = {
     /** The open thread. The host keeps it (e.g. in the URL) so it survives a reload. */
     selectedThreadId: string | undefined;
     onSelectedThreadChange: (threadId: string | undefined) => void;
     /** Opens a score from the thread drawer; scores live on host routes. */
     onOpenScore: (traceId: string, scoreId: string) => void;
+    /** The host's search params, so the time range, filters and sort survive a reload. Omitted: kept in memory. */
+    urlState?: ObservabilityListUrlState;
 };
 /** The threads page body: filter bar, thread list and the thread drawer. Router-agnostic. */
-export declare function ThreadsExplorerBody({ selectedThreadId, onSelectedThreadChange, onOpenScore, }: ThreadsExplorerBodyProps): import("react").JSX.Element;
+export declare function ThreadsExplorerBody({ selectedThreadId, onSelectedThreadChange, onOpenScore, urlState, }: ThreadsExplorerBodyProps): import("react").JSX.Element;

package/dist/src/domains/threads/thread-filters.d.ts

@@ -1,16 +1,17 @@
 import type { TraceQueryScalarPredicate } from '@mastra/core/storage';
+import type { StreamingTimingSupport } from '../traces/trace-filters';
 import type { TraceFilterGroup, TraceFilterToken } from '../traces/trace-query-filters';
 import type { FilterBarField } from '../../ds/components/FilterBar/types';
 /** Thread query fields the filter bar offers. `startedAt`/`endedAt` are left to the time-range chip. */
-export declare const THREAD_FILTER_FIELD_IDS: readonly ['status', 'traceCount', 'timeToFirstChunkMs', 'entityType', 'entityId', 'entityName', 'entityVersionId', 'threadId', 'resourceId', 'userId', 'organizationId', 'runId', 'sessionId', 'requestId', 'serviceName', 'experimentId', 'environment', 'executionSource'];
+export declare const THREAD_FILTER_FIELD_IDS: readonly ['status', 'traceCount', 'timeToFirstChunkMs', 'timeToFirstTokenMs', 'entityType', 'entityId', 'entityName', 'entityVersionId', 'threadId', 'resourceId', 'userId', 'organizationId', 'runId', 'sessionId', 'requestId', 'serviceName', 'experimentId', 'environment', 'executionSource'];
 /** FilterBar fields for the threads page: only paths and operators `queryTraceThreads()` accepts. */
-export declare function createThreadFilterBarFields({ entityNames, environments, }: {
+export declare function createThreadFilterBarFields({ withTimeToFirstChunk, withTimeToFirstToken, entityNames, environments, }: StreamingTimingSupport & {
     entityNames: readonly string[];
     environments: readonly string[];
 }): FilterBarField[];
 /**
  * The thread query `where` for the filter bar's tokens and groups, or `undefined` when nothing applies.
- * Conditions the thread query can't run (unknown fields, unusable values) are left out instead of
- * failing the request.
+ * Conditions the thread query can't run (unknown fields, streaming timings the store doesn't record,
+ * unusable values) are left out instead of failing the request.
  */
-export declare function buildThreadQueryWhere(tokens: TraceFilterToken[], groups: TraceFilterGroup[]): TraceQueryScalarPredicate | undefined;
+export declare function buildThreadQueryWhere(tokens: TraceFilterToken[], groups: TraceFilterGroup[], support: StreamingTimingSupport): TraceQueryScalarPredicate | undefined;

package/dist/src/domains/traces/components/columns-menu/columns-menu.d.ts

@@ -1,9 +1,9 @@
 import type { TraceQueryDiscoveryTimeRange } from '@mastra/react/hooks/traces';
 import type { TraceColumnPreferences, TraceColumnScope } from '../../trace-list-columns';
 import type { TracesMetricsSupport } from '../traces-explorer/traces-explorer-context';
-export type ColumnsMenuScope = TraceColumnScope | 'threads';
+export type ColumnsMenuScope = TraceColumnScope;
 export type ColumnsMenuProps = {
-    /** Which list the columns belong to. Each scope offers only the columns its rows carry; threads renders nothing. */
+    /** Which list the columns belong to. Each scope offers only the columns its rows carry. */
     scope: ColumnsMenuScope;
     /** The active column selection. The host owns it (and its persistence). */
     value: TraceColumnPreferences;
@@ -21,4 +21,4 @@ export type ColumnsMenuProps = {
  * the scope's query capability, and (for traces) discovers the metadata keys observed in the
  * time range on its own; the host only owns the selection.
  */
-export declare function ColumnsMenu({ scope, ...props }: ColumnsMenuProps): import("react").JSX.Element | null;
+export declare const ColumnsMenu: import("react").MemoExoticComponent<({ scope, value, onChange, discoveryTimeRange, metricsSupport, queryEnabled, }: ColumnsMenuProps) => import("react").JSX.Element>;

package/dist/src/domains/traces/components/trace-data-panel-view.d.ts

@@ -1,6 +1,7 @@
 import type { ReactNode } from 'react';
 import type { TraceUsageSummary } from '../trace-list-columns';
 import type { LightSpanRecord } from '../types';
+import type { TraceStreamingTimings } from './trace-span-timeline';
 import type { DataPanelProps } from '../../../ds/components/DataPanel';
 import type { LinkComponent } from '../../../ds/types/link-component';
 export type TraceDataPanelPlacement = 'traces-list' | 'trace-page';
@@ -45,6 +46,11 @@ export interface TraceDataPanelViewProps {
     entityHref?: string;
     /** Token and estimated-cost totals shown in the compact trace summary. */
     usage?: TraceUsageSummary;
+    /**
+     * Time to first chunk and first token of the trace root, marked on the timeline. Left off when
+     * `anchorSpanId` shows a branch, whose spans don't count from the root.
+     */
+    rootStreamingTimings?: Omit<TraceStreamingTimings, 'startedAt'>;
     /**
      * Span treated as the displayed root of the timeline. Required for branch
      * subtrees from `getBranch` where the anchor has a real parent that's outside
@@ -111,4 +117,4 @@ export interface TraceDataPanelViewProps {
      */
     spanPanelSlot?: ReactNode;
 }
-export declare function TraceDataPanelView({ traceId, spans, isLoading, onClose, onSpanSelect, onEvaluateTrace, onSaveAsDatasetItem, initialSpanId, onPrevious, onNext, size, depth, headerSlot, headerActionsSlot, title, placement, LinkComponent, traceHref, entityHref, usage, anchorSpanId, entityType, showUnavailableFeaturesMsg, scoresTabSlot, scoresTabBadge, feedbackTabSlot, feedbackTabBadge, featuredSpanIds, messagesPanelSlot, sideHeaderActions, sideView: controlledSideView, onSideViewChange, spanView: controlledSpanView, onSpanViewChange, spanPanelSlot, }: TraceDataPanelViewProps): import("react").JSX.Element;
+export declare function TraceDataPanelView({ traceId, spans, isLoading, onClose, onSpanSelect, onEvaluateTrace, onSaveAsDatasetItem, initialSpanId, onPrevious, onNext, size, depth, headerSlot, headerActionsSlot, title, placement, LinkComponent, traceHref, entityHref, usage, rootStreamingTimings, anchorSpanId, entityType, showUnavailableFeaturesMsg, scoresTabSlot, scoresTabBadge, feedbackTabSlot, feedbackTabBadge, featuredSpanIds, messagesPanelSlot, sideHeaderActions, sideView: controlledSideView, onSideViewChange, spanView: controlledSpanView, onSpanViewChange, spanPanelSlot, }: TraceDataPanelViewProps): import("react").JSX.Element;

package/dist/src/domains/traces/components/trace-span-panel.d.ts

@@ -40,6 +40,7 @@ export interface TraceSpanPanelProps {
     scoresTabBadge?: ReactNode;
     scoresTabSlot?: TraceDataPanelViewProps['scoresTabSlot'];
     usage?: TraceDataPanelViewProps['usage'];
+    rootStreamingTimings?: TraceDataPanelViewProps['rootStreamingTimings'];
     traceHref?: string;
     /** Drawer width; defaults to `wide`. */
     size?: TraceDataPanelViewProps['size'];
@@ -64,5 +65,5 @@ export interface TraceSpanPanelProps {
  * Encapsulates the span-detail fetch and prev/next span navigation that the traces page
  * and the agent chat traces aside used to duplicate.
  */
-export declare function TraceSpanPanel({ traceId, spans, isLoadingSpans, selectedSpanId, onSpanSelect, onClose, anchorSpanId, entityType, initialSpanId, onPrevious, onNext, onSaveAsDatasetItem, feedbackTabBadge, feedbackTabSlot, showPartialThread, featuredSpanIds, onHighlightSpans, isFullThreadOpen, onFullThreadOpenChange, withQueryTrace, withFeedback, onOpenScore, scoresTabBadge, scoresTabSlot, usage, traceHref, size, depth, headerSlot, headerActionsSlot, title, showUnavailableFeaturesMsg, spanView, onSpanViewChange, spanActiveTab, onSpanTabChange, spanFeedbackTabBadge, spanFeedbackTabSlot, }: TraceSpanPanelProps): import("react").JSX.Element;
+export declare function TraceSpanPanel({ traceId, spans, isLoadingSpans, selectedSpanId, onSpanSelect, onClose, anchorSpanId, entityType, initialSpanId, onPrevious, onNext, onSaveAsDatasetItem, feedbackTabBadge, feedbackTabSlot, showPartialThread, featuredSpanIds, onHighlightSpans, isFullThreadOpen, onFullThreadOpenChange, withQueryTrace, withFeedback, onOpenScore, scoresTabBadge, scoresTabSlot, usage, rootStreamingTimings, traceHref, size, depth, headerSlot, headerActionsSlot, title, showUnavailableFeaturesMsg, spanView, onSpanViewChange, spanActiveTab, onSpanTabChange, spanFeedbackTabBadge, spanFeedbackTabSlot, }: TraceSpanPanelProps): import("react").JSX.Element;
 export {};

package/dist/src/domains/traces/components/trace-span-timeline-markers.d.ts

@@ -0,0 +1,5 @@
+import type { TimelineMarkersLayout } from '../utils/timeline-markers';
+/** A "Metrics" row, closed by default, revealing one row per streaming timing laid out like the span rows. */
+export declare function TimelineTimingRows({ layout }: {
+    layout: TimelineMarkersLayout;
+}): import("react").JSX.Element;

package/dist/src/domains/traces/components/trace-span-timeline.d.ts

@@ -1,5 +1,8 @@
 import type { Dispatch, ReactNode, SetStateAction } from 'react';
 import type { UISpan } from '../types';
+import type { TraceStreamingTimings } from '../utils/timeline-markers';
+/** Axis ticks are approximate gridline marks, so two decimals are enough: `250 ms`, `3.74 s`. */
+export type { TraceStreamingTimings };
 export type TraceSpanTimelineProps = {
     hierarchicalSpans: UISpan[];
     onSpanClick: (id: string) => void;
@@ -13,10 +16,12 @@ export type TraceSpanTimelineProps = {
     revealSpanId?: string;
     /** Rendered full-width above the span rows. */
     leadingSlot?: ReactNode;
+    /** Adds a collapsed "Metrics" row above the spans, revealing a row per streaming timing. */
+    streamingTimings?: TraceStreamingTimings;
 };
 /**
  * Gantt-style view of a trace: the same hierarchy and expansion state as `TraceSpanTree`,
  * but each row is a compact name cell plus a bar on a shared time axis. Rendered with its
  * own row component (`SpanTimelineRow`), independent from the tree's rows.
  */
-export declare function TraceSpanTimeline({ hierarchicalSpans, onSpanClick, selectedSpanId, isLoading, fadedTypes, expandedSpanIds, setExpandedSpanIds, featuredSpanIds, revealSpanId, leadingSlot, }: TraceSpanTimelineProps): import("react").JSX.Element;
+export declare function TraceSpanTimeline({ hierarchicalSpans, onSpanClick, selectedSpanId, isLoading, fadedTypes, expandedSpanIds, setExpandedSpanIds, featuredSpanIds, revealSpanId, leadingSlot, streamingTimings, }: TraceSpanTimelineProps): import("react").JSX.Element;

package/dist/src/domains/traces/components/trace-time-range-chip.d.ts

@@ -11,10 +11,12 @@ export declare const TRACE_TIME_RANGE_ITEM: FilterBarItem;
 export type TraceTimeRangeChipProps = Pick<DateTimeRangePickerProps, 'preset' | 'onPresetChange' | 'dateFrom' | 'dateTo' | 'onDateChange' | 'onDateRangeChange' | 'disabled' | 'maxRangeMs' | 'minDate' | 'presets'> & {
     /** Shows a × that switches back to this preset whenever another range is selected. */
     defaultPreset?: DateRangePreset;
+    /** Replaces what the × does, e.g. to undo a histogram zoom before falling back to `defaultPreset`. */
+    onReset?: () => void;
 };
 /**
  * The trace list's date range rendered as a FilterBar chip: `Time <preset>`. Always
  * present and non-removable; the value segment opens the regular DateTimeRangePicker
  * menu/popover. With `defaultPreset`, a trailing × resets the range to it.
  */
-export declare function TraceTimeRangeChip({ defaultPreset, ...props }: TraceTimeRangeChipProps): import("react").JSX.Element;
+export declare function TraceTimeRangeChip({ defaultPreset, onReset, ...props }: TraceTimeRangeChipProps): import("react").JSX.Element;

package/dist/src/domains/traces/components/traces-explorer/index.d.ts

@@ -6,6 +6,7 @@ import { TracesExplorerLayout } from './traces-explorer-layout';
 import { TracesExplorerList } from './traces-explorer-list';
 import { TracesExplorerPanel } from './traces-explorer-panel';
 import { TracesExplorerRoot } from './traces-explorer-root';
+import { TracesExplorerSavedViews } from './traces-explorer-saved-views';
 export declare const TracesExplorer: typeof TracesExplorerRoot & {
     Layout: typeof TracesExplorerLayout;
     Body: typeof TracesExplorerBody;
@@ -16,13 +17,15 @@ export declare const TracesExplorer: typeof TracesExplorerRoot & {
     Histogram: typeof TracesExplorerHistogram;
     List: typeof TracesExplorerList;
     Panel: typeof TracesExplorerPanel;
+    SavedViews: typeof TracesExplorerSavedViews;
 };
 export type { TracesExplorerRootProps } from './traces-explorer-root';
 export type { TracesExplorerErrorRenderArgs, TracesExplorerLayoutProps } from './traces-explorer-layout';
 export type { TracesExplorerBodyProps } from './traces-explorer-body';
 export type { TracesExplorerFilterBarProps, TracesExplorerFilterChipsProps, TracesExplorerTimeRangeChipProps, } from './traces-explorer-filter-bar';
 export type { TracesExplorerPanelProps } from './traces-explorer-panel';
-export { DEFAULT_TRACES_FILTERS, DEFAULT_TRACES_SORT, EMPTY_TRACES_SELECTION, resolveTracesDateWindow, } from './traces-explorer-actions';
+export type { TracesExplorerSavedViewsProps } from './traces-explorer-saved-views';
+export { DEFAULT_TRACES_FILTERS, DEFAULT_TRACES_SORT, EMPTY_TRACES_SELECTION, TRACES_SORT_FIELDS, resolveTracesDateWindow, } from './traces-explorer-actions';
 export type { TracesExplorerState, TracesFilters, TracesSelection, TracesSort, TracesSortDirection, TracesSortField, } from './traces-explorer-actions';
 export { useTraceUsageColumns, useTracesColumns, useTracesConfig, useTracesFilters, useTracesList, useTracesListFetching, useTracesSelection, } from './traces-explorer-context';
 export type { TracesExplorerFeatures, TracesExplorerScope, TracesMetricsSupport } from './traces-explorer-context';

package/dist/src/domains/traces/components/traces-explorer/traces-explorer-actions.d.ts

@@ -1,4 +1,4 @@
-import type { EntityOptions, TraceFilterGroup, TraceFilterToken, TraceStatusFilter } from '../../trace-filters';
+import type { EntityOptions, TraceFilterGroup, TraceFilterToken, TraceQueryFieldSupport, TraceStatusFilter } from '../../trace-filters';
 import type { SpanTab, TraceDatePreset } from '../../types';
 import type { TraceSpanView } from '../trace-data-panel-view';
 export type TracesSelection = {
@@ -21,7 +21,8 @@ export type TracesFilters = {
 };
 export type TracesSortDirection = 'asc' | 'desc';
 /** Fields the traces list can be sorted by, named like the trace query's `orderBy` fields. */
-export type TracesSortField = 'startedAt' | 'timeToFirstChunkMs';
+export declare const TRACES_SORT_FIELDS: readonly ['startedAt', 'timeToFirstChunkMs', 'timeToFirstTokenMs'];
+export type TracesSortField = (typeof TRACES_SORT_FIELDS)[number];
 export type TracesSort = {
     field: TracesSortField;
     direction: TracesSortDirection;
@@ -57,7 +58,7 @@ export declare const applyDateRange: (filters: TracesFilters, dateFrom: Date | u
  * Groups pass through and stay visible in the bar: `buildTracesQueryRequest` leaves their unqueryable
  * conditions out of the query. Returns the same object when nothing is dropped.
  */
-export declare const sanitizeTracesFilters: (filters: TracesFilters, withRootDuration: boolean) => TracesFilters;
+export declare const sanitizeTracesFilters: (filters: TracesFilters, support: TraceQueryFieldSupport) => TracesFilters;
 /** Whether a status filter asks for `running`, which the trace query can't express and drops. */
 export declare const selectsRunningStatus: (filters: TracesFilters) => boolean;
 export declare const getSelectedEntityOption: (tokens: TraceFilterToken[]) => EntityOptions | undefined;
@@ -68,8 +69,7 @@ type TracesQueryWindow = {
     dateTo?: Date;
 };
 /** The trace query for the (sanitized) filters and the resolved date window. */
-export declare const buildTracesQueryRequest: ({ filters, dateFrom, dateTo, withRootDuration, now, }: TracesQueryWindow & {
-    withRootDuration: boolean;
+export declare const buildTracesQueryRequest: ({ filters, dateFrom, dateTo, now, ...support }: TracesQueryWindow & TraceQueryFieldSupport & {
     now: Date;
 }) => Pick<import("@mastra/client-js").QueryTracesInput, "timeRange" | "where">;
 /** The `listTracesLight` filters for servers without the trace query API (no groups there). */

package/dist/src/domains/traces/components/traces-explorer/traces-explorer-context.d.ts

@@ -37,10 +37,16 @@ export type TracesConfigContextValue = {
     /** The thread rows API is on, so the host can offer a threads view next to the traces list. */
     withThreadQuery: boolean;
     withRootDuration: boolean;
+    /** The server filters trace queries on the root span's `outcome` and `stopReason`. */
+    withOutcomeFields: boolean;
     /** Trace rows carry the root span's time to first chunk, so the TTFC column can be shown. */
     withTimeToFirstChunk: boolean;
     /** Trace queries can be ordered by the root span's time to first chunk. */
     withTimeToFirstChunkSort: boolean;
+    /** Trace rows carry the root span's time to first token, so the TTFT column can be shown. */
+    withTimeToFirstToken: boolean;
+    /** Trace queries can be ordered by the root span's time to first token. */
+    withTimeToFirstTokenSort: boolean;
     /** The server supports delta polling, so auto-refresh merges new traces instead of reloading pages. */
     withDeltaPolling: boolean;
     /** Whether field discovery should run: the server supports it and the trace query API is on. */
@@ -56,6 +62,10 @@ export type TracesFiltersActions = {
     setDatePreset: (preset: TraceDatePreset) => void;
     setDate: (value: Date | undefined, end: 'from' | 'to') => void;
     setDateRange: (from: Date | undefined, to: Date | undefined) => void;
+    /** Narrows the range to a histogram selection, remembering the range to return to on reset. */
+    zoomDateRange: (from: Date, to: Date) => void;
+    /** Undoes the last histogram zoom, or switches to `defaultPreset` when there is none to undo. */
+    resetDateRange: (defaultPreset: TraceDatePreset) => void;
 };
 export type TracesFiltersContextValue = TracesFiltersActions & {
     /** The host's filters with the entries this server can't query dropped. */
@@ -121,7 +131,7 @@ export declare const useTracesColumns: () => {
 export declare const CHECKING_USAGE_REASON = "Checking whether this storage supports usage data.";
 export declare const UNSUPPORTED_USAGE_REASON = "This observability store does not support token and cost metrics.";
 export type TraceUsageColumns = {
-    /** Column preferences without the columns the store can't serve (usage, time to first chunk). */
+    /** Column preferences without the columns the store can't serve (usage, time to first chunk/token). */
     displayedPreferences: TraceColumnPreferences;
     /** Whether usage should be fetched: metrics are supported and a usage column is visible. */
     usageEnabled: boolean;

package/dist/src/domains/traces/components/traces-explorer/traces-explorer-saved-views.d.ts

@@ -0,0 +1,7 @@
+import type { ObservabilitySavedViewsProps } from '../../../observability/saved-views';
+export type TracesExplorerSavedViewsProps = Pick<ObservabilitySavedViewsProps, 'searchParams' | 'setSearchParams' | 'className'>;
+/**
+ * Saved views of the traces page, with the explorer's columns. Takes the host's search params, which
+ * the host also maps to the explorer's filters. Renders nothing without a `SavedViewsProvider`.
+ */
+export declare function TracesExplorerSavedViews(props: TracesExplorerSavedViewsProps): import("react").JSX.Element;

package/dist/src/domains/traces/components/traces-list-view.d.ts

@@ -17,6 +17,10 @@ export type TracesListViewTrace = {
     model?: string | null;
     provider?: string | null;
     status?: string | null;
+    /** How the span or the trace's root span ended (`success`, `limit`, …); absent when not recorded. */
+    outcome?: string | null;
+    stopReason?: string | null;
+    stopReasonContext?: Record<string, unknown> | null;
     /** Server-rendered preview of `input`. Present on lightweight rows, which omit `input` itself. */
     inputPreview?: string | null;
     input?: unknown;
@@ -29,10 +33,18 @@ export type TracesListViewTrace = {
     endedAt?: Date | string | null;
     /** The root span's time to first chunk; `null` when it never streamed one. */
     timeToFirstChunkMs?: number | null;
+    /** The root span's time to first token; `null` when its model never produced one. */
+    timeToFirstTokenMs?: number | null;
     /** Thread rows only: every trace in the thread, regardless of the listed time range. */
     traceCount?: number;
     createdAt: Date | string;
 };
+/** Columns the list can be ordered by, named like the query `orderBy` fields. */
+export type TracesListSortField = 'startedAt' | 'timeToFirstChunkMs' | 'timeToFirstTokenMs';
+export type TracesListSort = {
+    field: TracesListSortField;
+    direction: DataListSort;
+};
 export type TracesListViewProps = {
     traces: TracesListViewTrace[];
     isLoading?: boolean;
@@ -62,19 +74,20 @@ export type TracesListViewProps = {
     usageByTraceId?: ReadonlyMap<string, TraceUsageSummary>;
     /** Called when a row is clicked. The current selection logic (toggle on same id) is the consumer's call. */
     onTraceClick: (trace: TracesListViewTrace) => void;
-    /** Current sort of the Created column. When `onSortChange` is provided the header becomes sortable. */
-    createdSort?: DataListSort;
-    onSortChange?: (direction: DataListSort, key: 'startedAt') => void;
-    /** Current sort of the TTFC column. When `onTimeToFirstChunkSortChange` is provided the header becomes sortable. */
-    timeToFirstChunkSort?: DataListSort;
-    onTimeToFirstChunkSortChange?: (direction: DataListSort) => void;
+    /** Current order of the list; only the header of `sort.field` shows a direction. */
+    sort?: TracesListSort;
+    /** Headers that become sortable when `onSortChange` is provided. Defaults to Start only. */
+    sortableFields?: readonly TracesListSortField[];
+    onSortChange?: (sort: TracesListSort) => void;
     /** When provided, custom column headers offer an `is <value>` filter for every value currently listed. */
     onFilterByField?: (field: TraceCustomColumn, value: string) => void;
     /** Storage id for the persisted column order. Use a distinct id per page so each keeps its own order. */
     listId?: string;
+    /** Show the Outcome column in place of Status. Defaults to `true`; thread rows carry no outcome. */
+    outcomeColumn?: boolean;
 };
 /**
  * Virtualized presentational list. Renders only the visible window via TanStack Virtual, and
  * uses DataList primitives for layout (CSS Grid with subgrid rows).
  */
-export declare function TracesListView({ traces, isLoading, isFetchingNextPage, hasNextPage, setEndOfListElement, filtersApplied, resource, featuredTraceId, featuredSpanId, isBranchesMode, recentlyAddedKeys, columnPreferences, usageByTraceId, onTraceClick, createdSort, onSortChange, timeToFirstChunkSort, onTimeToFirstChunkSortChange, onFilterByField, listId, }: TracesListViewProps): import("react").JSX.Element;
+export declare function TracesListView({ traces, isLoading, isFetchingNextPage, hasNextPage, setEndOfListElement, filtersApplied, resource, featuredTraceId, featuredSpanId, isBranchesMode, recentlyAddedKeys, columnPreferences, usageByTraceId, onTraceClick, sort, sortableFields, onSortChange, onFilterByField, listId, outcomeColumn, }: TracesListViewProps): import("react").JSX.Element;

package/dist/src/domains/traces/hooks/use-traces-list-source.d.ts

@@ -37,6 +37,11 @@ export declare function useTracesListSource({ query: buildQuery, orderBy, rollin
         status: 'success' | 'error';
         timeToFirstChunkMs?: (number | null) | undefined;
         timeToFirstTokenMs?: (number | null) | undefined;
+        outcome?: (string | null) | undefined;
+        stopReason?: (string | null) | undefined;
+        stopReasonContext?: ({
+            [key: string]: unknown;
+        } | null) | undefined;
     }[] | undefined;
     hasNextPage: boolean;
     isFetchingNextPage: boolean;

package/dist/src/domains/traces/trace-filters.d.ts

@@ -78,6 +78,8 @@ export declare const TRACE_PROPERTY_FILTER_PARAM_BY_FIELD: {
     readonly entityName: 'filterEntityName';
     readonly traceId: 'filterTraceId';
     readonly durationMs: 'filterDurationMs';
+    readonly timeToFirstChunkMs: 'filterTimeToFirstChunkMs';
+    readonly timeToFirstTokenMs: 'filterTimeToFirstTokenMs';
     readonly runId: 'filterRunId';
     readonly threadId: 'filterThreadId';
     readonly sessionId: 'filterSessionId';
@@ -88,11 +90,15 @@ export declare const TRACE_PROPERTY_FILTER_PARAM_BY_FIELD: {
     readonly serviceName: 'filterServiceName';
     readonly environment: 'filterEnvironment';
     readonly experimentId: 'filterExperimentId';
+    readonly outcome: 'filterOutcome';
+    readonly stopReason: 'filterStopReason';
     readonly 'spans.name': 'filterSpanName';
     readonly 'spans.spanType': 'filterSpanType';
     readonly 'spans.model': 'filterSpanModel';
     readonly 'spans.provider': 'filterSpanProvider';
     readonly 'spans.durationMs': 'filterSpanDurationMs';
+    readonly 'spans.timeToFirstChunkMs': 'filterSpanTimeToFirstChunkMs';
+    readonly 'spans.timeToFirstTokenMs': 'filterSpanTimeToFirstTokenMs';
     readonly 'spans.error': 'filterSpanError';
     readonly 'scores.scorerId': 'filterScorerId';
     readonly 'scores.score': 'filterScore';
@@ -138,6 +144,7 @@ export declare const TRACE_TEXT_OPERATORS: TraceFilterOperatorId[];
 export declare const TRACE_REQUIRED_STRING_OPERATORS: TraceFilterOperatorId[];
 export declare const TRACE_NUMBER_OPERATORS: TraceFilterOperatorId[];
 export declare const TRACE_PRESENCE_OPERATORS: TraceFilterOperatorId[];
+export declare const TRACE_TAGS_OPERATORS: TraceFilterOperatorId[];
 /** Structural subset of a discovery `canonicalFields` entry. */
 export type TraceQueryCanonicalFieldDescriptor = {
     path: string;
@@ -147,17 +154,34 @@ export type TraceQueryCanonicalFieldDescriptor = {
 /** Synthetic fields live in a single dedicated URL param, so they cannot carry an operator. */
 export declare const TRACE_SYNTHETIC_OPERATORS: TraceFilterOperatorId[];
 export declare const TRACE_FILTER_BAR_LABELS: Record<string, string>;
+/** Which optional trace query fields the server declares support for. */
+export type TraceQueryFieldSupport = {
+    /** Root `durationMs`, declared by `traceQueryRootDuration`. */
+    withRootDuration?: boolean;
+    /** Root and span `timeToFirstChunkMs`, declared by `traceQueryTimeToFirstChunk`. */
+    withTimeToFirstChunk?: boolean;
+    /** Root and span `timeToFirstTokenMs`, declared by `traceQueryTimeToFirstToken`. */
+    withTimeToFirstToken?: boolean;
+    /** Root `outcome` and `stopReason`, declared by `traceQueryOutcomeFields`. */
+    withOutcomeFields?: boolean;
+};
+/** The optional fields this server can't query: each needs its capability. */
+export declare const traceQueryUnqueryableFieldIds: ({ withRootDuration, withTimeToFirstChunk, withTimeToFirstToken, withOutcomeFields, }: TraceQueryFieldSupport) => ReadonlySet<string>;
+/** Which streaming timings the store records. Spans and threads query them without a prefix. */
+export type StreamingTimingSupport = Required<Pick<TraceQueryFieldSupport, 'withTimeToFirstChunk' | 'withTimeToFirstToken'>>;
+/** `fieldIds` without the streaming timings the store doesn't record: the query rejects a condition on one. */
+export declare function withoutUnrecordedStreamingTimings(fieldIds: ReadonlySet<string>, { withTimeToFirstChunk, withTimeToFirstToken }: StreamingTimingSupport): ReadonlySet<string>;
 export declare const traceFilterFieldIcon: (fieldId: string) => LucideIcon | undefined;
 /** Shared neutral accent for built-in, time-range, and dynamic filters. */
 export declare const traceFilterFieldColor: (_fieldId: string) => string;
+/** Outcome and stop reason: free text (custom spans set arbitrary values) with discovered suggestions. */
+export declare function createOutcomeFilterBarFields(base: (id: string) => Pick<FilterBarField, 'id' | 'label' | 'icon' | 'color'>, valueSuggestions?: (path: string) => FilterBarSuggestionsResolver | undefined): FilterBarField[];
 /** FilterBar field definitions for the trace pages. Fields the query API cannot
  *  filter on (see `TRACE_QUERY_UNSUPPORTED_FILTER_FIELDS`) are omitted, as is the
  *  `running` status, so no chip advertises a filter that has no effect. Hidden
  *  fields are never offered in the input's field step but still label existing
  *  (e.g. scoped, read-only) chips. */
-export declare function createTraceFilterBarFields({ availableRootEntityNames, availableEnvironments, hiddenFieldIds, metadataFields, canonicalTraceFields, valueSuggestions, withQueryTrace, withRootDuration, }: {
-    /** Offer the root `durationMs` field. Only when the server declares `traceQueryRootDuration`. */
-    withRootDuration?: boolean;
+export declare function createTraceFilterBarFields({ availableRootEntityNames, availableEnvironments, hiddenFieldIds, metadataFields, canonicalTraceFields, valueSuggestions, withQueryTrace, ...support }: TraceQueryFieldSupport & {
     /** Trace-scope field descriptors from the query discovery endpoint. Empty when discovery is unavailable. */
     canonicalTraceFields?: readonly TraceQueryCanonicalFieldDescriptor[];
     availableRootEntityNames: string[];

package/dist/src/domains/traces/trace-list-columns.d.ts

@@ -1,4 +1,4 @@
-export declare const TRACE_OPTIONAL_COLUMNS: readonly ['type', 'input', 'output', 'duration', 'traceCount', 'timeToFirstChunk', 'endTime', 'environment', 'model', 'provider', 'inputTokens', 'outputTokens', 'totalTokens', 'estimatedCost'];
+export declare const TRACE_OPTIONAL_COLUMNS: readonly ['type', 'input', 'output', 'duration', 'traceCount', 'timeToFirstChunk', 'timeToFirstToken', 'endTime', 'environment', 'model', 'provider', 'inputTokens', 'outputTokens', 'totalTokens', 'estimatedCost'];
 export type TraceOptionalColumn = (typeof TRACE_OPTIONAL_COLUMNS)[number];
 export declare const TRACE_USAGE_COLUMNS: readonly ["inputTokens", "outputTokens", "totalTokens", "estimatedCost"];
 /** Trace properties that are not regular columns but can be pinned as a custom column. */
@@ -13,10 +13,8 @@ export type TraceColumnPreferences = {
 import type { TraceUsageSummary } from '@mastra/react/hooks/traces';
 export type { TraceUsageSummary };
 export declare const DEFAULT_TRACE_COLUMN_PREFERENCES: TraceColumnPreferences;
-/** The Threads list: the trace defaults plus each thread's trace count. Not offered in any column picker. */
-export declare const THREAD_LIST_COLUMN_PREFERENCES: TraceColumnPreferences;
 /** A list a column selection belongs to. Each list only offers the columns its rows carry. */
-export type TraceColumnScope = 'traces' | 'spans';
+export type TraceColumnScope = 'traces' | 'spans' | 'threads';
 export type TraceColumnCatalog = {
     /** Plain columns offered in the picker, in menu order. */
     readonly standardColumns: readonly TraceOptionalColumn[];
@@ -31,13 +29,25 @@ export declare function isTraceCustomColumn(value: unknown): value is TraceCusto
 export declare function parseTraceColumnPreferences(serialized: string | undefined, defaults?: TraceColumnPreferences): TraceColumnPreferences;
 export declare function serializeTraceColumnPreferences(preferences: TraceColumnPreferences): string;
 /** Stable key per column of `buildTraceListColumns`, in the same order. Used to persist the column order. */
-export declare function buildTraceListColumnKeys(preferences: TraceColumnPreferences): string[];
-export declare function buildTraceListColumns(preferences: TraceColumnPreferences): string;
+export declare function buildTraceListColumnKeys(preferences: TraceColumnPreferences, { outcomeColumn }?: {
+    outcomeColumn?: boolean;
+}): string[];
+export declare function buildTraceListColumns(preferences: TraceColumnPreferences, { outcomeColumn }?: {
+    outcomeColumn?: boolean;
+}): string;
 /** Core names root spans `agent run: 'id'` (+ optional ` (resumed)`); the Primitive type column already carries
  *  the kind, so the list shows just the id and any suffix. Core names are untouched for exporters. */
 export declare function displayTraceName<T extends string | null | undefined>(name: T): T;
 export declare function formatTraceMetadataValue(metadata: Record<string, unknown> | null | undefined, key: string): string | undefined;
 export declare function hasTraceColumn(preferences: TraceColumnPreferences, column: TraceOptionalColumn): boolean;
+/**
+ * The preferences to draw when the store does not record every streaming timing: the
+ * unrecorded timing columns are hidden but stay saved, so they come back on a store that records them.
+ */
+export declare function withoutUnrecordedStreamingColumns(preferences: TraceColumnPreferences, { withTimeToFirstChunk, withTimeToFirstToken }: {
+    withTimeToFirstChunk: boolean;
+    withTimeToFirstToken: boolean;
+}): TraceColumnPreferences;
 export declare function toggleTraceColumn(preferences: TraceColumnPreferences, column: TraceOptionalColumn): TraceColumnPreferences;
 export declare function addTraceCustomColumn(preferences: TraceColumnPreferences, field: TraceCustomColumn): TraceColumnPreferences;
 export declare function removeTraceCustomColumn(preferences: TraceColumnPreferences, field: TraceCustomColumn): TraceColumnPreferences;

package/dist/src/domains/traces/utils/timeline-markers.d.ts

@@ -0,0 +1,25 @@
+import type { UISpan } from '../types';
+/** Streaming timings of the trace root, read from its listed row. */
+export type TraceStreamingTimings = {
+    /** When the root span started; both timings count from a point on its run. */
+    startedAt: string | Date;
+    timeToFirstChunkMs?: number | null;
+    timeToFirstTokenMs?: number | null;
+};
+/** A timing drawn as a bar on the track, as percentages of the trace duration. */
+export type TimelineTimingBar = {
+    durationMs: number;
+    leftPercent: number;
+    widthPercent: number;
+};
+export type TimelineMarkersLayout = {
+    /** From the root start up to the first chunk. */
+    firstChunk: TimelineTimingBar;
+    /** The model's own wait: from the inference start up to the first chunk. */
+    firstToken?: TimelineTimingBar;
+};
+/**
+ * TTFC counts from the root start and TTFT from the inference start, but both end on the first
+ * chunk. So both are bars ending on the same point of the axis, starting at different places.
+ */
+export declare function getTimelineMarkersLayout(spans: Pick<UISpan, 'startTime'>[], overallLatency: number, timings?: TraceStreamingTimings): TimelineMarkersLayout | undefined;

package/dist/src/domains/workflows/context/use-persisted-workflow-run.d.ts

@@ -24,6 +24,8 @@ export declare function usePersistedWorkflowRun(workflowId: string, runId: strin
             traceId?: string;
             spanId?: string;
             parentSpanId?: string;
+            resumedFromSpanId?: string;
+            externalParentSpanId?: string;
         } | undefined;
         runId: string;
         workflowName: string;