@mastra/pg 1.33.0 → 1.34.0-alpha.0

package/dist/index.cjs

@@ -34,6 +34,7 @@ let pg_connection_string = require("pg-connection-string");
 let _mastra_core_vector_filter = require("@mastra/core/vector/filter");
 let _mastra_core_base = require("@mastra/core/base");
 let crypto$1 = require("crypto");
+let timers_promises = require("timers/promises");
 let _mastra_core_features = require("@mastra/core/features");
 let _mastra_core_agent = require("@mastra/core/agent");
 let _mastra_core_evals = require("@mastra/core/evals");
@@ -2276,6 +2277,9 @@ var PinnedClientAdapter = class {
 		this.#tail = next.catch(() => void 0);
 		return next;
 	}
+	async drain() {
+		await this.#tail;
+	}
 	connect() {
 		throw new Error("PinnedClientAdapter.connect() is not supported during PostgresStore.init(). All DDL must flow through the pinned client.");
 	}
@@ -2458,6 +2462,39 @@ function buildConstraintName({ baseName, schemaName, maxLength = 63, hashWhenTru
 	return truncateIdentifier(fullName, maxLength);
 }
 // src/storage/db/pg-errors.ts
+/**
+* Postgres error classifiers for concurrent DDL.
+*
+* `CREATE SCHEMA / TABLE / INDEX IF NOT EXISTS` checks aren't atomic against
+* concurrent backends. Two callers racing past the existence probe can both
+* reach the catalog insert; the loser sees a duplicate-object error. These
+* helpers identify the exact codes we treat as "already exists by the time we
+* look" so every other error surfaces normally.
+*/
+var IndexBuildError = class extends Error {
+	constructor(indexName, schemaName, state, cause) {
+		super(`Could not create index ${schemaName}.${indexName}: ${state}`, { cause });
+		this.name = "IndexBuildError";
+	}
+};
+function* causes(error) {
+	const seen = /* @__PURE__ */ new Set();
+	while (typeof error === "object" && error !== null && !seen.has(error)) {
+		seen.add(error);
+		yield error;
+		error = "cause" in error ? error.cause : void 0;
+	}
+}
+/** Index recovery owns its retry budget, even through an outer MastraError. */
+function isRetryableDeadlock(error) {
+	for (const cause of causes(error)) if (cause instanceof IndexBuildError) return false;
+	for (const cause of causes(error)) if ("code" in cause && cause.code === "40P01") return true;
+	return false;
+}
+async function backoffAfterDeadlock(attempt) {
+	const base = 50 * 2 ** (attempt - 1);
+	await new Promise((resolve) => setTimeout(resolve, base + Math.random() * base * 2));
+}
 function asPgError(error) {
 	return error ?? {};
 }
@@ -2485,6 +2522,99 @@ function isDuplicateSchemaError(error) {
 	if (code === "23505" && constraint === "pg_namespace_nspname_index") return true;
 	return /schema .* already exists/i.test(message);
 }
+// src/storage/db/index-build.ts
+/** A cold snapshot cannot arbitrate DDL submitted by independent processes. */
+async function buildIndex(client, schemaName, indexName, build, logger) {
+	const deadline = performance.now() + 3e4;
+	let attempts = 0;
+	let failure;
+	let state = "not built";
+	let repairFailures = 0;
+	const observe = (db = client) => db.oneOrNone(`SELECT c.oid, i.indrelid AS table_oid, t.relname AS table_name,
+              tn.nspname AS table_schema, i.indisvalid AS valid
+       FROM pg_class c JOIN pg_namespace n ON n.oid = c.relnamespace
+       LEFT JOIN pg_index i ON i.indexrelid = c.oid
+       LEFT JOIN pg_class t ON t.oid = i.indrelid
+       LEFT JOIN pg_namespace tn ON tn.oid = t.relnamespace
+      WHERE n.nspname = $1 AND c.relname = $2`, [schemaName, indexName]);
+	while (true) {
+		const relation = await observe();
+		if (relation?.valid) return true;
+		if (relation && relation.valid === null) throw new IndexBuildError(indexName, schemaName, "name belongs to a non-index relation", failure);
+		if (relation) {
+			if (await client.oneOrNone(`SELECT p.pid FROM pg_stat_progress_create_index p
+          WHERE p.datid = (SELECT oid FROM pg_database WHERE datname = current_database())
+            AND p.pid <> pg_backend_pid()
+            AND (p.index_relid = $1 OR ((p.index_relid IS NULL OR p.index_relid = 0) AND EXISTS (
+              SELECT 1 FROM pg_locks l WHERE l.pid = p.pid AND l.database = p.datid
+                AND l.locktype = 'relation' AND l.relation = $2 AND l.granted
+                AND l.mode IN ('ShareUpdateExclusiveLock', 'ShareLock')
+            )))
+          LIMIT 1`, [relation.oid, relation.table_oid])) {
+				logger.warn(`Index ${indexName} is being built by another session; skipping`);
+				return false;
+			}
+			if (performance.now() >= deadline && state === "table busy during invalid-index repair") {
+				logger.warn(`Index ${indexName} could not be repaired because its table is busy; skipping`);
+				return false;
+			}
+			if (attempts >= 3 || performance.now() >= deadline) break;
+			state = "abandoned invalid index";
+			attempts++;
+			let lockUnavailable = false;
+			try {
+				const result = await client.tx(async (tx) => {
+					const table = `${(0, pg.escapeIdentifier)(relation.table_schema)}.${(0, pg.escapeIdentifier)(relation.table_name)}`;
+					await tx.none(`SET LOCAL lock_timeout = '100ms'`);
+					try {
+						await tx.none(`LOCK TABLE ${table} IN ACCESS EXCLUSIVE MODE`);
+					} catch (error) {
+						lockUnavailable = typeof error === "object" && error !== null && "code" in error && error.code === "55P03";
+						throw error;
+					}
+					const current = await observe(tx);
+					if (current?.valid) return "valid";
+					const locked = await tx.one("SELECT to_regclass($1)::oid AS oid", [table]);
+					if (!current || current.oid !== relation.oid || current.table_oid !== locked.oid) return "changed";
+					logger.warn(`Dropping invalid index ${indexName} left by an interrupted build; rebuilding it`);
+					await tx.none(`DROP INDEX ${(0, pg.escapeIdentifier)(schemaName)}.${(0, pg.escapeIdentifier)(indexName)}`);
+					return "dropped";
+				});
+				if (result === "valid") return true;
+				if (result === "changed") {
+					attempts--;
+					if (performance.now() >= deadline) break;
+					continue;
+				}
+			} catch (error) {
+				attempts--;
+				if (lockUnavailable) {
+					state = "table busy during invalid-index repair";
+					failure ??= error;
+					await (0, timers_promises.setTimeout)(100);
+					continue;
+				}
+				if (!isDuplicateRelationError(error) && !isRetryableDeadlock(error) && !(typeof error === "object" && error !== null && "code" in error && error.code === "42P01")) throw error;
+				failure ??= error;
+				if (++repairFailures >= 3 || performance.now() >= deadline) break;
+				continue;
+			}
+		} else {
+			if (attempts >= 3 || performance.now() >= deadline) break;
+			attempts++;
+		}
+		try {
+			await build();
+		} catch (error) {
+			if (!isDuplicateRelationError(error) && !isRetryableDeadlock(error)) throw error;
+			failure ??= error;
+			const deadlock = isRetryableDeadlock(error);
+			state = deadlock ? "index build deadlock" : "competing index creation";
+			if (deadlock && attempts < 3 && performance.now() < deadline) await backoffAfterDeadlock(attempts);
+		}
+	}
+	throw new IndexBuildError(indexName, schemaName, state, failure);
+}
 // src/storage/db/sanitize-json.ts
 const repair = (value) => value.replace(/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/g, "�").replaceAll("\0", "");
 function repairJson(value) {
@@ -2540,9 +2670,10 @@ async function loadSchemaSnapshot(client, schemaName) {
           AND c.relkind IN ('r', 'p')
           AND a.attnum > 0
           AND NOT a.attisdropped`, [schema]),
-		client.manyOrNone(`SELECT c.relname AS indexname, i.indisreplident AS is_replica_identity, i.indisprimary AS is_primary, i.indisvalid AS is_valid
+		client.manyOrNone(`SELECT c.relname AS indexname, t.relname AS table_name, i.indisreplident AS is_replica_identity, i.indisprimary AS is_primary, i.indisvalid AS is_valid
          FROM pg_catalog.pg_index i
          JOIN pg_catalog.pg_class c ON c.oid = i.indexrelid
+         JOIN pg_catalog.pg_class t ON t.oid = i.indrelid
          JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
         WHERE n.nspname = $1`, [schema])
 	]);
@@ -2573,13 +2704,11 @@ async function loadSchemaSnapshot(client, schemaName) {
 	}
 	const indexes = /* @__PURE__ */ new Set();
 	const replicaIdentityIndexes = /* @__PURE__ */ new Set();
-	const primaryKeyIndexes = /* @__PURE__ */ new Set();
-	const invalidIndexes = /* @__PURE__ */ new Set();
+	const primaryKeyIndexes = /* @__PURE__ */ new Map();
 	for (const row of indexRows) {
 		if (row.is_valid) indexes.add(row.indexname);
-		else invalidIndexes.add(row.indexname);
 		if (row.is_replica_identity) replicaIdentityIndexes.add(row.indexname);
-		if (row.is_primary) primaryKeyIndexes.add(row.indexname.toLowerCase());
+		if (row.is_primary) primaryKeyIndexes.set(row.indexname.toLowerCase(), row.table_name);
 	}
 	return {
 		schemaName: schema,
@@ -2589,8 +2718,7 @@ async function loadSchemaSnapshot(client, schemaName) {
 		notNullColumns,
 		indexes,
 		replicaIdentityIndexes,
-		primaryKeyIndexes,
-		invalidIndexes
+		primaryKeyIndexes
 	};
 }
 // src/storage/db/index.ts
@@ -3502,14 +3630,17 @@ MIGRATION REQUIRED: Duplicate spans detected in ${duplicateInfo.tableName}\n====
 			baseName: "mastra_ai_spans_traceid_spanid_pk",
 			schemaName: (this.schemaName ? schemaNamePrefix(this.schemaName) : "") || void 0
 		});
