@mastra/duckdb 1.15.0-alpha.2 → 1.15.0-alpha.4

package/dist/{observability-HUYFWVy-.js → observability-DWPWPNlL.js}

@@ -1,4 +1,4 @@
-import { n as DuckDBConnection, r as DuckDBQueryTimeoutError, t as spanQueryFeatures } from "./features-vjVgmb36.js";
+import { a as DuckDBConnection, i as timeToFirstChunkSupported, o as DuckDBQueryTimeoutError, r as timeToFirstChunkFeatures, t as spanQueryFeatures } from "./features-gvUXKO_o.js";
 import { ErrorCategory, ErrorDomain, MastraError } from "@mastra/core/error";
 import * as coreStorage from "@mastra/core/storage";
 import { BRANCH_SPAN_TYPES, METRIC_DISTINCT_COLUMNS, ObservabilityStorage, computeTraceStatus, createStorageErrorId, executeRetentionPrune, feedbackRecordSchema, listBranchesArgsSchema, listFeedbackArgsSchema, listLogsArgsSchema, listMetricsArgsSchema, listScoresArgsSchema, listTracesArgsSchema, resolveRetentionTargets, retentionCutoffMs, toTraceSpans } from "@mastra/core/storage";
@@ -2876,6 +2876,10 @@ const TRACE_FIELDS = {
 		sql: durationMsSql("r.startedAt", "r.endedAt"),
 		parameterType: "scalar"
 	},
+	timeToFirstChunkMs: {
+		sql: "r.timeToFirstChunkMs",
+		parameterType: "scalar"
+	},
 	entityName: {
 		sql: "r.entityName",
 		parameterType: "scalar"
@@ -2884,6 +2888,14 @@ const TRACE_FIELDS = {
 		sql: "r.entityType",
 		parameterType: "scalar"
 	},
+	name: {
+		sql: "r.name",
+		parameterType: "scalar"
+	},
+	spanType: {
+		sql: "r.spanType",
+		parameterType: "scalar"
+	},
 	environment: {
 		sql: "r.environment",
 		parameterType: "scalar"
@@ -2926,6 +2938,10 @@ const SPAN_FIELDS = {
 		sql: "s.durationMs",
 		parameterType: "scalar"
 	},
+	timeToFirstChunkMs: {
+		sql: "s.timeToFirstChunkMs",
+		parameterType: "scalar"
+	},
 	status: {
 		sql: "s.status",
 		parameterType: "scalar"
@@ -3135,6 +3151,7 @@ const TRACE_SELECT = `
   r.resourceId AS resourceId,
   r.startedAt AS startedAt,
   r.endedAt AS endedAt,
+  r.timeToFirstChunkMs AS timeToFirstChunkMs,
   r.entityName AS entityName,
   r.entityType AS entityType,
   r.environment AS environment,
@@ -3370,8 +3387,11 @@ const ROOT_PUSHDOWN_FIELDS = /* @__PURE__ */ new Set([
 	"userId",
 	"organizationId",
 	"endedAt",
+	"timeToFirstChunkMs",
 	"entityName",
 	"entityType",
+	"name",
+	"spanType",
 	"environment"
 ]);
 function isRootPushdownPredicate(predicate) {
@@ -3497,6 +3517,7 @@ function compileDuckDBTraceScope(relatedCollections, scope, timeRange, rootPredi
         startedAt,
         endedAt,
         ${durationMsSql("startedAt", "endedAt")} AS durationMs,
+        timeToFirstChunkMs,
         CASE WHEN error IS NOT NULL THEN 'error' ELSE 'success' END AS status,
         error,
         entityType,
@@ -3596,15 +3617,15 @@ ORDER BY delta_rows.deltaWatermark ASC NULLS LAST, delta_rows.traceId ASC`,
 		};
 	}
 	const orderField = plan.orderBy.field;
-	const direction = plan.orderBy.direction === "asc" ? "ASC" : "DESC";
+	const order = `${orderField} ${plan.orderBy.direction === "asc" ? "ASC" : "DESC"} NULLS LAST, traceId ASC`;
 	if (plan.paginationMode === "page") {
 		values.push(plan.perPage, plan.page * plan.perPage);
 		return {
 			sql: `${candidates},
   page_rows AS (
-    SELECT *, row_number() OVER (ORDER BY ${orderField} ${direction}, traceId ASC) AS __row_position
+    SELECT *, row_number() OVER (ORDER BY ${order}) AS __row_position
     FROM candidates
-    ORDER BY ${orderField} ${direction}, traceId ASC
+    ORDER BY ${order}
     LIMIT ? OFFSET ?
   ),
   page_total AS (
@@ -3619,8 +3640,13 @@ ORDER BY page_rows.__row_position ASC NULLS LAST`,
 		};
 	}
 	let pageCondition = "";
-	if (plan.cursor) {
-		pageCondition = `WHERE (${orderField} ${plan.orderBy.direction === "asc" ? ">" : "<"} CAST(? AS TIMESTAMP) OR (${orderField} = CAST(? AS TIMESTAMP) AND traceId > ?))`;
+	if (plan.cursor?.sortValue === null) {
+		pageCondition = `WHERE ${orderField} IS NULL AND traceId > ?`;
+		values.push(plan.cursor.traceId);
+	} else if (plan.cursor) {
+		const comparison = plan.orderBy.direction === "asc" ? ">" : "<";
+		const value = `CAST(? AS ${typeof plan.cursor.sortValue === "number" ? "DOUBLE" : "TIMESTAMP"})`;
+		pageCondition = `WHERE (${orderField} ${comparison} ${value} OR ${orderField} IS NULL OR (${orderField} = ${value} AND traceId > ?))`;
 		values.push(plan.cursor.sortValue, plan.cursor.sortValue, plan.cursor.traceId);
 	}
 	values.push(plan.limit + 1);
@@ -3629,7 +3655,7 @@ ORDER BY page_rows.__row_position ASC NULLS LAST`,
 SELECT *
 FROM candidates
 ${pageCondition}
-ORDER BY ${orderField} ${direction}, traceId ASC
+ORDER BY ${order}
 LIMIT ?`,
 		values
 	};
@@ -3812,6 +3838,29 @@ async function fillMissingTracePreviews(db, rows) {
 		for (const [preview, column] of TRACE_PREVIEW_PAYLOADS) if (needsPreview(row[preview])) row[preview] = previewFromPayload(payload?.[column] ?? null);
 	}
 }
