@mastra/duckdb 1.13.0-alpha.2 → 1.13.0

package/dist/docs/SKILL.md

@@ -3,7 +3,7 @@ name: mastra-duckdb
 description: Documentation for @mastra/duckdb. Use when working with @mastra/duckdb APIs, configuration, or implementation.
 metadata:
   package: "@mastra/duckdb"
-  version: "1.13.0-alpha.2"
+  version: "1.13.0"
 ---
 
 ## When to use

package/dist/docs/assets/SOURCE_MAP.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.13.0-alpha.2",
+  "version": "1.13.0",
   "package": "@mastra/duckdb",
   "exports": {},
   "modules": {}

package/dist/index.cjs

@@ -556,7 +556,7 @@ var ObservabilityStorageDuckDB = class extends _mastra_core_storage.Observabilit
 	async loadDelegate() {
 		if (this.delegate) return this.delegate;
 		if (this.unavailableError) return null;
-		if (!this.loadPromise) this.loadPromise = Promise.resolve().then(() => require("./observability-D4eFjsKJ.cjs")).then(({ ObservabilityStorageDuckDB }) => {
+		if (!this.loadPromise) this.loadPromise = Promise.resolve().then(() => require("./observability-DBm19qBS.cjs")).then(({ ObservabilityStorageDuckDB }) => {
 			const delegate = new ObservabilityStorageDuckDB({ db: this.db });
 			this.delegate = delegate;
 			return delegate;

package/dist/index.js

@@ -555,7 +555,7 @@ var ObservabilityStorageDuckDB = class extends ObservabilityStorage {
 	async loadDelegate() {
 		if (this.delegate) return this.delegate;
 		if (this.unavailableError) return null;
-		if (!this.loadPromise) this.loadPromise = import("./observability-DINJlR_a.js").then(({ ObservabilityStorageDuckDB }) => {
+		if (!this.loadPromise) this.loadPromise = import("./observability-x50aDnBm.js").then(({ ObservabilityStorageDuckDB }) => {
 			const delegate = new ObservabilityStorageDuckDB({ db: this.db });
 			this.delegate = delegate;
 			return delegate;

package/dist/{observability-D4eFjsKJ.cjs → observability-DBm19qBS.cjs}

@@ -3899,18 +3899,7 @@ const COMPARISON_SQL = {
 	gt: ">",
 	gte: ">="
 };
-/**
-* Compiles a trusted aggregate plan. The plan's caps are enforced by the planner and trusted here.
-*
-* Every candidate root is first reduced to a `facts` row (dimension values, duration, error flag,
-* countDistinct inputs, bucket) so grouping, measures, and joins only reference plain columns.
-* Without `interval`, groups are filtered, ordered, and limited in one grouped select. With
-* `interval`, a `ranked` CTE ranks groups on whole-window measures, then only the top `limit`
-* groups are expanded into per-bucket rows.
-*
-* Parameters are positional, so `values` is appended in the order placeholders appear in the text.
-*/
-function compileDuckDBTraceAggregate(plan) {
+function compileDuckDBTraceAggregate(plan, options = {}) {
 	const { ctes, values } = compileDuckDBTraceCandidates(plan, "r.*");
 	const dimensionSql = (field) => {
 		if (field.startsWith("metadata.")) return {
@@ -3950,10 +3939,31 @@ function compileDuckDBTraceAggregate(plan) {
 		if (intervalMs === void 0) throw new Error(`Unsupported trusted trace-aggregate interval: ${plan.interval}`);
 		factColumns.push(`epoch_ms((epoch_ms(r.startedAt) // ${intervalMs}) * ${intervalMs}) AS bucket`);
 	}
-	ctes.push(`facts AS (
+	const measureKinds = new Set(plan.measures.map((measure) => measureRule(measure.name)?.kind));
+	const hasCost = measureKinds.has("cost");
+	if (!hasCost && !measureKinds.has("tokens")) ctes.push(`facts AS (
     SELECT ${factColumns.join(",\n      ")}
     FROM candidates r
   )`);
+	else {
+		ctes.push(`base_facts AS (
+    SELECT r.traceId, ${factColumns.join(",\n      ")}
+    FROM candidates r
+  )`);
+		ctes.push(...compileUsageCtes(plan, values, {
+			hasCost,
+			dedupe: !options.metricIdsUnique
+		}));
+		const usageColumns = USAGE_METRIC_NAMES.map((_, index) => `CASE WHEN u.traceId IS NOT NULL THEN COALESCE(u.t${index}, 0) END AS t${index}`);
+		usageColumns.push(`u.traceId IS NOT NULL AS usageBearing`);
+		if (hasCost) usageColumns.push(`CASE WHEN u.priced THEN u.cost END AS traceCost`, `COALESCE(u.priced AND NOT u.pricingFailure, FALSE) AS covered`, `u.unitMin AS unitMin`, `u.unitMax AS unitMax`);
+		ctes.push(`facts AS (
+    SELECT b.*,
+      ${usageColumns.join(",\n      ")}
+    FROM base_facts b
+    LEFT JOIN usage u ON u.traceId = b.traceId
+  )`);
+	}
 	const measureSql = (name, alias = "") => {
 		const column = (name) => `${alias}${name}`;
 		if (name === "count") return "CAST(count(*) AS DOUBLE)";
@@ -3964,6 +3974,15 @@ function compileDuckDBTraceAggregate(plan) {
 		if (name === "duration.max") return `max(${column("durationMs")})`;
 		const percentile = PERCENTILES[name];
 		if (percentile !== void 0) return `quantile_cont(${column("durationMs")}, ${percentile})`;
+		const rule = measureRule(name);
+		if (rule?.kind === "tokens" && rule.metricNames) {
+			const value = rule.metricNames.map((metricName) => column(`t${usageMetricIndex(metricName)}`)).join(" + ");
+			return `CAST(${rule.statistic === "avg" ? "avg" : "sum"}(${value}) AS DOUBLE)`;
+		}
+		if (rule?.kind === "cost") {
+			const aggregate = rule.statistic === "avg" ? "avg" : "sum";
+			return `CASE WHEN ${mixedUnitsSql(alias)} THEN NULL ELSE CAST(${aggregate}(${column("traceCost")}) AS DOUBLE) END`;
+		}
 		const measure = plan.measures.find((candidate) => candidate.type === "countDistinct" && candidate.name === name);
 		const distinctColumn = measure && distinctColumns.get(measure.field);
 		if (distinctColumn === void 0) throw new Error(`Unsupported trusted trace-aggregate measure: ${name}`);
@@ -3997,7 +4016,11 @@ function compileDuckDBTraceAggregate(plan) {
 	const orderSql = [`${orderTarget} ${direction} NULLS LAST`, ...dimensionColumns.map((column) => `${column} ASC NULLS LAST`)].join(", ");
 	const groupSql = dimensionColumns.length > 0 ? `\nGROUP BY ${dimensionColumns.join(", ")}` : "";
 	if (plan.interval === void 0) {
-		const projected = [...dimensionColumns, ...plan.measures.map((measure, index) => `${measureSql(measure.name)} AS m${index}`)];
+		const projected = [
+			...dimensionColumns,
+			...plan.measures.map((measure, index) => `${measureSql(measure.name)} AS m${index}`),
+			...hasCost ? costColumns("") : []
+		];
 		values.push(...havingValues, plan.limit + 1);
 		return {
 			sql: `WITH ${ctes.join(",\n  ")}
@@ -4022,6 +4045,7 @@ LIMIT ?`,
 		...dimensionColumns.map((column) => `f.${column}`),
 		"f.bucket",
 		...plan.measures.map((measure, index) => `${measureSql(measure.name, "f.")} AS m${index}`),
+		...hasCost ? costColumns("f.") : [],
 		`(SELECT count(*) FROM ranked) > ? AS truncated`
 	];
 	values.push(plan.limit, plan.limit);
@@ -4040,8 +4064,97 @@ ORDER BY g.rank ASC, f.bucket ASC`,
 		values
 	};
 }
-async function aggregateTraces(db, plan) {
-	const compiled = compileDuckDBTraceAggregate(plan);
+const USAGE_METRIC_NAMES = _mastra_core_storage.TRACE_AGGREGATE_USAGE_METRIC_NAMES;
+function measureRule(name) {
+	return _mastra_core_storage.isTraceAggregateCanonicalMeasure(name) ? _mastra_core_storage.TRACE_AGGREGATE_MEASURE_REGISTRY[name] : void 0;
+}
+function usageMetricIndex(name) {
+	const index = USAGE_METRIC_NAMES.indexOf(name);
+	if (index === -1) throw new Error(`Unsupported trusted trace-aggregate token metric: ${name}`);
+	return index;
+}
+/** More than one distinct priced unit in the group; NULL (treated as false) when nothing is priced. */
+function mixedUnitsSql(alias) {
+	return `min(${alias}unitMin) <> max(${alias}unitMax)`;
+}
+/** Row cost fields, projected only for cost requests. */
+function costColumns(alias) {
+	const mixed = _mastra_core_storage.TRACE_AGGREGATE_MIXED_COST_UNIT.replaceAll("'", "''");
+	return [`CAST(count_if(${alias}covered) AS DOUBLE) / NULLIF(count_if(${alias}usageBearing), 0) AS costCoverage`, `CASE WHEN ${mixedUnitsSql(alias)} THEN '${mixed}' ELSE min(${alias}unitMin) END AS costUnit`];
+}
+/**
+* Builds `usage_bounds`, `usage_rows`, and `usage`: one row per candidate trace that has at least
+* one token metric row, holding per-name token sums (`t<i>`, indexed by
+* `TRACE_AGGREGATE_USAGE_METRIC_NAMES`) and, for cost requests, the trace's pricing state. Metric
+* rows are matched by traceId, usage metric name, tenant scope, and `timestamp >= from` only: a
+* trace that starts in the window can emit metrics after `to`, and the semi-join bounds the scan.
+*
+* DuckDB cannot push the `traceId IN (...)` semi-join into the table scan, so `usage_bounds`
+* first reads the exact timestamp range of the qualifying rows from narrow columns, and
+* `usage_rows` decompresses the wide columns only inside that range.
+*
+* Without the `metricId` primary key, retried copies are collapsed with `DISTINCT ON`; copies are
+* identical, so whichever survives is the same.
+*
+* Placeholders are bound in text order: `param` pushes each value as its placeholder is emitted.
+*/
+function compileUsageCtes(plan, values, { hasCost, dedupe }) {
+	const param = (value) => {
+		values.push(value);
+		return "?";
+	};
+	const list = (items) => items.map(param).join(", ");
+	const scope = (alias) => {
+		if (!plan.scope) return "";
+		let sql = `\n        AND ${alias}organizationId = ${param(plan.scope.organizationId)}`;
+		if (plan.scope.resourceId !== void 0) sql += `\n        AND ${alias}resourceId = ${param(plan.scope.resourceId)}`;
+		return sql;
+	};
+	const costNames = _mastra_core_storage.TRACE_AGGREGATE_COST_METRIC_NAMES;
+	const bounds = `usage_bounds AS (
+      SELECT min(timestamp) AS minTs, max(timestamp) AS maxTs
+      FROM metric_events
+      WHERE traceId IN (SELECT traceId FROM base_facts)
+        AND name IN (${list(USAGE_METRIC_NAMES)})
+        AND timestamp >= CAST(${param(plan.timeRange.from)} AS TIMESTAMP)${scope("")}
+    )`;
+	const costSelect = hasCost ? `,
+        m.estimatedCost,
+        m.costUnit,
+        m.name IN (${list(costNames)}) AS costRow,
+        CASE WHEN m.name IN (${list(costNames)})
+          THEN COALESCE(json_type(m.costMetadata, '$.error'), 'NULL') <> 'NULL'
+          ELSE FALSE
+        END AS hasError` : "";
+	const rows = `usage_rows AS (
+      SELECT ${dedupe ? "DISTINCT ON (m.metricId) " : ""}m.traceId, m.name, m.value${costSelect}
+      FROM metric_events m
+      WHERE m.timestamp >= (SELECT minTs FROM usage_bounds)
+        AND m.timestamp <= (SELECT maxTs FROM usage_bounds)
+        AND m.traceId IN (SELECT traceId FROM base_facts)
+        AND m.name IN (${list(USAGE_METRIC_NAMES)})${scope("m.")}
+    )`;
+	const columns = USAGE_METRIC_NAMES.map((name) => `sum(value) FILTER (WHERE name = ${param(name)})`).map((sql, index) => `${sql} AS t${index}`);
+	if (hasCost) {
+		const priced = "costRow AND estimatedCost IS NOT NULL AND costUnit IS NOT NULL AND NOT hasError";
+		columns.push(`sum(estimatedCost) FILTER (WHERE ${priced}) AS cost`, `bool_or(${priced}) AS priced`, `bool_or(costRow AND (hasError OR (estimatedCost IS NOT NULL AND costUnit IS NULL))) AS pricingFailure`, `min(costUnit) FILTER (WHERE ${priced}) AS unitMin`, `max(costUnit) FILTER (WHERE ${priced}) AS unitMax`);
+	}
+	return [
+		bounds,
+		rows,
+		`usage AS (
+      SELECT traceId,
+        ${columns.join(",\n        ")}
+      FROM usage_rows
+      GROUP BY traceId
+    )`
+	];
+}
+function nullableNumber(value) {
+	return value === null || value === void 0 ? null : Number(value);
+}
+async function aggregateTraces(db, plan, options = {}) {
+	const compiled = compileDuckDBTraceAggregate(plan, options);
 	let result;
 	try {
 		result = await db.query(compiled.sql, compiled.values);
@@ -4060,7 +4173,11 @@ async function aggregateTraces(db, plan) {
 	}
 	return {
 		rows: resultRows.map((row) => {
-			const shaped = { measures: Object.fromEntries(plan.measures.map((measure, index) => [measure.name, Number(row[`m${index}`])])) };
+			const shaped = { measures: Object.fromEntries(plan.measures.map((measure, index) => [measure.name, nullableNumber(row[`m${index}`])])) };
+			if ("costCoverage" in row) shaped.cost = {
+				coverage: nullableNumber(row.costCoverage),
+				unit: row.costUnit ?? null
+			};
 			if (plan.dimensions.length > 0) shaped.dimensions = Object.fromEntries(plan.dimensions.map((dimension, index) => {
 				const value = row[`d${index}`];
 				return [dimension, value == null ? null : String(value)];
@@ -5331,6 +5448,8 @@ var ObservabilityStorageDuckDB = class ObservabilityStorageDuckDB extends _mastr
 			indexed: false
 		}
 	};
+	/** Set by `init()`; until then aggregate queries dedupe metric rows on `metricId`. */
+	metricIdsUnique = false;
 	db;
 	constructor(config) {
 		super();
@@ -5367,6 +5486,7 @@ var ObservabilityStorageDuckDB = class ObservabilityStorageDuckDB extends _mastr
 		});
 		await this.db.executeBatch([...ALL_DDL, ...ALL_MIGRATIONS]);
 		await dropLegacyCursorIdDefaults(this.db);
+		this.metricIdsUnique = await hasPrimaryKey(this.db, "metric_events");
 	}
 	/**
 	* Manually migrate legacy signal tables to the signal-ID primary-key schema.
@@ -5480,7 +5600,7 @@ var ObservabilityStorageDuckDB = class ObservabilityStorageDuckDB extends _mastr
 		return queryTraces(this.db, plan);
 	}
 	async aggregateTraces(plan) {
-		return aggregateTraces(this.db, plan);
+		return aggregateTraces(this.db, plan, { metricIdsUnique: this.metricIdsUnique });
 	}
 	async getTraceQueryObservedFields(plan) {
 		return getTraceQueryObservedFields(this.db, plan);
@@ -5604,4 +5724,4 @@ var ObservabilityStorageDuckDB = class ObservabilityStorageDuckDB extends _mastr
 //#endregion
 exports.ObservabilityStorageDuckDB = ObservabilityStorageDuckDB;
 
-//# sourceMappingURL=observability-D4eFjsKJ.cjs.map
+//# sourceMappingURL=observability-DBm19qBS.cjs.map