-		const schemaFilter = this.schemaName || "public";
+		const fullTableName = getTableName$6({
+			indexName: _mastra_core_storage.TABLE_SPANS,
+			schemaName: getSchemaName$6(this.schemaName)
+		});
 		const snapshot = this.schemaSnapshot;
-		if (snapshot) return snapshot.primaryKeyIndexes.has(constraintName.toLowerCase());
-		return this.spansPrimaryKeyExistsLive(constraintName, schemaFilter);
+		if (snapshot) return snapshot.primaryKeyIndexes.get(constraintName.toLowerCase()) === _mastra_core_storage.TABLE_SPANS;
+		return this.spansPrimaryKeyExistsLive(constraintName, fullTableName);
 	}
 	/** Live-catalog variant of {@link spansPrimaryKeyExists}, bypassing the snapshot. */
-	async spansPrimaryKeyExistsLive(constraintName, schemaFilter) {
-		return (await this.client.oneOrNone(`SELECT EXISTS (SELECT 1 FROM pg_constraint WHERE conname = lower($1) AND connamespace = (SELECT oid FROM pg_namespace WHERE nspname = $2)) as exists`, [constraintName, schemaFilter]))?.exists ?? false;
+	async spansPrimaryKeyExistsLive(constraintName, fullTableName) {
+		return (await this.client.oneOrNone(`SELECT EXISTS (SELECT 1 FROM pg_constraint WHERE conname = lower($1) AND contype = 'p' AND conrelid = to_regclass($2)) as exists`, [constraintName, fullTableName]))?.exists ?? false;
 	}
 	/**
 	* Adds the PRIMARY KEY constraint on (traceId, spanId) to the spans table.
@@ -3524,13 +3655,8 @@ MIGRATION REQUIRED: Duplicate spans detected in ${duplicateInfo.tableName}\n====
 			baseName: "mastra_ai_spans_traceid_spanid_pk",
 			schemaName: (this.schemaName ? schemaNamePrefix(this.schemaName) : "") || void 0
 		});
-		const schemaFilter = this.schemaName || "public";
 		try {
-			if ((await this.client.oneOrNone(`
-        SELECT EXISTS (
-          SELECT 1 FROM pg_constraint WHERE conname = lower($1) AND connamespace = (SELECT oid FROM pg_namespace WHERE nspname = $2)
-        ) as exists
-      `, [constraintName, schemaFilter]))?.exists) {
+			if (await this.spansPrimaryKeyExistsLive(constraintName, fullTableName)) {
 				this.logger?.debug?.(`PRIMARY KEY constraint ${constraintName} already exists on ${fullTableName}`);
 				return;
 			}
@@ -3539,12 +3665,13 @@ MIGRATION REQUIRED: Duplicate spans detected in ${duplicateInfo.tableName}\n====
         ADD CONSTRAINT ${constraintName}
         PRIMARY KEY ("traceId", "spanId")
       `);
-			this.schemaSnapshot?.primaryKeyIndexes.add(constraintName.toLowerCase());
+			this.schemaSnapshot?.primaryKeyIndexes.set(constraintName.toLowerCase(), _mastra_core_storage.TABLE_SPANS);
 			this.logger?.info?.(`Added PRIMARY KEY constraint ${constraintName} to ${fullTableName}`);
 		} catch (error) {
-			if (isDuplicateRelationError(error)) {
-				if (await this.spansPrimaryKeyExistsLive(constraintName, schemaFilter)) {
-					this.schemaSnapshot?.primaryKeyIndexes.add(constraintName.toLowerCase());
+			const primaryKeyRace = typeof error === "object" && error !== null && "code" in error && error.code === "42P16";
+			if (isDuplicateRelationError(error) || primaryKeyRace) {
+				if (await this.spansPrimaryKeyExistsLive(constraintName, fullTableName)) {
+					this.schemaSnapshot?.primaryKeyIndexes.set(constraintName.toLowerCase(), _mastra_core_storage.TABLE_SPANS);
 					this.logger?.debug?.(`PRIMARY KEY constraint ${constraintName} was created by another process`);
 					return;
 				}
@@ -3761,7 +3888,6 @@ MIGRATION REQUIRED: Duplicate spans detected in ${duplicateInfo.tableName}\n====
 			});
 			const snapshot = this.schemaSnapshot;
 			if (snapshot?.indexes.has(name)) return;
-			if (!await this.prepareIndexBuild(name, schemaName)) return;
 			const uniqueStr = unique ? "UNIQUE " : "";
 			const concurrentStr = concurrent ? "CONCURRENTLY " : "";
 			const methodStr = method !== "btree" ? `USING ${method} ` : "";
@@ -3779,9 +3905,8 @@ MIGRATION REQUIRED: Duplicate spans detected in ${duplicateInfo.tableName}\n====
 			const tablespaceStr = tablespace ? ` TABLESPACE ${tablespace}` : "";
 			let withStr = "";
 			if (storage && Object.keys(storage).length > 0) withStr = ` WITH (${Object.entries(storage).map(([key, value]) => `${key} = ${value}`).join(", ")})`;
-			const sql = `CREATE ${uniqueStr}INDEX ${concurrentStr}${`"${(0, _mastra_core_utils.parseSqlIdentifier)(name, "index name")}"`} ON ${fullTableName} ${methodStr}(${columnsStr})${withStr}${tablespaceStr}${whereStr}`;
-			await this.timedIndexBuild(name, sql);
-			snapshot?.indexes.add(name);
+			const sql = `CREATE ${uniqueStr}INDEX ${concurrentStr}IF NOT EXISTS ${`"${(0, _mastra_core_utils.parseSqlIdentifier)(name, "index name")}"`} ON ${fullTableName} ${methodStr}(${columnsStr})${withStr}${tablespaceStr}${whereStr}`;
+			if (await buildIndex(this.client, schemaName, name, () => this.timedIndexBuild(name, sql), this.logger)) snapshot?.indexes.add(name);
 		} catch (error) {
 			throw new _mastra_core_error.MastraError({
 				id: (0, _mastra_core_storage.createStorageErrorId)("PG", "INDEX_CREATE", "FAILED"),
@@ -3806,36 +3931,7 @@ MIGRATION REQUIRED: Duplicate spans detected in ${duplicateInfo.tableName}\n====
 	async createIndexFromStatement(indexName, sql) {
 		const snapshot = this.schemaSnapshot;
 		if (snapshot?.indexes.has(indexName)) return;
-		if (!await this.prepareIndexBuild(indexName, this.schemaName || "public")) return;
-		await this.timedIndexBuild(indexName, sql);
-		snapshot?.indexes.add(indexName);
-	}
-	/**
-	* Decides whether `indexName` still needs building. Returns false when a valid
-	* index already exists, or when another session is currently building it.
-	* An invalid index left by an interrupted `CREATE INDEX CONCURRENTLY` is
-	* dropped (concurrently) so the caller rebuilds it — `IF NOT EXISTS` would
-	* otherwise keep the broken index forever.
-	*/
-	async prepareIndexBuild(indexName, schemaName) {
-		const snapshot = this.schemaSnapshot;
-		if (snapshot && !snapshot.invalidIndexes.has(indexName)) return true;
-		const existing = await this.client.oneOrNone(`SELECT i.indisvalid AS is_valid,
-              EXISTS (SELECT 1 FROM pg_stat_progress_create_index p WHERE p.index_relid = c.oid) AS building
-         FROM pg_catalog.pg_index i
-         JOIN pg_catalog.pg_class c ON c.oid = i.indexrelid
-         JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
-        WHERE c.relname = $1 AND n.nspname = $2`, [indexName, schemaName]);
-		if (!existing) return true;
-		if (existing.is_valid) return false;
-		if (existing.building) {
-			this.logger.warn(`Index ${indexName} is being built by another session; skipping`);
-			return false;
-		}
-		this.logger.warn(`Dropping invalid index ${indexName} left by an interrupted build; rebuilding it`);
-		const quotedIndexName = `"${(0, _mastra_core_utils.parseSqlIdentifier)(indexName, "index name")}"`;
-		await this.client.none(`DROP INDEX CONCURRENTLY IF EXISTS ${getSchemaName$6(this.schemaName)}.${quotedIndexName}`);
-		return true;
+		if (await buildIndex(this.client, this.schemaName || "public", indexName, () => this.timedIndexBuild(indexName, sql), this.logger)) snapshot?.indexes.add(indexName);
 	}
 	async timedIndexBuild(indexName, sql) {
 		const startedAt = Date.now();
@@ -17322,6 +17418,203 @@ function parseUpdateFeedbackReviewStatusArgs(args) {
 		reviewStatus: args.reviewStatus
 	};
 }
+// src/storage/domains/observability/v-next/partitioning.ts
+const DEFAULT_FUTURE_DAYS = 14;
+async function detectTimescale(client) {
+	const row = await client.oneOrNone(`SELECT EXISTS (SELECT 1 FROM pg_extension WHERE extname = 'timescaledb') AS "exists"`);
+	return Boolean(row?.exists);
+}
+async function detectPartman(client) {
+	const row = await client.oneOrNone(`SELECT EXISTS (SELECT 1 FROM pg_extension WHERE extname = 'pg_partman') AS "exists"`);
+	return Boolean(row?.exists);
+}
+async function getPartmanVersion(client) {
+	return (await client.oneOrNone(`SELECT extversion FROM pg_extension WHERE extname = 'pg_partman'`))?.extversion ?? null;
+}
+function getPartmanMajor(version) {
+	if (!version) return null;
+	const match = /^(\d+)/.exec(version);
+	return match ? Number(match[1]) : null;
+}
+async function resolveMode(client, options = {}) {
+	if (options.mode && options.mode !== "auto") return options.mode;
+	if (await detectTimescale(client)) return "timescale";
+	if (await detectPartman(client)) return "partman";
+	return "native";
+}
+function dayBounds(d) {
+	const year = d.getUTCFullYear();
+	const month = String(d.getUTCMonth() + 1).padStart(2, "0");
+	const day = String(d.getUTCDate()).padStart(2, "0");
+	const start = `${year}-${month}-${day} 00:00:00+00`;
+	const next = new Date(Date.UTC(year, d.getUTCMonth(), d.getUTCDate() + 1));
+	return {
+		start,
+		end: `${next.getUTCFullYear()}-${String(next.getUTCMonth() + 1).padStart(2, "0")}-${String(next.getUTCDate()).padStart(2, "0")} 00:00:00+00`,
+		suffix: `${year}${month}${day}`
+	};
+}
+function partitionName(table, suffix) {
+	return `${table}_p${suffix}`;
+}
+/**
+* Creates daily partition tables in [today - 1 day, today + futureDays].
+* Idempotent: uses CREATE TABLE IF NOT EXISTS.
+*/
+async function ensureNativePartitions(client, schema, options = {}) {
+	const windowDays = partitionWindow(options);
+	for (const table of ALL_SIGNAL_TABLES) await ensureDayPartitions(client, schema, table, windowDays);
+}
+/** The UTC days init() pre-creates: yesterday (optional) through today + futureDays. */
+function partitionWindow(options = {}, nowMs = Date.now()) {
+	const futureDays = options.futureDays ?? DEFAULT_FUTURE_DAYS;
+	const start = options.includeYesterday ?? true ? -1 : 0;
+	const days = [];
+	for (let i = start; i <= futureDays; i++) days.push(new Date(nowMs + i * 864e5));
+	return days;
+}
+/**
+* Keeps only the days inside the current partition window. The write path
+* creates partitions on demand within that window only, so a row with a
+* client-supplied timestamp far in the past or future cannot make the
+* database grow a table per day it names.
+*/
+function withinPartitionWindow(days, options = {}) {
+	const allowed = new Set(partitionWindow(options).map((d) => dayBounds(d).suffix));
+	return days.filter((d) => allowed.has(dayBounds(d).suffix));
+}
+/**
+* Creates and attaches a partition of `schema.table` for each UTC day in
+* `days` that has none. Each day is a `CREATE TABLE (LIKE parent)` followed by
+* `ATTACH PARTITION`, in one transaction, so a failed attach leaves no
+* detached child behind. When either step fails, the catalog is read again: a
+* day that a concurrent caller attached meanwhile counts as done, and any
+* other failure is rethrown.
+*/
+async function ensureDayPartitions(client, schema, table, days) {
+	const parent = qualifiedTable(schema, table);
+	const attached = await attachedPartitionNames(client, schema, table);
+	for (const d of days) {
+		const { start: partStart, end: partEnd, suffix } = dayBounds(d);
+		const childName = partitionName(table, suffix);
+		if (attached.has(childName)) continue;
+		const child = qualifiedName(schema, childName);
+		try {
+			await client.tx(async (t) => {
+				await t.none(`CREATE TABLE IF NOT EXISTS ${child} (LIKE ${parent} INCLUDING ALL)`);
+				await t.none(`ALTER TABLE ${parent} ATTACH PARTITION ${child}
+           FOR VALUES FROM ('${partStart}') TO ('${partEnd}')`);
+			});
+		} catch (error) {
+			if (!(await attachedPartitionNames(client, schema, table)).has(childName)) throw error;
+		}
+	}
+}
+/** Names of the children attached to `schema.table`, read from the catalog so no search_path can shadow it. */
+async function attachedPartitionNames(client, schema, table) {
+	const rows = await client.manyOrNone(`SELECT c.relname
+     FROM pg_catalog.pg_inherits i
+     JOIN pg_catalog.pg_class c ON c.oid = i.inhrelid
+     WHERE i.inhparent = (
+       SELECT p.oid
+       FROM pg_catalog.pg_class p
+       JOIN pg_catalog.pg_namespace n ON n.oid = p.relnamespace
+       WHERE n.nspname = $1 AND p.relname = $2
+     )`, [schema, table]);
+	return new Set(rows.map((r) => r.relname));
+}
+/**
+* `23514` raised by `ExecFindPartition`: the row's day has no attached
+* partition. The message is matched as a fallback only, because Postgres
+* translates it when `lc_messages` is not English.
+*/
+function isMissingPartitionError(error) {
+	const { code, routine, message = "" } = error ?? {};
+	return code === "23514" && (routine === "ExecFindPartition" || /no partition of relation/i.test(message));
+}
+/**
+* Calls `create_hypertable()` for each signal table.
+*
+* Postgres declarative partitioning and Timescale hypertables are mutually
+* exclusive, so the base DDL must have been generated with TableDDLMode
+* 'timescale' (no `PARTITION BY` clause). `if_not_exists` makes this
+* idempotent across re-inits.
+*/
+async function ensureTimescaleHypertables(client, schema) {
+	for (const table of ALL_SIGNAL_TABLES) {
+		const tableExpr = qualifiedTable(schema, table);
+		const timeColumn = SIGNAL_TIME_COLUMN[table].replace(/'/g, "''");
+		await client.none(`SELECT create_hypertable($1::regclass, '${timeColumn}', chunk_time_interval => INTERVAL '1 day', if_not_exists => true)`, [tableExpr]);
+	}
+}
+/**
+* Registers each signal table with pg_partman as a daily-interval parent and
+* lets partman create the child partitions.
+*
+* Retention is intentionally NOT configured here — it stays opt-in via the
+* future Mastra CLI surface.
+*
+* Prefers the pg_partman 5.x+ declarative API (`p_type := 'range'`) and keeps
+* a 4.x fallback (`p_type := 'native'`) for older installs. That lets the
+* adapter run against current arm64-friendly images without breaking existing
+* 4.x deployments.
+*/
+async function partmanParentRegistered(client, schema, table) {
+	const row = await client.oneOrNone(`SELECT EXISTS (
+       SELECT 1 FROM partman.part_config
+       WHERE parent_table = format('%I.%I', $1::text, $2::text)
+     ) AS "exists"`, [schema, table]);
+	return Boolean(row?.exists);
+}
+async function ensurePartmanHypertables(client, schema) {
+	const partmanMajor = getPartmanMajor(await getPartmanVersion(client));
+	for (const table of ALL_SIGNAL_TABLES) {
+		if (await partmanParentRegistered(client, schema, table)) continue;
+		for (let attempt = 0; attempt < 3; attempt++) try {
+			if (partmanMajor != null && partmanMajor >= 5) await client.none(`SELECT partman.create_parent(
+               p_parent_table := format('%I.%I', $1::text, $2::text),
+               p_control := $3,
+               p_interval := '1 day',
+               p_type := 'range'
+             )`, [
+				schema,
+				table,
+				SIGNAL_TIME_COLUMN[table]
+			]);
+			else await client.none(`SELECT partman.create_parent(
+               p_parent_table := format('%I.%I', $1::text, $2::text),
+               p_control := $3,
+               p_type := 'native',
+               p_interval := '1 day'
+             )`, [
+				schema,
+				table,
+				SIGNAL_TIME_COLUMN[table]
+			]);
+			break;
+		} catch (error) {
+			const message = error?.message ?? "";
+			if (error?.code === "23505" || /already managed by pg_partman/i.test(message) || /relation .* already exists/i.test(message)) break;
+			if (!/deadlock detected/i.test(message)) throw error;
+			if (await partmanParentRegistered(client, schema, table)) break;
+			if (attempt === 2) throw error;
+			await new Promise((resolve) => setTimeout(resolve, 25));
+		}
+	}
+}
+async function setupPartitioning(client, schema, options = {}) {
+	switch (await resolveMode(client, options)) {
+		case "timescale":
+			await ensureTimescaleHypertables(client, schema);
+			return "timescale";
+		case "partman":
+			await ensurePartmanHypertables(client, schema);
+			return "partman";
+		case "native":
+			await ensureNativePartitions(client, schema, options);
+			return "native";
+	}
+}
 // src/storage/domains/observability/v-next/sql.ts
 /**
 * SQL helpers for the v-next Postgres observability domain.
@@ -17402,6 +17695,54 @@ ${onConflict}`,
 		values
 	};
 }
+/**
+* Insert into a signal table. In native partition mode, a row whose day is
+* inside the partition window but has no partition yet gets one created, then
+* the insert runs once more. TimescaleDB and pg_partman own their partitions,
+* so in those modes the original error propagates untouched. The mode is the
+* one the store resolved; a store that never ran init() (`disableInit`)
+* detects it here, after the failed insert, so the hot path stays one query.
+*/
+async function insertRows(client, schema, table, records, partitioning, onConflict) {
+	const insert = buildInsert(schema, table, records, onConflict);
+	if (!insert) return;
+	try {
+		await client.query(insert.text, insert.values);
+	} catch (error) {
+		if (!isMissingPartitionError(error) || await resolveMode(client, partitioning) !== "native") throw error;
+		const days = withinPartitionWindow(recordDays(records, SIGNAL_TIME_COLUMN[table]), partitioning);
+		if (days.length === 0) throw error;
+		for (const day of days) await ensureDayPartitions(client, schema, table, [day]).catch((cause) => {
+			if (!isInsufficientPrivilegeError(cause)) throw cause;
+			throw new Error(partitionCreateFailure({
+				table,
+				day,
+				cause
+			}), { cause });
+		});
+		await client.query(insert.text, insert.values);
+	}
+}
+/** `42501`: the role may not create the child, or does not own the parent it must attach to. */
+function isInsufficientPrivilegeError(error) {
+	return error?.code === "42501";
+}
+function partitionCreateFailure({ table, day, cause }) {
+	const reason = cause instanceof Error ? cause.message : String(cause);
+	return `Could not create the ${table} partition for ${day.toISOString().slice(0, 10)} (UTC): ${reason}. Create the partitions with a role that can create tables in the schema and owns the observability tables, for example by calling ensurePartitions() on a schedule.`;
+}
+function recordDays(records, timeColumn) {
+	const days = /* @__PURE__ */ new Map();
+	for (const record of records) {
+		const value = record[timeColumn];
+		if (value == null) continue;
+		const d = new Date(value);
+		if (isNaN(d.getTime())) continue;
+		const day = new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate()));
+		days.set(day.toISOString(), day);
+	}
+	return [...days.values()];
+}
 /** Primary key of the span table; also the conflict target for span upserts. */
 const SPAN_KEY_COLUMNS = [
 	"traceId",
@@ -18312,16 +18653,14 @@ function pushFeedbackIdentity(acc, feedbackType, feedbackSource) {
 	}
 	acc.conditions.push(`"valueNumber" IS NOT NULL`);
 }
