@mastra/duckdb 1.19.0-alpha.0 → 1.19.0-alpha.2

package/dist/{observability-Bpaorjgj.js → observability-FlY1RbTC.js}

@@ -733,10 +733,6 @@ function buildPaginationClause(pagination) {
 // src/storage/domains/observability/preview-compat.ts
 const generator = coreStorage.buildStoredPreview;
 const canGeneratePreviews = typeof generator === "function";
-/** SQL detection only; preview formatting stays in TypeScript. Empty strings are intentional. */
-function missingPreviewSql(column) {
-	return canGeneratePreviews ? `${column} IS NULL` : "FALSE";
-}
 function needsPreview(value) {
 	return canGeneratePreviews && value == null;
 }
@@ -823,6 +819,17 @@ function payloadColumnSql(column) {
 	return `NULLIF(${column}, '${JSON_NULL_PLACEHOLDER}')`;
 }
 /**
+* The inclusive range of `dates`, used to bound lookups that find a page's rows by their keys.
+*
+* DuckDB cannot push an OR of key tuples (or a tuple semi-join) into the table scan, so without a
+* range it decompresses the payload columns of the whole table. A range reaches the scan as a plain
+* filter that zone maps can prune on, and it cannot change the result: it covers every looked-up row.
+*/
+function timeRangeOf(dates) {
+	const times = dates.map((date) => date.getTime());
+	return [new Date(Math.min(...times)), new Date(Math.max(...times))];
+}
+/**
 * Trim, drop blank, and dedupe tags before they are written, matching the
 * PostgreSQL and ClickHouse stores so tag predicates and discovery agree.
 */
@@ -1276,6 +1283,11 @@ async function deleteFeedback(db, args) {
 	}
 	await db.execute(`DELETE FROM feedback_events WHERE ${conditions.join(" AND ")}`, params);
 }
