@mastra/memory 1.26.2-alpha.0 → 1.26.2

package/dist/{src-DGdlH4fo.js → src-BYD6Wp5m.js}

@@ -14748,7 +14748,7 @@ By default recall returns **low** detail: truncated text and tool names only. Ea
 - Use \`detail: "high"\` to get full message content including tool arguments and results. This will only return the high detail version of a single message part at a time.
 - Use \`partIndex\` with a cursor to fetch a single part at full detail — for example, to read one specific tool result or code block without loading every part.
 
-If the result says \`truncated: true\`, the output was cut to fit the token budget. You can paginate or use \`partIndex\` to target specific content.
+If the result says \`truncated: true\`, the output was cut to fit the token budget. You can paginate or use \`partIndex\` to target specific content. If a single part is itself too large, follow the returned \`nextCharOffset\` as described below.
 
 ### Following up on truncated parts
 Low-detail results may include truncation hints like:
@@ -14756,6 +14756,8 @@ Low-detail results may include truncation hints like:
 
 **When you see these hints and need the full content, make the exact call described in the hint.** This is the normal workflow: first recall at low detail to scan, then drill into specific parts at high detail. Do not stop at the low-detail result if the user asked for exact content.
 
+If a single part is larger than the token budget, the \`partIndex\` result is \`truncated: true\` and includes \`nextCharOffset\`. Repeat the same call with \`charOffset\` set to that exact value to read the next chunk from where the previous one ended. Keep following \`nextCharOffset\` until the result no longer includes it — the chunks together contain the full part. Retrying without \`charOffset\` returns the same prefix again.
+
 ### When recall is NOT needed
 - The user is asking for a high-level summary and your observations already cover it
 - The question is about general preferences or facts that don't require source text
@@ -19122,6 +19124,36 @@ function truncateByTokens(text, maxTokens, hint) {
 		wasTruncated: true
 	};
 }
+function chunkTextByTokens(text, maxTokens, charOffset = 0) {
+	let startOffset = Math.max(0, Math.min(Math.floor(charOffset), text.length));
+	const startCode = text.charCodeAt(startOffset);
+	if (startCode >= 56320 && startCode <= 57343) startOffset += 1;
+	const remaining = text.slice(startOffset);
+	if (!remaining || estimateTokenCount(remaining) <= maxTokens) return {
+		text: remaining,
+		charOffset: startOffset,
+		truncated: false
+	};
+	let low = 0;
+	let high = remaining.length;
+	let best = "";
+	while (low <= high) {
+		const mid = Math.floor((low + high) / 2);
+		const candidate = safeSlice(remaining, mid);
+		const candidateTokens = estimateTokenCount(candidate);
+		if (candidate && candidateTokens <= maxTokens) {
+			best = candidate;
+			low = mid + 1;
+		} else high = mid - 1;
+	}
+	const nextCharOffset = startOffset + best.length;
+	return {
+		text: best,
+		charOffset: startOffset,
+		nextCharOffset,
+		truncated: nextCharOffset < text.length
+	};
+}
 function lowDetailPartLimit(type) {
 	if (type === "text") return AUTO_EXPAND_TEXT_TOKENS;
 	if (type === "tool-result" || type === "tool-call") return AUTO_EXPAND_TOOL_TOKENS;
@@ -19339,7 +19371,7 @@ function renderFormattedParts(parts, timestamps, options) {
 		tokenOffset: expandedTokens - options.maxTokens
 	};
 }
-async function recallPart({ memory, threadId, resourceId, cursor, partIndex, threadScope, maxTokens = DEFAULT_MAX_RESULT_TOKENS }) {
+async function recallPart({ memory, threadId, resourceId, cursor, partIndex, charOffset, threadScope, maxTokens = DEFAULT_MAX_RESULT_TOKENS }) {
 	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, {
@@ -19363,31 +19395,36 @@ async function recallPart({ memory, threadId, resourceId, cursor, partIndex, thr
 			if (nextMessage) {
 				const firstNextPart = formatMessageParts(nextMessage, "high")[0];
 				if (firstNextPart) {
-					const fallbackText = `${`Part index ${partIndex} not found in message ${cursor}; showing partIndex ${firstNextPart.partIndex} from next message ${firstNextPart.messageId}.\n\n`}${firstNextPart.text}`;
-					const truncatedText = truncateStringByTokens(fallbackText, maxTokens);
-					const wasTruncated = truncatedText !== fallbackText;
+					const fallbackChunk = chunkTextByTokens(`${`Part index ${partIndex} not found in message ${cursor}; showing partIndex ${firstNextPart.partIndex} from next message ${firstNextPart.messageId}.\n\n`}${firstNextPart.text}`, maxTokens, charOffset);
+					const fallbackContinuation = fallbackChunk.nextCharOffset ? `To continue this part, call recall cursor="${cursor}" partIndex=${partIndex} detail="high" charOffset=${fallbackChunk.nextCharOffset}.` : void 0;
 					return {
-						text: truncatedText,
+						text: fallbackChunk.text,
 						messageId: firstNextPart.messageId,
 						partIndex: firstNextPart.partIndex,
 						role: firstNextPart.role,
 						type: firstNextPart.type,
-						truncated: wasTruncated
+						truncated: fallbackChunk.truncated,
+						charOffset: fallbackChunk.charOffset,
+						nextCharOffset: fallbackChunk.nextCharOffset,
+						note: fallbackContinuation
 					};
 				}
 			}
 		}
 		throw new Error(`Part index ${partIndex} not found in message ${cursor}. Available indices: ${availableIndices}`);
 	}
-	const truncatedText = truncateStringByTokens(target.text, maxTokens);
-	const wasTruncated = truncatedText !== target.text;
+	const chunk = chunkTextByTokens(target.text, maxTokens, charOffset);
+	const note = chunk.nextCharOffset ? `To continue this part, call recall cursor="${target.messageId}" partIndex=${target.partIndex} detail="high" charOffset=${chunk.nextCharOffset}.` : void 0;
 	return {
-		text: truncatedText,
+		text: chunk.text,
 		messageId: target.messageId,
 		partIndex: target.partIndex,
 		role: target.role,
 		type: target.type,
-		truncated: wasTruncated
+		truncated: chunk.truncated,
+		charOffset: chunk.charOffset,
+		nextCharOffset: chunk.nextCharOffset,
+		note
 	};
 }
 async function recallMessages({ memory, threadId, resourceId, cursor, page = 1, limit = 20, detail = "low", partType, toolName, threadScope, maxTokens = DEFAULT_MAX_RESULT_TOKENS }) {
@@ -19669,11 +19706,16 @@ const recallTool = (_memoryConfig, options) => {
 					type: "integer",
 					minimum: 0,
 					description: "Fetch a single part from the cursor message by its positional index. When provided, returns only that part at high detail. Indices are shown as [p0], [p1], etc. in recall results."
+				},
+				charOffset: {
+					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\"."
 				}
 			}
 		},
 		execute: async (inputData, context) => {
-			const { mode, query, cursor, threadId: explicitThreadId, anchor, page, limit, detail, partType, toolName, partIndex, before, after } = inputData;
+			const { mode, query, cursor, threadId: explicitThreadId, anchor, page, limit, detail, partType, toolName, partIndex, charOffset, before, after } = inputData;
 			const memory = context?.memory;
 			const currentThreadId = context?.agent?.threadId;
 			const resourceId = context?.agent?.resourceId;
@@ -19786,6 +19828,7 @@ const recallTool = (_memoryConfig, options) => {
 				resourceId: isResourceScope ? resourceId : void 0,
 				cursor,
 				partIndex,
+				charOffset,
 				threadScope
 			});
 			return recallMessages({
@@ -22299,7 +22342,8 @@ var ObservationStep = class {
 	}
 	/**
 	* Run the full threshold observation pipeline:
-	* waitForBuffering → re-check → activate → reflect → blockAfter gate → observe
+	* waitForBuffering → re-check → activate → reflect → observe (sync fallback when
+	* buffered activation did not happen)
 	*/
 	async runThresholdObservation() {
 		const { threadId, resourceId, messageList } = this.turn;
@@ -28652,4 +28696,4 @@ Notes:
 //#endregion
 export { extractCurrentTask as A, OBSERVATION_CONTEXT_INSTRUCTIONS as B, WorkingMemoryExtractor as C, OBSERVER_SYSTEM_PROMPT as D, TokenCounter as E, injectAnchorIds as F, OBSERVATION_CONTINUATION_HINT as H, parseAnchorId as I, stripEphemeralAnchorIds as L, hasCurrentTaskSection as M, optimizeObservationsForContext as N, buildObserverPrompt as O, parseObserverOutput as P, Extractor as R, deepMergeWorkingMemory as S, summarizeConversation as T, OBSERVATION_CONTEXT_PROMPT as V, reconcileObservationGroupsFromReflection as _, extractWorkingMemoryContent as a, wrapInObservationGroup as b, WORKING_MEMORY_STATE_ID as c, getObservationsAsOf as d, ObservationalMemoryProcessor as f, parseObservationGroups as g, deriveObservationGroupProvenance as h, WorkingMemory as i, formatMessagesForObserver as j, buildObserverSystemPrompt as k, WORKING_MEMORY_STATE_PROCESSOR_ID as l, combineObservationGroupRanges as m, MessageHistory$1 as n, extractWorkingMemoryTags as o, ObservationalMemory as p, SemanticRecall as r, removeWorkingMemoryTags as s, Memory as t, WorkingMemoryStateProcessor as u, renderObservationGroupsForReflection as v, SUMMARIZE_THREAD_DEFAULTS as w, ModelByInputTokens as x, stripObservationGroups as y, OBSERVATIONAL_MEMORY_DEFAULTS as z };
 
-//# sourceMappingURL=src-DGdlH4fo.js.map
+//# sourceMappingURL=src-BYD6Wp5m.js.map