@mastra/memory 1.31.0-alpha.1 → 1.31.0-alpha.2

package/dist/docs/SKILL.md

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

package/dist/docs/assets/SOURCE_MAP.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.31.0-alpha.1",
+  "version": "1.31.0-alpha.2",
   "package": "@mastra/memory",
   "exports": {},
   "modules": {

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

@@ -849,6 +849,39 @@ Transform hooks are always awaited, on every path (manual `observe()`/`reflect()
 
 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.
 
+### Redact skill results
+
+Agent skills are injected into the agent as tools (`skill`, `skill_search`, `skill_read`). Their results contain the skill's full instructions or file contents, so without redaction the Observer re-observes that text every time a skill is used. `skillResultRedactor()` is a ready-made `beforeObservation` hook that replaces those results with a placeholder and leaves everything else in place. The tool call survives, so the Observer still records which skill was used and what it was called with.
+
+```typescript
+import { Memory } from '@mastra/memory'
+import { skillResultRedactor } from '@mastra/memory/hooks'
+
+const memory = new Memory({
+  options: {
+    observationalMemory: {
+      model: 'google/gemini-2.5-flash',
+      hooks: {
+        beforeObservation: skillResultRedactor(),
+      },
+    },
+  },
+})
+```
+
+Pass `toolNames` to redact results from a different set of tools. Because a hook is a function over the messages, it composes with your own transforms by chaining the outputs. Await each chained hook so an async one isn't discarded:
+
+```typescript
+const dropSkillResults = skillResultRedactor()
+
+hooks: {
+  beforeObservation: async input => {
+    const messages = (await dropSkillResults(input))?.messages ?? input.messages
+    return { messages: messages.filter(m => m.role !== 'signal') }
+  },
+}
+```
+
 ## Migrating existing threads
 
 No manual migration needed. OM reads existing messages and observes them lazily when thresholds are exceeded.

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

@@ -73,9 +73,9 @@ OM performs thresholding with fast local token estimation. Text uses `tokenx`, a
 
 **observation.maxTokensPerBatch** (`number`): Maximum tokens per batch when observing multiple threads in resource scope. Threads are chunked into batches of this size and processed in parallel. Lower values mean more parallelism but more API calls.
 
-**observation.modelSettings** (`ObservationalMemoryModelSettings`): Model settings for the Observer agent. The maxOutputTokens: 100\_000 default is only applied with default model selection (no model set, "default", or a ModelByInputTokens selector). Custom models get no maxOutputTokens default.
+**observation.modelSettings** (`ObservationalMemoryModelSettings`): Model settings for the Observer agent. The temperature: 0.3 default is only applied when the resolved model is known to support temperature. The maxOutputTokens: 100\_000 default is only applied with default model selection (no model set, "default", or a ModelByInputTokens selector). Custom models get no maxOutputTokens default.
 
-**observation.modelSettings.temperature** (`number`): Temperature for generation. Lower values produce more consistent output.
+**observation.modelSettings.temperature** (`number`): Temperature for generation. Lower values produce more consistent output. The 0.3 default is only applied when the resolved model is known to support temperature.
 
 **observation.modelSettings.maxOutputTokens** (`number`): Maximum output tokens. Set high to prevent truncation of observations. The 100000 default is only applied with default model selection; custom models get no default.
 
@@ -107,9 +107,9 @@ OM performs thresholding with fast local token estimation. Text uses `tokenx`, a
 
 **reflection.observationTokens** (`number`): Token count of observations that triggers reflection. When observation tokens exceed this threshold, the Reflector agent is called to condense them.
 
-**reflection.modelSettings** (`ObservationalMemoryModelSettings`): Model settings for the Reflector agent. The maxOutputTokens: 100\_000 default is only applied with default model selection (no model set, "default", or a ModelByInputTokens selector). Custom models get no maxOutputTokens default.
+**reflection.modelSettings** (`ObservationalMemoryModelSettings`): Model settings for the Reflector agent. The temperature: 0 default is only applied when the resolved model is known to support temperature. The maxOutputTokens: 100\_000 default is only applied with default model selection (no model set, "default", or a ModelByInputTokens selector). Custom models get no maxOutputTokens default.
 
-**reflection.modelSettings.temperature** (`number`): Temperature for generation. Lower values produce more consistent output.
+**reflection.modelSettings.temperature** (`number`): Temperature for generation. Lower values produce more consistent output. The 0 default is only applied when the resolved model is known to support temperature.
 
 **reflection.modelSettings.maxOutputTokens** (`number`): Maximum output tokens. Set high to prevent truncation of observations. The 100000 default is only applied with default model selection; custom models get no default.
 
@@ -883,6 +883,36 @@ const selector = new ModelByInputTokens({
 
 **getThresholds** (`() => number[]`): Returns the configured thresholds in ascending order. Useful for introspection.
 
+### skillResultRedactor
+
+`skillResultRedactor` builds a `beforeObservation` transform hook that redacts the results of the built-in Agent Skills tools (`skill`, `skill_search`, and `skill_read`) before the Observer model sees them. Each result is replaced with a placeholder while the tool call is kept, so the Observer still records which skill was used and what it was called with, without the skill text.
+
+```typescript
+import { Memory } from '@mastra/memory'
+import { skillResultRedactor } from '@mastra/memory/hooks'
+
+const memory = new Memory({
+  options: {
+    observationalMemory: {
+      model: 'google/gemini-2.5-flash',
+      hooks: {
+        beforeObservation: skillResultRedactor(),
+      },
+    },
+  },
+})
+```
+
+#### Parameters
+
+**toolNames** (`readonly string[]`): Tool names whose results are redacted. Defaults to the built-in skill tools: skill, skill\_search, and skill\_read. Use this to redact a different set of tool results.
+
+#### Returns
+
+`(input: { messages: MastraDBMessage[] } & ObserveHookContext) => { messages: MastraDBMessage[] } | undefined`
+
+The hook returns messages with matching tool results replaced by a placeholder, or `undefined` when no message matched (which passes the payload through unchanged). Tool calls, arguments, and every other message are left as they are.
+
 ### Related
 
 - [Observational Memory](https://mastra.ai/docs/memory/observational-memory)

package/dist/hooks.cjs

@@ -0,0 +1,158 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/processors/observational-memory/hooks.ts
+/**
+* Tool ids of the built-in Agent Skills tools created by `createSkillTools()`
+* in `@mastra/core` (`packages/core/src/workspace/skills/tools.ts`).
+*/
+const SKILL_TOOL_NAMES = [
+	"skill",
+	"skill_search",
+	"skill_read"
+];
+/**
+* Written in place of a redacted tool result. The Observer still records the
+* call and its outcome; only the payload is replaced.
+*/
+const REDACTED_TOOL_RESULT = "[tool result omitted]";
+function isRedactableToolResult(part, toolNames) {
+	if (part?.type !== "tool-invocation") return false;
+	if (part.toolInvocation.state !== "result") return false;
+	const toolName = part.toolInvocation.toolName;
+	if (typeof toolName !== "string" || !toolNames.has(toolName)) return false;
+	return part.toolInvocation.result !== void 0 || hasStoredModelOutput(part);
+}
+function hasStoredModelOutput(part) {
+	if (part?.type !== "tool-invocation") return false;
+	const mastra = part.providerMetadata?.mastra;
+	return !!mastra && typeof mastra === "object" && "modelOutput" in mastra;
+}
+/**
+* Legacy messages carry tool calls in a second `toolInvocations` array, which
+* `AIV5Adapter` falls back to when `parts` holds no tool invocation
+* (`AIV5Adapter.ts:264`). Leave it alone and a redacted result can be
+* resurrected from that array downstream. Only rewritten when it actually
+* holds a matching result, so non-legacy messages keep their array by
+* reference.
+*/
+function redactLegacyToolInvocations(toolInvocations, toolNames) {
+	if (!Array.isArray(toolInvocations)) return {
+		toolInvocations,
+		changed: false
+	};
+	let changed = false;
+	const next = toolInvocations.map((invocation) => {
+		if (invocation?.state !== "result" || typeof invocation.toolName !== "string" || !toolNames.has(invocation.toolName) || invocation.result === void 0) return invocation;
+		changed = true;
+		return {
+			...invocation,
+			result: REDACTED_TOOL_RESULT
+		};
+	});
+	return changed ? {
+		toolInvocations: next,
+		changed: true
+	} : {
+		toolInvocations,
+		changed: false
+	};
+}
+/**
+* Replace the result payload of a tool invocation with a placeholder, keeping
+* the call's identity (tool name, arguments, terminal state). The Observer
+* still records that the tool ran and what it was called with.
+*/
+function redactToolResult(part) {
+	const redacted = {
+		...part,
+		toolInvocation: {
+			...part.toolInvocation,
+			result: REDACTED_TOOL_RESULT
+		}
+	};
+	if (hasStoredModelOutput(part)) {
+		const providerMetadata = part.providerMetadata ?? {};
+		const mastra = providerMetadata.mastra;
+		return {
+			...redacted,
+			providerMetadata: {
+				...providerMetadata,
+				mastra: {
+					...mastra,
+					modelOutput: REDACTED_TOOL_RESULT
+				}
+			}
+		};
+	}
+	return redacted;
+}
+/**
+* Build a `beforeObservation` hook that keeps Agent Skills results out of the
+* Observer payload.
+*
+* The `skill` tool returns a skill's instructions verbatim as its result, and
+* `skill_read` / `skill_search` return skill file contents, so without redaction
+* the Observer re-observes the full skill text every time a skill is used.
+* `skillResultRedactor()` replaces the result payload with a placeholder and
+* leaves the tool call in place, so the Observer still records which skill was
+* used without the skill text.
+*
+* ```typescript
+* const memory = new Memory({
+*   options: {
+*     observationalMemory: {
+*       model: 'google/gemini-2.5-flash',
+*       hooks: { beforeObservation: skillResultRedactor() },
+*     },
+*   },
+* });
+* ```
+*
+* Because a hook is a function over the messages, this composes with your own
+* transforms by chaining the outputs. Await each chained hook so an async one
+* doesn't resolve to a promise that gets discarded:
+*
+* ```typescript
+* const dropSkillResults = skillResultRedactor();
+*
+* hooks: {
+*   beforeObservation: async input => {
+*     const messages = (await dropSkillResults(input))?.messages ?? input.messages;
+*     return { messages: messages.filter(m => m.role !== 'signal') };
+*   },
+* }
+* ```
+*/
+function skillResultRedactor(options) {
+	const toolNames = new Set(options?.toolNames ?? SKILL_TOOL_NAMES);
+	return ({ messages }) => {
+		let changed = false;
+		const transformed = messages.map((message) => {
+			const parts = message.content?.parts;
+			let messageChanged = false;
+			const legacy = redactLegacyToolInvocations(message.content?.toolInvocations, toolNames);
+			if (legacy.changed) messageChanged = true;
+			let nextParts = parts;
+			if (Array.isArray(parts)) nextParts = parts.map((part) => {
+				if (!isRedactableToolResult(part, toolNames)) return part;
+				messageChanged = true;
+				return redactToolResult(part);
+			});
+			if (!messageChanged) return message;
+			changed = true;
+			return {
+				...message,
+				content: {
+					...message.content,
+					parts: nextParts,
+					toolInvocations: legacy.toolInvocations
+				}
+			};
+		});
+		return changed ? { messages: transformed } : void 0;
+	};
+}
+//#endregion
+exports.SKILL_TOOL_NAMES = SKILL_TOOL_NAMES;
+exports.skillResultRedactor = skillResultRedactor;
+
+//# sourceMappingURL=hooks.cjs.map

package/dist/hooks.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.cjs","names":[],"sources":["../src/processors/observational-memory/hooks.ts"],"sourcesContent":["import type { MastraDBMessage } from '@mastra/core/agent';\n\nimport type { ObserveTransformHooks } from './types';\n\ntype MessagePart = MastraDBMessage['content']['parts'][number];\n\ntype ToolInvocationPart = Extract<MessagePart, { type: 'tool-invocation' }>;\n\ntype BeforeObservationHook = NonNullable<ObserveTransformHooks['beforeObservation']>;\n\ntype ToolInvocations = NonNullable<MastraDBMessage['content']['toolInvocations']>;\ntype StoredToolInvocation = ToolInvocations[number];\n\n/**\n * Tool ids of the built-in Agent Skills tools created by `createSkillTools()`\n * in `@mastra/core` (`packages/core/src/workspace/skills/tools.ts`).\n */\nexport const SKILL_TOOL_NAMES = ['skill', 'skill_search', 'skill_read'] as const;\n\n/**\n * A `beforeObservation` transform hook: it only rewrites messages. It receives\n * the messages about to be sent to the Observer and returns `{ messages }` to\n * replace them, or `undefined` to pass the payload through unchanged.\n */\nexport type ObserverMessageTransform = (\n  ...args: Parameters<BeforeObservationHook>\n) => { messages: MastraDBMessage[] } | undefined;\n\nexport interface SkillResultRedactorOptions {\n  /**\n   * Tool names whose results are redacted. Defaults to\n   * {@link SKILL_TOOL_NAMES}.\n   */\n  toolNames?: readonly string[];\n}\n\n/**\n * Written in place of a redacted tool result. The Observer still records the\n * call and its outcome; only the payload is replaced.\n */\nconst REDACTED_TOOL_RESULT = '[tool result omitted]';\n\nfunction isRedactableToolResult(part: MessagePart, toolNames: Set<string>): part is ToolInvocationPart {\n  if (part?.type !== 'tool-invocation') return false;\n  // Only `state: 'result'` parts render a `Tool Result <name>` body, so only\n  // those carry the tool's output.\n  if (part.toolInvocation.state !== 'result') return false;\n  const toolName = part.toolInvocation.toolName;\n  if (typeof toolName !== 'string' || !toolNames.has(toolName)) return false;\n  // Nothing to redact when the tool returned no payload.\n  return part.toolInvocation.result !== undefined || hasStoredModelOutput(part);\n}\n\nfunction hasStoredModelOutput(part: MessagePart): boolean {\n  if (part?.type !== 'tool-invocation') return false;\n  const mastra = part.providerMetadata?.mastra;\n  return !!mastra && typeof mastra === 'object' && 'modelOutput' in mastra;\n}\n\n/**\n * Legacy messages carry tool calls in a second `toolInvocations` array, which\n * `AIV5Adapter` falls back to when `parts` holds no tool invocation\n * (`AIV5Adapter.ts:264`). Leave it alone and a redacted result can be\n * resurrected from that array downstream. Only rewritten when it actually\n * holds a matching result, so non-legacy messages keep their array by\n * reference.\n */\nfunction redactLegacyToolInvocations(\n  toolInvocations: ToolInvocations | undefined,\n  toolNames: Set<string>,\n): { toolInvocations: ToolInvocations | undefined; changed: boolean } {\n  if (!Array.isArray(toolInvocations)) return { toolInvocations, changed: false };\n\n  let changed = false;\n  const next: ToolInvocations = toolInvocations.map(invocation => {\n    if (\n      invocation?.state !== 'result' ||\n      typeof invocation.toolName !== 'string' ||\n      !toolNames.has(invocation.toolName) ||\n      invocation.result === undefined\n    ) {\n      return invocation;\n    }\n    changed = true;\n    return { ...invocation, result: REDACTED_TOOL_RESULT } as StoredToolInvocation;\n  });\n\n  return changed ? { toolInvocations: next, changed: true } : { toolInvocations, changed: false };\n}\n\n/**\n * Replace the result payload of a tool invocation with a placeholder, keeping\n * the call's identity (tool name, arguments, terminal state). The Observer\n * still records that the tool ran and what it was called with.\n */\nfunction redactToolResult(part: ToolInvocationPart): ToolInvocationPart {\n  const redacted: ToolInvocationPart = {\n    ...part,\n    toolInvocation: { ...part.toolInvocation, result: REDACTED_TOOL_RESULT },\n  };\n\n  // `resolveToolResultValue` prefers `providerMetadata.mastra.modelOutput` over\n  // `toolInvocation.result`, so a stored model output has to be replaced too.\n  // Copy rather than mutate: these message objects are shared with the stored\n  // history, which keeps the full result.\n  if (hasStoredModelOutput(part)) {\n    const providerMetadata = part.providerMetadata ?? {};\n    const mastra = providerMetadata.mastra as Record<string, unknown>;\n    return {\n      ...redacted,\n      providerMetadata: { ...providerMetadata, mastra: { ...mastra, modelOutput: REDACTED_TOOL_RESULT } },\n    };\n  }\n\n  return redacted;\n}\n\n/**\n * Build a `beforeObservation` hook that keeps Agent Skills results out of the\n * Observer payload.\n *\n * The `skill` tool returns a skill's instructions verbatim as its result, and\n * `skill_read` / `skill_search` return skill file contents, so without redaction\n * the Observer re-observes the full skill text every time a skill is used.\n * `skillResultRedactor()` replaces the result payload with a placeholder and\n * leaves the tool call in place, so the Observer still records which skill was\n * used without the skill text.\n *\n * ```typescript\n * const memory = new Memory({\n *   options: {\n *     observationalMemory: {\n *       model: 'google/gemini-2.5-flash',\n *       hooks: { beforeObservation: skillResultRedactor() },\n *     },\n *   },\n * });\n * ```\n *\n * Because a hook is a function over the messages, this composes with your own\n * transforms by chaining the outputs. Await each chained hook so an async one\n * doesn't resolve to a promise that gets discarded:\n *\n * ```typescript\n * const dropSkillResults = skillResultRedactor();\n *\n * hooks: {\n *   beforeObservation: async input => {\n *     const messages = (await dropSkillResults(input))?.messages ?? input.messages;\n *     return { messages: messages.filter(m => m.role !== 'signal') };\n *   },\n * }\n * ```\n */\nexport function skillResultRedactor(options?: SkillResultRedactorOptions): ObserverMessageTransform {\n  const toolNames = new Set<string>(options?.toolNames ?? SKILL_TOOL_NAMES);\n\n  return ({ messages }) => {\n    let changed = false;\n\n    const transformed = messages.map(message => {\n      const parts = message.content?.parts;\n\n      let messageChanged = false;\n\n      // Legacy-only messages carry no `parts` at all, so this runs before the\n      // parts check rather than being skipped by it.\n      const legacy = redactLegacyToolInvocations(message.content?.toolInvocations, toolNames);\n      if (legacy.changed) messageChanged = true;\n\n      let nextParts = parts;\n      if (Array.isArray(parts)) {\n        nextParts = parts.map(part => {\n          if (!isRedactableToolResult(part, toolNames)) return part;\n          messageChanged = true;\n          return redactToolResult(part);\n        });\n      }\n\n      if (!messageChanged) return message;\n\n      changed = true;\n      return {\n        ...message,\n        content: { ...message.content, parts: nextParts, toolInvocations: legacy.toolInvocations },\n      };\n    });\n\n    // `undefined` means \"pass through unchanged\", so leave untouched payloads alone.\n    return changed ? { messages: transformed } : undefined;\n  };\n}\n"],"mappings":";;;;;;AAiBA,MAAa,mBAAmB;CAAC;CAAS;CAAgB;AAAY;;;;;AAuBtE,MAAM,uBAAuB;AAE7B,SAAS,uBAAuB,MAAmB,WAAoD;CACrG,IAAI,MAAM,SAAS,mBAAmB,OAAO;CAG7C,IAAI,KAAK,eAAe,UAAU,UAAU,OAAO;CACnD,MAAM,WAAW,KAAK,eAAe;CACrC,IAAI,OAAO,aAAa,YAAY,CAAC,UAAU,IAAI,QAAQ,GAAG,OAAO;CAErE,OAAO,KAAK,eAAe,WAAW,KAAA,KAAa,qBAAqB,IAAI;AAC9E;AAEA,SAAS,qBAAqB,MAA4B;CACxD,IAAI,MAAM,SAAS,mBAAmB,OAAO;CAC7C,MAAM,SAAS,KAAK,kBAAkB;CACtC,OAAO,CAAC,CAAC,UAAU,OAAO,WAAW,YAAY,iBAAiB;AACpE;;;;;;;;;AAUA,SAAS,4BACP,iBACA,WACoE;CACpE,IAAI,CAAC,MAAM,QAAQ,eAAe,GAAG,OAAO;EAAE;EAAiB,SAAS;CAAM;CAE9E,IAAI,UAAU;CACd,MAAM,OAAwB,gBAAgB,KAAI,eAAc;EAC9D,IACE,YAAY,UAAU,YACtB,OAAO,WAAW,aAAa,YAC/B,CAAC,UAAU,IAAI,WAAW,QAAQ,KAClC,WAAW,WAAW,KAAA,GAEtB,OAAO;EAET,UAAU;EACV,OAAO;GAAE,GAAG;GAAY,QAAQ;EAAqB;CACvD,CAAC;CAED,OAAO,UAAU;EAAE,iBAAiB;EAAM,SAAS;CAAK,IAAI;EAAE;EAAiB,SAAS;CAAM;AAChG;;;;;;AAOA,SAAS,iBAAiB,MAA8C;CACtE,MAAM,WAA+B;EACnC,GAAG;EACH,gBAAgB;GAAE,GAAG,KAAK;GAAgB,QAAQ;EAAqB;CACzE;CAMA,IAAI,qBAAqB,IAAI,GAAG;EAC9B,MAAM,mBAAmB,KAAK,oBAAoB,CAAC;EACnD,MAAM,SAAS,iBAAiB;EAChC,OAAO;GACL,GAAG;GACH,kBAAkB;IAAE,GAAG;IAAkB,QAAQ;KAAE,GAAG;KAAQ,aAAa;IAAqB;GAAE;EACpG;CACF;CAEA,OAAO;AACT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCA,SAAgB,oBAAoB,SAAgE;CAClG,MAAM,YAAY,IAAI,IAAY,SAAS,aAAa,gBAAgB;CAExE,QAAQ,EAAE,eAAe;EACvB,IAAI,UAAU;EAEd,MAAM,cAAc,SAAS,KAAI,YAAW;GAC1C,MAAM,QAAQ,QAAQ,SAAS;GAE/B,IAAI,iBAAiB;GAIrB,MAAM,SAAS,4BAA4B,QAAQ,SAAS,iBAAiB,SAAS;GACtF,IAAI,OAAO,SAAS,iBAAiB;GAErC,IAAI,YAAY;GAChB,IAAI,MAAM,QAAQ,KAAK,GACrB,YAAY,MAAM,KAAI,SAAQ;IAC5B,IAAI,CAAC,uBAAuB,MAAM,SAAS,GAAG,OAAO;IACrD,iBAAiB;IACjB,OAAO,iBAAiB,IAAI;GAC9B,CAAC;GAGH,IAAI,CAAC,gBAAgB,OAAO;GAE5B,UAAU;GACV,OAAO;IACL,GAAG;IACH,SAAS;KAAE,GAAG,QAAQ;KAAS,OAAO;KAAW,iBAAiB,OAAO;IAAgB;GAC3F;EACF,CAAC;EAGD,OAAO,UAAU,EAAE,UAAU,YAAY,IAAI,KAAA;CAC/C;AACF"}

package/dist/hooks.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Prebuilt Observational Memory transform hooks.
+ *
+ * These are ready-made `beforeObservation` hooks you can pass to
+ * `observationalMemory.hooks`, so common redaction needs don't require writing
+ * the hook yourself.
+ *
+ * @example
+ * ```typescript
+ * import { Memory } from '@mastra/memory';
+ * import { skillResultRedactor } from '@mastra/memory/hooks';
+ *
+ * const memory = new Memory({
+ *   options: {
+ *     observationalMemory: {
+ *       model: 'google/gemini-2.5-flash',
+ *       hooks: { beforeObservation: skillResultRedactor() },
+ *     },
+ *   },
+ * });
+ * ```
+ */
+export { skillResultRedactor, SKILL_TOOL_NAMES } from './processors/observational-memory/hooks.js';
+export type { ObserverMessageTransform, SkillResultRedactorOptions } from './processors/observational-memory/hooks.js';
+//# sourceMappingURL=hooks.d.ts.map

package/dist/hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../src/hooks.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,OAAO,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,MAAM,yCAAyC,CAAC;AAChG,YAAY,EAAE,wBAAwB,EAAE,0BAA0B,EAAE,MAAM,yCAAyC,CAAC"}

package/dist/hooks.js

@@ -0,0 +1,156 @@
+//#region src/processors/observational-memory/hooks.ts
+/**
+* Tool ids of the built-in Agent Skills tools created by `createSkillTools()`
+* in `@mastra/core` (`packages/core/src/workspace/skills/tools.ts`).
+*/
+const SKILL_TOOL_NAMES = [
+	"skill",
+	"skill_search",
+	"skill_read"
+];
+/**
+* Written in place of a redacted tool result. The Observer still records the
+* call and its outcome; only the payload is replaced.
+*/
+const REDACTED_TOOL_RESULT = "[tool result omitted]";
+function isRedactableToolResult(part, toolNames) {
+	if (part?.type !== "tool-invocation") return false;
+	if (part.toolInvocation.state !== "result") return false;
+	const toolName = part.toolInvocation.toolName;
+	if (typeof toolName !== "string" || !toolNames.has(toolName)) return false;
+	return part.toolInvocation.result !== void 0 || hasStoredModelOutput(part);
+}
+function hasStoredModelOutput(part) {
+	if (part?.type !== "tool-invocation") return false;
+	const mastra = part.providerMetadata?.mastra;
+	return !!mastra && typeof mastra === "object" && "modelOutput" in mastra;
+}
+/**
+* Legacy messages carry tool calls in a second `toolInvocations` array, which
+* `AIV5Adapter` falls back to when `parts` holds no tool invocation
+* (`AIV5Adapter.ts:264`). Leave it alone and a redacted result can be
+* resurrected from that array downstream. Only rewritten when it actually
+* holds a matching result, so non-legacy messages keep their array by
+* reference.
+*/
+function redactLegacyToolInvocations(toolInvocations, toolNames) {
+	if (!Array.isArray(toolInvocations)) return {
+		toolInvocations,
+		changed: false
+	};
+	let changed = false;
+	const next = toolInvocations.map((invocation) => {
+		if (invocation?.state !== "result" || typeof invocation.toolName !== "string" || !toolNames.has(invocation.toolName) || invocation.result === void 0) return invocation;
+		changed = true;
+		return {
+			...invocation,
+			result: REDACTED_TOOL_RESULT
+		};
+	});
+	return changed ? {
+		toolInvocations: next,
+		changed: true
+	} : {
+		toolInvocations,
+		changed: false
+	};
+}
+/**
+* Replace the result payload of a tool invocation with a placeholder, keeping
+* the call's identity (tool name, arguments, terminal state). The Observer
+* still records that the tool ran and what it was called with.
+*/
+function redactToolResult(part) {
+	const redacted = {
+		...part,
+		toolInvocation: {
+			...part.toolInvocation,
+			result: REDACTED_TOOL_RESULT
+		}
+	};
+	if (hasStoredModelOutput(part)) {
+		const providerMetadata = part.providerMetadata ?? {};
+		const mastra = providerMetadata.mastra;
+		return {
+			...redacted,
+			providerMetadata: {
+				...providerMetadata,
+				mastra: {
+					...mastra,
+					modelOutput: REDACTED_TOOL_RESULT
+				}
+			}
+		};
+	}
+	return redacted;
+}
+/**
+* Build a `beforeObservation` hook that keeps Agent Skills results out of the
+* Observer payload.
+*
+* The `skill` tool returns a skill's instructions verbatim as its result, and
+* `skill_read` / `skill_search` return skill file contents, so without redaction
+* the Observer re-observes the full skill text every time a skill is used.
+* `skillResultRedactor()` replaces the result payload with a placeholder and
+* leaves the tool call in place, so the Observer still records which skill was
+* used without the skill text.
+*
+* ```typescript
+* const memory = new Memory({
+*   options: {
+*     observationalMemory: {
+*       model: 'google/gemini-2.5-flash',
+*       hooks: { beforeObservation: skillResultRedactor() },
+*     },
+*   },
+* });
+* ```
+*
+* Because a hook is a function over the messages, this composes with your own
+* transforms by chaining the outputs. Await each chained hook so an async one
+* doesn't resolve to a promise that gets discarded:
+*
+* ```typescript
+* const dropSkillResults = skillResultRedactor();
+*
+* hooks: {
+*   beforeObservation: async input => {
+*     const messages = (await dropSkillResults(input))?.messages ?? input.messages;
+*     return { messages: messages.filter(m => m.role !== 'signal') };
+*   },
+* }
+* ```
+*/
+function skillResultRedactor(options) {
+	const toolNames = new Set(options?.toolNames ?? SKILL_TOOL_NAMES);
+	return ({ messages }) => {
+		let changed = false;
+		const transformed = messages.map((message) => {
+			const parts = message.content?.parts;
+			let messageChanged = false;
+			const legacy = redactLegacyToolInvocations(message.content?.toolInvocations, toolNames);
+			if (legacy.changed) messageChanged = true;
+			let nextParts = parts;
+			if (Array.isArray(parts)) nextParts = parts.map((part) => {
+				if (!isRedactableToolResult(part, toolNames)) return part;
+				messageChanged = true;
+				return redactToolResult(part);
+			});
+			if (!messageChanged) return message;
+			changed = true;
+			return {
+				...message,
+				content: {
+					...message.content,
+					parts: nextParts,
+					toolInvocations: legacy.toolInvocations
+				}
+			};
+		});
+		return changed ? { messages: transformed } : void 0;
+	};
+}
+//#endregion
+export { SKILL_TOOL_NAMES, skillResultRedactor };
+
+//# sourceMappingURL=hooks.js.map

package/dist/hooks.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.js","names":[],"sources":["../src/processors/observational-memory/hooks.ts"],"sourcesContent":["import type { MastraDBMessage } from '@mastra/core/agent';\n\nimport type { ObserveTransformHooks } from './types';\n\ntype MessagePart = MastraDBMessage['content']['parts'][number];\n\ntype ToolInvocationPart = Extract<MessagePart, { type: 'tool-invocation' }>;\n\ntype BeforeObservationHook = NonNullable<ObserveTransformHooks['beforeObservation']>;\n\ntype ToolInvocations = NonNullable<MastraDBMessage['content']['toolInvocations']>;\ntype StoredToolInvocation = ToolInvocations[number];\n\n/**\n * Tool ids of the built-in Agent Skills tools created by `createSkillTools()`\n * in `@mastra/core` (`packages/core/src/workspace/skills/tools.ts`).\n */\nexport const SKILL_TOOL_NAMES = ['skill', 'skill_search', 'skill_read'] as const;\n\n/**\n * A `beforeObservation` transform hook: it only rewrites messages. It receives\n * the messages about to be sent to the Observer and returns `{ messages }` to\n * replace them, or `undefined` to pass the payload through unchanged.\n */\nexport type ObserverMessageTransform = (\n  ...args: Parameters<BeforeObservationHook>\n) => { messages: MastraDBMessage[] } | undefined;\n\nexport interface SkillResultRedactorOptions {\n  /**\n   * Tool names whose results are redacted. Defaults to\n   * {@link SKILL_TOOL_NAMES}.\n   */\n  toolNames?: readonly string[];\n}\n\n/**\n * Written in place of a redacted tool result. The Observer still records the\n * call and its outcome; only the payload is replaced.\n */\nconst REDACTED_TOOL_RESULT = '[tool result omitted]';\n\nfunction isRedactableToolResult(part: MessagePart, toolNames: Set<string>): part is ToolInvocationPart {\n  if (part?.type !== 'tool-invocation') return false;\n  // Only `state: 'result'` parts render a `Tool Result <name>` body, so only\n  // those carry the tool's output.\n  if (part.toolInvocation.state !== 'result') return false;\n  const toolName = part.toolInvocation.toolName;\n  if (typeof toolName !== 'string' || !toolNames.has(toolName)) return false;\n  // Nothing to redact when the tool returned no payload.\n  return part.toolInvocation.result !== undefined || hasStoredModelOutput(part);\n}\n\nfunction hasStoredModelOutput(part: MessagePart): boolean {\n  if (part?.type !== 'tool-invocation') return false;\n  const mastra = part.providerMetadata?.mastra;\n  return !!mastra && typeof mastra === 'object' && 'modelOutput' in mastra;\n}\n\n/**\n * Legacy messages carry tool calls in a second `toolInvocations` array, which\n * `AIV5Adapter` falls back to when `parts` holds no tool invocation\n * (`AIV5Adapter.ts:264`). Leave it alone and a redacted result can be\n * resurrected from that array downstream. Only rewritten when it actually\n * holds a matching result, so non-legacy messages keep their array by\n * reference.\n */\nfunction redactLegacyToolInvocations(\n  toolInvocations: ToolInvocations | undefined,\n  toolNames: Set<string>,\n): { toolInvocations: ToolInvocations | undefined; changed: boolean } {\n  if (!Array.isArray(toolInvocations)) return { toolInvocations, changed: false };\n\n  let changed = false;\n  const next: ToolInvocations = toolInvocations.map(invocation => {\n    if (\n      invocation?.state !== 'result' ||\n      typeof invocation.toolName !== 'string' ||\n      !toolNames.has(invocation.toolName) ||\n      invocation.result === undefined\n    ) {\n      return invocation;\n    }\n    changed = true;\n    return { ...invocation, result: REDACTED_TOOL_RESULT } as StoredToolInvocation;\n  });\n\n  return changed ? { toolInvocations: next, changed: true } : { toolInvocations, changed: false };\n}\n\n/**\n * Replace the result payload of a tool invocation with a placeholder, keeping\n * the call's identity (tool name, arguments, terminal state). The Observer\n * still records that the tool ran and what it was called with.\n */\nfunction redactToolResult(part: ToolInvocationPart): ToolInvocationPart {\n  const redacted: ToolInvocationPart = {\n    ...part,\n    toolInvocation: { ...part.toolInvocation, result: REDACTED_TOOL_RESULT },\n  };\n\n  // `resolveToolResultValue` prefers `providerMetadata.mastra.modelOutput` over\n  // `toolInvocation.result`, so a stored model output has to be replaced too.\n  // Copy rather than mutate: these message objects are shared with the stored\n  // history, which keeps the full result.\n  if (hasStoredModelOutput(part)) {\n    const providerMetadata = part.providerMetadata ?? {};\n    const mastra = providerMetadata.mastra as Record<string, unknown>;\n    return {\n      ...redacted,\n      providerMetadata: { ...providerMetadata, mastra: { ...mastra, modelOutput: REDACTED_TOOL_RESULT } },\n    };\n  }\n\n  return redacted;\n}\n\n/**\n * Build a `beforeObservation` hook that keeps Agent Skills results out of the\n * Observer payload.\n *\n * The `skill` tool returns a skill's instructions verbatim as its result, and\n * `skill_read` / `skill_search` return skill file contents, so without redaction\n * the Observer re-observes the full skill text every time a skill is used.\n * `skillResultRedactor()` replaces the result payload with a placeholder and\n * leaves the tool call in place, so the Observer still records which skill was\n * used without the skill text.\n *\n * ```typescript\n * const memory = new Memory({\n *   options: {\n *     observationalMemory: {\n *       model: 'google/gemini-2.5-flash',\n *       hooks: { beforeObservation: skillResultRedactor() },\n *     },\n *   },\n * });\n * ```\n *\n * Because a hook is a function over the messages, this composes with your own\n * transforms by chaining the outputs. Await each chained hook so an async one\n * doesn't resolve to a promise that gets discarded:\n *\n * ```typescript\n * const dropSkillResults = skillResultRedactor();\n *\n * hooks: {\n *   beforeObservation: async input => {\n *     const messages = (await dropSkillResults(input))?.messages ?? input.messages;\n *     return { messages: messages.filter(m => m.role !== 'signal') };\n *   },\n * }\n * ```\n */\nexport function skillResultRedactor(options?: SkillResultRedactorOptions): ObserverMessageTransform {\n  const toolNames = new Set<string>(options?.toolNames ?? SKILL_TOOL_NAMES);\n\n  return ({ messages }) => {\n    let changed = false;\n\n    const transformed = messages.map(message => {\n      const parts = message.content?.parts;\n\n      let messageChanged = false;\n\n      // Legacy-only messages carry no `parts` at all, so this runs before the\n      // parts check rather than being skipped by it.\n      const legacy = redactLegacyToolInvocations(message.content?.toolInvocations, toolNames);\n      if (legacy.changed) messageChanged = true;\n\n      let nextParts = parts;\n      if (Array.isArray(parts)) {\n        nextParts = parts.map(part => {\n          if (!isRedactableToolResult(part, toolNames)) return part;\n          messageChanged = true;\n          return redactToolResult(part);\n        });\n      }\n\n      if (!messageChanged) return message;\n\n      changed = true;\n      return {\n        ...message,\n        content: { ...message.content, parts: nextParts, toolInvocations: legacy.toolInvocations },\n      };\n    });\n\n    // `undefined` means \"pass through unchanged\", so leave untouched payloads alone.\n    return changed ? { messages: transformed } : undefined;\n  };\n}\n"],"mappings":";;;;;AAiBA,MAAa,mBAAmB;CAAC;CAAS;CAAgB;AAAY;;;;;AAuBtE,MAAM,uBAAuB;AAE7B,SAAS,uBAAuB,MAAmB,WAAoD;CACrG,IAAI,MAAM,SAAS,mBAAmB,OAAO;CAG7C,IAAI,KAAK,eAAe,UAAU,UAAU,OAAO;CACnD,MAAM,WAAW,KAAK,eAAe;CACrC,IAAI,OAAO,aAAa,YAAY,CAAC,UAAU,IAAI,QAAQ,GAAG,OAAO;CAErE,OAAO,KAAK,eAAe,WAAW,KAAA,KAAa,qBAAqB,IAAI;AAC9E;AAEA,SAAS,qBAAqB,MAA4B;CACxD,IAAI,MAAM,SAAS,mBAAmB,OAAO;CAC7C,MAAM,SAAS,KAAK,kBAAkB;CACtC,OAAO,CAAC,CAAC,UAAU,OAAO,WAAW,YAAY,iBAAiB;AACpE;;;;;;;;;AAUA,SAAS,4BACP,iBACA,WACoE;CACpE,IAAI,CAAC,MAAM,QAAQ,eAAe,GAAG,OAAO;EAAE;EAAiB,SAAS;CAAM;CAE9E,IAAI,UAAU;CACd,MAAM,OAAwB,gBAAgB,KAAI,eAAc;EAC9D,IACE,YAAY,UAAU,YACtB,OAAO,WAAW,aAAa,YAC/B,CAAC,UAAU,IAAI,WAAW,QAAQ,KAClC,WAAW,WAAW,KAAA,GAEtB,OAAO;EAET,UAAU;EACV,OAAO;GAAE,GAAG;GAAY,QAAQ;EAAqB;CACvD,CAAC;CAED,OAAO,UAAU;EAAE,iBAAiB;EAAM,SAAS;CAAK,IAAI;EAAE;EAAiB,SAAS;CAAM;AAChG;;;;;;AAOA,SAAS,iBAAiB,MAA8C;CACtE,MAAM,WAA+B;EACnC,GAAG;EACH,gBAAgB;GAAE,GAAG,KAAK;GAAgB,QAAQ;EAAqB;CACzE;CAMA,IAAI,qBAAqB,IAAI,GAAG;EAC9B,MAAM,mBAAmB,KAAK,oBAAoB,CAAC;EACnD,MAAM,SAAS,iBAAiB;EAChC,OAAO;GACL,GAAG;GACH,kBAAkB;IAAE,GAAG;IAAkB,QAAQ;KAAE,GAAG;KAAQ,aAAa;IAAqB;GAAE;EACpG;CACF;CAEA,OAAO;AACT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCA,SAAgB,oBAAoB,SAAgE;CAClG,MAAM,YAAY,IAAI,IAAY,SAAS,aAAa,gBAAgB;CAExE,QAAQ,EAAE,eAAe;EACvB,IAAI,UAAU;EAEd,MAAM,cAAc,SAAS,KAAI,YAAW;GAC1C,MAAM,QAAQ,QAAQ,SAAS;GAE/B,IAAI,iBAAiB;GAIrB,MAAM,SAAS,4BAA4B,QAAQ,SAAS,iBAAiB,SAAS;GACtF,IAAI,OAAO,SAAS,iBAAiB;GAErC,IAAI,YAAY;GAChB,IAAI,MAAM,QAAQ,KAAK,GACrB,YAAY,MAAM,KAAI,SAAQ;IAC5B,IAAI,CAAC,uBAAuB,MAAM,SAAS,GAAG,OAAO;IACrD,iBAAiB;IACjB,OAAO,iBAAiB,IAAI;GAC9B,CAAC;GAGH,IAAI,CAAC,gBAAgB,OAAO;GAE5B,UAAU;GACV,OAAO;IACL,GAAG;IACH,SAAS;KAAE,GAAG,QAAQ;KAAS,OAAO;KAAW,iBAAiB,OAAO;IAAgB;GAC3F;EACF,CAAC;EAGD,OAAO,UAAU,EAAE,UAAU,YAAY,IAAI,KAAA;CAC/C;AACF"}

package/dist/index.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_src = require("./src-BCvV2aGL.cjs");
+const require_src = require("./src-C4niho1P.cjs");
 let _mastra_core_processors = require("@mastra/core/processors");
 exports.Extractor = require_src.Extractor;
 exports.KnowledgeSemanticIndexCoordinator = require_src.KnowledgeSemanticIndexCoordinator;

package/dist/index.js

@@ -1,2 +1,2 @@
-import { C as SUMMARIZE_THREAD_DEFAULTS, G as ModelByInputTokens, H as KnowledgeSemanticIndexCoordinator, S as WorkingMemoryExtractor, U as StaleKnowledgeSemanticIndexError, V as Subconscious, X as Extractor, a as extractWorkingMemoryContent, b as WorkingMemoryStateProcessor, c as getObservationsAsOf, i as WorkingMemory, n as MessageHistory, o as extractWorkingMemoryTags, r as SemanticRecall, s as removeWorkingMemoryTags, t as Memory, v as WORKING_MEMORY_STATE_ID, w as summarizeConversation, x as deepMergeWorkingMemory, y as WORKING_MEMORY_STATE_PROCESSOR_ID } from "./src-Ju0u9OWc.js";
+import { C as SUMMARIZE_THREAD_DEFAULTS, G as ModelByInputTokens, H as KnowledgeSemanticIndexCoordinator, S as WorkingMemoryExtractor, U as StaleKnowledgeSemanticIndexError, V as Subconscious, X as Extractor, a as extractWorkingMemoryContent, b as WorkingMemoryStateProcessor, c as getObservationsAsOf, i as WorkingMemory, n as MessageHistory, o as extractWorkingMemoryTags, r as SemanticRecall, s as removeWorkingMemoryTags, t as Memory, v as WORKING_MEMORY_STATE_ID, w as summarizeConversation, x as deepMergeWorkingMemory, y as WORKING_MEMORY_STATE_PROCESSOR_ID } from "./src-DquR-jTR.js";
 export { Extractor, KnowledgeSemanticIndexCoordinator, Memory, MessageHistory, ModelByInputTokens, SUMMARIZE_THREAD_DEFAULTS, SemanticRecall, StaleKnowledgeSemanticIndexError, Subconscious, WORKING_MEMORY_STATE_ID, WORKING_MEMORY_STATE_PROCESSOR_ID, WorkingMemory, WorkingMemoryExtractor, WorkingMemoryStateProcessor, deepMergeWorkingMemory, extractWorkingMemoryContent, extractWorkingMemoryTags, getObservationsAsOf, removeWorkingMemoryTags, summarizeConversation };

package/dist/processors/index.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_src = require("../src-BCvV2aGL.cjs");
+const require_src = require("../src-C4niho1P.cjs");
 exports.Extractor = require_src.Extractor;
 exports.KnowledgeSemanticIndexCoordinator = require_src.KnowledgeSemanticIndexCoordinator;
 exports.ModelByInputTokens = require_src.ModelByInputTokens;

package/dist/processors/index.js

@@ -1,2 +1,2 @@
-import { A as formatMessagesForObserver, B as OBSERVATION_CONTINUATION_HINT, D as buildObserverPrompt, E as OBSERVER_SYSTEM_PROMPT, F as parseAnchorId, G as ModelByInputTokens, H as KnowledgeSemanticIndexCoordinator, I as stripEphemeralAnchorIds, J as publishSubconsciousActivity, K as SUBCONSCIOUS_ACTIVITY_STATE_ID, L as OBSERVATIONAL_MEMORY_DEFAULTS, M as optimizeObservationsForContext, N as parseObserverOutput, O as buildObserverSystemPrompt, P as injectAnchorIds, R as OBSERVATION_CONTEXT_INSTRUCTIONS, S as WorkingMemoryExtractor, T as TokenCounter, U as StaleKnowledgeSemanticIndexError, V as Subconscious, W as SubconsciousRemindExtractor, X as Extractor, Y as renderSubconsciousActivity, _ as wrapInObservationGroup, c as getObservationsAsOf, d as combineObservationGroupRanges, f as deriveObservationGroupProvenance, g as stripObservationGroups, h as renderObservationGroupsForReflection, j as hasCurrentTaskSection, k as extractCurrentTask, l as ObservationalMemoryProcessor, m as reconcileObservationGroupsFromReflection, p as parseObservationGroups, q as buildSubconsciousActivitySnapshot, u as ObservationalMemory, w as summarizeConversation, z as OBSERVATION_CONTEXT_PROMPT } from "../src-Ju0u9OWc.js";
+import { A as formatMessagesForObserver, B as OBSERVATION_CONTINUATION_HINT, D as buildObserverPrompt, E as OBSERVER_SYSTEM_PROMPT, F as parseAnchorId, G as ModelByInputTokens, H as KnowledgeSemanticIndexCoordinator, I as stripEphemeralAnchorIds, J as publishSubconsciousActivity, K as SUBCONSCIOUS_ACTIVITY_STATE_ID, L as OBSERVATIONAL_MEMORY_DEFAULTS, M as optimizeObservationsForContext, N as parseObserverOutput, O as buildObserverSystemPrompt, P as injectAnchorIds, R as OBSERVATION_CONTEXT_INSTRUCTIONS, S as WorkingMemoryExtractor, T as TokenCounter, U as StaleKnowledgeSemanticIndexError, V as Subconscious, W as SubconsciousRemindExtractor, X as Extractor, Y as renderSubconsciousActivity, _ as wrapInObservationGroup, c as getObservationsAsOf, d as combineObservationGroupRanges, f as deriveObservationGroupProvenance, g as stripObservationGroups, h as renderObservationGroupsForReflection, j as hasCurrentTaskSection, k as extractCurrentTask, l as ObservationalMemoryProcessor, m as reconcileObservationGroupsFromReflection, p as parseObservationGroups, q as buildSubconsciousActivitySnapshot, u as ObservationalMemory, w as summarizeConversation, z as OBSERVATION_CONTEXT_PROMPT } from "../src-DquR-jTR.js";
 export { Extractor, KnowledgeSemanticIndexCoordinator, ModelByInputTokens, OBSERVATIONAL_MEMORY_DEFAULTS, OBSERVATION_CONTEXT_INSTRUCTIONS, OBSERVATION_CONTEXT_PROMPT, OBSERVATION_CONTINUATION_HINT, OBSERVER_SYSTEM_PROMPT, ObservationalMemory, ObservationalMemoryProcessor, SUBCONSCIOUS_ACTIVITY_STATE_ID, StaleKnowledgeSemanticIndexError, Subconscious, SubconsciousRemindExtractor, TokenCounter, WorkingMemoryExtractor, buildObserverPrompt, buildObserverSystemPrompt, buildSubconsciousActivitySnapshot, combineObservationGroupRanges, deriveObservationGroupProvenance, extractCurrentTask, formatMessagesForObserver, getObservationsAsOf, hasCurrentTaskSection, injectAnchorIds, optimizeObservationsForContext, parseAnchorId, parseObservationGroups, parseObserverOutput, publishSubconsciousActivity, reconcileObservationGroupsFromReflection, renderObservationGroupsForReflection, renderSubconsciousActivity, stripEphemeralAnchorIds, stripObservationGroups, summarizeConversation, wrapInObservationGroup };

package/dist/processors/observational-memory/hooks.d.ts

@@ -0,0 +1,63 @@
+import type { MastraDBMessage } from '@mastra/core/agent';
+import type { ObserveTransformHooks } from './types.js';
+type BeforeObservationHook = NonNullable<ObserveTransformHooks['beforeObservation']>;
+/**
+ * Tool ids of the built-in Agent Skills tools created by `createSkillTools()`
+ * in `@mastra/core` (`packages/core/src/workspace/skills/tools.ts`).
+ */
+export declare const SKILL_TOOL_NAMES: readonly ["skill", "skill_search", "skill_read"];
+/**
+ * A `beforeObservation` transform hook: it only rewrites messages. It receives
+ * the messages about to be sent to the Observer and returns `{ messages }` to
+ * replace them, or `undefined` to pass the payload through unchanged.
+ */
+export type ObserverMessageTransform = (...args: Parameters<BeforeObservationHook>) => {
+    messages: MastraDBMessage[];
+} | undefined;
+export interface SkillResultRedactorOptions {
+    /**
+     * Tool names whose results are redacted. Defaults to
+     * {@link SKILL_TOOL_NAMES}.
+     */
+    toolNames?: readonly string[];
+}
+/**
+ * Build a `beforeObservation` hook that keeps Agent Skills results out of the
+ * Observer payload.
+ *
+ * The `skill` tool returns a skill's instructions verbatim as its result, and
+ * `skill_read` / `skill_search` return skill file contents, so without redaction
+ * the Observer re-observes the full skill text every time a skill is used.
+ * `skillResultRedactor()` replaces the result payload with a placeholder and
+ * leaves the tool call in place, so the Observer still records which skill was
+ * used without the skill text.
+ *
+ * ```typescript
+ * const memory = new Memory({
+ *   options: {
+ *     observationalMemory: {
+ *       model: 'google/gemini-2.5-flash',
+ *       hooks: { beforeObservation: skillResultRedactor() },
+ *     },
+ *   },
+ * });
+ * ```
+ *
+ * Because a hook is a function over the messages, this composes with your own
+ * transforms by chaining the outputs. Await each chained hook so an async one
+ * doesn't resolve to a promise that gets discarded:
+ *
+ * ```typescript
+ * const dropSkillResults = skillResultRedactor();
+ *
+ * hooks: {
+ *   beforeObservation: async input => {
+ *     const messages = (await dropSkillResults(input))?.messages ?? input.messages;
+ *     return { messages: messages.filter(m => m.role !== 'signal') };
+ *   },
+ * }
+ * ```
+ */
+export declare function skillResultRedactor(options?: SkillResultRedactorOptions): ObserverMessageTransform;
+export {};
+//# sourceMappingURL=hooks.d.ts.map

package/dist/processors/observational-memory/hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../../../src/processors/observational-memory/hooks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAE1D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAMrD,KAAK,qBAAqB,GAAG,WAAW,CAAC,qBAAqB,CAAC,mBAAmB,CAAC,CAAC,CAAC;AAKrF;;;GAGG;AACH,eAAO,MAAM,gBAAgB,kDAAmD,CAAC;AAEjF;;;;GAIG;AACH,MAAM,MAAM,wBAAwB,GAAG,CACrC,GAAG,IAAI,EAAE,UAAU,CAAC,qBAAqB,CAAC,KACvC;IAAE,QAAQ,EAAE,eAAe,EAAE,CAAA;CAAE,GAAG,SAAS,CAAC;AAEjD,MAAM,WAAW,0BAA0B;IACzC;;;OAGG;IACH,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC/B;AAmFD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,CAAC,EAAE,0BAA0B,GAAG,wBAAwB,CAqClG"}

package/dist/processors/observational-memory/observation-groups.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"observation-groups.d.ts","sourceRoot":"","sources":["../../../src/processors/observational-memory/observation-groups.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAkDD,wBAAgB,gBAAgB,IAAI,MAAM,CAEzC;AAED,wBAAgB,sBAAsB,CACpC,YAAY,EAAE,MAAM,EACpB,KAAK,EAAE,MAAM,EACb,EAAE,SAAqB,EACvB,eAAe,CAAC,EAAE,MAAM,EAAE,EAC1B,IAAI,CAAC,EAAE,MAAM,GACZ,MAAM,CAIR;AAED,wBAAgB,sBAAsB,CAAC,YAAY,EAAE,MAAM,GAAG,gBAAgB,EAAE,CA0B/E;AAED,wBAAgB,sBAAsB,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CASnE;AASD,wBAAgB,6BAA6B,CAAC,MAAM,EAAE,gBAAgB,EAAE,GAAG,MAAM,CAgBhF;AAED,wBAAgB,oCAAoC,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAgBxF;AAOD,wBAAgB,gCAAgC,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,gBAAgB,EAAE,GAAG,gBAAgB,EAAE,CAiChH;AAED,wBAAgB,wCAAwC,CAAC,OAAO,EAAE,MAAM,EAAE,kBAAkB,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAyBnH"}
+{"version":3,"file":"observation-groups.d.ts","sourceRoot":"","sources":["../../../src/processors/observational-memory/observation-groups.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAgKD,wBAAgB,gBAAgB,IAAI,MAAM,CAEzC;AAED,wBAAgB,sBAAsB,CACpC,YAAY,EAAE,MAAM,EACpB,KAAK,EAAE,MAAM,EACb,EAAE,SAAqB,EACvB,eAAe,CAAC,EAAE,MAAM,EAAE,EAC1B,IAAI,CAAC,EAAE,MAAM,GACZ,MAAM,CAIR;AAED,wBAAgB,sBAAsB,CAAC,YAAY,EAAE,MAAM,GAAG,gBAAgB,EAAE,CAyB/E;AAED,wBAAgB,sBAAsB,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAQnE;AAmCD,wBAAgB,6BAA6B,CAAC,MAAM,EAAE,gBAAgB,EAAE,GAAG,MAAM,CAiChF;AAED,wBAAgB,oCAAoC,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAaxF;AAcD,wBAAgB,gCAAgC,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,gBAAgB,EAAE,GAAG,gBAAgB,EAAE,CA6ChH;AAED,wBAAgB,wCAAwC,CAAC,OAAO,EAAE,MAAM,EAAE,kBAAkB,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAyBnH"}