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

package/dist/{observability-DJs6G-BH.cjs → observability-D70dyGYt.cjs}

@@ -1,4 +1,4 @@
-const require_features = require("./features-BAGbFa2n.cjs");
+const require_features = require("./features-DxaUwIC2.cjs");
 let _mastra_core_error = require("@mastra/core/error");
 let _mastra_core_storage = require("@mastra/core/storage");
 _mastra_core_storage = require_features.__toESM(_mastra_core_storage, 1);
@@ -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,
@@ -3812,6 +3833,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,
+		...require_features.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 +3863,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 _mastra_core_storage.traceQueryResponseSchema.parse({
 			traces,
 			...deltaPollingFeatureEnabled() && typeof _mastra_core_storage.encodeTraceQueryDeltaCursor === "function" ? { deltaCursor: _mastra_core_storage.encodeTraceQueryDeltaCursor(plan, "duckdb", String(rows[0]?.streamHead ?? 0)) } : {},
@@ -3866,26 +3891,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 = _mastra_core_storage.getTraceQueryDeltaWatermark(plan, "duckdb") ?? "0";
 		const head = String(rows[0]?.streamHead ?? 0);
@@ -3926,6 +3932,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(_mastra_core_storage.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 +3981,8 @@ const fields = [
 	"serviceName",
 	"experimentId",
 	"environment",
-	"executionSource"
+	"executionSource",
+	"timeToFirstChunkMs"
 ];
 function keys(rows, values, alias = "") {
 	return rows.map((row) => `(${identityFields.map((field) => {
@@ -4073,10 +4086,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(),
+		...require_features.timeToFirstChunkSupported && { timeToFirstChunkMs: timeToFirstChunkMs == null ? null : Number(timeToFirstChunkMs) }
 	}));
 	const page = rows.slice(0, plan.limit);
 	if (!page.length) return buildSpanQueryResponse(plan, [], []);
@@ -4127,11 +4141,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() + _mastra_core_storage.TRACE_QUERY_DEFAULT_TIMEOUT_MS;
+	const run = async (sql, values) => {
+		const remaining = Math.floor(deadline - performance.now());
+		if (remaining <= 0) throw new _mastra_core_storage.TraceQueryExecutionError();
+		try {
+			return await db.query(sql, values, remaining);
+		} catch (error) {
+			if (error instanceof require_features.DuckDBQueryTimeoutError) throw new _mastra_core_storage.TraceQueryExecutionError();
+			if (error instanceof Error && /out of memory/i.test(error.message)) throw new _mastra_core_storage.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 [_mastra_core_storage.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 ? _mastra_core_storage.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 +6167,15 @@ var ObservabilityStorageDuckDB = class ObservabilityStorageDuckDB extends _mastr
 			"trace-query",
 			"trace-aggregate",
 			...require_features.spanQueryFeatures,
+			...typeof _mastra_core_storage.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",
+			...require_features.timeToFirstChunkFeatures,
+			"trace-query-root-span-fields"
 		];
 		return [
 			"metrics",
@@ -5920,12 +6190,15 @@ var ObservabilityStorageDuckDB = class ObservabilityStorageDuckDB extends _mastr
 			"trace-query",
 			"trace-aggregate",
 			...require_features.spanQueryFeatures,
+			...typeof _mastra_core_storage.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",
+			...require_features.timeToFirstChunkFeatures,
+			"trace-query-root-span-fields"
 		];
 	}
 	async createSpan(args) {
@@ -5971,6 +6244,7 @@ var ObservabilityStorageDuckDB = class ObservabilityStorageDuckDB extends _mastr
 		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 +6360,4 @@ var ObservabilityStorageDuckDB = class ObservabilityStorageDuckDB extends _mastr
 //#endregion
 exports.ObservabilityStorageDuckDB = ObservabilityStorageDuckDB;
 
-//# sourceMappingURL=observability-DJs6G-BH.cjs.map
+//# sourceMappingURL=observability-D70dyGYt.cjs.map