@mastra/oracledb 0.2.3 → 0.2.4

package/dist/docs/SKILL.md

@@ -3,7 +3,7 @@ name: mastra-oracledb
 description: Documentation for @mastra/oracledb. Use when working with @mastra/oracledb APIs, configuration, or implementation.
 metadata:
   package: "@mastra/oracledb"
-  version: "0.2.3"
+  version: "0.2.4"
 ---
 
 ## When to use

package/dist/docs/assets/SOURCE_MAP.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.2.3",
+  "version": "0.2.4",
   "package": "@mastra/oracledb",
   "exports": {},
   "modules": {}

package/dist/docs/references/docs-memory-observational-memory.md

@@ -718,7 +718,7 @@ Buffered observations also include continuation hints, a suggested next response
 
 When message production outpaces the Observer, the `blockAfter` safety threshold allows activation to overshoot the retention target instead of using fewer chunks. Activation still uses no more chunks than needed to reach the target, and the default settings remain unaffected. A synchronous observation runs when the `messageTokens` threshold is reached and buffered activation didn't happen. Buffered activation usually preserves a minimum remaining context (the smaller of \~1k tokens or the configured retention floor), but a single buffered chunk that covers the whole pending window still activates and can leave less.
 
-Reflection works similarly, the Reflector runs in the background when observations reach a fraction of the reflection threshold.
+Reflection works similarly: the Reflector runs in the background when observations reach a fraction of the reflection threshold.
 
 ### Settings
 