+/** Retrieves the latest feedback record with this ID, or null when missing. */
+async function getFeedbackById(db, feedbackId) {
+	const rows = await db.query(`SELECT * FROM feedback_events WHERE feedbackId = ? ORDER BY timestamp DESC LIMIT 1`, [feedbackId]);
+	return rows[0] ? rowToFeedbackRecord(rows[0]) : null;
+}
 /** Update the review workflow status of a single feedback event. */
 async function updateFeedbackReviewStatus(db, args) {
 	const { feedbackId, reviewStatus } = parseUpdateFeedbackReviewStatusArgs(args);
@@ -3897,7 +3909,7 @@ const TRACE_PREVIEW_PAYLOADS = [
 async function fillMissingTracePreviews(db, rows) {
 	const flagged = rows.filter((row) => row.traceId != null && TRACE_PREVIEW_PAYLOADS.some(([preview]) => needsPreview(row[preview])));
 	if (flagged.length === 0) return;
-	const values = [];
+	const values = timeRangeOf(flagged.map((row) => row.rootTimestamp));
 	const where = flagged.map((row) => {
 		values.push(row.traceId, row.rootSpanId, row.rootEventType, row.rootTimestamp, row.rootCursorId);
 		return "(traceId = ? AND spanId = ? AND eventType = ? AND timestamp = ? AND cursorId IS NOT DISTINCT FROM ?)";
@@ -3907,7 +3919,7 @@ async function fillMissingTracePreviews(db, rows) {
       ${payloadColumnSql("output")} AS output,
       error
     FROM span_events
-    WHERE parentSpanId IS NULL AND (${where})`, values);
+    WHERE parentSpanId IS NULL AND timestamp BETWEEN ? AND ? AND (${where})`, values);
 	const byTrace = new Map(payloads.map((payload) => [String(payload.traceId), payload]));
 	for (const row of flagged) {
 		const payload = byTrace.get(String(row.traceId));
@@ -4174,6 +4186,17 @@ const previewPayloads = [
 	["outputPreview", payloadColumnSql("output")],
 	["errorPreview", "error"]
 ];
+function eventRowsFilter(rows) {
+	const values = timeRangeOf(rows.map((row) => row.endedAt));
+	return {
+		sql: `endedAt BETWEEN ? AND ? AND (${rows.map((row) => {
+			const key = keys([row], values);
+			values.push(row.cursorId, row.endedAt);
+			return `(${key} AND cursorId IS NOT DISTINCT FROM ? AND endedAt = ?)`;
+		}).join(" OR ")})`,
+		values
+	};
+}
 async function querySpans(db, plan) {
 	const deadline = performance.now() + coreStorage.TRACE_QUERY_DEFAULT_TIMEOUT_MS;
 	const query = async (sql, values) => {
@@ -4202,17 +4225,21 @@ async function querySpans(db, plan) {
 	}));
 	const page = rows.slice(0, plan.limit);
 	if (!page.length) return buildSpanQueryResponse(plan, [], []);
-	const payloadValues = [];
-	const payloadWhere = page.map((row) => {
-		const key = keys([row], payloadValues);
-		payloadValues.push(row.cursorId, row.endedAt);
-		return `(${key} AND cursorId IS NOT DISTINCT FROM ? AND endedAt = ?)`;
-	}).join(" OR ");
-	const previewRows = await query(`SELECT DISTINCT ${identities}, CAST(stopReasonContext AS VARCHAR) AS stopReasonContext,
+	const lookupColumns = `${identities}, CAST(stopReasonContext AS VARCHAR) AS stopReasonContext,
     COALESCE(model, CASE WHEN json_type(attributes, '$.model') = 'VARCHAR' THEN json_extract_string(attributes, '$.model') END) AS model,
     COALESCE(provider, CASE WHEN json_type(attributes, '$.provider') = 'VARCHAR' THEN json_extract_string(attributes, '$.provider') END) AS provider,
-    ${previewPayloads.map(([preview, payload]) => `${preview}, CASE WHEN ${missingPreviewSql(preview)} THEN CAST(${payload} AS VARCHAR) END AS ${preview}Payload`).join(",\n    ")}
-    FROM span_events WHERE ${payloadWhere}`, payloadValues);
+    ${previewPayloads.map(([preview]) => preview).join(", ")}`;
+	const pageFilter = eventRowsFilter(page);
+	const storedRows = await query(`SELECT DISTINCT ${lookupColumns} FROM span_events WHERE ${pageFilter.sql}`, pageFilter.values);
+	const withoutPreview = new Set(storedRows.filter((row) => previewPayloads.some(([preview]) => needsPreview(row[preview]))).map((row) => coreStorage.spanQueryIdentityKey(row)));
+	const rowsWithoutPreview = page.filter((row) => withoutPreview.has(coreStorage.spanQueryIdentityKey(row)));
+	let previewRows = storedRows;
+	if (rowsWithoutPreview.length) {
+		const payloadFilter = eventRowsFilter(rowsWithoutPreview);
+		const payloadRows = await query(`SELECT DISTINCT ${lookupColumns}, ${previewPayloads.map(([preview, payload]) => `CAST(${payload} AS VARCHAR) AS ${preview}Payload`).join(", ")}
+      FROM span_events WHERE ${payloadFilter.sql}`, payloadFilter.values);
+		previewRows = [...storedRows.filter((row) => !withoutPreview.has(coreStorage.spanQueryIdentityKey(row))), ...payloadRows];
+	}
 	const payloads = previewRows.map((row) => {
 		const payload = {
 			organizationId: row.organizationId,
@@ -4387,6 +4414,22 @@ function compileDuckDBThreadRowsQuery(plan, strategy = "full") {
 		values
 	};
 }
+/**
+* A chat's first and last traces can be months apart, so the range alone can cover the whole table.
+* The IN list lets DuckDB also skip the row groups between them.
+*/
+function rootRowsFilter(roots) {
+	const endedAts = roots.map((root) => root.endedAt);
+	const values = [...timeRangeOf(endedAts), ...endedAts];
+	const keys = roots.map((root) => `(${Object.entries(root).map(([field, value]) => {
+		values.push(value);
+		return `${field} ${field === "organizationId" || field === "resourceId" ? "IS NOT DISTINCT FROM" : "="} ?`;
+	}).join(" AND ")})`);
+	return {
+		sql: `endedAt BETWEEN ? AND ? AND endedAt IN (${endedAts.map(() => "?").join(", ")}) AND (${keys.join(" OR ")})`,
+		values
+	};
+}
 async function queryThreadRows(db, plan, strategy = "auto") {
 	const deadline = performance.now() + coreStorage.TRACE_QUERY_DEFAULT_TIMEOUT_MS;
 	const run = async (sql, values) => {
@@ -4416,38 +4459,47 @@ async function queryThreadRows(db, plan, strategy = "auto") {
 		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,
+	const roots = page.flatMap((row) => ["first", "last"].map((which) => ({
+		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`]
+	})));
+	const pageFilter = rootRowsFilter(roots);
+	const rootRows = await run(`SELECT organizationId, traceId, cursorId,
     ${contextFields.map((field) => field === "executionSource" ? "source AS executionSource" : field).join(", ")},
     CASE WHEN spanType = 'agent_run' THEN timeToFirstChunkMs END AS timeToFirstChunkMs,
     CASE WHEN spanType = 'agent_run' THEN timeToFirstTokenMs END AS timeToFirstTokenMs,
     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);
+    inputPreview, outputPreview, errorPreview
+    FROM span_events
+    WHERE ${pageFilter.sql}`, pageFilter.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 byRoot = new Map(rootRows.map((row) => [key(row.organizationId, row.traceId, row.cursorId), row]));
+	const rootsWithoutPreview = roots.filter((root) => {
+		const row = byRoot.get(key(root.organizationId, root.traceId, root.cursorId));
+		return row && [
+			row.inputPreview,
+			row.outputPreview,
+			row.errorPreview
+		].some(needsPreview);
+	});
+	if (rootsWithoutPreview.length) {
+		const payloadFilter = rootRowsFilter(rootsWithoutPreview);
+		const payloads = await run(`SELECT organizationId, traceId, cursorId,
+      CAST(${payloadColumnSql("input")} AS VARCHAR) AS input,
+      CAST(${payloadColumnSql("output")} AS VARCHAR) AS output,
+      CAST(error AS VARCHAR) AS error
+      FROM span_events
+      WHERE ${payloadFilter.sql}`, payloadFilter.values);
+		for (const payload of payloads) Object.assign(byRoot.get(key(payload.organizationId, payload.traceId, payload.cursorId)), payload);
+	}
 	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));
@@ -5071,7 +5123,9 @@ const SPAN_RECONSTRUCT_SELECT_LIGHT_LIST = `
     ${argMaxNonNull("resourceId")},
     ${argMaxNonNull("error")},
     ${argMaxNonNull("metadata")},
-    ${RECONSTRUCT_PREVIEWS_SQL}
+    ${RECONSTRUCT_PREVIEWS_SQL},
+    min(timestamp) AS firstEventAt,
+    max(timestamp) AS lastEventAt
   FROM span_events
 `;
 /**
@@ -5202,11 +5256,18 @@ async function fillMissingReconstructedPreviews(db, rows) {
 	const flagged = rows.filter((row) => PREVIEW_PAYLOADS.some(([preview]) => needsPreview(row[preview])));
 	if (flagged.length === 0) return;
 	const traceIds = [...new Set(flagged.map((row) => row.traceId))];
+	const [minTs, maxTs] = timeRangeOf(flagged.flatMap((row) => [row.firstEventAt, row.lastEventAt]));
 	const payloads = await db.query(`SELECT traceId, spanId, ${PREVIEW_PAYLOADS.map(([, payload]) => argMaxNonNull(payload)).join(", ")}
      FROM span_events
-     WHERE traceId IN (${traceIds.map(() => "?").join(", ")})
+     WHERE timestamp BETWEEN ? AND ?
+       AND traceId IN (${traceIds.map(() => "?").join(", ")})
        AND (traceId, spanId) IN (SELECT * FROM (VALUES ${flagged.map(() => "(?, ?)").join(", ")}))
-     GROUP BY traceId, spanId`, [...traceIds, ...flagged.flatMap((row) => [row.traceId, row.spanId])]);
+     GROUP BY traceId, spanId`, [
+		minTs,
+		maxTs,
+		...traceIds,
+		...flagged.flatMap((row) => [row.traceId, row.spanId])
+	]);
 	const byKey = new Map(payloads.map((payload) => [`${payload.traceId}\u0000${payload.spanId}`, payload]));
 	for (const row of flagged) {
 		const payload = byKey.get(`${row.traceId}\u0000${row.spanId}`);
@@ -6311,6 +6372,9 @@ ${args.tables.map((table) => `  - ${table.table}`).join("\n")}\n\nTo fix this, r
 * Uses an append-only event-sourced model with SQL-based reconstruction for spans.
 */
 var ObservabilityStorageDuckDB = class ObservabilityStorageDuckDB extends ObservabilityStorage {
+	get persistenceLocation() {
+		return "local";
+	}
 	static retentionTables = {
 		spans: {
 			table: "span_events",
@@ -6591,6 +6655,9 @@ var ObservabilityStorageDuckDB = class ObservabilityStorageDuckDB extends Observ
 	async getScoreById(scoreId) {
 		return getScoreById(this.db, scoreId);
 	}
+	async getFeedbackById(feedbackId) {
+		return getFeedbackById(this.db, feedbackId);
+	}
 	async getScoreAggregate(args) {
 		return getScoreAggregate(this.db, args);
 	}
@@ -6633,4 +6700,4 @@ var ObservabilityStorageDuckDB = class ObservabilityStorageDuckDB extends Observ
 };
 export { ObservabilityStorageDuckDB };
 
-//# sourceMappingURL=observability-Bpaorjgj.js.map
+//# sourceMappingURL=observability-FlY1RbTC.js.map