@mastra/pg 1.31.3-alpha.0 → 1.32.0-alpha.2

package/dist/docs/SKILL.md

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

package/dist/docs/assets/SOURCE_MAP.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.31.3-alpha.0",
+  "version": "1.32.0-alpha.2",
   "package": "@mastra/pg",
   "exports": {},
   "modules": {}

package/dist/docs/references/docs-memory-semantic-recall.md

@@ -403,6 +403,8 @@ Memory uses a single embedder for both storing and recalling messages, so pick o
 
 Multilingual E5 produces 1024-dimensional vectors. Your vector index must be created with matching dimensions, and E5 vectors can't be mixed with vectors from another embedder in the same index.
 
+FastEmbed models embed at most 512 tokens per input (roughly 2,000 to 2,500 characters of English text). Longer inputs are truncated, so text past the limit doesn't affect the embedding and can't be found by semantic recall. The AI SDK v3 FastEmbed models return a warning when this happens. The legacy v1 and v2 models don't. If you embed long documents with FastEmbed, chunk them to fit the window, for example with `maxSize: 1500` in `MDocument.chunk()`.
+
 ## PostgreSQL index optimization
 
 When using PostgreSQL as your vector store, you can optimize semantic recall performance by configuring the vector index. This is particularly important for large-scale deployments with thousands of messages.

package/dist/index.cjs

