@mastra/memory 1.26.2-alpha.0 → 1.26.2

package/dist/{src-CTwoCwmY.cjs → src-b5E69E65.cjs}

@@ -14769,7 +14769,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:
@@ -14777,6 +14777,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
@@ -19143,6 +19145,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 || (0, tokenx.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 = (0, tokenx.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;
@@ -19360,7 +19392,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, {
@@ -19384,31 +19416,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 }) {
@@ -19690,11 +19727,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;
@@ -19807,6 +19849,7 @@ const recallTool = (_memoryConfig, options) => {
 				resourceId: isResourceScope ? resourceId : void 0,
 				cursor,
 				partIndex,
+				charOffset,
 				threadScope
 			});
 			return recallMessages({
@@ -22320,7 +22363,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;
@@ -28906,4 +28950,4 @@ Object.defineProperty(exports, "wrapInObservationGroup", {
 	}
 });
 
-//# sourceMappingURL=src-CTwoCwmY.cjs.map
+//# sourceMappingURL=src-b5E69E65.cjs.map