-async function createFeedback(client, schema, args) {
+async function createFeedback(client, schema, args, partitioning) {
 	const row = feedbackRecordToRow(args.feedback);
-	const insert = buildInsert(schema, TABLE_FEEDBACK_EVENTS, [row], FEEDBACK_UPSERT_CLAUSE);
-	if (insert) await client.query(insert.text, insert.values);
+	await insertRows(client, schema, TABLE_FEEDBACK_EVENTS, [row], partitioning, FEEDBACK_UPSERT_CLAUSE);
 }
-async function batchCreateFeedback(client, schema, args) {
+async function batchCreateFeedback(client, schema, args, partitioning) {
 	if (args.feedbacks.length === 0) return;
 	const rows = [...new Map(args.feedbacks.map((feedback) => [feedback.feedbackId, feedback])).values()].map(feedbackRecordToRow);
-	const insert = buildInsert(schema, TABLE_FEEDBACK_EVENTS, rows, FEEDBACK_UPSERT_CLAUSE);
-	if (insert) await client.query(insert.text, insert.values);
+	await insertRows(client, schema, TABLE_FEEDBACK_EVENTS, rows, partitioning, FEEDBACK_UPSERT_CLAUSE);
 }
 async function updateFeedbackReviewStatus(client, schema, args) {
 	const { feedbackId, reviewStatus } = parseUpdateFeedbackReviewStatusArgs(args);
@@ -18519,11 +18858,10 @@ function applyLogFilters(acc, filters) {
 	applyCommonFilters(acc, filters);
 	applySingleOrArrayFilter(acc, "level", filters?.level);
 }
-async function batchCreateLogs(client, schema, args) {
+async function batchCreateLogs(client, schema, args, partitioning) {
 	if (args.logs.length === 0) return;
 	const rows = args.logs.map(logRecordToRow);
-	const insert = buildInsert(schema, TABLE_LOG_EVENTS, rows);
-	if (insert) await client.query(insert.text, insert.values);
+	await insertRows(client, schema, TABLE_LOG_EVENTS, rows, partitioning);
 }
 async function listLogs(client, schema, args) {
 	const { mode, filters, pagination, orderBy, after, limit } = _mastra_core_storage.listLogsArgsSchema.parse(args);
@@ -18594,11 +18932,10 @@ function pushMetricNameFilter(acc, names) {
 	acc.conditions.push(`"name" IN (${placeholders})`);
 	acc.params.push(...names);
 }
-async function batchCreateMetrics(client, schema, args) {
+async function batchCreateMetrics(client, schema, args, partitioning) {
 	if (args.metrics.length === 0) return;
 	const rows = args.metrics.map(metricRecordToRow);
-	const insert = buildInsert(schema, TABLE_METRIC_EVENTS, rows);
-	if (insert) await client.query(insert.text, insert.values);
+	await insertRows(client, schema, TABLE_METRIC_EVENTS, rows, partitioning);
 }
 async function listMetrics(client, schema, args) {
 	const { mode, filters, pagination, orderBy, after, limit } = _mastra_core_storage.listMetricsArgsSchema.parse(args);
@@ -18800,165 +19137,6 @@ async function getMetricPercentiles(client, schema, args) {
   `;
 	return { series: percentileSeriesFromRows(await client.manyOrNone(sql, acc.params), args.percentiles) };
 }
-// src/storage/domains/observability/v-next/partitioning.ts
-const DEFAULT_FUTURE_DAYS = 14;
-async function detectTimescale(client) {
-	const row = await client.oneOrNone(`SELECT EXISTS (SELECT 1 FROM pg_extension WHERE extname = 'timescaledb') AS "exists"`);
-	return Boolean(row?.exists);
-}
-async function detectPartman(client) {
-	const row = await client.oneOrNone(`SELECT EXISTS (SELECT 1 FROM pg_extension WHERE extname = 'pg_partman') AS "exists"`);
-	return Boolean(row?.exists);
-}
-async function getPartmanVersion(client) {
-	return (await client.oneOrNone(`SELECT extversion FROM pg_extension WHERE extname = 'pg_partman'`))?.extversion ?? null;
-}
-function getPartmanMajor(version) {
-	if (!version) return null;
-	const match = /^(\d+)/.exec(version);
-	return match ? Number(match[1]) : null;
-}
-async function resolveMode(client, options = {}) {
-	if (options.mode && options.mode !== "auto") return options.mode;
-	if (await detectTimescale(client)) return "timescale";
-	if (await detectPartman(client)) return "partman";
-	return "native";
-}
-function dayBounds(d) {
-	const year = d.getUTCFullYear();
-	const month = String(d.getUTCMonth() + 1).padStart(2, "0");
-	const day = String(d.getUTCDate()).padStart(2, "0");
-	const start = `${year}-${month}-${day} 00:00:00+00`;
-	const next = new Date(Date.UTC(year, d.getUTCMonth(), d.getUTCDate() + 1));
-	return {
-		start,
-		end: `${next.getUTCFullYear()}-${String(next.getUTCMonth() + 1).padStart(2, "0")}-${String(next.getUTCDate()).padStart(2, "0")} 00:00:00+00`,
-		suffix: `${year}${month}${day}`
-	};
-}
-function partitionName(table, suffix) {
-	return `${table}_p${suffix}`;
-}
-/**
-* Creates daily partition tables in [today - 1 day, today + futureDays].
-* Idempotent: uses CREATE TABLE IF NOT EXISTS.
-*/
-async function ensureNativePartitions(client, schema, options = {}) {
-	const futureDays = options.futureDays ?? DEFAULT_FUTURE_DAYS;
-	const start = options.includeYesterday ?? true ? -1 : 0;
-	const baseNowMs = Date.now();
-	for (const table of ALL_SIGNAL_TABLES) for (let i = start; i <= futureDays; i++) {
-		const { start: partStart, end: partEnd, suffix } = dayBounds(new Date(baseNowMs + i * 864e5));
-		const child = qualifiedName(schema, partitionName(table, suffix));
-		const parent = qualifiedTable(schema, table);
-		try {
-			await client.none(`CREATE TABLE IF NOT EXISTS ${child} (LIKE ${parent} INCLUDING ALL)`);
-		} catch (error) {
-			if (!isDuplicateRelationError(error)) throw error;
-		}
-		try {
-			await client.none(`ALTER TABLE ${parent} ATTACH PARTITION ${child}
-           FOR VALUES FROM ('${partStart}') TO ('${partEnd}')`);
-		} catch (error) {
-			if (!isAlreadyAttachedError(error)) throw error;
-		}
-	}
-}
-/**
-* `ALTER TABLE ATTACH PARTITION` fails with `42P17 invalid_object_definition`
-* when the target table is already a partition of *any* parent (including
-* the one we want). On older PG it can also surface as 42710 or a generic
-* message. We err on the side of treating any "already a partition" wording
-* as success so concurrent inits converge cleanly.
-*/
-function isAlreadyAttachedError(error) {
-	const code = error?.code;
-	const message = error?.message ?? "";
-	if (code === "42P17" || code === "42710") return /is already a partition/i.test(message) || /already a partition/i.test(message);
-	return /is already a partition/i.test(message);
-}
-/**
-* Calls `create_hypertable()` for each signal table.
-*
-* Postgres declarative partitioning and Timescale hypertables are mutually
-* exclusive, so the base DDL must have been generated with TableDDLMode
-* 'timescale' (no `PARTITION BY` clause). `if_not_exists` makes this
-* idempotent across re-inits.
-*/
-async function ensureTimescaleHypertables(client, schema) {
-	for (const table of ALL_SIGNAL_TABLES) {
-		const tableExpr = qualifiedTable(schema, table);
-		const timeColumn = SIGNAL_TIME_COLUMN[table].replace(/'/g, "''");
-		await client.none(`SELECT create_hypertable($1::regclass, '${timeColumn}', chunk_time_interval => INTERVAL '1 day', if_not_exists => true)`, [tableExpr]);
-	}
-}
-/**
-* Registers each signal table with pg_partman as a daily-interval parent and
-* lets partman create the child partitions.
-*
-* Retention is intentionally NOT configured here — it stays opt-in via the
-* future Mastra CLI surface.
-*
-* Prefers the pg_partman 5.x+ declarative API (`p_type := 'range'`) and keeps
-* a 4.x fallback (`p_type := 'native'`) for older installs. That lets the
-* adapter run against current arm64-friendly images without breaking existing
-* 4.x deployments.
-*/
-async function ensurePartmanHypertables(client, schema) {
-	const partmanMajor = getPartmanMajor(await getPartmanVersion(client));
-	for (const table of ALL_SIGNAL_TABLES) {
-		if ((await client.oneOrNone(`SELECT EXISTS (
-         SELECT 1 FROM partman.part_config
-         WHERE parent_table = format('%I.%I', $1::text, $2::text)
-       ) AS "exists"`, [schema, table]))?.exists) continue;
-		for (let attempt = 0; attempt < 3; attempt++) try {
-			if (partmanMajor != null && partmanMajor >= 5) await client.none(`SELECT partman.create_parent(
-               p_parent_table := format('%I.%I', $1::text, $2::text),
-               p_control := $3,
-               p_interval := '1 day',
-               p_type := 'range'
-             )`, [
-				schema,
-				table,
-				SIGNAL_TIME_COLUMN[table]
-			]);
-			else await client.none(`SELECT partman.create_parent(
-               p_parent_table := format('%I.%I', $1::text, $2::text),
-               p_control := $3,
-               p_type := 'native',
-               p_interval := '1 day'
-             )`, [
-				schema,
-				table,
-				SIGNAL_TIME_COLUMN[table]
-			]);
-			break;
-		} catch (error) {
-			const message = error?.message ?? "";
-			if (error?.code === "23505" || /already managed by pg_partman/i.test(message) || /relation .* already exists/i.test(message)) break;
-			if (!/deadlock detected/i.test(message)) throw error;
-			if ((await client.oneOrNone(`SELECT EXISTS (
-             SELECT 1 FROM partman.part_config
-             WHERE parent_table = format('%I.%I', $1::text, $2::text)
-           ) AS "exists"`, [schema, table]))?.exists) break;
-			if (attempt === 2) throw error;
-			await new Promise((resolve) => setTimeout(resolve, 25));
-		}
-	}
-}
-async function setupPartitioning(client, schema, options = {}) {
-	switch (await resolveMode(client, options)) {
-		case "timescale":
-			await ensureTimescaleHypertables(client, schema);
-			return "timescale";
-		case "partman":
-			await ensurePartmanHypertables(client, schema);
-			return "partman";
-		case "native":
-			await ensureNativePartitions(client, schema, options);
-			return "native";
-	}
-}
 // src/storage/domains/observability/v-next/retention.ts
 /**
 * Age-based retention for the v-next Postgres observability domain.
@@ -19124,16 +19302,14 @@ function collapseExactScoreConflicts(rows) {
 	}
 	return [...records.values()];
 }
-async function createScore(client, schema, args) {
+async function createScore(client, schema, args, partitioning) {
 	const row = scoreRecordToRow(args.score);
-	const insert = buildInsert(schema, TABLE_SCORE_EVENTS, [row], scoreRewriteConflict(row));
-	if (insert) await client.query(insert.text, insert.values);
+	await insertRows(client, schema, TABLE_SCORE_EVENTS, [row], partitioning, scoreRewriteConflict(row));
 }
-async function batchCreateScores(client, schema, args) {
+async function batchCreateScores(client, schema, args, partitioning) {
 	if (args.scores.length === 0) return;
 	const rows = collapseExactScoreConflicts(args.scores.map(scoreRecordToRow));
-	const insert = buildInsert(schema, TABLE_SCORE_EVENTS, rows, scoreRewriteConflict(rows[0]));
-	if (insert) await client.query(insert.text, insert.values);
+	await insertRows(client, schema, TABLE_SCORE_EVENTS, rows, partitioning, scoreRewriteConflict(rows[0]));
 }
 /**
 * Delete score events by scoreId. Optional `organizationId` and `resourceId`
@@ -19364,7 +19540,15 @@ const TRACE_STATUS_SQL = `CASE WHEN r."error" IS NOT NULL THEN 'error' ELSE 'suc
 const timeToFirstChunkSupported = "timeToFirstChunkMs" in _mastra_core_storage.TRACE_QUERY_FIELD_REGISTRY.trace;
 /** Core before the sort rejects `orderBy` on the field, so the sort is only declared when core plans it. */
 const timeToFirstChunkSortSupported = _mastra_core_storage.TRACE_QUERY_ORDER_FIELDS?.includes("timeToFirstChunkMs") === true;
-const timeToFirstChunkFeatures = [...timeToFirstChunkSupported ? ["trace-query-time-to-first-chunk"] : [], ...timeToFirstChunkSortSupported ? ["trace-query-time-to-first-chunk-sort"] : []];
+/** Same rule for time to first token: returned and sorted only when core knows the field. */
+const timeToFirstTokenSupported = "timeToFirstTokenMs" in _mastra_core_storage.TRACE_QUERY_FIELD_REGISTRY.trace;
+const timeToFirstTokenSortSupported = _mastra_core_storage.TRACE_QUERY_ORDER_FIELDS?.includes("timeToFirstTokenMs") === true;
+const timingFeatures = [
+	...timeToFirstChunkSupported ? ["trace-query-time-to-first-chunk"] : [],
+	...timeToFirstChunkSortSupported ? ["trace-query-time-to-first-chunk-sort"] : [],
+	...timeToFirstTokenSupported ? ["trace-query-time-to-first-token"] : [],
+	...timeToFirstTokenSortSupported ? ["trace-query-time-to-first-token-sort"] : []
+];
 /**
 * Keyset bounds for a cursor's sort value: terms for rows strictly past it in `direction`, and the
 * condition for rows level with it. Empty values sort last in both directions, so they are past
@@ -19397,6 +19581,7 @@ const TRACE_FIELDS = {
 	endedAt: "r.\"endedAt\"",
 	durationMs: durationMsSql("r.\"startedAt\"", "r.\"endedAt\""),
 	timeToFirstChunkMs: "r.\"timeToFirstChunkMs\"",
+	timeToFirstTokenMs: "r.\"timeToFirstTokenMs\"",
 	entityId: "r.\"entityId\"",
 	entityName: "r.\"entityName\"",
 	entityType: "r.\"entityType\"",
@@ -19415,6 +19600,7 @@ const SPAN_FIELDS = {
 	endedAt: "s.\"endedAt\"",
 	durationMs: "s.\"durationMs\"",
 	timeToFirstChunkMs: "s.\"timeToFirstChunkMs\"",
+	timeToFirstTokenMs: "s.\"timeToFirstTokenMs\"",
 	status: "s.\"status\"",
 	error: "s.\"error\"",
 	entityType: "s.\"entityType\"",
@@ -19485,6 +19671,7 @@ const TRACE_SELECT = `
   r."startedAt" AS "startedAt",
   r."endedAt" AS "endedAt",
   r."timeToFirstChunkMs" AS "timeToFirstChunkMs",
+  r."timeToFirstTokenMs" AS "timeToFirstTokenMs",
   r."entityName" AS "entityName",
   r."entityType" AS "entityType",
   r."environment" AS "environment",
@@ -19854,6 +20041,7 @@ function compilePostgresTraceScope(schema, selection, relationCollections, scope
         ELSE ${durationMsSql("s.\"startedAt\"", "s.\"endedAt\"")}
       END AS "durationMs",
       s."timeToFirstChunkMs",
+      s."timeToFirstTokenMs",
       CASE WHEN s."error" IS NOT NULL THEN 'error' ELSE 'success' END AS "status",
       s."error",
       s."entityType",
@@ -20228,6 +20416,7 @@ function traceRowToResult(row) {
 		startedAt: asIsoTimestamp$1(row.startedAt),
 		endedAt: asIsoTimestamp$1(row.endedAt),
 		...timeToFirstChunkSupported && { timeToFirstChunkMs: row.timeToFirstChunkMs == null ? null : Number(row.timeToFirstChunkMs) },
+		...timeToFirstTokenSupported && { timeToFirstTokenMs: row.timeToFirstTokenMs == null ? null : Number(row.timeToFirstTokenMs) },
 		entityName: row.entityName == null ? null : String(row.entityName),
 		entityType: row.entityType == null ? null : String(row.entityType),
 		environment: row.environment == null ? null : String(row.environment),
@@ -20383,7 +20572,8 @@ const fields = [
 	"experimentId",
 	"environment",
 	"executionSource",
-	"timeToFirstChunkMs"
+	"timeToFirstChunkMs",
+	"timeToFirstTokenMs"
 ];
 const identities = identityFields.map((field) => `"${field}"`).join(", ");
 const identityOrder = identityFields.map((field) => `"${field}" COLLATE "C" ASC NULLS LAST`).join(", ");
@@ -20515,9 +20705,10 @@ async function querySpans(client, schema, plan, timeoutMs) {
 	return runWithPostgresTraceQueryTimeout(client, timeoutMs, async (tx) => {
 		const query = compilePostgresSpanQuery(schema, plan);
 		const rows = await tx.any(query.text, query.values);
-		const selected = rows.map(({ version: _version, startedAt, endedAt, timeToFirstChunkMs, ...row }) => ({
+		const selected = rows.map(({ version: _version, startedAt, endedAt, timeToFirstChunkMs, timeToFirstTokenMs, ...row }) => ({
 			...row,
 			...timeToFirstChunkSupported && { timeToFirstChunkMs },
+			...timeToFirstTokenSupported && { timeToFirstTokenMs },
 			startedAt: startedAt.toISOString(),
 			endedAt: endedAt.toISOString()
 		}));
@@ -20649,7 +20840,11 @@ function compilePostgresThreadRowsQuery(schema, plan, strategy = "full") {
 	}
 	const qualify = plan.timeRange.mode === "traces" ? "s.\"inWindow\"" : `s."${plan.timeRange.field}" >= $1 AND s."${plan.timeRange.field}" < $2`;
 	const filtered = predicateFields(plan.where);
-	const firstContext = [...contextFields, "timeToFirstChunkMs"].filter((field) => field === "resourceId" || filtered.has(field));
+	const firstContext = [
+		...contextFields,
+		"timeToFirstChunkMs",
+		"timeToFirstTokenMs"
+	].filter((field) => field === "resourceId" || filtered.has(field));
 	const lastFields = [
 		"traceId",
 		"spanId",
@@ -20663,7 +20858,7 @@ function compilePostgresThreadRowsQuery(schema, plan, strategy = "full") {
 		text: `WITH ${scopedRoots}, ${strategy === "candidates" ? `${candidates}, ` : ""}current_roots AS (
     SELECT DISTINCT ON ("organizationId", "traceId")
       "organizationId", "threadId", "traceId", "spanId", "cursorId", "startedAt", "endedAt", "isPending",
-      ${firstContext.map((field) => field === "timeToFirstChunkMs" ? `CASE WHEN "spanType" = 'agent_run' THEN "timeToFirstChunkMs" END AS "timeToFirstChunkMs"` : `"${field}"`).join(", ")}
+      ${firstContext.map((field) => field === "timeToFirstChunkMs" || field === "timeToFirstTokenMs" ? `CASE WHEN "spanType" = 'agent_run' THEN "${field}" END AS "${field}"` : `"${field}"`).join(", ")}
       ${filtered.has("status") ? ", CASE WHEN error IS NULL THEN 'success' ELSE 'error' END AS status" : ""}
     FROM scoped_roots ${strategy === "candidates" ? `WHERE (${identity("traceId")}) IN (SELECT ${identity("traceId")} FROM candidate_traces)` : ""}
     ORDER BY "organizationId", "traceId", "startedAt" ASC, "spanId" COLLATE "C", "cursorId" DESC
@@ -20729,6 +20924,7 @@ async function queryThreadRows(client, schema, plan, timeoutMs, strategy = "auto
 	}));
 	const payloads = await run(`SELECT "organizationId", "traceId", "cursorId", ${contextFields.map((field) => `"${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",
@@ -20757,6 +20953,7 @@ async function queryThreadRows(client, schema, plan, timeoutMs, strategy = "auto
 			endedAt: row.endedAt.toISOString(),
 			traceCount: Number(row.traceCount),
 			timeToFirstChunkMs: first.timeToFirstChunkMs,
+			...timeToFirstTokenSupported && { timeToFirstTokenMs: first.timeToFirstTokenMs },
 			inputPreview: readPreview(first.inputPreview, first.input),
 			outputPreview: readPreview(last.outputPreview, last.output),
 			errorPreview: readPreview(last.errorPreview, last.error)
@@ -21713,10 +21910,9 @@ async function readBranchesStreamHeadCursor(client, span, filters) {
 	return encodeDeltaCursor(await readSafeXactHorizon(client), 0);
 }
 // src/storage/domains/observability/v-next/tracing.ts
-async function writeSpanRows(client, schema, rows) {
+async function writeSpanRows(client, schema, rows, partitioning) {
 	const deduped = dedupeSpanRows(rows);
-	const insert = buildInsert(schema, TABLE_SPAN_EVENTS, deduped, spanConflictClause(Object.keys(deduped[0] ?? {})));
-	if (insert) await client.query(insert.text, insert.values);
+	await insertRows(client, schema, TABLE_SPAN_EVENTS, deduped, partitioning, spanConflictClause(Object.keys(deduped[0] ?? {})));
 }
 /**
 * Collapse rows that share a primary key within a single batch. Postgres
@@ -21736,12 +21932,12 @@ function dedupeSpanRows(rows) {
 	}
 	return [...byKey.values()];
 }
-async function createSpan(client, schema, args) {
-	await writeSpanRows(client, schema, [spanRecordToRow(args.span)]);
+async function createSpan(client, schema, args, partitioning) {
+	await writeSpanRows(client, schema, [spanRecordToRow(args.span)], partitioning);
 }
-async function batchCreateSpans(client, schema, args) {
+async function batchCreateSpans(client, schema, args, partitioning) {
 	if (args.records.length === 0) return;
-	await writeSpanRows(client, schema, args.records.map(spanRecordToRow));
+	await writeSpanRows(client, schema, args.records.map(spanRecordToRow), partitioning);
 }
 async function getSpans(client, schema, args) {
 	if (args.spanIds.length === 0) return {
@@ -21962,6 +22158,18 @@ var ObservabilityStoragePostgresVNext = class ObservabilityStoragePostgresVNext
 		return this.#partitionMode;
 	}
 	/**
+	* Create any missing day partitions from yesterday through today +
+	* `futureDays`, without the rest of init(). For apps whose runtime role
+	* cannot run DDL: call it on a schedule with a role that owns the
+	* observability tables. Safe to call repeatedly on one instance. Does
+	* nothing with TimescaleDB or pg_partman, which create their own partitions.
+	*/
+	async ensurePartitions() {
+		return this.#run("VNEXT_ENSURE_PARTITIONS", async () => {
+			if ((this.#partitionMode ??= await resolveMode(this.#client, this.#partitioning)) === "native") await ensureNativePartitions(this.#client, this.#schema, this.#partitioning);
+		});
+	}
+	/**
 	* All five signal tables are insert-only growth tables. The anchor column is
 	* each table's partition / chunk key, so age-based expiry drops whole day
 	* partitions instead of deleting rows (see `./retention.ts`). `indexed: true`
@@ -22065,7 +22273,7 @@ var ObservabilityStoragePostgresVNext = class ObservabilityStoragePostgresVNext
 			"trace-query-tenant-scope",
 			"feedback",
 			"trace-query-context-ids",
-			...timeToFirstChunkFeatures,
+			...timingFeatures,
 			"trace-query-root-span-fields",
 			"trace-query-root-entity-id"
 		];
@@ -22090,11 +22298,23 @@ var ObservabilityStoragePostgresVNext = class ObservabilityStoragePostgresVNext
 			"trace-query-tenant-scope",
 			"feedback",
 			"trace-query-context-ids",
-			...timeToFirstChunkFeatures,
+			...timingFeatures,
 			"trace-query-root-span-fields",
 			"trace-query-root-entity-id"
 		];
 	}
+	/**
+	* Partitioning options for the write path, with `mode` fixed to the mode
+	* this store resolved (in init(), or lazily in prune()) so the write path
+	* does not detect it again. Until then the configured mode stands in and
+	* the write path resolves it itself when a partition is missing.
+	*/
+	#writePartitioning() {
+		return {
+			...this.#partitioning,
+			mode: this.#partitionMode ?? this.#partitioning.mode
+		};
+	}
 	async #run(op, fn, details) {
 		try {
 			return await fn();
@@ -22103,13 +22323,13 @@ var ObservabilityStoragePostgresVNext = class ObservabilityStoragePostgresVNext
 		}
 	}
 	async createSpan(args) {
-		await this.#run("CREATE_SPAN", () => createSpan(this.#client, this.#schema, args), {
+		await this.#run("CREATE_SPAN", () => createSpan(this.#client, this.#schema, args, this.#writePartitioning()), {
 			traceId: args.span.traceId,
 			spanId: args.span.spanId
 		});
 	}
 	async batchCreateSpans(args) {
-		await this.#run("BATCH_CREATE_SPANS", () => batchCreateSpans(this.#client, this.#schema, args), { count: args.records.length });
+		await this.#run("BATCH_CREATE_SPANS", () => batchCreateSpans(this.#client, this.#schema, args, this.#writePartitioning()), { count: args.records.length });
 	}
 	async getSpan(args) {
 		return this.#run("GET_SPAN", () => getSpan(this.#readClient, this.#schema, args), {
@@ -22163,22 +22383,22 @@ var ObservabilityStoragePostgresVNext = class ObservabilityStoragePostgresVNext
 		return this.#run("LIST_BRANCHES", () => listBranches(this.#readClient, this.#schema, args));
 	}
 	async batchCreateLogs(args) {
-		await this.#run("BATCH_CREATE_LOGS", () => batchCreateLogs(this.#client, this.#schema, args), { count: args.logs.length });
+		await this.#run("BATCH_CREATE_LOGS", () => batchCreateLogs(this.#client, this.#schema, args, this.#writePartitioning()), { count: args.logs.length });
 	}
 	async batchCreateMetrics(args) {
-		await this.#run("BATCH_CREATE_METRICS", () => batchCreateMetrics(this.#client, this.#schema, args), { count: args.metrics.length });
+		await this.#run("BATCH_CREATE_METRICS", () => batchCreateMetrics(this.#client, this.#schema, args, this.#writePartitioning()), { count: args.metrics.length });
 	}
 	async createScore(args) {
-		await this.#run("CREATE_SCORE", () => createScore(this.#client, this.#schema, args));
+		await this.#run("CREATE_SCORE", () => createScore(this.#client, this.#schema, args, this.#writePartitioning()));
 	}
 	async batchCreateScores(args) {
-		await this.#run("BATCH_CREATE_SCORES", () => batchCreateScores(this.#client, this.#schema, args), { count: args.scores.length });
+		await this.#run("BATCH_CREATE_SCORES", () => batchCreateScores(this.#client, this.#schema, args, this.#writePartitioning()), { count: args.scores.length });
 	}
 	async createFeedback(args) {
-		await this.#run("CREATE_FEEDBACK", () => createFeedback(this.#client, this.#schema, args));
+		await this.#run("CREATE_FEEDBACK", () => createFeedback(this.#client, this.#schema, args, this.#writePartitioning()));
 	}
 	async batchCreateFeedback(args) {
-		await this.#run("BATCH_CREATE_FEEDBACK", () => batchCreateFeedback(this.#client, this.#schema, args), { count: args.feedbacks.length });
+		await this.#run("BATCH_CREATE_FEEDBACK", () => batchCreateFeedback(this.#client, this.#schema, args, this.#writePartitioning()), { count: args.feedbacks.length });
 	}
 	async deleteScores(args) {
 		await this.#run("DELETE_SCORES", () => deleteScores(this.#client, this.#schema, args), { count: args.scoreIds.length });
@@ -27588,12 +27808,20 @@ var PostgresStore = class extends _mastra_core_storage.MastraCompositeStore {
 	}
 	async #runPinnedInit() {
 		let pinnedClient;
+		let pinned;
 		try {
 			pinnedClient = await this.#writePool.connect();
-			const pinned = new PinnedClientAdapter(this.#writePool, pinnedClient);
+			pinned = new PinnedClientAdapter(this.#writePool, pinnedClient);
 			this.#db.pin(pinned);
-			this.#db.setSchemaSnapshot(await loadSchemaSnapshot(pinned, this.schema));
-			await Promise.all(Object.entries(this.stores).filter(([name, store]) => name !== "knowledge" && store).map(([, store]) => store.init()));
+			for (let attempt = 1; attempt <= 3; attempt++) {
+				this.#db.setSchemaSnapshot(await loadSchemaSnapshot(pinned, this.schema));
+				const failures = (await Promise.allSettled(Object.entries(this.stores).filter(([name, store]) => name !== "knowledge" && store).map(([, store]) => Promise.resolve().then(() => store.init())))).filter((result) => result.status === "rejected");
+				if (failures.length === 0) break;
+				const terminal = failures.find((result) => !isRetryableDeadlock(result.reason));
+				if (terminal || attempt === 3) throw (terminal ?? failures[0]).reason;
+				this.#db.setSchemaSnapshot(null);
+				await backoffAfterDeadlock(attempt);
+			}
 			this.isInitialized = true;
 		} catch (error) {
 			this.#initPromise = null;
@@ -27604,6 +27832,7 @@ var PostgresStore = class extends _mastra_core_storage.MastraCompositeStore {
 				category: _mastra_core_error.ErrorCategory.THIRD_PARTY
 			}, error);
 		} finally {
+			await pinned?.drain();
 			this.#db.setSchemaSnapshot(null);
 			if (pinnedClient) {
 				this.#db.unpin();
@@ -27758,6 +27987,10 @@ var PostgresStoreVNext = class extends PostgresStore {
 			owned: true
 		};
 	}
+	/** See {@link ObservabilityStoragePostgresVNext.ensurePartitions}. */
+	async ensurePartitions() {
+		await this.stores.observability.ensurePartitions();
+	}
 	/**
 	* Closes both the primary pool (when owned) and the observability pool
 	* (when this store created it). Safe to call multiple times.