+function traceFromRow(row) {
+	return {
+		traceId: String(row.traceId),
+		rootSpanId: String(row.rootSpanId),
+		name: row.name,
+		entityId: row.entityId ?? null,
+		parentSpanId: row.parentSpanId ?? null,
+		createdAt: asIsoTimestamp(row.startedAt),
+		metadata: parseJson(row.metadata) ?? null,
+		inputPreview: apiPreview(row.inputPreview),
+		outputPreview: apiPreview(row.outputPreview),
+		errorPreview: apiPreview(row.errorPreview),
+		threadId: row.threadId == null ? null : String(row.threadId),
+		resourceId: row.resourceId == null ? null : String(row.resourceId),
+		startedAt: asIsoTimestamp(row.startedAt),
+		endedAt: asIsoTimestamp(row.endedAt),
+		entityName: row.entityName == null ? null : String(row.entityName),
+		entityType: row.entityType == null ? null : String(row.entityType),
+		environment: row.environment == null ? null : String(row.environment),
+		status: row.status,
+		...timeToFirstChunkSupported && { timeToFirstChunkMs: row.timeToFirstChunkMs == null ? null : Number(row.timeToFirstChunkMs) }
+	};
+}
 async function queryTraces(db, plan) {
 	if (plan.paginationMode === "delta") assertDeltaPollingEnabled();
 	if (plan.paginationMode === "page") {
@@ -3819,26 +3868,7 @@ async function queryTraces(db, plan) {
 		const rows = await db.query(query.sql, query.values);
 		const total = Number(rows[0]?.total ?? 0);
 		await fillMissingTracePreviews(db, rows);
-		const traces = rows.filter((row) => row.traceId != null).map((row) => ({
-			traceId: String(row.traceId),
-			rootSpanId: String(row.rootSpanId),
-			name: row.name,
-			entityId: row.entityId ?? null,
-			parentSpanId: row.parentSpanId ?? null,
-			createdAt: asIsoTimestamp(row.startedAt),
-			metadata: parseJson(row.metadata) ?? null,
-			inputPreview: apiPreview(row.inputPreview),
-			outputPreview: apiPreview(row.outputPreview),
-			errorPreview: apiPreview(row.errorPreview),
-			threadId: row.threadId == null ? null : String(row.threadId),
-			resourceId: row.resourceId == null ? null : String(row.resourceId),
-			startedAt: asIsoTimestamp(row.startedAt),
-			endedAt: asIsoTimestamp(row.endedAt),
-			entityName: row.entityName == null ? null : String(row.entityName),
-			entityType: row.entityType == null ? null : String(row.entityType),
-			environment: row.environment == null ? null : String(row.environment),
-			status: row.status
-		}));
+		const traces = rows.filter((row) => row.traceId != null).map(traceFromRow);
 		return coreStorage.traceQueryResponseSchema.parse({
 			traces,
 			...deltaPollingFeatureEnabled() && typeof coreStorage.encodeTraceQueryDeltaCursor === "function" ? { deltaCursor: coreStorage.encodeTraceQueryDeltaCursor(plan, "duckdb", String(rows[0]?.streamHead ?? 0)) } : {},
@@ -3866,26 +3896,7 @@ async function queryTraces(db, plan) {
 		});
 	}
 	await fillMissingTracePreviews(db, visibleRows);
-	const traces = visibleRows.map((row) => ({
-		traceId: String(row.traceId),
-		rootSpanId: String(row.rootSpanId),
-		name: row.name,
-		entityId: row.entityId ?? null,
-		parentSpanId: row.parentSpanId ?? null,
-		createdAt: asIsoTimestamp(row.startedAt),
-		metadata: parseJson(row.metadata) ?? null,
-		inputPreview: apiPreview(row.inputPreview),
-		outputPreview: apiPreview(row.outputPreview),
-		errorPreview: apiPreview(row.errorPreview),
-		threadId: row.threadId == null ? null : String(row.threadId),
-		resourceId: row.resourceId == null ? null : String(row.resourceId),
-		startedAt: asIsoTimestamp(row.startedAt),
-		endedAt: asIsoTimestamp(row.endedAt),
-		entityName: row.entityName == null ? null : String(row.entityName),
-		entityType: row.entityType == null ? null : String(row.entityType),
-		environment: row.environment == null ? null : String(row.environment),
-		status: row.status
-	}));
+	const traces = visibleRows.map(traceFromRow);
 	if (plan.paginationMode === "delta") {
 		const previous = coreStorage.getTraceQueryDeltaWatermark(plan, "duckdb") ?? "0";
 		const head = String(rows[0]?.streamHead ?? 0);
@@ -3904,7 +3915,7 @@ async function queryTraces(db, plan) {
 		traces,
 		page: { next: rows.length > plan.limit && last ? coreStorage.encodeTraceQueryCursor(plan, {
 			result: "traces",
-			sortValue: last[plan.orderBy.field],
+			sortValue: last[plan.orderBy.field] ?? null,
 			traceId: last.traceId
 		}) : null }
 	});
@@ -3926,6 +3937,12 @@ async function queryThreads(db, plan) {
 function compileSpanQueryPredicate(predicate) {
 	return compileScalarPredicate(predicate, SPAN_QUERY_FIELDS);
 }
+function compileThreadQueryPredicate(predicate) {
+	return compileScalarPredicate(predicate, Object.fromEntries(Object.entries(coreStorage.THREAD_QUERY_FIELD_REGISTRY).map(([field, rule]) => [field, {
+		sql: `s.${field}`,
+		parameterType: rule.valueKind === "timestamp" ? "timestamp" : "scalar"
+	}])));
+}
 //#endregion
 //#region src/storage/domains/observability/span-query.ts
 const identityFields = [
@@ -3969,7 +3986,8 @@ const fields = [
 	"serviceName",
 	"experimentId",
 	"environment",
-	"executionSource"
+	"executionSource",
+	"timeToFirstChunkMs"
 ];
 function keys(rows, values, alias = "") {
 	return rows.map((row) => `(${identityFields.map((field) => {
@@ -3983,13 +4001,16 @@ function afterCursor(plan) {
 		values: []
 	};
 	const cursor = plan.cursor;
-	const comparisons = [`s.${plan.orderBy.field} ${plan.orderBy.direction === "asc" ? ">" : "<"} CAST(? AS TIMESTAMP)`];
-	const values = [cursor.sortValue];
+	const sort = `s.${plan.orderBy.field}`;
+	const empty = cursor.sortValue === null;
+	const value = `CAST(? AS ${typeof cursor.sortValue === "number" ? "DOUBLE" : "TIMESTAMP"})`;
+	const comparisons = empty ? [] : [`${sort} ${plan.orderBy.direction === "asc" ? ">" : "<"} ${value}`, `${sort} IS NULL`];
+	const values = empty ? [] : [cursor.sortValue];
 	for (let i = 0; i < identityFields.length; i++) {
 		const field = identityFields[i];
 		if (cursor[field] === null) continue;
-		const equal = [`s.${plan.orderBy.field} = CAST(? AS TIMESTAMP)`];
-		values.push(cursor.sortValue);
+		const equal = [empty ? `${sort} IS NULL` : `${sort} = ${value}`];
+		if (!empty) values.push(cursor.sortValue);
 		for (const prior of identityFields.slice(0, i)) {
 			equal.push(`s.${prior} IS NOT DISTINCT FROM ?`);
 			values.push(cursor[prior]);
@@ -4048,7 +4069,7 @@ function compileDuckDBSpanQuery(plan) {
 			"cursorId"
 		].map((field) => `s.${field}`).join(", ")}
   FROM ranked s WHERE rank = 1 AND endedAt IS NOT NULL AND startedAt >= CAST(? AS TIMESTAMP) AND startedAt < CAST(? AS TIMESTAMP) AND (${predicate.sql}) AND ${after.sql}
-  ORDER BY s.${plan.orderBy.field} ${plan.orderBy.direction === "asc" ? "ASC" : "DESC"}, ${identityFields.map((field) => `s.${field} ASC NULLS LAST`).join(", ")}
+  ORDER BY s.${plan.orderBy.field} ${plan.orderBy.direction === "asc" ? "ASC" : "DESC"} NULLS LAST, ${identityFields.map((field) => `s.${field} ASC NULLS LAST`).join(", ")}
   LIMIT ?`,
 		values
 	};
@@ -4073,10 +4094,11 @@ async function querySpans(db, plan) {
 	};
 	const compiled = compileDuckDBSpanQuery(plan);
 	const rows = await query(compiled.sql, compiled.values);
-	const selected = rows.map(({ cursorId: _cursorId, startedAt, endedAt, ...row }) => ({
+	const selected = rows.map(({ cursorId: _cursorId, startedAt, endedAt, timeToFirstChunkMs, ...row }) => ({
 		...row,
 		startedAt: startedAt.toISOString(),
-		endedAt: endedAt.toISOString()
+		endedAt: endedAt.toISOString(),
+		...timeToFirstChunkSupported && { timeToFirstChunkMs: timeToFirstChunkMs == null ? null : Number(timeToFirstChunkMs) }
 	}));
 	const page = rows.slice(0, plan.limit);
 	if (!page.length) return buildSpanQueryResponse(plan, [], []);
@@ -4127,11 +4149,264 @@ async function querySpans(db, plan) {
 	return buildSpanQueryResponse(plan, hydrated, payloads, metrics);
 }
 //#endregion
+//#region src/storage/domains/observability/thread-query.ts
+const contextFields = [
+	"resourceId",
+	"userId",
+	"entityType",
+	"entityId",
+	"entityName",
+	"entityVersionId",
+	"runId",
+	"sessionId",
+	"requestId",
+	"serviceName",
+	"experimentId",
+	"environment",
+	"executionSource"
+];
+function predicateFields(predicate, fields = /* @__PURE__ */ new Set()) {
+	if (!predicate) return fields;
+	if (predicate.type === "boolean") for (const arg of predicate.args) predicateFields(arg, fields);
+	else if (predicate.type === "not") predicateFields(predicate.arg, fields);
+	else fields.add(predicate.field);
+	return fields;
+}
+function canUseThreadCandidates(probe) {
+	return Number(probe.threadCount) <= 16384 && Number(probe.traceCount) <= 1e5 && Number(probe.threadBytes) + Number(probe.traceBytes) <= 4 * 1024 * 1024;
+}
+function compileDuckDBThreadRowsQuery(plan, strategy = "full") {
+	const values = [];
+	const scope = [];
+	if (plan.scope) {
+		values.push(plan.scope.organizationId);
+		scope.push("organizationId = ?");
+		if (plan.scope.resourceId !== void 0) {
+			values.push(plan.scope.resourceId);
+			scope.push("resourceId = ?");
+		}
+	}
+	const identity = (field) => `(organizationId IS NULL, COALESCE(organizationId, ''), ${field})`;
+	const threadFilter = `${identity("threadId")} IN (SELECT ${identity("threadId")} FROM candidate_threads)`;
+	const endWindow = plan.timeRange.mode === "threads" && plan.timeRange.field === "endedAt";
+	const scopedEvents = `scoped_events AS NOT MATERIALIZED (
+    SELECT * FROM span_events WHERE parentSpanId IS NULL ${scope.length ? `AND ${scope.join(" AND ")}` : ""}
+  )`;
+	const candidates = `window_traces AS MATERIALIZED (
+    SELECT DISTINCT organizationId, traceId FROM scoped_events
+    WHERE ${endWindow ? "endedAt" : "timestamp"} >= CAST(? AS TIMESTAMP) AND ${endWindow ? "endedAt" : "timestamp"} < CAST(? AS TIMESTAMP)
+      ${endWindow ? "" : "AND eventType = 'start'"}
+  ), candidate_threads AS MATERIALIZED (
+    SELECT DISTINCT organizationId, threadId FROM scoped_events
+    WHERE threadId IS NOT NULL AND ${identity("traceId")} IN (SELECT ${identity("traceId")} FROM window_traces)
+    ${strategy === "probe" ? "LIMIT 16385" : ""}
+  ), candidate_traces AS MATERIALIZED (
+    SELECT DISTINCT organizationId, traceId FROM scoped_events WHERE ${threadFilter}
+    ${strategy === "probe" ? "LIMIT 100001" : ""}
+  )`;
+	if (strategy !== "full") values.push(plan.timeRange.from, plan.timeRange.to);
+	if (strategy === "probe") return {
+		sql: `WITH ${scopedEvents}, ${candidates}
+      SELECT (SELECT count(*) FROM candidate_threads) AS threadCount,
+        (SELECT COALESCE(sum(octet_length(encode(COALESCE(organizationId, ''))) + octet_length(encode(threadId))), 0) FROM candidate_threads) AS threadBytes,
+        count(*) AS traceCount, COALESCE(sum(octet_length(encode(COALESCE(organizationId, ''))) + octet_length(encode(traceId))), 0) AS traceBytes
+      FROM candidate_traces`,
+		values
+	};
+	values.push(plan.timeRange.from, plan.timeRange.to);
+	const qualify = plan.timeRange.mode === "traces" ? "s.inWindow" : `s.${plan.timeRange.field} >= CAST(? AS TIMESTAMP) AND s.${plan.timeRange.field} < CAST(? AS TIMESTAMP)`;
+	if (plan.timeRange.mode === "threads") values.push(plan.timeRange.from, plan.timeRange.to);
+	const predicate = plan.where ? compileThreadQueryPredicate(plan.where) : {
+		sql: "TRUE",
+		values: []
+	};
+	values.push(...predicate.values);
+	let after = "TRUE";
+	if (plan.cursor) {
+		const cursor = plan.cursor;
+		const terms = [`s.${plan.orderBy.field} ${plan.orderBy.direction === "asc" ? ">" : "<"} CAST(? AS TIMESTAMP)`];
+		values.push(cursor.sortValue);
+		const ids = ["organizationId", "threadId"];
+		for (let i = 0; i < ids.length; i++) {
+			const field = ids[i];
+			if (cursor[field] === null) continue;
+			const equal = [`s.${plan.orderBy.field} = CAST(? AS TIMESTAMP)`];
+			values.push(cursor.sortValue);
+			for (const prior of ids.slice(0, i)) {
+				equal.push(`s.${prior} IS NOT DISTINCT FROM ?`);
+				values.push(cursor[prior]);
+			}
+			values.push(cursor[field]);
+			terms.push(`(${equal.join(" AND ")} AND (s.${field} > ? OR s.${field} IS NULL))`);
+		}
+		after = `(${terms.join(" OR ")})`;
+	}
+	values.push(plan.limit + 1);
+	const filtered = predicateFields(plan.where);
+	const firstContext = [...contextFields, "timeToFirstChunkMs"].filter((field) => field === "resourceId" || filtered.has(field));
+	const contextExpression = (field) => field === "executionSource" ? "source AS executionSource" : field === "timeToFirstChunkMs" ? "CASE WHEN spanType = 'agent_run' THEN timeToFirstChunkMs END AS timeToFirstChunkMs" : field;
+	const lastFields = [
+		"traceId",
+		"spanId",
+		"cursorId",
+		"resourceId",
+		"endedAt",
+		...filtered.has("status") ? ["status"] : []
+	];
+	return {
+		sql: `WITH ${scopedEvents}, ${strategy === "candidates" ? `${candidates}, ` : ""}root_events AS (
+    SELECT organizationId, threadId, traceId, spanId, cursorId, endedAt,
+      ${firstContext.map(contextExpression).join(", ")},
+      min(timestamp) FILTER (WHERE eventType = 'start') OVER (PARTITION BY organizationId, traceId, spanId) AS startedAt
+      ${filtered.has("status") ? ", CASE WHEN error IS NULL THEN 'success' ELSE 'error' END AS status" : ""}
+    FROM scoped_events ${strategy === "candidates" ? `WHERE ${identity("traceId")} IN (SELECT ${identity("traceId")} FROM candidate_traces)` : ""}
+  ), current_roots AS (
+    SELECT *, row_number() OVER (PARTITION BY organizationId, traceId ORDER BY startedAt ASC, spanId, cursorId DESC) AS rootRank
+    FROM root_events
+  ), ranked AS (
+    SELECT *, row_number() OVER first_order AS rank,
+      max(endedAt) OVER population AS lastActivity, count(*) OVER population AS traceCount,
+      bool_or(startedAt >= CAST(? AS TIMESTAMP) AND startedAt < CAST(? AS TIMESTAMP)) OVER population AS inWindow,
+      ${lastFields.map((field) => `first_value(${field}) OVER last_order AS last${field[0].toUpperCase()}${field.slice(1)}`).join(", ")}
+    FROM current_roots WHERE rootRank = 1 AND endedAt IS NOT NULL AND startedAt IS NOT NULL AND threadId IS NOT NULL ${strategy === "candidates" ? `AND ${threadFilter}` : ""}
+    WINDOW population AS (PARTITION BY organizationId, threadId),
+      first_order AS (PARTITION BY organizationId, threadId ORDER BY startedAt, traceId),
+      last_order AS (PARTITION BY organizationId, threadId ORDER BY startedAt DESC, traceId DESC)
+  ), rows AS (
+    SELECT organizationId, threadId, traceId AS firstTraceId, spanId AS firstSpanId, cursorId AS firstCursorId,
+      endedAt AS firstEndedAt, startedAt, lastActivity AS endedAt, traceCount, inWindow,
+      ${firstContext.join(", ")},
+      ${lastFields.map((field) => `last${field[0].toUpperCase()}${field.slice(1)}${field === "status" ? " AS status" : ""}`).join(", ")}
+    FROM ranked WHERE rank = 1
+  ) SELECT * FROM rows s WHERE ${qualify} AND (${predicate.sql}) AND ${after}
+    ORDER BY s.${plan.orderBy.field} ${plan.orderBy.direction === "asc" ? "ASC" : "DESC"}, s.organizationId ASC NULLS LAST, s.threadId ASC LIMIT ?`,
+		values
+	};
+}
+async function queryThreadRows(db, plan, strategy = "auto") {
+	const deadline = performance.now() + coreStorage.TRACE_QUERY_DEFAULT_TIMEOUT_MS;
+	const run = async (sql, values) => {
+		const remaining = Math.floor(deadline - performance.now());
+		if (remaining <= 0) throw new coreStorage.TraceQueryExecutionError();
+		try {
+			return await db.query(sql, values, remaining);
+		} catch (error) {
+			if (error instanceof DuckDBQueryTimeoutError) throw new coreStorage.TraceQueryExecutionError();
+			if (error instanceof Error && /out of memory/i.test(error.message)) throw new coreStorage.TraceQueryResourceLimitError();
+			throw error;
+		}
+	};
+	if (strategy === "auto") {
+		const probeQuery = compileDuckDBThreadRowsQuery(plan, "probe");
+		const [probe] = await run(probeQuery.sql, probeQuery.values);
+		if (Number(probe.threadCount) === 0) return {
+			threads: [],
+			page: { next: null }
+		};
+		strategy = canUseThreadCandidates(probe) ? "candidates" : "full";
+	}
+	const compiled = compileDuckDBThreadRowsQuery(plan, strategy);
+	const selected = await run(compiled.sql, compiled.values);
+	const page = selected.slice(0, plan.limit);
+	if (!page.length) return {
+		threads: [],
+		page: { next: null }
+	};
+	const values = [];
+	const keys = page.flatMap((row) => ["first", "last"].map((which) => {
+		const entries = {
+			organizationId: row.organizationId,
+			resourceId: which === "first" ? row.resourceId : row.lastResourceId,
+			traceId: row[`${which}TraceId`],
+			spanId: row[`${which}SpanId`],
+			cursorId: row[`${which}CursorId`],
+			endedAt: row[`${which}EndedAt`]
+		};
+		return `(${Object.entries(entries).map(([field, value]) => {
+			values.push(value);
+			return `${field} ${field === "organizationId" || field === "resourceId" ? "IS NOT DISTINCT FROM" : "="} ?`;
+		}).join(" AND ")})`;
+	}));
+	const payloads = await run(`SELECT organizationId, traceId, cursorId, spanType,
+    ${contextFields.map((field) => field === "executionSource" ? "source AS executionSource" : field).join(", ")},
+    CASE WHEN spanType = 'agent_run' THEN timeToFirstChunkMs END AS timeToFirstChunkMs,
+    CASE WHEN error IS NULL THEN 'success' ELSE 'error' END AS status,
+    ${[
+		"input",
+		"output",
+		"error"
+	].map((field) => `${field}Preview, CASE WHEN ${missingPreviewSql(`${field}Preview`)} THEN CAST(${field === "error" ? field : payloadColumnSql(field)} AS VARCHAR) END AS ${field}`).join(", ")}
+    FROM span_events WHERE ${keys.join(" OR ")}`, values);
+	const key = (org, trace, version) => JSON.stringify([
+		org,
+		trace,
+		String(version)
+	]);
+	const byRoot = new Map(payloads.map((row) => [key(row.organizationId, row.traceId, row.cursorId), row]));
+	const agents = page.filter((row) => byRoot.get(key(row.organizationId, row.firstTraceId, row.firstCursorId))?.spanType === "agent_run");
+	const models = /* @__PURE__ */ new Map();
+	if (agents.length) {
+		const modelValues = [];
+		const rows = await run(`WITH generations AS (
+        SELECT organizationId, traceId, spanId, endedAt, cursorId, attributes,
+          min(timestamp) FILTER (WHERE eventType = 'start') OVER (PARTITION BY organizationId, traceId, spanId) AS startedAt
+        FROM span_events WHERE spanType = 'model_generation' AND (${agents.map((row) => `(${Object.entries({
+			organizationId: row.organizationId,
+			resourceId: row.resourceId,
+			traceId: row.firstTraceId,
+			parentSpanId: row.firstSpanId
+		}).map(([field, value]) => {
+			modelValues.push(value);
+			return `${field} ${field === "organizationId" || field === "resourceId" ? "IS NOT DISTINCT FROM" : "="} ?`;
+		}).join(" AND ")})`).join(" OR ")})
+      ) SELECT organizationId, traceId,
+        CASE WHEN json_type(attributes, '$.model') = 'VARCHAR' THEN json_extract_string(attributes, '$.model') END AS model,
+        CASE WHEN json_type(attributes, '$.provider') = 'VARCHAR' THEN json_extract_string(attributes, '$.provider') END AS provider
+        FROM generations WHERE endedAt IS NOT NULL
+        QUALIFY row_number() OVER (PARTITION BY organizationId, traceId ORDER BY startedAt, spanId, cursorId DESC) = 1`, modelValues);
+		for (const row of rows) models.set(JSON.stringify([row.organizationId, row.traceId]), row);
+	}
+	const threads = page.flatMap((row) => {
+		const first = byRoot.get(key(row.organizationId, row.firstTraceId, row.firstCursorId));
+		const last = byRoot.get(key(row.organizationId, row.lastTraceId, row.lastCursorId));
+		if (!first || !last) return [];
+		const model = models.get(JSON.stringify([row.organizationId, row.firstTraceId]));
+		return [coreStorage.threadQueryRowSchema.parse({
+			organizationId: row.organizationId,
+			threadId: row.threadId,
+			firstTraceId: row.firstTraceId,
+			lastTraceId: row.lastTraceId,
+			...Object.fromEntries(contextFields.map((field) => [field, first[field]])),
+			status: last.status,
+			startedAt: row.startedAt.toISOString(),
+			endedAt: row.endedAt.toISOString(),
+			traceCount: Number(row.traceCount),
+			timeToFirstChunkMs: first.timeToFirstChunkMs,
+			model: model?.model ?? null,
+			provider: model?.provider ?? null,
+			inputPreview: readPreview(first.inputPreview, first.input, true),
+			outputPreview: readPreview(last.outputPreview, last.output, true),
+			errorPreview: readPreview(last.errorPreview, last.error, true)
+		})];
+	});
+	const last = page.at(-1);
+	return {
+		threads,
+		page: { next: selected.length > plan.limit ? coreStorage.encodeThreadQueryCursor(plan, {
+			organizationId: last.organizationId,
+			threadId: last.threadId,
+			sortValue: last[plan.orderBy.field].toISOString()
+		}) : null }
+	};
+}
+//#endregion
 //#region src/storage/domains/observability/trace-aggregate.ts
 /** Trace-root column expressions (alias `r`) for each groupable dimension; same values `where` sees. */
 const DIMENSION_SQL = {
 	entityType: "r.entityType",
 	entityName: "r.entityName",
+	name: "r.name",
+	spanType: "r.spanType",
 	environment: "r.environment",
 	status: TRACE_STATUS_SQL,
 	serviceName: "r.serviceName",
@@ -5900,12 +6175,15 @@ var ObservabilityStorageDuckDB = class ObservabilityStorageDuckDB extends Observ
 			"trace-query",
 			"trace-aggregate",
 			...spanQueryFeatures,
+			...typeof coreStorage.planThreadRowsQuery === "function" ? ["thread-query-rows"] : [],
 			"trace-query-root-duration",
 			"trace-query-discovery",
 			"thread-query",
 			"trace-query-tenant-scope",
 			"feedback",
-			"trace-query-context-ids"
+			"trace-query-context-ids",
+			...timeToFirstChunkFeatures,
+			"trace-query-root-span-fields"
 		];
 		return [
 			"metrics",
@@ -5920,12 +6198,15 @@ var ObservabilityStorageDuckDB = class ObservabilityStorageDuckDB extends Observ
 			"trace-query",
 			"trace-aggregate",
 			...spanQueryFeatures,
+			...typeof coreStorage.planThreadRowsQuery === "function" ? ["thread-query-rows"] : [],
 			"trace-query-root-duration",
 			"trace-query-discovery",
 			"thread-query",
 			"trace-query-tenant-scope",
 			"feedback",
-			"trace-query-context-ids"
+			"trace-query-context-ids",
+			...timeToFirstChunkFeatures,
+			"trace-query-root-span-fields"
 		];
 	}
 	async createSpan(args) {
@@ -5971,6 +6252,7 @@ var ObservabilityStorageDuckDB = class ObservabilityStorageDuckDB extends Observ
 		return getTraceQueryValues(this.db, plan);
 	}
 	async queryThreads(plan) {
+		if (plan.result === "threadRows") return queryThreadRows(this.db, plan);
 		return queryThreads(this.db, plan);
 	}
 	async listTracesLight(args) {
@@ -6086,4 +6368,4 @@ var ObservabilityStorageDuckDB = class ObservabilityStorageDuckDB extends Observ
 //#endregion
 export { ObservabilityStorageDuckDB };
 
-//# sourceMappingURL=observability-HUYFWVy-.js.map
+//# sourceMappingURL=observability-DWPWPNlL.js.map