@mastra/duckdb 1.14.1 → 1.15.0-alpha.1

package/dist/{observability-CXUQZgpz.js → observability-DTTykJwa.js}

@@ -1,4 +1,4 @@
-import { n as DuckDBConnection, r as DuckDBQueryTimeoutError, t as spanQueryFeatures } from "./features-D3sUOsCL.js";
+import { n as DuckDBConnection, r as DuckDBQueryTimeoutError, t as spanQueryFeatures } from "./features-vjVgmb36.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";
@@ -727,9 +727,27 @@ function readPreview(preview, payload, jsonEncoded = false) {
 }
 /** Older response builders may shorten previews or turn empty strings into null. */
 function buildSpanQueryResponse(...args) {
-	if (canGeneratePreviews) return coreStorage.buildSpanQueryResponse(...args);
-	const [plan, selected, payloads, metrics] = args;
-	const response = coreStorage.buildSpanQueryResponse(plan, selected, [], metrics);
+	const [plan, selected, payloads, metrics = []] = args;
+	const compatibleSelected = coreStorage.SPAN_QUERY_FIELD_REGISTRY ? selected : selected.map((row) => ({
+		organizationId: row.organizationId,
+		resourceId: row.resourceId,
+		traceId: row.traceId,
+		spanId: row.spanId,
+		parentSpanId: row.parentSpanId,
+		name: row.name,
+		spanType: row.spanType,
+		status: row.status,
+		startedAt: row.startedAt,
+		endedAt: row.endedAt,
+		durationMs: row.durationMs,
+		entityType: row.entityType,
+		entityId: row.entityId,
+		entityName: row.entityName,
+		model: row.model,
+		provider: row.provider
+	}));
+	if (canGeneratePreviews) return coreStorage.buildSpanQueryResponse(plan, compatibleSelected, payloads, metrics);
+	const response = coreStorage.buildSpanQueryResponse(plan, compatibleSelected, [], metrics);
 	const byIdentity = new Map(payloads.map((payload) => [coreStorage.spanQueryIdentityKey(payload), payload]));
 	for (const span of response.spans) {
 		const payload = byIdentity.get(coreStorage.spanQueryIdentityKey(span));
@@ -1606,7 +1624,10 @@ async function getStreamHeadCursor$2(db) {
 }
 //#endregion
 //#region src/storage/domains/observability/metrics.ts
-const METRIC_FILTER_FIELD_MAPPINGS = { traceIds: "traceId" };
+const METRIC_FILTER_FIELD_MAPPINGS = {
+	traceIds: "traceId",
+	experimentIds: "experimentId"
+};
 function resolveDistinctColumnSql(distinctColumn) {
 	if (!distinctColumn) throw new Error(`count_distinct aggregation requires a 'distinctColumn' argument`);
 	if (!METRIC_DISTINCT_COLUMNS.includes(distinctColumn)) throw new Error(`Invalid distinctColumn: ${distinctColumn}`);
@@ -2952,6 +2973,73 @@ const SPAN_FIELDS = {
 		parameterType: "scalar"
 	}
 };
+const SPAN_QUERY_FIELDS = {
+	...SPAN_FIELDS,
+	traceId: {
+		sql: "s.traceId",
+		parameterType: "scalar"
+	},
+	spanId: {
+		sql: "s.spanId",
+		parameterType: "scalar"
+	},
+	parentSpanId: {
+		sql: "s.parentSpanId",
+		parameterType: "scalar"
+	},
+	threadId: {
+		sql: "s.threadId",
+		parameterType: "scalar"
+	},
+	resourceId: {
+		sql: "s.resourceId",
+		parameterType: "scalar"
+	},
+	requestId: {
+		sql: "s.requestId",
+		parameterType: "scalar"
+	},
+	serviceName: {
+		sql: "s.serviceName",
+		parameterType: "scalar"
+	},
+	experimentId: {
+		sql: "s.experimentId",
+		parameterType: "scalar"
+	},
+	environment: {
+		sql: "s.environment",
+		parameterType: "scalar"
+	},
+	executionSource: {
+		sql: "s.executionSource",
+		parameterType: "scalar"
+	},
+	parentEntityType: {
+		sql: "s.parentEntityType",
+		parameterType: "scalar"
+	},
+	parentEntityId: {
+		sql: "s.parentEntityId",
+		parameterType: "scalar"
+	},
+	parentEntityName: {
+		sql: "s.parentEntityName",
+		parameterType: "scalar"
+	},
+	rootEntityType: {
+		sql: "s.rootEntityType",
+		parameterType: "scalar"
+	},
+	rootEntityId: {
+		sql: "s.rootEntityId",
+		parameterType: "scalar"
+	},
+	rootEntityName: {
+		sql: "s.rootEntityName",
+		parameterType: "scalar"
+	}
+};
 const SCORE_FIELDS = {
 	scorerId: {
 		sql: "s.scorerId",
@@ -3832,9 +3920,9 @@ async function queryThreads(db, plan) {
 		}) : null }
 	});
 }
