@mastra/pg 1.31.1 → 1.31.2-alpha.1

package/dist/index.cjs

@@ -2472,6 +2472,10 @@ function repairJson(value) {
 	}
 	return value;
 }
+/** Repair text for a PostgreSQL `text` column, which rejects NUL characters. */
+function toPgText(value) {
+	return repair(value);
+}
 /** Serialize JSON values without emitting Unicode sequences PostgreSQL rejects. */
 function toPgJson(value) {
 	const json = JSON.stringify(value);
@@ -14563,6 +14567,7 @@ var MemoryPG = class MemoryPG extends _mastra_core_storage.MemoryStorage {
 };
 //#endregion
 //#region src/storage/domains/notifications/index.ts
+const COMPOSITE_PRIMARY_KEY$1 = _mastra_core_storage.TABLE_CONFIGS[_mastra_core_storage.TABLE_NOTIFICATIONS].compositePrimaryKey;
 const statusTimestamp = (status, now) => {
 	if (status === "delivered") return { deliveredAt: now };
 	if (status === "seen") return { seenAt: now };
@@ -14674,11 +14679,58 @@ var NotificationsPG = class NotificationsPG extends _mastra_core_storage.Notific
 	async init() {
 		await this.#db.createTable({
 			tableName: _mastra_core_storage.TABLE_NOTIFICATIONS,
-			schema: _mastra_core_storage.TABLE_SCHEMAS[_mastra_core_storage.TABLE_NOTIFICATIONS]
+			schema: _mastra_core_storage.TABLE_SCHEMAS[_mastra_core_storage.TABLE_NOTIFICATIONS],
+			compositePrimaryKey: COMPOSITE_PRIMARY_KEY$1
 		});
+		await this.ensurePrimaryKey();
 		await this.createDefaultIndexes();
 		await this.createCustomIndexes();
 	}
+	async #hasPrimaryKey() {
+		return !!(await this.#db.client.oneOrNone(`SELECT EXISTS (
+        SELECT 1 FROM pg_index i
+        JOIN pg_class c ON c.oid = i.indrelid
+        JOIN pg_namespace n ON n.oid = c.relnamespace
+        WHERE c.relname = $1 AND n.nspname = $2 AND i.indisprimary
+      ) AS exists`, [_mastra_core_storage.TABLE_NOTIFICATIONS, this.#schema]))?.exists;
+	}
+	/**
+	* Tables created before the composite primary key was declared have no key at
+	* all, which allows duplicate ids and leaves the table without a replica
+	* identity (UPDATE/DELETE fail under logical replication). `createTable` is a
+	* no-op for existing tables, so add the key here. If duplicate rows already
+	* exist, or the role does not own the table, the key cannot be added; warn with
+	* remediation instead of blocking init.
+	*/
+	async ensurePrimaryKey() {
+		if (await this.#hasPrimaryKey()) return;
+		const tableName = getTableName$5({
+			indexName: _mastra_core_storage.TABLE_NOTIFICATIONS,
+			schemaName: getSchemaName$5(this.#schema)
+		});
+		const keyColumns = COMPOSITE_PRIMARY_KEY$1.map((column) => `"${(0, _mastra_core_utils.parseSqlIdentifier)(column, "column name")}"`).join(", ");
+		const remediation = `ALTER TABLE ${tableName} ADD PRIMARY KEY (${keyColumns});`;
+		if (await this.#db.client.oneOrNone(`SELECT 1 FROM ${tableName} GROUP BY ${keyColumns} HAVING count(*) > 1 LIMIT 1`)) {
+			this.logger?.warn?.(`${tableName} contains duplicate (${keyColumns}) rows, so its PRIMARY KEY could not be added. Remove the duplicates, then run: ${remediation}`);
+			return;
+		}
+		try {
+			await this.#db.client.none(`ALTER TABLE ${tableName} ADD PRIMARY KEY (${keyColumns})`);
+			this.logger?.info?.(`Added PRIMARY KEY (${keyColumns}) to ${tableName}`);
+		} catch (error) {
+			if (await this.#hasPrimaryKey()) return;
+			if (error?.code === "42501") {
+				this.logger?.warn?.(`Insufficient privilege to add PRIMARY KEY (${keyColumns}) to ${tableName}. Ask the table owner to run: ${remediation}`);
+				return;
+			}
+			throw new _mastra_core_error.MastraError({
+				id: (0, _mastra_core_storage.createStorageErrorId)("PG", "ADD_NOTIFICATIONS_PRIMARY_KEY", "FAILED"),
+				domain: _mastra_core_error.ErrorDomain.STORAGE,
+				category: _mastra_core_error.ErrorCategory.THIRD_PARTY,
+				details: { tableName }
+			}, error);
+		}
+	}
 	/**
 	* Lazily ensures a btree index exists on each configured policy's retention
 	* anchor column so age-based `prune()` deletes stay fast on large tables.
@@ -14762,6 +14814,7 @@ var NotificationsPG = class NotificationsPG extends _mastra_core_storage.Notific
 			tableName: _mastra_core_storage.TABLE_NOTIFICATIONS,
 			schema: _mastra_core_storage.TABLE_SCHEMAS[_mastra_core_storage.TABLE_NOTIFICATIONS],
 			schemaName,
+			compositePrimaryKey: COMPOSITE_PRIMARY_KEY$1,
 			includeAllConstraints: true
 		}));
 		for (const idx of NotificationsPG.getDefaultIndexDefs(schemaPrefix)) statements.push(generateIndexSQL(idx, schemaName));
@@ -16026,6 +16079,21 @@ const SPAN_EVENT_COLUMNS = [
 		name: "requestContext",
 		type: "jsonb",
 		nullable: true
+	},
+	{
+		name: "inputPreview",
+		type: "text",
+		nullable: true
+	},
+	{
+		name: "outputPreview",
+		type: "text",
+		nullable: true
+	},
+	{
+		name: "errorPreview",
+		type: "text",
+		nullable: true
 	}
 ];
 const METRIC_EVENT_COLUMNS = [
@@ -16681,15 +16749,27 @@ function allTableDDL(schema, mode) {
 * default does not rewrite the table, and the ALTER cascades to partitions.
 */
 function additiveColumns(schema) {
-	return [{
-		table: TABLE_SPAN_EVENTS,
-		column: "isPending",
-		ddl: `ALTER TABLE ${qualifiedTable(schema, TABLE_SPAN_EVENTS)} ADD COLUMN IF NOT EXISTS "isPending" boolean NOT NULL DEFAULT false`
-	}, {
-		table: TABLE_FEEDBACK_EVENTS,
-		column: "reviewStatus",
-		ddl: `ALTER TABLE ${qualifiedTable(schema, TABLE_FEEDBACK_EVENTS)} ADD COLUMN IF NOT EXISTS "reviewStatus" text NOT NULL DEFAULT 'needs-review'`
-	}];
+	return [
+		{
+			table: TABLE_SPAN_EVENTS,
+			column: "isPending",
+			ddl: `ALTER TABLE ${qualifiedTable(schema, TABLE_SPAN_EVENTS)} ADD COLUMN IF NOT EXISTS "isPending" boolean NOT NULL DEFAULT false`
+		},
+		...[
+			"inputPreview",
+			"outputPreview",
+			"errorPreview"
+		].map((column) => ({
+			table: TABLE_SPAN_EVENTS,
+			column,
+			ddl: `ALTER TABLE ${qualifiedTable(schema, TABLE_SPAN_EVENTS)} ADD COLUMN IF NOT EXISTS "${column}" text`
+		})),
+		{
+			table: TABLE_FEEDBACK_EVENTS,
+			column: "reviewStatus",
+			ddl: `ALTER TABLE ${qualifiedTable(schema, TABLE_FEEDBACK_EVENTS)} ADD COLUMN IF NOT EXISTS "reviewStatus" text NOT NULL DEFAULT 'needs-review'`
+		}
+	];
 }
 /** Existence probe for an additive column. Params: schema, table, column. */
 const columnExistsSQL = `SELECT 1 FROM information_schema.columns