@@ -809,6 +809,46 @@ const memory = new Memory({
 - `previousObserverTokens: 0` → omit previous observations completely.
 - `previousObserverTokens: false` → disable truncation and keep full previous observations.
 
+## Hooks
+
+OM exposes two kinds of config-level hooks on `observationalMemory.hooks`:
+
+- **Lifecycle hooks** (`onObservationStart`, `onObservationEnd`, `onReflectionStart`, `onReflectionEnd`) are telemetry callbacks. They receive `threadId`, `resourceId`, and `trigger`, and the end hooks also receive the model call's `usage`, `providerMetadata`, and any `error`. They never change what OM stores.
+- **Transform hooks** (`beforeObservation`, `afterObservation`, `beforeReflection`, `afterReflection`) intercept the data flowing through a cycle. Return `void` to pass the input through unchanged, or return a replacement to change what the Observer/Reflector sees or what gets persisted.
+
+```typescript
+const memory = new Memory({
+  options: {
+    observationalMemory: {
+      model: 'google/gemini-2.5-flash',
+      hooks: {
+        // Drop or redact messages before the Observer sees them.
+        beforeObservation: ({ messages }) => ({
+          messages: messages.filter(m => !isSensitive(m)),
+        }),
+        // Rewrite observations before they are persisted.
+        afterObservation: ({ observations, threadId }) => ({
+          observations: redact(observations),
+        }),
+        // Rewrite the text the Reflector condenses, or its output.
+        beforeReflection: ({ observations }) => ({
+          observations: stripInternalNotes(observations),
+        }),
+        afterReflection: async ({ observations, resourceId }) => {
+          await syncToExternalStore(resourceId, observations)
+        },
+      },
+    },
+  },
+})
+```
+
+Transform hooks are always awaited, on every path (manual `observe()`/`reflect()`, turn-synchronous observation, and async buffering). If `beforeObservation` returns an empty `messages` array, the Observer model call is skipped and the filtered messages are still marked as observed. If a transform hook throws, the cycle fails before committing the transformed observation or reflection text. This doesn't roll back extractor callbacks or other side effects that have already run.
+
+`afterObservation` and `afterReflection` replace only the observation or reflection text. They don't recompute or redact the separate structured extractor results stored in thread metadata. Reflection extraction and its callbacks run before `afterReflection`, so rewriting the reflection doesn't rerun those callbacks. Use extractor configuration and callbacks to control structured values. Don't treat an after hook as a redaction boundary for all cycle data.
+
+Because hooks receive `threadId` and `resourceId`, you can also use them to update [working memory](https://mastra.ai/docs/memory/working-memory) via `memory.updateWorkingMemory()` during a cycle. These external updates aren't atomic with the OM text commit.
+
 ## Migrating existing threads
 
 No manual migration needed. OM reads existing messages and observes them lazily when thresholds are exceeded.

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

@@ -650,7 +650,7 @@ Key metadata considerations:
 
 ## Deleting vectors
 
-When building RAG applications, you often need to clean up stale vectors when documents are deleted or updated. Mastra provides the `deleteVectors` method that supports deleting vectors by metadata filters, making it straightforward to remove all embeddings associated with a specific document.
+Use `deleteVectors` with a metadata filter to remove embeddings associated with a document. This is useful for cleaning up stale vectors after a document is deleted or updated.
 
 ### Delete by Metadata Filter
 

package/dist/index.cjs

@@ -6106,6 +6106,34 @@ async function batchCreateScores(db, _schemaName, args) {
 		throw storageError("BATCH_CREATE_SCORES", "FAILED", { count: args.scores.length }, error, _mastra_core_error.ErrorCategory.USER);
 	}
 }
+/**
+* Delete scores by scoreId, optionally scoped to a tenant (`organizationId` /
+* `resourceId` are ANDed into the predicate so a scoped caller can never
+* delete another tenant's rows).
+*/
+async function deleteScores(db, schemaName, args) {
+	if (args.scoreIds.length === 0) return;
+	const binds = {};
+	const placeholders = args.scoreIds.map((scoreId, index) => {
+		binds[`scoreId${index}`] = scoreId;
+		return `:scoreId${index}`;
+	});
+	const conditions = [`${scoreQcol(void 0, "id")} IN (${placeholders.join(", ")})`];
+	if (args.organizationId !== void 0) {
+		binds.organizationId = args.organizationId;
+		const organizationIdColumn = scoreQcol(void 0, "organizationId");
+		conditions.push(`(${organizationIdColumn} = :organizationId OR (${organizationIdColumn} IS NULL AND JSON_VALUE(${scoreQcol(void 0, "metadata")}, '$.organizationId' RETURNING VARCHAR2(4000) NULL ON ERROR) = :organizationId))`);
+	}
+	if (args.resourceId !== void 0) {
+		binds.resourceId = args.resourceId;
+		conditions.push(`${scoreQcol(void 0, "resourceId")} = :resourceId`);
+	}
+	try {
+		await db.none(`DELETE FROM ${qualifyName(_mastra_core_storage.TABLE_SCORERS, schemaName)} WHERE ${conditions.join(" AND ")}`, binds);
+	} catch (error) {
+		throw storageError("DELETE_SCORES", "FAILED", { count: args.scoreIds.length }, error, _mastra_core_error.ErrorCategory.USER);
+	}
+}
 async function getScoreById(db, schemaName, scoreId) {
 	try {
 		const row = await db.oneOrNone(`${scoreSelect("s")} FROM ${qualifyName(_mastra_core_storage.TABLE_SCORERS, schemaName)} s WHERE ${scoreQcol("s", "id")} = :scoreId`, { scoreId });
@@ -6145,7 +6173,7 @@ function transformObservabilityScoreRow(row) {
 		rootEntityId: optionalString$1(metadata?.rootEntityId),
 		rootEntityName: optionalString$1(metadata?.rootEntityName),
 		userId: optionalString$1(metadata?.userId),
-		organizationId: optionalString$1(metadata?.organizationId),
+		organizationId: optionalString$1(row.organizationId) ?? optionalString$1(metadata?.organizationId),
 		resourceId: optionalString$1(row.resourceId),
 		runId: optionalString$1(row.runId),
 		sessionId: optionalString$1(metadata?.sessionId),
@@ -6233,6 +6261,7 @@ function scoreRecordToTableRecord(score) {
 		entityId: score.entityId,
 		source,
 		resourceId: score.resourceId,
+		organizationId: score.organizationId,
 		threadId: score.threadId,
 		createdAt: timestamp,
 		updatedAt: timestamp
@@ -6755,6 +6784,9 @@ var ObservabilityOracle = class ObservabilityOracle extends _mastra_core_storage
 	async batchCreateScores(args) {
 		return batchCreateScores(this.db, this.schemaName, args);
 	}
+	async deleteScores(args) {
+		return deleteScores(this.db, this.schemaName, args);
+	}
 	async getScoreById(scoreId) {
 		return getScoreById(this.db, this.schemaName, scoreId);
 	}