-/** Compile a span-row filter with exactly the same rules as trace span predicates. */
+/** Compile a direct span-query filter using its dedicated field mapping. */
 function compileSpanQueryPredicate(predicate) {
-	return compileScalarPredicate(predicate, SPAN_FIELDS);
+	return compileScalarPredicate(predicate, SPAN_QUERY_FIELDS);
 }
 //#endregion
 //#region src/storage/domains/observability/span-query.ts
@@ -3844,6 +3932,15 @@ const identityFields = [
 	"traceId",
 	"spanId"
 ];
+const missingFields = /* @__PURE__ */ new Set([
+	"parentEntityType",
+	"parentEntityId",
+	"parentEntityName",
+	"rootEntityType",
+	"rootEntityId",
+	"rootEntityName",
+	"executionSource"
+]);
 const identities = identityFields.join(", ");
 const fields = [
 	...identityFields,
@@ -3854,11 +3951,23 @@ const fields = [
 	"entityId",
 	"entityName",
 	"entityVersionId",
+	"parentEntityType",
+	"parentEntityId",
+	"parentEntityName",
 	"parentEntityVersionId",
+	"rootEntityType",
+	"rootEntityId",
+	"rootEntityName",
 	"rootEntityVersionId",
+	"threadId",
 	"runId",
 	"sessionId",
-	"userId"
+	"userId",
+	"requestId",
+	"serviceName",
+	"experimentId",
+	"environment",
+	"executionSource"
 ];
 function keys(rows, values, alias = "") {
 	return rows.map((row) => `(${identityFields.map((field) => {
@@ -3909,6 +4018,8 @@ function compileDuckDBSpanQuery(plan) {
 	const after = afterCursor(plan);
 	values.push(plan.timeRange.from, plan.timeRange.to, ...predicate.values, ...after.values, plan.limit + 1);
 	const join = identityFields.map((field) => `e.${field} IS NOT DISTINCT FROM c.${field}`).join(" AND ");
+	const legacyModelFields = coreStorage.SPAN_QUERY_FIELD_REGISTRY ? "" : `CASE WHEN json_type(e.attributes, '$.model') = 'VARCHAR' THEN json_extract_string(e.attributes, '$.model') END AS model,
+       CASE WHEN json_type(e.attributes, '$.provider') = 'VARCHAR' THEN json_extract_string(e.attributes, '$.provider') END AS provider,`;
 	return {
 		sql: `WITH candidates AS MATERIALIZED (
     SELECT ${identities} FROM span_events
@@ -3916,10 +4027,9 @@ function compileDuckDBSpanQuery(plan) {
       ${scope.length ? `AND ${scope.join(" AND ")}` : ""}
     GROUP BY ${identities}
   ), ranked AS (
-    SELECT ${fields.map((field) => `e.${field}`).join(", ")},
+    SELECT ${fields.map((field) => missingFields.has(field) ? `CAST(NULL AS VARCHAR) AS ${field}` : `e.${field}`).join(", ")},
       min(e.timestamp) FILTER (WHERE e.eventType = 'start') OVER (PARTITION BY ${identityFields.map((field) => `e.${field}`).join(", ")}) AS startedAt, e.endedAt, e.cursorId,
-      CASE WHEN json_type(e.attributes, '$.model') = 'VARCHAR' THEN json_extract_string(e.attributes, '$.model') END AS model,
-      CASE WHEN json_type(e.attributes, '$.provider') = 'VARCHAR' THEN json_extract_string(e.attributes, '$.provider') END AS provider,
+      ${legacyModelFields}
       date_diff('millisecond', min(e.timestamp) FILTER (WHERE e.eventType = 'start') OVER (PARTITION BY ${identityFields.map((field) => `e.${field}`).join(", ")}), e.endedAt) AS durationMs,
       CASE WHEN e.error IS NULL THEN 'success' ELSE 'error' END AS status,
       CASE WHEN e.error IS NULL THEN NULL ELSE 'error' END AS error,
@@ -3928,15 +4038,7 @@ function compileDuckDBSpanQuery(plan) {
     FROM span_events e INNER JOIN candidates c ON ${join}
   )
   SELECT ${[
-			...identityFields,
-			"parentSpanId",
-			"name",
-			"spanType",
-			"entityType",
-			"entityId",
-			"entityName",
-			"model",
-			"provider",
+			...fields,
 			"startedAt",
 			"endedAt",
 			"durationMs",
@@ -3975,16 +4077,19 @@ async function querySpans(db, plan) {
 		endedAt: endedAt.toISOString()
 	}));
 	const page = rows.slice(0, plan.limit);
-	if (!page.length) return coreStorage.buildSpanQueryResponse(plan, selected, [], []);
+	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 payloads = (await query(`SELECT DISTINCT ${identities},
+	const previewRows = await query(`SELECT DISTINCT ${identities},
+    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,
     ${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)).map((row) => {
+    FROM span_events WHERE ${payloadWhere}`, payloadValues);
+	const payloads = previewRows.map((row) => {
 		const payload = {
 			organizationId: row.organizationId,
 			resourceId: row.resourceId,
@@ -4000,15 +4105,24 @@ async function querySpans(db, plan) {
 		}
 		return payload;
 	});
-	const metricValues = [];
-	const metricWhere = keys(page, metricValues);
-	const metrics = await query(`SELECT ${identities}, name, estimatedCost, costUnit,
-    json_extract_string(costMetadata, '$.allocation') AS allocation,
-    COALESCE(json_exists(costMetadata, '$.error'), false) AS costError
-    FROM metric_events WHERE (${metricWhere}) AND name LIKE 'mastra_model_%'
-    LIMIT ${coreStorage.SPAN_QUERY_MAX_COST_METRICS + 1}`, metricValues);
-	if (metrics.length > coreStorage.SPAN_QUERY_MAX_COST_METRICS) throw new coreStorage.TraceQueryResourceLimitError();
-	return buildSpanQueryResponse(plan, selected, payloads, metrics);
+	const metadata = new Map(previewRows.map((row) => [coreStorage.spanQueryIdentityKey(row), row]));
+	const hydrated = selected.map((row) => ({
+		...row,
+		model: metadata.get(coreStorage.spanQueryIdentityKey(row))?.model ?? null,
+		provider: metadata.get(coreStorage.spanQueryIdentityKey(row))?.provider ?? null
+	}));
+	let metrics = [];
+	if (!coreStorage.SPAN_QUERY_FIELD_REGISTRY) {
+		const metricValues = [];
+		const metricWhere = keys(page, metricValues);
+		metrics = await query(`SELECT ${identities}, name, estimatedCost, costUnit,
+      json_extract_string(costMetadata, '$.allocation') AS allocation,
+      COALESCE(json_exists(costMetadata, '$.error'), false) AS costError
+      FROM metric_events WHERE (${metricWhere}) AND name LIKE 'mastra_model_%'
+      LIMIT ${coreStorage.SPAN_QUERY_MAX_COST_METRICS + 1}`, metricValues);
+		if (metrics.length > coreStorage.SPAN_QUERY_MAX_COST_METRICS) throw new coreStorage.TraceQueryResourceLimitError();
+	}
+	return buildSpanQueryResponse(plan, hydrated, payloads, metrics);
 }
 //#endregion
 //#region src/storage/domains/observability/trace-aggregate.ts
@@ -5966,4 +6080,4 @@ var ObservabilityStorageDuckDB = class ObservabilityStorageDuckDB extends Observ
 //#endregion
 export { ObservabilityStorageDuckDB };
 
-//# sourceMappingURL=observability-CXUQZgpz.js.map
+//# sourceMappingURL=observability-DTTykJwa.js.map