@@ -17011,6 +17091,46 @@ function whereOrEmpty(acc) {
 	return acc.conditions.length ? `WHERE ${acc.conditions.join(" AND ")}` : "";
 }
 //#endregion
+//#region src/storage/domains/observability/v-next/preview-compat.ts
+const generator = _mastra_core_storage.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;
+}
+function storedPreview(preview, value, serialized) {
+	return canGeneratePreviews ? generator(preview, value, serialized) : preview ?? null;
+}
+function readPreview(preview, payload, jsonEncoded = false) {
+	const supplied = preview;
+	if (!canGeneratePreviews) return supplied ?? null;
+	if (supplied != null) return supplied.trim() || null;
+	let value = payload;
+	if (needsPreview(preview) && jsonEncoded && typeof payload === "string") try {
+		value = JSON.parse(payload);
+	} catch {
+		value = null;
+	}
+	return storedPreview(supplied, value, jsonEncoded && typeof payload === "string" ? payload : void 0) || null;
+}
+/** 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 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));
+		span.inputPreview = payload?.inputPreview ?? null;
+		span.outputPreview = payload?.outputPreview ?? null;
+		span.errorPreview = payload?.errorPreview ?? null;
+	}
+	return response;
+}
+//#endregion
 //#region src/storage/domains/observability/v-next/review-status.ts
 const FEEDBACK_REVIEW_STATUSES = ["needs-review", "reviewed"];
 function isFeedbackReviewStatus(value) {
@@ -17036,6 +17156,137 @@ function parseUpdateFeedbackReviewStatusArgs(args) {
 	};
 }
 //#endregion
+//#region src/storage/domains/observability/v-next/sql.ts
+/**
+* SQL helpers for the v-next Postgres observability domain.
+*
+* Provides a multi-row INSERT builder with a configurable conflict clause
+* (`ON CONFLICT DO NOTHING` by default, for retry idempotency), and explicit
+* jsonb / text[] casts so the pg driver doesn't have to guess column types.
+*/
+/**
+* Encode a JS value for a `$N::jsonb` cast. Always `JSON.stringify` so a
+* plain string like `"hello"` becomes `"hello"` (a valid JSON scalar) and
+* not the bare word `hello`, which Postgres rejects when cast to jsonb.
+*
+* The result is sanitized because Postgres rejects some sequences that are
+* legal in JSON: NUL (`\u0000`) fails with 22P05 and unpaired UTF-16
+* surrogates fail with 22P02. Inserts here are batched into a single
+* multi-row statement, so one bad value would otherwise reject the whole
+* batch of observability events.
+*/
+function encodeJsonb(value) {
+	if (value === null || value === void 0) return null;
+	if (value instanceof EncodedJsonb) return value.json;
+	return toPgJson(value);
+}
+/**
+* A jsonb value the caller already serialized with `toPgJson`, so `buildInsert`
+* sends it as is instead of serializing it again. Span writes serialize their
+* payloads up front because the stored previews are built from that same text.
+*/
+var EncodedJsonb = class {
+	json;
+	constructor(json) {
+		this.json = json;
+	}
+};
+/** Serialize a value for a jsonb column once, for callers that also need the text. */
+function encodeJsonbValue(value) {
+	if (value === null || value === void 0) return null;
+	const json = toPgJson(value);
+	return json === void 0 ? null : new EncodedJsonb(json);
+}
+/**
+* Build a multi-row INSERT with explicit column types and ON CONFLICT DO NOTHING.
+*
+* @param schema     Schema name.
+* @param table      Table name.
+* @param records    Array of records (each is a column-name → value object).
+*                   All records must have identical key sets.
+* @returns          { text, values } ready to pass to `client.query`.
+*/
+function buildInsert(schema, table, records, onConflict = "ON CONFLICT DO NOTHING") {
+	if (records.length === 0) return null;
+	const columns = Object.keys(records[0]).map((c) => (0, _mastra_core_utils.parseSqlIdentifier)(c, "column name"));
+	const quotedColumns = columns.map((c) => `"${c}"`).join(", ");
+	const values = [];
+	const rowPlaceholders = [];
+	let p = 1;
+	for (const record of records) {
+		const placeholders = columns.map((col) => {
+			const raw = record[col];
+			if (JSONB_COLUMNS.has(col)) {
+				values.push(encodeJsonb(raw));
+				return `$${p++}::jsonb`;
+			}
+			if (TEXT_ARRAY_COLUMNS.has(col)) {
+				values.push(Array.isArray(raw) ? raw : []);
+				return `$${p++}::text[]`;
+			}
+			values.push(raw === void 0 ? null : raw);
+			return `$${p++}`;
+		});
+		rowPlaceholders.push(`(${placeholders.join(", ")})`);
+	}
+	return {
+		text: `INSERT INTO ${qualifiedTable(schema, table)} (${quotedColumns})
+VALUES ${rowPlaceholders.join(", ")}
+${onConflict}`,
+		values
+	};
+}
+/** Primary key of the span table; also the conflict target for span upserts. */
+const SPAN_KEY_COLUMNS = [
+	"traceId",
+	"spanId",
+	"endedAt"
+];
+/**
+* Conflict clause for span writes.
+*
+* A span is written twice under the event-sourced strategy: once when it starts
+* (`isPending = true`, `endedAt` synthesized from `startedAt`) and once when it
+* ends. Those two rows normally differ in `endedAt` and so coexist under the
+* primary key. A zero-duration span is the exception — its real `endedAt`
+* equals its `startedAt`, so the end row collides with the pending row. Letting
+* `DO NOTHING` win there would strand the span as permanently running, so the
+* end row overwrites the pending one instead.
+*
+* The `WHERE` guard keeps the clause a no-op for every other conflict, which
+* preserves insert-only retry idempotency: a replayed end row cannot clobber
+* the row it duplicates, and a late-arriving start row cannot revert an ended
+* span to pending.
+*/
+function spanConflictClause(columns) {
+	return `ON CONFLICT ("traceId", "spanId", "endedAt") DO UPDATE SET ${columns.filter((column) => !SPAN_KEY_COLUMNS.includes(column)).map((column) => `"${column}" = EXCLUDED."${column}"`).join(", ")}
+WHERE ${TABLE_SPAN_EVENTS}."isPending" AND NOT EXCLUDED."isPending"`;
+}
+/**
+* Ordering that picks the winning row for a span under the event-sourced write
+* model. An ended row always beats a pending row for the same span; among rows
+* of the same kind the latest write wins, with `cursorId` breaking ties between
+* rows that share a timestamp. Combine with `DISTINCT ON` (or `LIMIT 1`) after
+* the grouping key to collapse a span's rows down to one.
+*/
+const SPAN_COLLAPSE_ORDER = "\"isPending\" ASC, \"endedAt\" DESC, \"cursorId\" DESC";
+/**
+* Standard SELECT column list for tracing tables. The select projects every
+* column the row→record converters expect.
+*/
+const SPAN_SELECT_COLUMNS = `
+${buildSelectColumns(SPAN_EVENT_COLUMNS)}`;
+const SPAN_LIGHT_SELECT_COLUMNS = `
+${buildNamedSelectColumns(SPAN_LIGHT_SELECT_COLUMN_NAMES)}`;
+const METRIC_SELECT_COLUMNS = `
+${buildSelectColumns(METRIC_EVENT_COLUMNS)}`;
+const LOG_SELECT_COLUMNS = `
+${buildSelectColumns(LOG_EVENT_COLUMNS)}`;
+const SCORE_SELECT_COLUMNS = `
+${buildSelectColumns(SCORE_EVENT_COLUMNS)}`;
+const FEEDBACK_SELECT_COLUMNS = `
+${buildSelectColumns(FEEDBACK_EVENT_COLUMNS)}`;
+//#endregion
 //#region src/storage/domains/observability/v-next/helpers.ts
 const PROMOTED_KEYS = /* @__PURE__ */ new Set([
 	"experimentId",
@@ -17185,10 +17436,26 @@ function commonContextToRow(record) {
 		serviceName: record.serviceName ?? null
 	};
 }
+/**
+* Serialize a span payload for its jsonb column and build its stored preview from the same value.
+* Nonblank upstream previews win (trimmed and capped like generated ones). The preview goes into a `text` column, which
+* rejects NUL, so it gets the same repair `toPgJson` applies to the payload.
+*/
+function spanPayload(value, upstream) {
+	const encoded = encodeJsonbValue(value);
+	const preview = storedPreview(upstream, value, encoded?.json);
+	return {
+		encoded,
+		preview: preview === null ? null : toPgText(preview)
+	};
+}
 function spanRecordToRow(span) {
 	const isPending = !span.isEvent && span.endedAt == null;
 	const endedAt = span.isEvent ? span.startedAt : span.endedAt ?? span.startedAt;
 	const metadata = span.metadata ?? null;
+	const input = spanPayload(span.input, span.inputPreview);
+	const output = spanPayload(span.output, span.outputPreview);
+	const error = spanPayload(span.error, span.errorPreview);
 	return {
 		...commonContextToRow(span),
 		traceId: span.traceId,
@@ -17206,10 +17473,13 @@ function spanRecordToRow(span) {
 		scope: jsonField(span.scope),
 		attributes: jsonField(span.attributes),
 		links: jsonField(span.links),
-		input: jsonField(span.input),
-		output: jsonField(span.output),
-		error: jsonField(span.error),
-		requestContext: jsonField(span.requestContext)
+		input: input.encoded,
+		output: output.encoded,
+		error: error.encoded,
+		requestContext: jsonField(span.requestContext),
+		inputPreview: input.preview,
+		outputPreview: output.preview,
+		errorPreview: error.preview
 	};
 }
 /**
@@ -17276,6 +17546,32 @@ function rowToLightSpanRecord(row) {
 		updatedAt: null
 	};
 }
+/** A stored preview as lists return it: `''` (nothing to preview) and NULL become null. */
+function listPreview(value) {
+	return readPreview(value);
+}
+/**
+* Build a trace-list {@link LightSpanRecord} from a row that projected the light trace-list columns
+* (see `TRACE_LIGHT_SELECT_COLUMNS` in traces.ts): the timeline fields plus the memory context,
+* metadata and the stored previews. Callers fill in previews for rows written before they were
+* stored first.
+*/
+function rowToLightTraceRecord(row) {
+	const record = rowToLightSpanRecord(row);
+	return {
+		...record,
+		status: (0, _mastra_core_storage.computeTraceStatus)({
+			error: record.error,
+			endedAt: record.endedAt
+		}),
+		threadId: row.threadId == null ? null : String(row.threadId),
+		resourceId: row.resourceId == null ? null : String(row.resourceId),
+		metadata: parsedJson(row.metadataRaw) ?? void 0,
+		inputPreview: listPreview(row.inputPreview),
+		outputPreview: listPreview(row.outputPreview),
+		errorPreview: listPreview(row.errorPreview)
+	};
+}
 function logRecordToRow(log) {
 	return {
 		...commonContextToRow(log),
@@ -17791,119 +18087,6 @@ const COMPLEX_GROUP_BY_EXCLUDED = /* @__PURE__ */ new Set([
 	"requestContext"
 ]);
 //#endregion
-//#region src/storage/domains/observability/v-next/sql.ts
-/**
-* SQL helpers for the v-next Postgres observability domain.
-*
-* Provides a multi-row INSERT builder with a configurable conflict clause
-* (`ON CONFLICT DO NOTHING` by default, for retry idempotency), and explicit
-* jsonb / text[] casts so the pg driver doesn't have to guess column types.
-*/
-/**
-* Encode a JS value for a `$N::jsonb` cast. Always `JSON.stringify` so a
-* plain string like `"hello"` becomes `"hello"` (a valid JSON scalar) and
-* not the bare word `hello`, which Postgres rejects when cast to jsonb.
-*
-* The result is sanitized because Postgres rejects some sequences that are
-* legal in JSON: NUL (`\u0000`) fails with 22P05 and unpaired UTF-16
-* surrogates fail with 22P02. Inserts here are batched into a single
-* multi-row statement, so one bad value would otherwise reject the whole
-* batch of observability events.
-*/
-function encodeJsonb(value) {
-	if (value === null || value === void 0) return null;
-	return toPgJson(value);
-}
-/**
-* Build a multi-row INSERT with explicit column types and ON CONFLICT DO NOTHING.
-*
-* @param schema     Schema name.
-* @param table      Table name.
-* @param records    Array of records (each is a column-name → value object).
-*                   All records must have identical key sets.
-* @returns          { text, values } ready to pass to `client.query`.
-*/
-function buildInsert(schema, table, records, onConflict = "ON CONFLICT DO NOTHING") {
-	if (records.length === 0) return null;
-	const columns = Object.keys(records[0]).map((c) => (0, _mastra_core_utils.parseSqlIdentifier)(c, "column name"));
-	const quotedColumns = columns.map((c) => `"${c}"`).join(", ");
-	const values = [];
-	const rowPlaceholders = [];
-	let p = 1;
-	for (const record of records) {
-		const placeholders = columns.map((col) => {
-			const raw = record[col];
-			if (JSONB_COLUMNS.has(col)) {
-				values.push(encodeJsonb(raw));
-				return `$${p++}::jsonb`;
-			}
-			if (TEXT_ARRAY_COLUMNS.has(col)) {
-				values.push(Array.isArray(raw) ? raw : []);
-				return `$${p++}::text[]`;
-			}
-			values.push(raw === void 0 ? null : raw);
-			return `$${p++}`;
-		});
-		rowPlaceholders.push(`(${placeholders.join(", ")})`);
-	}
-	return {
-		text: `INSERT INTO ${qualifiedTable(schema, table)} (${quotedColumns})
-VALUES ${rowPlaceholders.join(", ")}
-${onConflict}`,
-		values
-	};
-}
-/** Primary key of the span table; also the conflict target for span upserts. */
-const SPAN_KEY_COLUMNS = [
-	"traceId",
-	"spanId",
-	"endedAt"
-];
-/**
-* Conflict clause for span writes.
-*
-* A span is written twice under the event-sourced strategy: once when it starts
-* (`isPending = true`, `endedAt` synthesized from `startedAt`) and once when it
-* ends. Those two rows normally differ in `endedAt` and so coexist under the
-* primary key. A zero-duration span is the exception — its real `endedAt`
-* equals its `startedAt`, so the end row collides with the pending row. Letting
-* `DO NOTHING` win there would strand the span as permanently running, so the
-* end row overwrites the pending one instead.
-*
-* The `WHERE` guard keeps the clause a no-op for every other conflict, which
-* preserves insert-only retry idempotency: a replayed end row cannot clobber
-* the row it duplicates, and a late-arriving start row cannot revert an ended
-* span to pending.
-*/
-function spanConflictClause(columns) {
-	return `ON CONFLICT ("traceId", "spanId", "endedAt") DO UPDATE SET ${columns.filter((column) => !SPAN_KEY_COLUMNS.includes(column)).map((column) => `"${column}" = EXCLUDED."${column}"`).join(", ")}
-WHERE ${TABLE_SPAN_EVENTS}."isPending" AND NOT EXCLUDED."isPending"`;
-}
-/**
-* Ordering that picks the winning row for a span under the event-sourced write
-* model. An ended row always beats a pending row for the same span; among rows
-* of the same kind the latest write wins, with `cursorId` breaking ties between
-* rows that share a timestamp. Combine with `DISTINCT ON` (or `LIMIT 1`) after
-* the grouping key to collapse a span's rows down to one.
-*/
-const SPAN_COLLAPSE_ORDER = "\"isPending\" ASC, \"endedAt\" DESC, \"cursorId\" DESC";
-/**
-* Standard SELECT column list for tracing tables. The select projects every
-* column the row→record converters expect.
-*/
-const SPAN_SELECT_COLUMNS = `
-${buildSelectColumns(SPAN_EVENT_COLUMNS)}`;
-const SPAN_LIGHT_SELECT_COLUMNS = `
-${buildNamedSelectColumns(SPAN_LIGHT_SELECT_COLUMN_NAMES)}`;
-const METRIC_SELECT_COLUMNS = `
-${buildSelectColumns(METRIC_EVENT_COLUMNS)}`;
-const LOG_SELECT_COLUMNS = `
-${buildSelectColumns(LOG_EVENT_COLUMNS)}`;
-const SCORE_SELECT_COLUMNS = `
-${buildSelectColumns(SCORE_EVENT_COLUMNS)}`;
-const FEEDBACK_SELECT_COLUMNS = `
-${buildSelectColumns(FEEDBACK_EVENT_COLUMNS)}`;
-//#endregion
 //#region src/storage/domains/observability/v-next/feedback.ts
 /**
 * Feedback operations for the v-next Postgres observability domain.
@@ -19062,7 +19245,10 @@ const TRACE_SELECT = `
   r."entityId" AS "entityId",
   r."parentSpanId" AS "parentSpanId",
   r."metadataRaw" AS "metadata",
-  r."input" AS "input",
+  r."inputPreview" AS "inputPreview",
+  r."outputPreview" AS "outputPreview",
+  r."errorPreview" AS "errorPreview",
+  r."cursorId" AS "cursorId",
   r."threadId" AS "threadId",
   r."resourceId" AS "resourceId",
   r."startedAt" AS "startedAt",
@@ -19520,7 +19706,7 @@ function compilePostgresTraceQuery(schema, plan, mode = "data", safeHorizon) {
 			safeHorizon
 		};
 	}
-	const { ctes, values } = compilePostgresTraceCandidates(schema, plan, `${TRACE_SELECT}${plan.paginationMode === "delta" ? ", r.\"xactId\", r.\"cursorId\"" : ""}`, deltaWindow);
+	const { ctes, values } = compilePostgresTraceCandidates(schema, plan, `${TRACE_SELECT}${plan.paginationMode === "delta" ? ", r.\"xactId\"" : ""}`, deltaWindow);
 	const candidates = `WITH ${ctes.join(",\n")}`;
 	if (plan.paginationMode === "page" && mode === "count") return {
 		text: `${candidates}
@@ -19762,6 +19948,34 @@ async function setRemainingTimeout(transaction, deadline) {
 	if (remainingTimeoutMs <= 0) throw new _mastra_core_storage.TraceQueryExecutionError();
 	await transaction.query(`SELECT set_config('statement_timeout', $1, true)`, [`${remainingTimeoutMs}ms`]);
 }
+const PREVIEW_PAYLOADS$2 = [
+	["inputPreview", "input"],
+	["outputPreview", "output"],
+	["errorPreview", "error"]
+];
+/**
+* Fill the previews of root rows written before the preview columns existed (stored preview NULL)
+* by reading just those rows' payloads, and only the payloads whose preview is missing. Rows are
+* keyed by `cursorId`, which identifies the exact root row the list picked.
+*
+* jsonb comes back decoded, so the preview is built with `buildPreview(value)`. jsonb also
+* normalizes object key order, so a compact-JSON fallback preview can differ from the one the
+* writer would have stored from the original value. That is acceptable for these old rows.
+*/
+async function fillMissingTracePreviews(transaction, schema, rows, deadline) {
+	const missing = rows.filter((row) => PREVIEW_PAYLOADS$2.some(([preview]) => needsPreview(row[preview])));
+	if (!missing.length) return;
+	await setRemainingTimeout(transaction, deadline);
+	const payloads = await transaction.any(`SELECT e."cursorId"::text AS "cursorId",
+      ${PREVIEW_PAYLOADS$2.map(([preview, payload]) => `${missing.some((row) => needsPreview(row[preview])) ? `e."${payload}"` : "NULL"} AS "${payload}"`).join(",\n      ")}
+    FROM ${qualifiedTable(schema, TABLE_SPAN_EVENTS)} e
+    WHERE (e."traceId", e."cursorId") IN (SELECT * FROM unnest($1::text[], $2::bigint[]))`, [missing.map((row) => String(row.traceId)), missing.map((row) => String(row.cursorId))]);
+	const byCursor = new Map(payloads.map((payload) => [String(payload.cursorId), payload]));
+	for (const row of missing) {
+		const payload = byCursor.get(String(row.cursorId));
+		for (const [preview, column] of PREVIEW_PAYLOADS$2) if (needsPreview(row[preview])) row[preview] = readPreview(row[preview], payload?.[column]);
+	}
+}
 function traceRowToResult(row) {
 	return {
 		traceId: String(row.traceId),
@@ -19771,7 +19985,9 @@ function traceRowToResult(row) {
 		parentSpanId: row.parentSpanId ?? null,
 		createdAt: asIsoTimestamp$1(row.startedAt),
 		metadata: row.metadata ?? null,
-		inputPreview: _mastra_core_storage.buildInputPreview(row.input) ?? null,
+		inputPreview: readPreview(row.inputPreview),
+		outputPreview: readPreview(row.outputPreview),
+		errorPreview: readPreview(row.errorPreview),
 		threadId: row.threadId == null ? null : String(row.threadId),
 		resourceId: row.resourceId == null ? null : String(row.resourceId),
 		startedAt: asIsoTimestamp$1(row.startedAt),
@@ -19799,6 +20015,7 @@ async function queryTraces(client, schema, plan, timeoutMs) {
 				rows = await transaction.any(query.text, query.values);
 			}
 			const visible = rows.slice(0, plan.limit);
+			await fillMissingTracePreviews(transaction, schema, visible, deadline);
 			const last = visible.at(-1);
 			return _mastra_core_storage.traceQueryResponseSchema.parse({
 				traces: visible.map(traceRowToResult),
@@ -19828,6 +20045,7 @@ async function queryTraces(client, schema, plan, timeoutMs) {
 			if (remainingTimeoutMs <= 0) throw new _mastra_core_storage.TraceQueryExecutionError();
 			await transaction.query(`SELECT set_config('statement_timeout', $1, true)`, [`${remainingTimeoutMs}ms`]);
 			const rows = await transaction.any(dataQuery.text, dataQuery.values);
+			await fillMissingTracePreviews(transaction, schema, rows, deadline);
 			return {
 				total: Number(countRows[0]?.count ?? 0),
 				rows,
@@ -19847,7 +20065,12 @@ async function queryTraces(client, schema, plan, timeoutMs) {
 		});
 	}
 	const query = compilePostgresTraceQuery(schema, plan);
-	const rows = await runWithPostgresTraceQueryTimeout(client, timeoutMs, (transaction) => transaction.any(query.text, query.values));
+	const deadline = performance.now() + _mastra_core_storage.resolveTraceQueryTimeoutMs(timeoutMs);
+	const rows = await runWithPostgresTraceQueryTimeout(client, timeoutMs, async (transaction) => {
+		const rows = await transaction.any(query.text, query.values);
+		if (plan.result === "traces") await fillMissingTracePreviews(transaction, schema, rows.slice(0, plan.limit), deadline);
+		return rows;
+	});
 	const visibleRows = rows.slice(0, plan.limit);
 	if (plan.result === "groups") {
 		const groups = visibleRows.map((row) => ({ threadId: String(row.threadId) }));
@@ -20004,6 +20227,29 @@ function compilePostgresSpanQuery(schema, plan) {
 		values
 	};
 }
+const PREVIEW_PAYLOADS$1 = [
+	["inputPreview", "input"],
+	["outputPreview", "output"],
+	["errorPreview", "error"]
+];
+/**
+* Stored previews of a hydrated row, built from the payload where the stored preview is NULL.
+* jsonb comes back decoded, so the fallback uses `buildPreview(value)`. jsonb normalizes object key
+* order, so a compact-JSON fallback preview can differ from what the writer would have stored from
+* the original value; that is acceptable for rows written before the preview columns existed.
+*/
+function toSpanQueryPayload(row) {
+	const [inputPreview, outputPreview, errorPreview] = PREVIEW_PAYLOADS$1.map(([preview, payload]) => readPreview(row[preview], row[payload]));
+	return {
+		organizationId: row.organizationId ?? null,
+		resourceId: row.resourceId ?? null,
+		traceId: String(row.traceId),
+		spanId: String(row.spanId),
+		inputPreview,
+		outputPreview,
+		errorPreview
+	};
+}
 async function querySpans(client, schema, plan, timeoutMs) {
 	const deadline = performance.now() + _mastra_core_storage.resolveTraceQueryTimeoutMs(timeoutMs);
 	return runWithPostgresTraceQueryTimeout(client, timeoutMs, async (tx) => {
@@ -20028,9 +20274,9 @@ 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},
-      left(input::text, ${_mastra_core_storage.SPAN_QUERY_MAX_PREVIEW_CHARACTERS + 1}) AS "inputPreview", left(output::text, ${_mastra_core_storage.SPAN_QUERY_MAX_PREVIEW_CHARACTERS + 1}) AS "outputPreview"
-      FROM ${qualifiedTable(schema, TABLE_SPAN_EVENTS)} WHERE ${payloadWhere}`, payloadValues);
+		const payloads = (await tx.any(`SELECT ${identities},
+      ${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);
@@ -20041,7 +20287,7 @@ async function querySpans(client, schema, plan, timeoutMs) {
         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 _mastra_core_storage.buildSpanQueryResponse(plan, selected, payloads, metrics);
+		return buildSpanQueryResponse(plan, selected, payloads, metrics);
 	}, { repeatableRead: true });
 }
 //#endregion
@@ -20506,16 +20752,73 @@ function buildListTracesFilters(filters, spanTable, nextParamIdx) {
 * array-of-strings representation here.
 */
 const SPAN_SELECT_COLUMNS_ALIASED = SPAN_SELECT_COLUMNS.replace(/\n/g, " ").split(",").map((c) => `r.${c.trim()}`).join(", ");
+const FULL_PROJECTION = {
+	columns: SPAN_SELECT_COLUMNS_ALIASED,
+	mapRows: (_client, _span, rows) => (0, _mastra_core_storage.toTraceSpans)(rows.map(rowToSpanRecord))
+};
+/**
+* Columns a light trace list renders: the timeline fields, memory context, metadata and the stored
+* previews. The `input` / `output` payloads stay off the read path; rows written before the
+* previews were stored get theirs from the payloads, read for just those rows.
+*/
+const TRACE_LIGHT_SELECT_COLUMNS = [
+	...SPAN_LIGHT_SELECT_COLUMN_NAMES,
+	"threadId",
+	"resourceId",
+	"metadataRaw",
+	"inputPreview",
+	"outputPreview",
+	"errorPreview"
+].map((column) => `r."${column}"`).join(", ");
+const PREVIEW_PAYLOADS = [
+	["inputPreview", "input"],
+	["outputPreview", "output"],
+	["errorPreview", "error"]
+];
+/**
+* Builds the previews of rows written before previews were stored (NULL preview) from those rows'
+* payloads. Only the flagged rows' payloads are read, so this fades out as old rows age out.
+*
+* `jsonb` comes back decoded with its keys reordered, so a compact-JSON preview built here can
+* differ in key order from the one the writer would have stored. Acceptable for old rows.
+*/
+async function fillMissingPreviews(client, span, rows) {
+	const missing = rows.filter((row) => PREVIEW_PAYLOADS.some(([preview]) => needsPreview(row[preview])));
+	if (!missing.length) return;
+	const payloads = await client.manyOrNone(`SELECT e."cursorId"::text AS "cursorId",
+      ${PREVIEW_PAYLOADS.map(([preview, payload]) => `${missing.some((row) => needsPreview(row[preview])) ? `e."${payload}"` : "NULL"} AS "${payload}"`).join(",\n      ")}
+     FROM ${span} e
+     WHERE (e."traceId", e."cursorId") IN (SELECT * FROM unnest($1::text[], $2::bigint[]))`, [missing.map((row) => String(row.traceId)), missing.map((row) => String(row.cursorId))]);
+	const byCursor = new Map(payloads.map((payload) => [String(payload.cursorId), payload]));
+	for (const row of missing) {
+		const payload = byCursor.get(String(row.cursorId));
+		for (const [preview, column] of PREVIEW_PAYLOADS) if (needsPreview(row[preview])) row[preview] = readPreview(row[preview], payload?.[column]);
+	}
+}
+const LIGHT_PROJECTION = {
+	columns: TRACE_LIGHT_SELECT_COLUMNS,
+	mapRows: async (client, span, rows) => {
+		await fillMissingPreviews(client, span, rows);
+		return rows.map(rowToLightTraceRecord);
+	}
+};
 async function listTraces(client, schema, args) {
+	return listTraceRows(client, schema, args, FULL_PROJECTION);
+}
+/** Trace list projecting only the columns a list renders, with stored previews instead of payloads. */
+async function listTracesLight(client, schema, args) {
+	return listTraceRows(client, schema, args, LIGHT_PROJECTION);
+}
+async function listTraceRows(client, schema, args, projection) {
 	const { mode, filters, pagination, orderBy, after, limit } = _mastra_core_storage.listTracesArgsSchema.parse(args);
 	const span = qualifiedTable(schema, TABLE_SPAN_EVENTS);
 	if (mode === "delta") {
 		assertDeltaPollingEnabled();
-		return listTracesDelta(client, span, filters, after, limit);
+		return listTracesDelta(client, span, projection, filters, after, limit);
 	}
-	return listTracesPage(client, span, filters, pagination.page, pagination.perPage, orderBy.field, orderBy.direction);
+	return listTracesPage(client, span, projection, filters, pagination.page, pagination.perPage, orderBy.field, orderBy.direction);
 }
-async function listTracesPage(client, span, filters, page, perPage, orderField, orderDir) {
+async function listTracesPage(client, span, projection, filters, page, perPage, orderField, orderDir) {
 	const { conditions, params, nextParamIdx } = buildListTracesFilters(filters, span, 1);
 	let i = nextParamIdx;
 	const whereClause = `WHERE ${conditions.join(" AND ")}`;
@@ -20523,15 +20826,18 @@ async function listTracesPage(client, span, filters, page, perPage, orderField,
 	const countRow = await client.oneOrNone(`SELECT COUNT(*)::text AS count FROM ${span} r ${whereClause}`, params);
 	const count = Number(countRow?.count ?? 0);
 	let spans = [];
-	if (count > 0) spans = (await client.manyOrNone(`SELECT ${SPAN_SELECT_COLUMNS_ALIASED}
+	if (count > 0) {
+		const rows = await client.manyOrNone(`SELECT ${projection.columns}
        FROM ${span} r
        ${whereClause}
        ${orderClause}
        LIMIT $${i++} OFFSET $${i++}`, [
-		...params,
-		perPage,
-		page * perPage
-	])).map(rowToSpanRecord);
+			...params,
+			perPage,
+			page * perPage
+		]);
+		spans = await projection.mapRows(client, span, rows);
+	}
 	const deltaCursor = deltaPollingFeatureEnabled() ? await readTracesStreamHeadCursor(client, span, filters) : void 0;
 	return {
 		pagination: {
@@ -20540,11 +20846,11 @@ async function listTracesPage(client, span, filters, page, perPage, orderField,
 			perPage,
 			hasMore: (page + 1) * perPage < count
 		},
-		spans: (0, _mastra_core_storage.toTraceSpans)(spans),
+		spans,
 		...deltaCursor !== void 0 ? { deltaCursor } : {}
 	};
 }
-async function listTracesDelta(client, span, filters, after, limit) {
+async function listTracesDelta(client, span, projection, filters, after, limit) {
 	if (after === void 0) {
 		const deltaCursor = await readTracesStreamHeadCursor(client, span, filters);
 		return {
@@ -20564,7 +20870,7 @@ async function listTracesDelta(client, span, filters, after, limit) {
 	params.push(afterCursor.xactId, afterCursor.cursorId);
 	conditions.push(`r."xactId" < $${i++}::xid8`);
 	params.push(safeHorizon);
-	const rows = await client.manyOrNone(`SELECT ${SPAN_SELECT_COLUMNS_ALIASED}
+	const rows = await client.manyOrNone(`SELECT ${projection.columns}
      FROM ${span} r
      WHERE ${conditions.join(" AND ")}
      ORDER BY r."xactId" ASC, r."cursorId" ASC
@@ -20573,7 +20879,7 @@ async function listTracesDelta(client, span, filters, after, limit) {
 	const visible = rows.slice(0, limit);
 	const deltaCursor = visible.length > 0 ? encodeDeltaCursor(visible[visible.length - 1].xactId, visible[visible.length - 1].cursorId) : encodeDeltaCursor(safeHorizon, 0);
 	return {
-		spans: (0, _mastra_core_storage.toTraceSpans)(visible.map(rowToSpanRecord)),
+		spans: await projection.mapRows(client, span, visible),
 		delta: {
 			limit,
 			hasMore
@@ -21284,6 +21590,9 @@ var ObservabilityStoragePostgresVNext = class ObservabilityStoragePostgresVNext
 	async listTraces(args) {
 		return this.#run("LIST_TRACES", () => listTraces(this.#readClient, this.#schema, args));
 	}
+	async listTracesLight(args) {
+		return this.#run("LIST_TRACES_LIGHT", () => listTracesLight(this.#readClient, this.#schema, args));
+	}
 	async querySpans(plan) {
 		return this.#run("QUERY_SPANS", () => querySpans(this.#readClient, this.#schema, plan, this.#traceQueryTimeoutMs));
 	}