@@ -6327,7 +6327,11 @@ var DatasetsPG = class DatasetsPG extends _mastra_core_storage.DatasetsStorage {
 			const queryParams = [];
 			let paramIndex = 1;
 			if (args.filters) {
-				const { organizationId, projectId, candidateKey, candidateId, targetType, targetIds, name } = args.filters;
+				const { organizationId, projectId, candidateKey, candidateId, targetType, targetIds, datasetIds, name } = args.filters;
+				if (datasetIds !== void 0) {
+					conditions.push(`"id" = ANY($${paramIndex++}::text[])`);
+					queryParams.push(datasetIds);
+				}
 				if (organizationId !== void 0) {
 					conditions.push(`"organizationId" = $${paramIndex++}`);
 					queryParams.push(organizationId);
@@ -16030,6 +16034,11 @@ const SPAN_EVENT_COLUMNS = [
 		name: "endedAt",
 		type: "timestamptz"
 	},
+	{
+		name: "timeToFirstChunkMs",
+		type: "double precision",
+		nullable: true
+	},
 	{
 		name: "tags",
 		type: "text[]",
@@ -16764,6 +16773,11 @@ function additiveColumns(schema) {
 			column,
 			ddl: `ALTER TABLE ${qualifiedTable(schema, TABLE_SPAN_EVENTS)} ADD COLUMN IF NOT EXISTS "${column}" text`
 		})),
+		{
+			table: TABLE_SPAN_EVENTS,
+			column: "timeToFirstChunkMs",
+			ddl: `ALTER TABLE ${qualifiedTable(schema, TABLE_SPAN_EVENTS)} ADD COLUMN IF NOT EXISTS "timeToFirstChunkMs" double precision`
+		},
 		{
 			table: TABLE_FEEDBACK_EVENTS,
 			column: "reviewStatus",
@@ -17118,9 +17132,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 _mastra_core_storage.buildSpanQueryResponse(...args);
-	const [plan, selected, payloads, metrics] = args;
-	const response = _mastra_core_storage.buildSpanQueryResponse(plan, selected, [], metrics);
+	const [plan, selected, payloads, metrics = []] = args;
+	const compatibleSelected = _mastra_core_storage.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 _mastra_core_storage.buildSpanQueryResponse(plan, compatibleSelected, payloads, metrics);
+	const response = _mastra_core_storage.buildSpanQueryResponse(plan, compatibleSelected, [], metrics);
 	const byIdentity = new Map(payloads.map((payload) => [_mastra_core_storage.spanQueryIdentityKey(payload), payload]));
 	for (const span of response.spans) {
 		const payload = byIdentity.get(_mastra_core_storage.spanQueryIdentityKey(span));
@@ -17467,6 +17499,7 @@ function spanRecordToRow(span) {
 		isPending,
 		startedAt: toIsoOrDate(span.startedAt),
 		endedAt: toIsoOrDate(endedAt),
+		timeToFirstChunkMs: span.timeToFirstChunkMs ?? null,
 		tags: normalizeTags(span.tags),
 		metadataSearch: buildMetadataSearch(metadata),
 		metadataRaw: jsonField(metadata),
@@ -18390,6 +18423,7 @@ async function listLogsDelta(client, table, filters, after, limit) {
 function applyMetricFilters(acc, filters) {
 	applyCommonFilters(acc, filters);
 	applySingleOrArrayFilter(acc, "traceId", filters?.traceIds);
+	applySingleOrArrayFilter(acc, "experimentId", filters?.experimentIds);
 	applySingleOrArrayFilter(acc, "name", filters?.name);
 	applySingleOrArrayFilter(acc, "provider", filters?.provider);
 	applySingleOrArrayFilter(acc, "model", filters?.model);
@@ -19216,6 +19250,25 @@ const SPAN_FIELDS = {
 	userId: "s.\"userId\"",
 	organizationId: "s.\"organizationId\""
 };
+const SPAN_QUERY_FIELDS = {
+	...SPAN_FIELDS,
+	traceId: "s.\"traceId\"",
+	spanId: "s.\"spanId\"",
+	parentSpanId: "s.\"parentSpanId\"",
+	threadId: "s.\"threadId\"",
+	resourceId: "s.\"resourceId\"",
+	requestId: "s.\"requestId\"",
+	serviceName: "s.\"serviceName\"",
+	experimentId: "s.\"experimentId\"",
+	environment: "s.\"environment\"",
+	executionSource: "s.\"executionSource\"",
+	parentEntityType: "s.\"parentEntityType\"",
+	parentEntityId: "s.\"parentEntityId\"",
+	parentEntityName: "s.\"parentEntityName\"",
+	rootEntityType: "s.\"rootEntityType\"",
+	rootEntityId: "s.\"rootEntityId\"",
+	rootEntityName: "s.\"rootEntityName\""
+};
 const SCORE_FIELDS = {
 	scorerId: "s.\"scorerId\"",
 	scorerVersion: "s.\"scorerVersion\"",
@@ -20107,9 +20160,9 @@ async function queryThreads(client, schema, plan, timeoutMs) {
 		}) : 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, offset) {
-	return compileScalarPredicate(predicate, SPAN_FIELDS, offset);
+	return compileScalarPredicate(predicate, SPAN_QUERY_FIELDS, offset);
 }
 //#endregion
 //#region src/storage/domains/observability/v-next/span-query.ts
@@ -20128,11 +20181,23 @@ const fields = [
 	"entityId",
 	"entityName",
 	"entityVersionId",
+	"parentEntityType",
+	"parentEntityId",
+	"parentEntityName",
 	"parentEntityVersionId",
+	"rootEntityType",
+	"rootEntityId",
+	"rootEntityName",
 	"rootEntityVersionId",
+	"threadId",
 	"runId",
 	"sessionId",
-	"userId"
+	"userId",
+	"requestId",
+	"serviceName",
+	"experimentId",
+	"environment",
+	"executionSource"
 ];
 const identities = identityFields.map((field) => `"${field}"`).join(", ");
 const identityOrder = identityFields.map((field) => `"${field}" COLLATE "C" ASC NULLS LAST`).join(", ");
@@ -20182,6 +20247,8 @@ function compilePostgresSpanQuery(schema, plan) {
 	const after = afterCursor(plan, values);
 	values.push(plan.limit + 1);
 	const table = qualifiedTable(schema, TABLE_SPAN_EVENTS);
+	const legacyModelFields = _mastra_core_storage.SPAN_QUERY_FIELD_REGISTRY ? "" : `CASE WHEN jsonb_typeof(attributes -> 'model') = 'string' THEN attributes ->> 'model' END AS model,
+       CASE WHEN jsonb_typeof(attributes -> 'provider') = 'string' THEN attributes ->> 'provider' END AS provider,`;
 	return {
 		text: `WITH candidate_ids AS MATERIALIZED (
     SELECT DISTINCT ${identities} FROM ${table}
@@ -20190,8 +20257,7 @@ function compilePostgresSpanQuery(schema, plan) {
   ), current_spans AS MATERIALIZED (
     SELECT DISTINCT ON (${identities})
       ${fields.map((field) => `"${field}"`).join(", ")}, "startedAt", "endedAt", "cursorId"::text AS version,
-      CASE WHEN jsonb_typeof(attributes -> 'model') = 'string' THEN attributes ->> 'model' END AS model,
-      CASE WHEN jsonb_typeof(attributes -> 'provider') = 'string' THEN attributes ->> 'provider' END AS provider,
+      ${legacyModelFields}
       (EXTRACT(EPOCH FROM ("endedAt" - "startedAt")) * 1000)::float8 AS "durationMs",
       CASE WHEN error IS NULL THEN 'success' ELSE 'error' END AS status,
       error IS NOT NULL AS "hasError"
@@ -20206,15 +20272,7 @@ function compilePostgresSpanQuery(schema, plan) {
     SELECT *, CASE WHEN "hasError" THEN 'error' ELSE NULL END AS error FROM current_spans
   )
   SELECT ${[
-			...identityFields,
-			"parentSpanId",
-			"name",
-			"spanType",
-			"entityType",
-			"entityId",
-			"entityName",
-			"model",
-			"provider",
+			...fields,
 			"startedAt",
 			"endedAt",
 			"durationMs",
@@ -20261,7 +20319,7 @@ async function querySpans(client, schema, plan, timeoutMs) {
 			endedAt: endedAt.toISOString()
 		}));
 		const page = rows.slice(0, plan.limit);
-		if (!page.length) return _mastra_core_storage.buildSpanQueryResponse(plan, selected, [], []);
+		if (!page.length) return buildSpanQueryResponse(plan, [], []);
 		const remaining = async () => {
 			const ms = Math.floor(deadline - performance.now());
 			if (ms <= 0) throw new _mastra_core_storage.TraceQueryExecutionError();
@@ -20274,20 +20332,32 @@ async function querySpans(client, schema, plan, timeoutMs) {
 			payloadValues.push(row.version);
 			return `(${key} AND "cursorId" = $${payloadValues.length}::bigint)`;
 		}).join(" OR ");
-		const payloads = (await tx.any(`SELECT ${identities},
+		const payloadRows = await tx.any(`SELECT ${identities},
+      CASE WHEN jsonb_typeof(attributes -> 'model') = 'string' THEN attributes ->> 'model' END AS model,
+      CASE WHEN jsonb_typeof(attributes -> 'provider') = 'string' THEN attributes ->> 'provider' END AS provider,
       ${PREVIEW_PAYLOADS$1.map(([preview, payload]) => `"${preview}", CASE WHEN ${missingPreviewSql(`"${preview}"`)} THEN "${payload}" END AS "${payload}"`).join(",\n      ")}
-      FROM ${qualifiedTable(schema, TABLE_SPAN_EVENTS)} WHERE ${payloadWhere}`, payloadValues)).map(toSpanQueryPayload);
-		await remaining();
-		const metricValues = [];
-		const metricWhere = selectedKeys(page, metricValues);
-		const metrics = await tx.any(`SELECT ${identities}, name, "estimatedCost", "costUnit",
-      "costMetadata" ->> 'allocation' AS allocation, COALESCE("costMetadata" ? 'error', false) AS "costError"
-      FROM (SELECT DISTINCT ON (${identities}, "metricId") ${identities}, name, "estimatedCost", "costUnit", "costMetadata" FROM ${qualifiedTable(schema, TABLE_METRIC_EVENTS)}
-        WHERE (${metricWhere}) AND name LIKE 'mastra_model_%'
-        ORDER BY ${identities}, "metricId", "cursorId" DESC) m
-      LIMIT ${_mastra_core_storage.SPAN_QUERY_MAX_COST_METRICS + 1}`, metricValues);
-		if (metrics.length > _mastra_core_storage.SPAN_QUERY_MAX_COST_METRICS) throw new _mastra_core_storage.TraceQueryResourceLimitError();
-		return buildSpanQueryResponse(plan, selected, payloads, metrics);
+      FROM ${qualifiedTable(schema, TABLE_SPAN_EVENTS)} WHERE ${payloadWhere}`, payloadValues);
+		const payloads = payloadRows.map(toSpanQueryPayload);
+		const metadata = new Map(payloadRows.map((row) => [_mastra_core_storage.spanQueryIdentityKey(row), row]));
+		const hydrated = selected.map((row) => ({
+			...row,
+			model: metadata.get(_mastra_core_storage.spanQueryIdentityKey(row))?.model ?? null,
+			provider: metadata.get(_mastra_core_storage.spanQueryIdentityKey(row))?.provider ?? null
+		}));
+		let metrics = [];
+		if (!_mastra_core_storage.SPAN_QUERY_FIELD_REGISTRY) {
+			await remaining();
+			const metricValues = [];
+			const metricWhere = selectedKeys(page, metricValues);
+			metrics = await tx.any(`SELECT ${identities}, name, "estimatedCost", "costUnit",
+          "costMetadata" ->> 'allocation' AS allocation, COALESCE("costMetadata" ? 'error', false) AS "costError"
+          FROM (SELECT DISTINCT ON (${identities}, "metricId") ${identities}, name, "estimatedCost", "costUnit", "costMetadata" FROM ${qualifiedTable(schema, TABLE_METRIC_EVENTS)}
+            WHERE (${metricWhere}) AND name LIKE 'mastra_model_%'
+            ORDER BY ${identities}, "metricId", "cursorId" DESC) m
+          LIMIT ${_mastra_core_storage.SPAN_QUERY_MAX_COST_METRICS + 1}`, metricValues);
+			if (metrics.length > _mastra_core_storage.SPAN_QUERY_MAX_COST_METRICS) throw new _mastra_core_storage.TraceQueryResourceLimitError();
+		}
+		return buildSpanQueryResponse(plan, hydrated, payloads, metrics);
 	}, { repeatableRead: true });
 }
 //#endregion
@@ -21331,7 +21401,7 @@ async function dangerouslyClearTracing(client, schema) {
 * application database — observability writes will degrade app performance.
 * Use it through `MastraCompositeStore` with a dedicated Postgres connection.
 */
-const spanQueryFeatures = typeof _mastra_core_storage.planSpanQuery === "function" ? ["span-query"] : [];
+const spanQueryFeatures = typeof _mastra_core_storage.planSpanQuery === "function" ? ["span-query", "span-query-context-fields"] : [];
 function wrapError(op, error, details) {
 	if (error instanceof _mastra_core_error.MastraError || error instanceof _mastra_core_storage.TraceQueryCursorError || error instanceof _mastra_core_storage.TraceQueryExecutionError || error instanceof _mastra_core_storage.TraceQueryResourceLimitError) throw error;
 	throw new _mastra_core_error.MastraError({