@mastra/pg 1.25.0 → 1.26.0-alpha.1

package/dist/docs/SKILL.md

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

package/dist/docs/assets/SOURCE_MAP.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.25.0",
+  "version": "1.26.0-alpha.1",
   "package": "@mastra/pg",
   "exports": {},
   "modules": {}

package/dist/docs/references/reference-memory-memory-class.md

@@ -41,6 +41,8 @@ export const agent = new Agent({
 
 **options.lastMessages** (`number | false`): Number of most recent messages to include in context. Set to false to disable the message history feature entirely (messages are not loaded into context or saved). Use Number.MAX\_SAFE\_INTEGER to retrieve all messages with no limit. To load messages without saving new ones, use the readOnly option. The window slides forward on every request, so once a thread exceeds the limit, each turn invalidates the provider prompt cache. For long-running conversations, use Observational Memory instead.
 
+**options.messageHistory** (`{ maxTokens: number; atMaxRemoveTokens?: number }`): Token budget for the complete prompt, including remembered history, system instructions, context, and the current turn. When the prompt exceeds maxTokens, the oldest remembered messages are dropped until the prompt is at most maxTokens - atMaxRemoveTokens (defaults to 25% of maxTokens). Protected content is never removed. Linked tool calls and results are removed together. During agent runs, trimmed history is excluded from later turns via a persisted per-thread boundary, but the messages themselves stay in storage. When set without an explicit lastMessages, the default 10-message cap is not applied. Set maxTokens to 0 to disable message history. Prefer this over lastMessages, since message count is a poor proxy for context size.
+
 **options.readOnly** (`boolean`): When true, prevents memory from saving new messages and provides working memory as read-only context (without the updateWorkingMemory tool). Useful for read-only operations like previews, internal routing agents, or sub agents that should reference but not modify memory.
 
 **options.semanticRecall** (`boolean | { topK: number; messageRange: number | { before: number; after: number }; scope?: 'thread' | 'resource' }`): Enable semantic search in message history. Can be a boolean or an object with configuration options. When enabled, requires both vector store and embedder to be configured. Default topK is 4, default messageRange is {before: 1, after: 1}.

package/dist/docs/references/reference-rag-vector-databases.md

@@ -248,6 +248,34 @@ await store.upsert({
 })
 ```
 
+**Weaviate**:
+
+```ts
+import { WeaviateVector } from '@mastra/weaviate'
+
+const store = new WeaviateVector({
+  id: 'weaviate-vector',
+  httpHost: process.env.WEAVIATE_HOST,
+  httpPort: 443,
+  httpSecure: true,
+  grpcHost: process.env.WEAVIATE_GRPC_HOST,
+  grpcPort: 443,
+  grpcSecure: true,
+  apiKey: process.env.WEAVIATE_API_KEY,
+})
+
+await store.createIndex({
+  indexName: 'myCollection',
+  dimension: 1536,
+})
+
+await store.upsert({
+  indexName: 'myCollection',
+  vectors: embeddings,
+  metadata: chunks.map(chunk => ({ text: chunk.text })),
+})
+```
+
 **Cloudflare**:
 
 ```ts
@@ -534,6 +562,17 @@ Namespace names must:
 
 - Example: `_namespace` isn't valid (starts with underscore)
 
+**Weaviate**:
+
+Index names map to Weaviate collections, which:
+
+- Are capitalized by Weaviate (the first letter is upper-cased)
+- Should contain only letters, numbers, and the `_` character
+- Must start with a letter, since only the first character is upper-cased (a leading digit or symbol stays invalid)
+- Preserve the original Mastra index name in the collection description, so `listIndexes()` and `describeIndex()` return the name you supplied
+- Example: `my_collection` is stored as `My_collection` and returned as `my_collection`
+- Example: `123_collection` isn't valid (starts with a digit)
+
 **Cloudflare**:
 
 Index names must:

package/dist/index.cjs

@@ -2484,6 +2484,7 @@ async function loadSchemaSnapshot(client, schemaName) {
 }
 //#endregion
 //#region src/storage/db/index.ts
+const POSTGRES_MAX_BIND_PARAMETERS$1 = 65535;
 /**
 * Resolves PgDomainConfig to a database client and schema.
 * Handles creating a new pool if config is provided.
@@ -3037,6 +3038,90 @@ var PgDB = class extends _mastra_core_base.MastraBase {
              ON CONFLICT ("traceId", "spanId") DO NOTHING`, values);
 		} else await client.none(`INSERT INTO ${fullTableName} (${columnList}) VALUES (${placeholders})`, values);
 	}
+	getChunkRowLimit(columnCount) {
+		if (columnCount === 0) return 0;
+		return Math.max(1, Math.floor(POSTGRES_MAX_BIND_PARAMETERS$1 / columnCount));
+	}
+	getSpanConflictIdentifier(record) {
+		const traceId = record.traceId;
+		const spanId = record.spanId;
+		if (traceId === void 0 || spanId === void 0) return;
+		return `${String(traceId)}|${String(spanId)}`;
+	}
+	async normalizeForInsert(tableName, record) {
+		this.addTimestampZColumns(record);
+		const filteredRecord = await this.filterRecordToKnownColumns(tableName, record);
+		return {
+			columns: Object.keys(filteredRecord).map((column) => (0, _mastra_core_utils.parseSqlIdentifier)(column, "column name")),
+			values: this.prepareValuesForInsert(filteredRecord, tableName),
+			conflictKey: tableName === _mastra_core_storage.TABLE_SPANS ? this.getSpanConflictIdentifier(filteredRecord) : void 0
+		};
+	}
+	buildMultiRowInsertStatement({ tableName, columns, rows }) {
+		const fullTableName = getTableName$6({
+			indexName: tableName,
+			schemaName: getSchemaName$6(this.schemaName)
+		});
+		const columnList = columns.map((column) => `"${column}"`).join(", ");
+		const bindParams = [];
+		const values = [];
+		let bindIndex = 1;
+		for (const rowValues of rows) {
+			const placeholders = rowValues.map(() => `$${bindIndex++}`);
+			bindParams.push(`(${placeholders.join(", ")})`);
+			values.push(...rowValues);
+		}
+		let query = `INSERT INTO ${fullTableName} (${columnList}) VALUES ${bindParams.join(", ")}`;
+		if (tableName === _mastra_core_storage.TABLE_SPANS) {
+			const updateColumns = columns.filter((column) => column !== "traceId" && column !== "spanId");
+			if (updateColumns.length > 0) {
+				const updateClause = updateColumns.map((column) => `"${column}" = EXCLUDED."${column}"`).join(", ");
+				query += ` ON CONFLICT ("traceId", "spanId") DO UPDATE SET ${updateClause}`;
+			} else query += ` ON CONFLICT ("traceId", "spanId") DO NOTHING`;
+		}
+		return {
+			query,
+			values
+		};
+	}
+	async executeBatchInsert(client, { tableName, records }) {
+		const preparedRecords = [];
+		for (const record of records) preparedRecords.push(await this.normalizeForInsert(tableName, record));
+		let pendingColumns;
+		let pendingConflictKeys = /* @__PURE__ */ new Set();
+		let pendingRows = [];
+		let pendingLimit = 0;
+		const flush = async () => {
+			if (!pendingColumns || pendingRows.length === 0) return;
+			const statement = this.buildMultiRowInsertStatement({
+				tableName,
+				columns: pendingColumns,
+				rows: pendingRows
+			});
+			await client.none(statement.query, statement.values);
+			pendingColumns = void 0;
+			pendingRows = [];
+			pendingConflictKeys = /* @__PURE__ */ new Set();
+			pendingLimit = 0;
+		};
+		for (const { columns, values, conflictKey } of preparedRecords) {
+			if (columns.length === 0) continue;
+			const columnsSignature = columns.join("\0");
+			const currentPendingColumns = pendingColumns;
+			const isSpans = tableName === _mastra_core_storage.TABLE_SPANS;
+			const conflictDuplicate = isSpans && conflictKey !== void 0 && pendingConflictKeys.has(conflictKey);
+			const exceedsLimit = pendingRows.length >= pendingLimit;
+			if (currentPendingColumns === void 0 || columnsSignature !== currentPendingColumns.join("\0") || conflictDuplicate || exceedsLimit) {
+				await flush();
+				pendingColumns = columns;
+				pendingLimit = this.getChunkRowLimit(columns.length);
+				pendingRows = [values];
+				pendingConflictKeys = /* @__PURE__ */ new Set();
+			} else pendingRows.push(values);
+			if (isSpans && conflictKey !== void 0) pendingConflictKeys.add(conflictKey);
+		}
+		await flush();
+	}
 	async insert({ tableName, record }) {
 		try {
 			await this.executeInsert(this.client, {
@@ -3485,9 +3570,9 @@ MIGRATION REQUIRED: Duplicate spans detected in ${duplicateInfo.tableName}\n====
 	async batchInsert({ tableName, records }) {
 		try {
 			await this.client.tx(async (tx) => {
-				for (const record of records) await this.executeInsert(tx, {
+				await this.executeBatchInsert(tx, {
 					tableName,
-					record
+					records
 				});
 			});
 		} catch (error) {
@@ -17631,6 +17716,75 @@ LIMIT $${values.length}`,
 		values
 	};
 }
+function discoveryRegistry(scope) {
+	if (scope === "trace") return TRACE_FIELDS;
+	if (scope === "spans") return SPAN_FIELDS;
+	if (scope === "scores") return SCORE_FIELDS;
+	return FEEDBACK_FIELDS;
+}
+function discoverySource(scope) {
+	if (scope === "trace") return "root_scope r";
+	if (scope === "spans") return "current_spans s";
+	if (scope === "scores") return "current_scores s";
+	return "current_feedback s";
+}
+function discoveryCollections(scope) {
+	return scope === "trace" ? /* @__PURE__ */ new Set() : /* @__PURE__ */ new Set([scope]);
+}
+function compilePostgresTraceQueryObservedFields(schema, plan) {
+	const { ctes, values } = compilePostgresTraceScope(schema, plan, /* @__PURE__ */ new Set());
+	const searchParameter = values.length + 1;
+	const search = plan.search ? `AND strpos(lower('metadata.' || entry.key), lower($${searchParameter})) > 0` : "";
+	if (plan.search) values.push(plan.search);
+	values.push(plan.limit + 1);
+	return {
+		text: `WITH ${ctes.join(",\n")}
+SELECT 'metadata.' || entry.key AS path, count(*)::bigint AS occurrences
+FROM root_scope r
+CROSS JOIN LATERAL jsonb_each(CASE WHEN jsonb_typeof(r."metadataRaw") = 'object' THEN r."metadataRaw" ELSE '{}'::jsonb END) entry
+WHERE jsonb_typeof(entry.value) = 'string'
+  AND btrim(entry.value #>> '{}') <> ''
+  AND entry.key <> ''
+  AND strpos(entry.key, '.') = 0
+  AND octet_length('metadata.' || entry.key) <= ${_mastra_core_storage.TRACE_QUERY_MAX_PATH_BYTES}
+  AND octet_length(entry.value #>> '{}') <= ${_mastra_core_storage.TRACE_QUERY_MAX_STRING_BYTES}
+  ${search}
+GROUP BY entry.key
+ORDER BY occurrences DESC, ('metadata.' || entry.key) COLLATE "C" ASC
+LIMIT $${values.length}`,
+		values
+	};
+}
+function compilePostgresTraceQueryValues(schema, plan) {
+	const { ctes, values } = compilePostgresTraceScope(schema, plan, discoveryCollections(plan.predicateScope));
+	let field;
+	if (plan.predicateScope === "trace" && plan.path.startsWith("metadata.")) {
+		const keyParameter = `$${values.length + 1}`;
+		field = `COALESCE(
+      CASE WHEN jsonb_typeof(r."metadataSearch" -> ${keyParameter}) = 'string' THEN r."metadataSearch" ->> ${keyParameter} END,
+      CASE WHEN jsonb_typeof(r."metadataRaw" -> ${keyParameter}) = 'string' THEN NULLIF(btrim(r."metadataRaw" ->> ${keyParameter}), '') END
+    )`;
+		values.push(plan.path.slice(9));
+	} else field = fieldSql(discoveryRegistry(plan.predicateScope), plan.path);
+	const searchParameter = values.length + 1;
+	const search = plan.search ? `AND strpos(lower(value), lower($${searchParameter})) > 0` : "";
+	if (plan.search) values.push(plan.search);
+	values.push(plan.limit + 1);
+	return {
+		text: `WITH ${ctes.join(",\n")}, extracted AS (
+  SELECT ${field}::text AS value FROM ${discoverySource(plan.predicateScope)}
+)
+SELECT value, count(*)::bigint AS count
+FROM extracted
+WHERE value IS NOT NULL
+  AND octet_length(value) <= ${_mastra_core_storage.TRACE_QUERY_MAX_STRING_BYTES}
+  ${search}
+GROUP BY value
+ORDER BY count DESC, value COLLATE "C" ASC
+LIMIT $${values.length}`,
+		values
+	};
+}
 function asIsoTimestamp$1(value) {
 	if (value === null || value === void 0) throw new Error("Trace query returned a null timestamp");
 	return value instanceof Date ? value.toISOString() : new Date(value).toISOString();
@@ -17652,6 +17806,29 @@ async function runWithPostgresTraceQueryTimeout(client, timeoutMs, execute) {
 		throw error;
 	}
 }
+async function getTraceQueryObservedFields(client, schema, plan, timeoutMs) {
+	if (plan.predicateScope !== "trace") return {
+		observedFields: [],
+		observedFieldsTruncated: false
+	};
+	const query = compilePostgresTraceQueryObservedFields(schema, plan);
+	const rows = await runWithPostgresTraceQueryTimeout(client, timeoutMs, (transaction) => transaction.any(query.text, query.values));
+	return {
+		observedFields: rows.slice(0, plan.limit).map((row) => _mastra_core_storage.createTraceQueryObservedFieldDescriptor(String(row.path), Number(row.occurrences))),
+		observedFieldsTruncated: rows.length > plan.limit
+	};
+}
+async function getTraceQueryValues(client, schema, plan, timeoutMs) {
+	const query = compilePostgresTraceQueryValues(schema, plan);
+	const rows = await runWithPostgresTraceQueryTimeout(client, timeoutMs, (transaction) => transaction.any(query.text, query.values));
+	return _mastra_core_storage.getTraceQueryValuesResponseSchema.parse({
+		values: rows.slice(0, plan.limit).map((row) => ({
+			value: String(row.value),
+			count: Number(row.count)
+		})),
+		valuesTruncated: rows.length > plan.limit
+	});
+}
 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));
@@ -18598,6 +18775,7 @@ var ObservabilityStoragePostgresVNext = class ObservabilityStoragePostgresVNext
 			"metrics",
 			"logs",
 			"trace-query",
+			"trace-query-discovery",
 			"thread-query"
 		];
 		return [
@@ -18605,6 +18783,7 @@ var ObservabilityStoragePostgresVNext = class ObservabilityStoragePostgresVNext
 			"logs",
 			"delta-polling",
 			"trace-query",
+			"trace-query-discovery",
 			"thread-query"
 		];
 	}
@@ -18651,6 +18830,12 @@ var ObservabilityStoragePostgresVNext = class ObservabilityStoragePostgresVNext
 	async queryTraces(plan) {
 		return this.#run("QUERY_TRACES", () => queryTraces(this.#readClient, this.#schema, plan, this.#traceQueryTimeoutMs));
 	}
+	async getTraceQueryObservedFields(plan) {
+		return this.#run("GET_TRACE_QUERY_OBSERVED_FIELDS", () => getTraceQueryObservedFields(this.#readClient, this.#schema, plan, this.#traceQueryTimeoutMs));
+	}
+	async getTraceQueryValues(plan) {
+		return this.#run("GET_TRACE_QUERY_VALUES", () => getTraceQueryValues(this.#readClient, this.#schema, plan, this.#traceQueryTimeoutMs));
+	}
 	async queryThreads(plan) {
 		return this.#run("QUERY_THREADS", () => queryThreads(this.#readClient, this.#schema, plan, this.#traceQueryTimeoutMs));
 	}
@@ -23430,7 +23615,12 @@ var PgFactoryStorageOps = class {
 		const assignments = columns.map((column, i) => `"${column}" = $${i + 1}`).join(", ");
 		const filter = this.#buildWhere(schema, where, columns.length + 1);
 		const args = [...columns.map((column) => this.#serialize(this.#column(schema, column), set[column])), ...filter.args];
-		return (await queryable.query(`UPDATE "${schema.name}" SET ${assignments} WHERE ${filter.sql}`, args)).rowCount ?? 0;
+		try {
+			return (await queryable.query(`UPDATE "${schema.name}" SET ${assignments} WHERE ${filter.sql}`, args)).rowCount ?? 0;
+		} catch (error) {
+			if (isUniqueViolation(error)) throw new _mastra_core_storage.UniqueViolationError(collection, { cause: error });
+			throw error;
+		}
 	}
 	async deleteMany(collection, where) {
 		const schema = this.#schema(collection);