@mastra/pg 1.25.0 → 1.25.1-alpha.0

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.25.1-alpha.0"
 ---
 
 ## When to use

package/dist/docs/assets/SOURCE_MAP.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.25.0",
+  "version": "1.25.1-alpha.0",
   "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) {
@@ -23430,7 +23515,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);