@mastra/memory 1.33.0 → 1.34.0-alpha.0

package/dist/{src-CMESxrGy.cjs → src-Cm4sUXMu.cjs}

@@ -29,8 +29,6 @@ var __toESM$1 = (mod, isNodeMode, target) => (target = mod != null ? __create$1(
 	enumerable: true
 }) : target, mod));
 //#endregion
-let crypto$1 = require("crypto");
-crypto$1 = __toESM$1(crypto$1, 1);
 let zod_v3 = require("zod/v3");
 let zod = require("zod");
 let zod_v4 = require("zod/v4");
@@ -53,6 +51,7 @@ let _mastra_core_tools = require("@mastra/core/tools");
 let _mastra_core_request_context = require("@mastra/core/request-context");
 let _mastra_core_llm = require("@mastra/core/llm");
 let async_hooks = require("async_hooks");
+let crypto$1 = require("crypto");
 let probe_image_size_sync_js = require("probe-image-size/sync.js");
 probe_image_size_sync_js = __toESM$1(probe_image_size_sync_js, 1);
 let _mastra_core_schema = require("@mastra/core/schema");
@@ -15693,6 +15692,10 @@ if (OM_DEBUG_LOG) {
 //#endregion
 //#region src/processors/observational-memory/subconscious/activity.ts
 const SUBCONSCIOUS_ACTIVITY_STATE_ID = "subconscious-activity";
+async function hashContents(contents) {
+	const digest = await globalThis.crypto.subtle.digest("SHA-256", new TextEncoder().encode(contents));
+	return Buffer.from(digest).toString("hex");
+}
 async function getActivityTarget(store, event, scope) {
 	if (event.recordType === "node") {
 		const node = await store.getNode(event.recordId);
@@ -15794,7 +15797,7 @@ async function publishSubconsciousError(input) {
 	await input.sendStateSignal({
 		id: SUBCONSCIOUS_ACTIVITY_STATE_ID,
 		mode: "snapshot",
-		cacheKey: (0, crypto$1.createHash)("sha256").update(contents).digest("hex"),
+		cacheKey: await hashContents(contents),
 		tagName: "state",
 		attributes: { id: SUBCONSCIOUS_ACTIVITY_STATE_ID },
 		metadata: { origin: "subconscious" },
@@ -15806,7 +15809,7 @@ async function publishSubconsciousActivity(input) {
 	if (!input.sendStateSignal) return void 0;
 	const snapshot = await buildSubconsciousActivitySnapshot(input);
 	const contents = renderSubconsciousActivity(snapshot);
-	const cacheKey = (0, crypto$1.createHash)("sha256").update(contents).digest("hex");
+	const cacheKey = await hashContents(contents);
 	await input.sendStateSignal({
 		id: SUBCONSCIOUS_ACTIVITY_STATE_ID,
 		mode: "snapshot",
@@ -17541,7 +17544,7 @@ function createAskMemoryTool(options) {
 				status: "rejected",
 				error: `ask_memory could not resolve calling agent ${parentAgentId} from the registered runtime.`
 			};
-			const replyId = `subconscious:remind:${crypto$1.default.randomUUID()}:reply`;
+			const replyId = `subconscious:remind:${crypto.randomUUID()}:reply`;
 			try {
 				const scope = resolveKnowledgeToolScope(context);
 				const model = await resolveSubconsciousAgentModel({
@@ -17678,7 +17681,7 @@ function createReplyToMemoryQuestionTool(options) {
 				reason: "already-terminal"
 			};
 			const trimmedAnswer = answer.trim();
-			const signalId = `${replyId}:${moreComing ? `partial:${crypto$1.default.createHash("sha256").update(trimmedAnswer).digest("hex").slice(0, 12)}` : "terminal"}:signal`;
+			const signalId = `${replyId}:${moreComing ? `partial:${Buffer.from(await globalThis.crypto.subtle.digest("SHA-256", new TextEncoder().encode(trimmedAnswer))).toString("hex").slice(0, 12)}` : "terminal"}:signal`;
 			if (deliveredSignalIds.has(signalId)) return {
 				delivered: true,
 				replyId,
@@ -21344,7 +21347,7 @@ function optimizeObservationsForContext(observations) {
 //#region src/processors/observational-memory/temporary-memory.ts
 function createTemporaryOmMemoryContext(prefix) {
 	const options = {
-		thread: `${prefix}-${(0, crypto$1.randomUUID)()}`,
+		thread: `${prefix}-${globalThis.crypto.randomUUID()}`,
 		resource: prefix,
 		options: {
 			lastMessages: 10,
@@ -22197,6 +22200,10 @@ function isLikelyBase64Content(value) {
 	if (value.length < 16 || value.length % 4 !== 0 || /\s/.test(value) || isLikelyFilesystemPath(value)) return false;
 	return /^[A-Za-z0-9+/]+={0,2}$/.test(value);
 }
+/**
+* Decodes a stored attachment payload (data URI, raw base64, Buffer, or typed array) into bytes.
+* Returns undefined for remote URLs, filesystem paths, and anything that isn't a decodable payload.
+*/
 function decodeImageBuffer(value) {
 	if (typeof Buffer !== "undefined" && Buffer.isBuffer(value)) return value;
 	if (value instanceof Uint8Array) return Buffer.from(value);
@@ -24066,6 +24073,145 @@ function makePart(msg, partIndex, type, fullText, detail, toolName) {
 		toolName
 	};
 }
+const PROVIDER_FILE_ID_PATTERN = /^file-[A-Za-z0-9_-]+$/;
+const REUSABLE_URL_PATTERN = /^[a-z][a-z0-9+.-]*:\/\/\S+$/i;
+const DATA_URI_PATTERN = /^data:([^;,]*)/i;
+const INLINE_DATA_OMITTED = "(inline data omitted)";
+/**
+* Reads the payload and media type of a stored image/file part. Stored parts use the v4
+* (`data`/`mimeType`) or v5 (`url`/`mediaType`) shape; prompt-style image parts carry the
+* payload in `image`. A data URI's header supplies the media type when none was stored.
+*/
+function readAttachmentPayload(part) {
+	const payload = part.image ?? part.data ?? part.url;
+	const payloadString = payload instanceof URL ? payload.href : typeof payload === "string" ? payload.trim() : "";
+	const dataUriMatch = DATA_URI_PATTERN.exec(payloadString);
+	const mediaType = [
+		part.mimeType,
+		part.mediaType,
+		dataUriMatch?.[1]
+	].find((v) => typeof v === "string" && v.length > 0);
+	const hasBytes = payload instanceof Uint8Array || payload instanceof ArrayBuffer;
+	return {
+		payload,
+		payloadString,
+		isDataUri: dataUriMatch !== null,
+		hasBytes,
+		mediaType
+	};
+}
+/** Returns the reference text for a payload the agent can reuse, or undefined for inline data. */
+function describeReusableReference(payloadString) {
+	if (PROVIDER_FILE_ID_PATTERN.test(payloadString)) return `file id: ${payloadString}`;
+	if (REUSABLE_URL_PATTERN.test(payloadString)) return `url: ${payloadString}`;
+}
+/**
+* Renders an image/file part with its media type and, when the stored payload is a reusable
+* reference (URL or provider file ID), that reference so the agent can reuse the attachment.
+* Inline payloads (data URIs, base64, bytes) are never rendered.
+*/
+function formatAttachmentPart(partType, part) {
+	const filename = typeof part.filename === "string" && part.filename ? `: ${part.filename}` : "";
+	const { payloadString, isDataUri, hasBytes, mediaType } = readAttachmentPayload(part);
+	let reference = "";
+	if (!isDataUri && payloadString) reference = describeReusableReference(payloadString) ?? INLINE_DATA_OMITTED;
+	else if (isDataUri || hasBytes) reference = INLINE_DATA_OMITTED;
+	return [
+		`[${partType === "image" ? "Image" : "File"}${filename}]`,
+		mediaType,
+		reference
+	].filter(Boolean).join(" ");
+}
+const INLINE_MEDIA_PART_TYPES = /* @__PURE__ */ new Set([
+	"media",
+	"image-data",
+	"file-data",
+	"image",
+	"file"
+]);
+/**
+* Replaces inline media payloads nested in a stored tool result (for example a `media` part in
+* `modelOutput`, or a viewed attachment) with a placeholder, so rendering the result as text never
+* dumps base64. URLs and provider file IDs are kept because the agent can reuse them.
+*/
+function omitInlineMediaPayloads(value, seen = /* @__PURE__ */ new WeakMap()) {
+	if (typeof value !== "object" || value === null) return value;
+	if (seen.has(value)) return seen.get(value);
+	if (Array.isArray(value)) {
+		const items = [];
+		seen.set(value, items);
+		for (const item of value) items.push(omitInlineMediaPayloads(item, seen));
+		return items;
+	}
+	const record = value;
+	const isMediaPart = typeof record.type === "string" && INLINE_MEDIA_PART_TYPES.has(record.type);
+	const result = {};
+	seen.set(value, result);
+	for (const [key, entry] of Object.entries(record)) if (isMediaPart && (key === "data" || key === "image") && typeof entry === "string" && !describeReusableReference(entry.trim())) result[key] = INLINE_DATA_OMITTED;
+	else result[key] = omitInlineMediaPayloads(entry, seen);
+	return result;
+}
+/**
+* Media types the model can be handed directly. Mirrors the observational memory observer's
+* default `observeAttachments` allowlist — anything else (docx, pptx, video, …) is not a type
+* providers accept as an inline part, so it stays text-only.
+*/
+function isViewableAttachmentMediaType(mediaType) {
+	if (!mediaType) return false;
+	const normalized = mediaType.toLowerCase();
+	return normalized.startsWith("image/") || normalized === "application/pdf";
+}
+/** Mirrors core's DEFAULT_MAX_MEDIA_BYTES cap on inline media results. */
+const MAX_VIEWABLE_ATTACHMENT_BYTES = 10 * 1024 * 1024;
+function isRecallAttachmentContent(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const content = value.content;
+	if (!Array.isArray(content) || content.length !== 2) return false;
+	return content.every((part) => {
+		if (typeof part !== "object" || part === null) return false;
+		const { type, text, data, mimeType } = part;
+		if (type === "text") return typeof text === "string";
+		return (type === "image" || type === "file") && typeof data === "string" && typeof mimeType === "string";
+	});
+}
+/**
+* Turns an attachment part into a model-viewable payload. Only inline payloads are returned, as
+* base64 bytes. Everything else — remote URLs, provider file IDs, oversized payloads, unsupported
+* media types — comes back as an explanation for the agent instead.
+*/
+function resolveViewableAttachment(part) {
+	const { payload, payloadString, isDataUri, hasBytes, mediaType } = readAttachmentPayload(part);
+	if (!payloadString && !hasBytes) return { note: "This attachment has no stored payload to show." };
+	if (!isViewableAttachmentMediaType(mediaType)) return { note: mediaType ? `Attachments of type ${mediaType} can't be shown inline. Use the attachment's url or file id if you need to reference it.` : "This attachment has no media type recorded, so it can't be shown inline." };
+	if (isHttpUrlString(payloadString)) return { note: "This attachment is stored at a remote URL, so it can't be shown inline. Use its url if you need to reference it." };
+	if (payloadString.length * .75 > MAX_VIEWABLE_ATTACHMENT_BYTES) return { note: "This attachment is too large to show inline." };
+	const bytes = decodeImageBuffer(isDataUri ? `data:${payloadString.slice(5)}` : payloadString || payload);
+	if (!bytes) return { note: "This attachment's payload is not inline data, so it can't be shown." };
+	if (bytes.byteLength > MAX_VIEWABLE_ATTACHMENT_BYTES) return { note: "This attachment is too large to show inline." };
+	return {
+		data: bytes.toString("base64"),
+		mimeType: mediaType
+	};
+}
+/**
+* Presents a resolved attachment to the model as a native base64 `media` part alongside its text
+* description.
+*/
+function recallAttachmentToModelOutput(output) {
+	if (!isRecallAttachmentContent(output)) return void 0;
+	const [textPart, attachment] = output.content;
+	return {
+		type: "content",
+		value: [{
+			type: "text",
+			text: textPart.text
+		}, {
+			type: "media",
+			data: attachment.data,
+			mediaType: attachment.mimeType
+		}]
+	};
+}
 function formatMessageParts(msg, detail) {
 	const parts = [];
 	if (typeof msg.content === "string") {
@@ -24098,7 +24244,7 @@ function formatMessageParts(msg, detail) {
 				}
 				if (inv.state === "result") {
 					const { value: resultValue } = resolveToolResultValue(part, inv.result);
-					const resultStr = formatToolResultForObserver(resultValue, { maxTokens: HIGH_DETAIL_TOOL_RESULT_TOKENS });
+					const resultStr = formatToolResultForObserver(omitInlineMediaPayloads(resultValue), { maxTokens: HIGH_DETAIL_TOOL_RESULT_TOKENS });
 					const fullText = `[Tool Result: ${inv.toolName}]\n${resultStr}`;
 					parts.push(makePart(msg, i, "tool-result", fullText, detail, inv.toolName));
 				}
@@ -24121,25 +24267,14 @@ function formatMessageParts(msg, detail) {
 		} else if (partType === "tool-result") {
 			const toolName = part.toolName;
 			if (toolName) {
-				const fullText = `[Tool Result: ${toolName}]\n${formatToolResultForObserver(part.output ?? part.result, { maxTokens: HIGH_DETAIL_TOOL_RESULT_TOKENS })}`;
+				const fullText = `[Tool Result: ${toolName}]\n${formatToolResultForObserver(omitInlineMediaPayloads(part.output ?? part.result), { maxTokens: HIGH_DETAIL_TOOL_RESULT_TOKENS })}`;
 				parts.push(makePart(msg, i, "tool-result", fullText, detail, toolName));
 			}
 		} else if (partType === "reasoning") {
 			const reasoning = part.reasoning ?? part.text;
 			if (reasoning) parts.push(makePart(msg, i, "reasoning", reasoning, detail));
-		} else if (partType === "image" || partType === "file") {
-			const filename = part.filename;
-			const label = filename ? `: ${filename}` : "";
-			const fullText = `[${partType === "image" ? "Image" : "File"}${label}]`;
-			parts.push({
-				messageId: msg.id,
-				partIndex: i,
-				role: msg.role,
-				type: partType,
-				text: fullText,
-				fullText
-			});
-		} else if (partType?.startsWith("data-")) {} else if (partType) {
+		} else if (partType === "image" || partType === "file") parts.push(makePart(msg, i, partType, formatAttachmentPart(partType, part), detail));
+		else if (partType?.startsWith("data-")) {} else if (partType) {
 			const fullText = `[${partType}]`;
 			parts.push({
 				messageId: msg.id,
@@ -24312,6 +24447,29 @@ async function recallPart({ memory, threadId, resourceId, cursor, partIndex, cha
 		note
 	};
 }
+async function recallAttachmentView({ memory, threadId, resourceId, cursor, partIndex, threadScope, retrievalScope = "thread" }) {
+	if (!memory || typeof memory.getMemoryStore !== "function") throw new Error("Memory instance is required for recall");
+	if (!threadId) throw new Error("Thread ID is required for recall");
+	const resolved = await resolveCursorMessage(memory, cursor, {
+		resourceId,
+		threadScope,
+		enforceThreadScope: retrievalScope !== "resource"
+	});
+	if ("hint" in resolved) return { messages: resolved.hint };
+	const rawPart = getMessageParts(resolved)[partIndex];
+	const partType = rawPart?.type;
+	if (!rawPart || partType !== "image" && partType !== "file") return { messages: `Part ${partIndex} of message ${cursor} is ${rawPart ? `a ${partType ?? "unknown"}-type part` : "missing"}, not an attachment. Call recall with the same cursor and partIndex without viewAttachment to read it.` };
+	const resolvedAttachment = resolveViewableAttachment(rawPart);
+	if ("note" in resolvedAttachment) return { messages: `${formatAttachmentPart(partType, rawPart)} — ${resolvedAttachment.note}` };
+	return { content: [{
+		type: "text",
+		text: formatAttachmentPart(partType, rawPart)
+	}, {
+		type: partType === "image" ? "image" : "file",
+		data: resolvedAttachment.data,
+		mimeType: resolvedAttachment.mimeType
+	}] };
+}
 async function recallMessages({ memory, threadId, resourceId, cursor, page = 1, limit = 20, detail = "low", partType, toolName, threadScope, retrievalScope = "thread", maxTokens = DEFAULT_MAX_RESULT_TOKENS }) {
 	if (!memory) throw new Error("Memory instance is required for recall");
 	if (!threadId) throw new Error("Thread ID is required for recall");
@@ -24597,11 +24755,15 @@ const recallTool = (_memoryConfig, options) => {
 					type: "integer",
 					minimum: 0,
 					description: "Continue reading a truncated single part from this position. Pass the exact nextCharOffset value returned by a previous call; do not compute it yourself. Only applies with cursor and partIndex in mode=\"messages\"."
+				},
+				viewAttachment: {
+					type: "boolean",
+					description: "Show the actual attachment instead of just describing it. Requires cursor and partIndex, and only applies when that part is an image or file. Use it after recall shows you an attachment you need to look at."
 				}
 			}
 		},
 		execute: async (inputData, context) => {
-			const { mode, query, cursor, threadId: explicitThreadId, anchor, page, limit, detail, partType, toolName, partIndex, charOffset, before, after } = inputData;
+			const { mode, query, cursor, threadId: explicitThreadId, anchor, page, limit, detail, partType, toolName, partIndex, charOffset, before, after, viewAttachment } = inputData;
 			const memory = context?.memory;
 			const currentThreadId = context?.agent?.threadId;
 			const resourceId = context?.agent?.resourceId;
@@ -24690,6 +24852,7 @@ const recallTool = (_memoryConfig, options) => {
 				targetThreadId = resolved.threadId;
 			}
 			if (!targetThreadId) throw new Error("Thread ID is required for recall");
+			if (viewAttachment && (!cursor || partIndex === void 0 || partIndex === null)) return { messages: "viewAttachment needs both cursor and partIndex so it knows which attachment to show. Call recall with cursor, partIndex, and viewAttachment: true." };
 			if (!cursor) {
 				const result = await recallThreadFromStart({
 					memory,
@@ -24708,16 +24871,27 @@ const recallTool = (_memoryConfig, options) => {
 				};
 				return result;
 			}
-			if (partIndex !== void 0 && partIndex !== null) return recallPart({
-				memory,
-				threadId: targetThreadId,
-				resourceId,
-				cursor,
-				partIndex,
-				charOffset,
-				threadScope,
-				retrievalScope
-			});
+			if (partIndex !== void 0 && partIndex !== null) {
+				if (viewAttachment) return recallAttachmentView({
+					memory,
+					threadId: targetThreadId,
+					resourceId,
+					cursor,
+					partIndex,
+					threadScope,
+					retrievalScope
+				});
+				return recallPart({
+					memory,
+					threadId: targetThreadId,
+					resourceId,
+					cursor,
+					partIndex,
+					charOffset,
+					threadScope,
+					retrievalScope
+				});
+			}
 			return recallMessages({
 				memory,
 				threadId: targetThreadId,
@@ -24731,7 +24905,8 @@ const recallTool = (_memoryConfig, options) => {
 				threadScope,
 				retrievalScope
 			});
-		}
+		},
+		toModelOutput: recallAttachmentToModelOutput
 	});
 };
 //#endregion
@@ -25692,7 +25867,7 @@ function stripReflectionGroupMetadata(body) {
 	return body.replace(/^_range:\s*`[^`]*`_\s*\n?/m, "").trim();
 }
 function generateAnchorId() {
-	return (0, crypto$1.randomBytes)(8).toString("hex");
+	return Buffer.from(globalThis.crypto.getRandomValues(/* @__PURE__ */ new Uint8Array(8))).toString("hex");
 }
 function wrapInObservationGroup(observations, range, id = generateAnchorId(), _sourceGroupIds, kind) {
 	const content = observations.trim();
@@ -29044,7 +29219,7 @@ function inferReproIdRemap(preMessages, postMessages) {
 }
 function createOmReproCaptureDir(threadId, label) {
 	const sanitizedThreadId = sanitizeCapturePathSegment(threadId);
-	const captureDir = (0, path.join)(process.cwd(), getOmReproCaptureDir(), sanitizedThreadId, `${Date.now()}-${label}-${(0, crypto$1.randomUUID)()}`);
+	const captureDir = (0, path.join)(process.cwd(), getOmReproCaptureDir(), sanitizedThreadId, `${Date.now()}-${label}-${globalThis.crypto.randomUUID()}`);
 	(0, fs.mkdirSync)(captureDir, { recursive: true });
 	return captureDir;
 }
@@ -33596,18 +33771,19 @@ Notes:
 		const embedResult = await this.embedMessageContent(text);
 		if (embedResult.embeddings.length === 0 || embedResult.dimension === void 0) return;
 		const { indexName } = await this.createObservationEmbeddingIndex(embedResult.dimension);
-		const ids = embedResult.chunks.map((_, chunkIndex) => {
-			const hash = (0, crypto$1.createHash)("sha256").update(JSON.stringify([
+		const ids = [];
+		for (const [chunkIndex] of embedResult.chunks.entries()) {
+			const hash = Buffer.from(await globalThis.crypto.subtle.digest("SHA-256", new TextEncoder().encode(JSON.stringify([
 				resourceId,
 				threadId,
 				groupId,
 				chunkIndex
-			])).digest();
+			]))));
 			hash[6] = hash[6] & 15 | 128;
 			hash[8] = hash[8] & 63 | 128;
 			const hex = hash.toString("hex", 0, 16);
-			return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
-		});
+			ids.push(`${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`);
+		}
 		await this.vector.upsert({
 			indexName,
 			ids,
@@ -34774,4 +34950,4 @@ Object.defineProperty(exports, "wrapInObservationGroup", {
 	}
 });
 
-//# sourceMappingURL=src-CMESxrGy.cjs.map
+//# sourceMappingURL=src-Cm4sUXMu.cjs.map