@mastra/ai-sdk 1.7.1 → 1.8.0-alpha.0

package/dist/index.js

@@ -9,7 +9,7 @@ import { MASTRA_RESOURCE_ID_KEY } from "@mastra/core/request-context";
 import { MessageList, TripWire, aiV5ModelMessageToV2PromptMessage } from "@mastra/core/agent";
 import { RequestContext } from "@mastra/core/di";
 import { MessageHistory, SemanticRecall, WorkingMemory } from "@mastra/core/processors";
-//#region ../../packages/_vendored/ai_v5/dist/dist-Qv-F35RT.js
+//#region ../../packages/_vendored/ai_v5/dist/dist-BuEMdYEn.js
 var marker$1$4 = "vercel.ai.error";
 var symbol$1$5 = Symbol.for(marker$1$4);
 var _a$1$5;
@@ -533,6 +533,26 @@ async function cancelResponseBody$1(response) {
 		await ((_a2 = response.body) == null ? void 0 : _a2.cancel());
 	} catch (e) {}
 }
+var initialGlobalFetch$1 = globalThis.fetch;
+isNodeDefaultFetch$1(initialGlobalFetch$1);
+function isNodeDefaultFetch$1(fetch) {
+	const source = Function.prototype.toString.call(fetch);
+	return source.includes("internal/deps/undici") || source.includes("lazy loading of undici");
+}
+function getCurrentModulePath$1() {
+	const originalPrepareStackTrace = Error.prepareStackTrace;
+	try {
+		Error.prepareStackTrace = (_error, callSites) => callSites;
+		const error = /* @__PURE__ */ new Error("Capture current module path");
+		Error.captureStackTrace(error, getCurrentModulePath$1);
+		const [caller] = error.stack;
+		const fileName = caller == null ? void 0 : caller.getFileName();
+		if (fileName == null) throw new Error("Unable to determine the current module path");
+		return fileName;
+	} finally {
+		Error.prepareStackTrace = originalPrepareStackTrace;
+	}
+}
 var DEFAULT_MAX_DOWNLOAD_SIZE$1 = 2 * 1024 * 1024 * 1024;
 async function readResponseWithSizeLimit$1({ response, url, maxBytes = DEFAULT_MAX_DOWNLOAD_SIZE$1 }) {
 	const contentLength = response.headers.get("content-length");
@@ -636,11 +656,11 @@ function withUserAgentSuffix$1(headers, ...userAgentSuffixParts) {
 	normalizedHeaders.set("user-agent", [currentUserAgentHeader, ...userAgentSuffixParts].filter(Boolean).join(" "));
 	return Object.fromEntries(normalizedHeaders.entries());
 }
-var VERSION$4 = "3.0.30";
+var VERSION$4 = "3.0.31";
 var getOriginalFetch = () => globalThis.fetch;
-var getFromApi = async ({ url, headers = {}, successfulResponseHandler, failedResponseHandler, abortSignal, fetch: fetch2 = getOriginalFetch() }) => {
+var getFromApi = async ({ url, headers = {}, successfulResponseHandler, failedResponseHandler, abortSignal, fetch = getOriginalFetch() }) => {
 	try {
-		const response = await fetch2(url, {
+		const response = await fetch(url, {
 			method: "GET",
 			headers: withUserAgentSuffix$1(headers, `ai-sdk/provider-utils/${VERSION$4}`, getRuntimeEnvironmentUserAgent$1()),
 			signal: abortSignal
@@ -866,7 +886,7 @@ function parseJsonEventStream({ stream, schema }) {
 	} }));
 }
 var getOriginalFetch2 = () => globalThis.fetch;
-var postJsonToApi = async ({ url, headers, body, failedResponseHandler, successfulResponseHandler, abortSignal, fetch: fetch2 }) => postToApi({
+var postJsonToApi = async ({ url, headers, body, failedResponseHandler, successfulResponseHandler, abortSignal, fetch }) => postToApi({
 	url,
 	headers: {
 		"Content-Type": "application/json",
@@ -879,11 +899,11 @@ var postJsonToApi = async ({ url, headers, body, failedResponseHandler, successf
 	failedResponseHandler,
 	successfulResponseHandler,
 	abortSignal,
-	fetch: fetch2
+	fetch
 });
-var postToApi = async ({ url, headers = {}, body, successfulResponseHandler, failedResponseHandler, abortSignal, fetch: fetch2 = getOriginalFetch2() }) => {
+var postToApi = async ({ url, headers = {}, body, successfulResponseHandler, failedResponseHandler, abortSignal, fetch = getOriginalFetch2() }) => {
 	try {
-		const response = await fetch2(url, {
+		const response = await fetch(url, {
 			method: "POST",
 			headers: withUserAgentSuffix$1(headers, `ai-sdk/provider-utils/${VERSION$4}`, getRuntimeEnvironmentUserAgent$1()),
 			body: body.content,
@@ -2945,7 +2965,7 @@ async function getVercelRequestId() {
 	var _a10;
 	return (_a10 = getContext().headers) == null ? void 0 : _a10["x-vercel-id"];
 }
-var VERSION$2 = "2.0.115";
+var VERSION$2 = "2.0.125";
 var AI_GATEWAY_PROTOCOL_VERSION = "0.0.1";
 function createGatewayProvider(options = {}) {
 	var _a10, _b10;
@@ -4395,19 +4415,48 @@ function processUIMessageStream$1({ stream, messageMetadataSchema, dataPartSchem
 	return stream.pipeThrough(new TransformStream({ async transform(chunk, controller) {
 		await runUpdateMessageJob(async ({ state, write }) => {
 			var _a16, _b, _c, _d;
+			function getCurrentStepParts() {
+				const parts = state.message.parts;
+				let currentStepStartIndex = parts.length - 1;
+				while (currentStepStartIndex >= 0 && parts[currentStepStartIndex].type !== "step-start") currentStepStartIndex--;
+				return parts.slice(currentStepStartIndex + 1);
+			}
+			function getCurrentStepToolInvocations() {
+				return getCurrentStepParts().filter(isToolUIPart$1);
+			}
 			function getToolInvocation(toolCallId) {
-				const toolInvocation = state.message.parts.filter(isToolUIPart$1).find((invocation) => invocation.toolCallId === toolCallId);
+				let toolInvocation = getCurrentStepToolInvocations().find((invocation) => invocation.toolCallId === toolCallId);
+				if (toolInvocation == null) {
+					const parts = state.message.parts;
+					for (let i = parts.length - 1; i >= 0; i--) {
+						const part = parts[i];
+						if (isToolUIPart$1(part) && part.toolCallId === toolCallId) {
+							toolInvocation = part;
+							break;
+						}
+					}
+				}
 				if (toolInvocation == null) throw new Error("tool-output-error must be preceded by a tool-input-available");
 				return toolInvocation;
 			}
 			function getDynamicToolInvocation(toolCallId) {
-				const toolInvocation = state.message.parts.filter((part) => part.type === "dynamic-tool").find((invocation) => invocation.toolCallId === toolCallId);
+				let toolInvocation = getCurrentStepParts().filter((part) => part.type === "dynamic-tool").find((invocation) => invocation.toolCallId === toolCallId);
+				if (toolInvocation == null) {
+					const parts = state.message.parts;
+					for (let i = parts.length - 1; i >= 0; i--) {
+						const part = parts[i];
+						if (part.type === "dynamic-tool" && part.toolCallId === toolCallId) {
+							toolInvocation = part;
+							break;
+						}
+					}
+				}
 				if (toolInvocation == null) throw new Error("tool-output-error must be preceded by a tool-input-available");
 				return toolInvocation;
 			}
-			function updateToolPart(options) {
+			function updateToolPart(options, existingPart) {
 				var _a17;
-				const part = state.message.parts.find((part2) => isToolUIPart$1(part2) && part2.toolCallId === options.toolCallId);
+				const part = existingPart != null ? existingPart : getCurrentStepParts().find((part2) => isToolUIPart$1(part2) && part2.toolCallId === options.toolCallId);
 				const anyOptions = options;
 				const anyPart = part;
 				if (part != null) {
@@ -4432,9 +4481,9 @@ function processUIMessageStream$1({ stream, messageMetadataSchema, dataPartSchem
 					...anyOptions.providerMetadata != null ? { callProviderMetadata: anyOptions.providerMetadata } : {}
 				});
 			}
-			function updateDynamicToolPart(options) {
+			function updateDynamicToolPart(options, existingPart) {
 				var _a17, _b2;
-				const part = state.message.parts.find((part2) => part2.type === "dynamic-tool" && part2.toolCallId === options.toolCallId);
+				const part = existingPart != null ? existingPart : getCurrentStepParts().find((part2) => part2.type === "dynamic-tool" && part2.toolCallId === options.toolCallId);
 				const anyOptions = options;
 				const anyPart = part;
 				if (part != null) {
@@ -4555,7 +4604,7 @@ function processUIMessageStream$1({ stream, messageMetadataSchema, dataPartSchem
 					write();
 					break;
 				case "tool-input-start": {
-					const toolInvocations = state.message.parts.filter(isToolUIPart$1);
+					const toolInvocations = getCurrentStepParts().filter(isToolUIPart$1);
 					state.partialToolCalls[chunk.toolCallId] = {
 						text: "",
 						toolName: chunk.toolName,
@@ -4650,7 +4699,7 @@ function processUIMessageStream$1({ stream, messageMetadataSchema, dataPartSchem
 							input: toolInvocation.input,
 							output: chunk.output,
 							preliminary: chunk.preliminary
-						});
+						}, toolInvocation);
 					} else {
 						const toolInvocation = getToolInvocation(chunk.toolCallId);
 						updateToolPart({
@@ -4661,7 +4710,7 @@ function processUIMessageStream$1({ stream, messageMetadataSchema, dataPartSchem
 							output: chunk.output,
 							providerExecuted: chunk.providerExecuted,
 							preliminary: chunk.preliminary
-						});
+						}, toolInvocation);
 					}
 					write();
 					break;
@@ -4675,7 +4724,7 @@ function processUIMessageStream$1({ stream, messageMetadataSchema, dataPartSchem
 							input: toolInvocation.input,
 							errorText: chunk.errorText,
 							providerExecuted: chunk.providerExecuted
-						});
+						}, toolInvocation);
 					} else {
 						const toolInvocation = getToolInvocation(chunk.toolCallId);
 						updateToolPart({
@@ -4686,7 +4735,7 @@ function processUIMessageStream$1({ stream, messageMetadataSchema, dataPartSchem
 							rawInput: toolInvocation.rawInput,
 							errorText: chunk.errorText,
 							providerExecuted: chunk.providerExecuted
-						});
+						}, toolInvocation);
 					}
 					write();
 					break;
@@ -4977,7 +5026,7 @@ function createUIMessageStream$1({ execute, onError = () => "An error occurred."
 	});
 }
 //#endregion
-//#region ../../packages/_vendored/ai_v6/dist/dist-BomuqvJJ.js
+//#region ../../packages/_vendored/ai_v6/dist/dist-BTWHzT8H.js
 var marker$1 = "vercel.ai.error";
 var symbol$1 = Symbol.for(marker$1);
 var _a$1;
@@ -5317,6 +5366,26 @@ var _b;
 		return AISDKError.hasMarker(error, marker$2);
 	}
 });
+var initialGlobalFetch = globalThis.fetch;
+isNodeDefaultFetch(initialGlobalFetch);
+function isNodeDefaultFetch(fetch) {
+	const source = Function.prototype.toString.call(fetch);
+	return source.includes("internal/deps/undici") || source.includes("lazy loading of undici");
+}
+function getCurrentModulePath() {
+	const originalPrepareStackTrace = Error.prepareStackTrace;
+	try {
+		Error.prepareStackTrace = (_error, callSites) => callSites;
+		const error = /* @__PURE__ */ new Error("Capture current module path");
+		Error.captureStackTrace(error, getCurrentModulePath);
+		const [caller] = error.stack;
+		const fileName = caller == null ? void 0 : caller.getFileName();
+		if (fileName == null) throw new Error("Unable to determine the current module path");
+		return fileName;
+	} finally {
+		Error.prepareStackTrace = originalPrepareStackTrace;
+	}
+}
 var createIdGenerator = ({ prefix, size = 16, alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", separator = "-" } = {}) => {
 	const generator = () => {
 		const alphabetLength = alphabet.length;
@@ -7267,6 +7336,25 @@ _a16 = symbol16;
 function asArray(value) {
 	return value === void 0 ? [] : Array.isArray(value) ? value : [value];
 }
+function mergeObjects(base, overrides) {
+	if (base === void 0 && overrides === void 0) return;
+	if (base === void 0) return overrides;
+	if (overrides === void 0) return base;
+	const result = { ...base };
+	for (const key in overrides) {
+		if (key === "__proto__" || key === "constructor" || key === "prototype") continue;
+		if (Object.prototype.hasOwnProperty.call(overrides, key)) {
+			const overridesValue = overrides[key];
+			if (overridesValue === void 0) continue;
+			const baseValue = key in base ? base[key] : void 0;
+			const isSourceObject = overridesValue !== null && typeof overridesValue === "object" && !Array.isArray(overridesValue) && !(overridesValue instanceof Date) && !(overridesValue instanceof RegExp);
+			const isTargetObject = baseValue !== null && baseValue !== void 0 && typeof baseValue === "object" && !Array.isArray(baseValue) && !(baseValue instanceof Date) && !(baseValue instanceof RegExp);
+			if (isSourceObject && isTargetObject) result[key] = mergeObjects(baseValue, overridesValue);
+			else result[key] = overridesValue;
+		}
+	}
+	return result;
+}
 var dataContentSchema = z.union([
 	z.string(),
 	z.instanceof(Uint8Array),
@@ -7450,25 +7538,6 @@ z.union([
 	assistantModelMessageSchema,
 	toolModelMessageSchema
 ]);
-function mergeObjects(base, overrides) {
-	if (base === void 0 && overrides === void 0) return;
-	if (base === void 0) return overrides;
-	if (overrides === void 0) return base;
-	const result = { ...base };
-	for (const key in overrides) {
-		if (key === "__proto__" || key === "constructor" || key === "prototype") continue;
-		if (Object.prototype.hasOwnProperty.call(overrides, key)) {
-			const overridesValue = overrides[key];
-			if (overridesValue === void 0) continue;
-			const baseValue = key in base ? base[key] : void 0;
-			const isSourceObject = overridesValue !== null && typeof overridesValue === "object" && !Array.isArray(overridesValue) && !(overridesValue instanceof Date) && !(overridesValue instanceof RegExp);
-			const isTargetObject = baseValue !== null && baseValue !== void 0 && typeof baseValue === "object" && !Array.isArray(baseValue) && !(baseValue instanceof Date) && !(baseValue instanceof RegExp);
-			if (isSourceObject && isTargetObject) result[key] = mergeObjects(baseValue, overridesValue);
-			else result[key] = overridesValue;
-		}
-	}
-	return result;
-}
 new TextEncoder();
 __export({}, {
 	array: () => array,
@@ -8080,8 +8149,27 @@ function processUIMessageStream({ stream, messageMetadataSchema, dataPartSchemas
 	return stream.pipeThrough(new TransformStream({ async transform(chunk, controller) {
 		await runUpdateMessageJob(async ({ state, write }) => {
 			var _a22, _b, _c, _d;
+			function getCurrentStepParts() {
+				const parts = state.message.parts;
+				let currentStepStartIndex = parts.length - 1;
+				while (currentStepStartIndex >= 0 && parts[currentStepStartIndex].type !== "step-start") currentStepStartIndex--;
+				return parts.slice(currentStepStartIndex + 1);
+			}
+			function getCurrentStepToolInvocations() {
+				return getCurrentStepParts().filter(isToolUIPart);
+			}
 			function getToolInvocation(toolCallId) {
-				const toolInvocation = state.message.parts.filter(isToolUIPart).find((invocation) => invocation.toolCallId === toolCallId);
+				let toolInvocation = getCurrentStepToolInvocations().find((invocation) => invocation.toolCallId === toolCallId);
+				if (toolInvocation == null) {
+					const parts = state.message.parts;
+					for (let i = parts.length - 1; i >= 0; i--) {
+						const part = parts[i];
+						if (isToolUIPart(part) && part.toolCallId === toolCallId) {
+							toolInvocation = part;
+							break;
+						}
+					}
+				}
 				if (toolInvocation == null) throw new UIMessageStreamError({
 					chunkType: "tool-invocation",
 					chunkId: toolCallId,
@@ -8089,9 +8177,9 @@ function processUIMessageStream({ stream, messageMetadataSchema, dataPartSchemas
 				});
 				return toolInvocation;
 			}
-			function updateToolPart(options) {
+			function updateToolPart(options, existingPart) {
 				var _a23;
-				const part = state.message.parts.find((part2) => isStaticToolUIPart(part2) && part2.toolCallId === options.toolCallId);
+				const part = existingPart != null ? existingPart : getCurrentStepParts().find((part2) => isStaticToolUIPart(part2) && part2.toolCallId === options.toolCallId);
 				const anyOptions = options;
 				const anyPart = part;
 				if (part != null) {
@@ -8125,9 +8213,9 @@ function processUIMessageStream({ stream, messageMetadataSchema, dataPartSchemas
 					...anyOptions.providerMetadata != null && !(options.state === "output-available" || options.state === "output-error") ? { callProviderMetadata: anyOptions.providerMetadata } : {}
 				});
 			}
-			function updateDynamicToolPart(options) {
+			function updateDynamicToolPart(options, existingPart) {
 				var _a23, _b2;
-				const part = state.message.parts.find((part2) => part2.type === "dynamic-tool" && part2.toolCallId === options.toolCallId);
+				const part = existingPart != null ? existingPart : getCurrentStepParts().find((part2) => part2.type === "dynamic-tool" && part2.toolCallId === options.toolCallId);
 				const anyOptions = options;
 				const anyPart = part;
 				if (part != null) {
@@ -8282,7 +8370,7 @@ function processUIMessageStream({ stream, messageMetadataSchema, dataPartSchemas
 					write();
 					break;
 				case "tool-input-start": {
-					const toolInvocations = state.message.parts.filter(isStaticToolUIPart);
+					const toolInvocations = getCurrentStepParts().filter(isStaticToolUIPart);
 					state.partialToolCalls[chunk.toolCallId] = {
 						text: "",
 						toolName: chunk.toolName,
@@ -8367,7 +8455,7 @@ function processUIMessageStream({ stream, messageMetadataSchema, dataPartSchemas
 					if (onToolCall && !chunk.providerExecuted) await onToolCall({ toolCall: chunk });
 					break;
 				case "tool-input-error": {
-					const existingPart = state.message.parts.filter(isToolUIPart).find((p) => p.toolCallId === chunk.toolCallId);
+					const existingPart = getCurrentStepParts().filter(isToolUIPart).find((p) => p.toolCallId === chunk.toolCallId);
 					if (existingPart != null ? existingPart.type === "dynamic-tool" : !!chunk.dynamic) updateDynamicToolPart({
 						toolCallId: chunk.toolCallId,
 						toolName: chunk.toolName,
@@ -8421,7 +8509,7 @@ function processUIMessageStream({ stream, messageMetadataSchema, dataPartSchemas
 						providerMetadata: chunk.providerMetadata,
 						title: toolInvocation.title,
 						toolMetadata: toolInvocation.toolMetadata
-					});
+					}, toolInvocation);
 					else updateToolPart({
 						toolCallId: chunk.toolCallId,
 						toolName: getStaticToolName(toolInvocation),
@@ -8433,7 +8521,7 @@ function processUIMessageStream({ stream, messageMetadataSchema, dataPartSchemas
 						providerMetadata: chunk.providerMetadata,
 						title: toolInvocation.title,
 						toolMetadata: toolInvocation.toolMetadata
-					});
+					}, toolInvocation);
 					write();
 					break;
 				}
@@ -8449,7 +8537,7 @@ function processUIMessageStream({ stream, messageMetadataSchema, dataPartSchemas
 						providerMetadata: chunk.providerMetadata,
 						title: toolInvocation.title,
 						toolMetadata: toolInvocation.toolMetadata
-					});
+					}, toolInvocation);
 					else updateToolPart({
 						toolCallId: chunk.toolCallId,
 						toolName: getStaticToolName(toolInvocation),
@@ -8461,7 +8549,7 @@ function processUIMessageStream({ stream, messageMetadataSchema, dataPartSchemas
 						providerMetadata: chunk.providerMetadata,
 						title: toolInvocation.title,
 						toolMetadata: toolInvocation.toolMetadata
-					});
+					}, toolInvocation);
 					write();
 					break;
 				}
@@ -9316,6 +9404,7 @@ function convertFullStreamChunkToUIMessageStream({ part, messageMetadataValue, s
 //#endregion
 //#region src/transformers.ts
 const PRIMITIVE_CACHE_SYMBOL = Symbol("primitive-cache");
+const COMPLETED_STEPS_SYMBOL = Symbol("completed-steps-cache");
 function cloneWorkflowStep(step, includeOutput) {
 	return {
 		name: step.name,
@@ -9443,7 +9532,8 @@ function createAgentStreamToAISDKTransformer(convertMastraChunkToAISDK, { lastMe
 			if (transformedChunk) if (transformedChunk.type === "tool-agent") {
 				const payload = transformedChunk.payload;
 				const agentTransformed = transformAgent(payload, bufferedSteps);
-				if (agentTransformed) controller.enqueue(agentTransformed);
+				if (agentTransformed) if (Array.isArray(agentTransformed)) for (const part of agentTransformed) controller.enqueue(part);
+				else controller.enqueue(agentTransformed);
 			} else if (transformedChunk.type === "tool-workflow") {
 				const payload = transformedChunk.payload;
 				const workflowChunk = transformWorkflow(payload, bufferedSteps, true, void 0, void 0, convertMastraChunkToAISDK);
@@ -9526,30 +9616,7 @@ function AgentStreamToAISDKV6Transformer({ lastMessageId, sendStart = true, send
 	});
 }
 function ensureAgentRunState(bufferedSteps, runId) {
-	if (!bufferedSteps.has(runId)) bufferedSteps.set(runId, {
-		id: "",
-		object: null,
-		finishReason: null,
-		usage: null,
-		warnings: [],
-		text: "",
-		reasoning: [],
-		sources: [],
-		files: [],
-		toolCalls: [],
-		pendingToolCalls: [],
-		toolResults: [],
-		request: {},
-		response: {
-			id: "",
-			timestamp: /* @__PURE__ */ new Date(),
-			modelId: "",
-			messages: []
-		},
-		providerMetadata: void 0,
-		steps: [],
-		status: "running"
-	});
+	if (!bufferedSteps.has(runId)) bufferedSteps.set(runId, createAgentRunState());
 	return bufferedSteps.get(runId);
 }
 function upsertPendingToolCall(pendingToolCalls = [], toolCallId, updates) {
@@ -9585,36 +9652,109 @@ function appendPendingToolCallArgs(pendingToolCalls = [], payload) {
 function removePendingToolCall(pendingToolCalls = [], toolCallId) {
 	return pendingToolCalls.filter((call) => call.toolCallId !== toolCallId);
 }
+function createAgentResponseState() {
+	return {
+		id: "",
+		timestamp: /* @__PURE__ */ new Date(),
+		modelId: "",
+		messages: []
+	};
+}
+function createAgentRunState(id = "") {
+	return {
+		id,
+		object: null,
+		finishReason: null,
+		usage: null,
+		warnings: [],
+		text: "",
+		reasoning: [],
+		sources: [],
+		files: [],
+		toolCalls: [],
+		pendingToolCalls: [],
+		toolResults: [],
+		request: {},
+		response: createAgentResponseState(),
+		providerMetadata: void 0,
+		steps: [],
+		status: "running"
+	};
+}
+function cloneAgentResponse(response, { includeMessages }) {
+	if (!response) return response;
+	return {
+		...response,
+		...Object.prototype.hasOwnProperty.call(response, "messages") ? { messages: includeMessages ? response.messages : [] } : {},
+		...Object.prototype.hasOwnProperty.call(response, "dbMessages") ? { dbMessages: includeMessages ? response.dbMessages : [] } : {},
+		...Object.prototype.hasOwnProperty.call(response, "uiMessages") ? { uiMessages: includeMessages ? response.uiMessages : [] } : {}
+	};
+}
+function cloneAgentStep(step, { includeDetails }) {
+	if (includeDetails) return {
+		...step,
+		response: cloneAgentResponse(step.response, { includeMessages: true })
+	};
+	return {
+		...step,
+		object: null,
+		files: [],
+		sources: [],
+		toolCalls: [],
+		pendingToolCalls: [],
+		toolResults: [],
+		dynamicToolCalls: [],
+		dynamicToolResults: [],
+		staticToolCalls: [],
+		staticToolResults: [],
+		text: "",
+		reasoning: [],
+		content: Array.isArray(step.content) ? [] : step.content,
+		reasoningText: typeof step.reasoningText === "string" ? "" : step.reasoningText,
+		response: cloneAgentResponse(step.response, { includeMessages: false })
+	};
+}
+function serializeAgentRun(current, { includeCompletedStepDetails, includeResponseMessages }) {
+	const { _textOffset: _to, _reasoningOffset: _ro, ...data } = current;
+	return {
+		...data,
+		response: cloneAgentResponse(data.response, { includeMessages: includeResponseMessages }),
+		steps: data.steps.map((step) => cloneAgentStep(step, { includeDetails: includeCompletedStepDetails }))
+	};
+}
+function createAgentDataPart(args) {
+	const { current, runId, includeCompletedStepDetails, includeResponseMessages } = args;
+	return {
+		type: "data-tool-agent",
+		id: runId,
+		data: serializeAgentRun(current, {
+			includeCompletedStepDetails,
+			includeResponseMessages
+		})
+	};
+}
+function createAgentStepDataPart(args) {
+	const { runId, stepIndex, step } = args;
+	return {
+		type: "data-tool-agent-step",
+		id: `${runId}:${stepIndex}`,
+		data: {
+			runId,
+			stepIndex,
+			step: cloneAgentStep(step, { includeDetails: true })
+		}
+	};
+}
 function transformAgent(payload, bufferedSteps) {
 	let hasChanged = false;
+	let completedStep = null;
 	switch (payload.type) {
-		case "start":
-			bufferedSteps.set(payload.runId, {
-				id: payload.payload.id,
-				object: null,
-				finishReason: null,
-				usage: null,
-				warnings: [],
-				text: "",
-				reasoning: [],
-				sources: [],
-				files: [],
-				toolCalls: [],
-				pendingToolCalls: [],
-				toolResults: [],
-				request: {},
-				response: {
-					id: "",
-					timestamp: /* @__PURE__ */ new Date(),
-					modelId: "",
-					messages: []
-				},
-				providerMetadata: void 0,
-				steps: [],
-				status: "running"
-			});
+		case "start": {
+			const startState = createAgentRunState(payload.payload.id);
+			bufferedSteps.set(payload.runId, startState);
 			hasChanged = true;
 			break;
+		}
 		case "tool-call-input-streaming-start": {
 			const toolInputStartRun = ensureAgentRunState(bufferedSteps, payload.runId);
 			const existing = toolInputStartRun.pendingToolCalls?.find((call) => call.toolCallId === payload.payload.toolCallId);
@@ -9745,6 +9885,7 @@ function transformAgent(payload, bufferedSteps) {
 			break;
 		case "step-finish": {
 			const stepRun = ensureAgentRunState(bufferedSteps, payload.runId);
+			const stepIndex = stepRun.steps.length;
 			const { steps: _steps, _textOffset, _reasoningOffset, ...stepRunWithoutSteps } = stepRun;
 			const textOffset = _textOffset || 0;
 			const reasoningOffset = _reasoningOffset || 0;
@@ -9786,18 +9927,28 @@ function transformAgent(payload, bufferedSteps) {
 				_textOffset: stepRun.text.length,
 				_reasoningOffset: stepRun.reasoning.length
 			});
+			completedStep = {
+				stepIndex,
+				step: stepResult
+			};
 			hasChanged = true;
 			break;
 		}
 		default: break;
 	}
 	if (hasChanged) {
-		const { _textOffset: _to, _reasoningOffset: _ro, ...data } = bufferedSteps.get(payload.runId);
-		return {
-			type: "data-tool-agent",
-			id: payload.runId,
-			data
-		};
+		const snapshot = createAgentDataPart({
+			current: bufferedSteps.get(payload.runId),
+			runId: payload.runId,
+			includeCompletedStepDetails: payload.type === "finish",
+			includeResponseMessages: payload.type === "finish"
+		});
+		if (completedStep) return [snapshot, createAgentStepDataPart({
+			runId: payload.runId,
+			stepIndex: completedStep.stepIndex,
+			step: completedStep.step
+		})];
+		return snapshot;
 	}
 	return null;
 }
@@ -10223,10 +10374,24 @@ function transformNetwork(payload, bufferedNetworks, isNested) {
 				const step = current.steps.find((step) => step.id === stepId);
 				if (!step) return null;
 				step[PRIMITIVE_CACHE_SYMBOL] = step[PRIMITIVE_CACHE_SYMBOL] || /* @__PURE__ */ new Map();
+				if (payload.payload.type === "start") delete step[COMPLETED_STEPS_SYMBOL];
 				const result = transformAgent(payload.payload, step[PRIMITIVE_CACHE_SYMBOL]);
-				if (result) {
-					const { request, response, ...data } = result.data;
+				const snapshot = Array.isArray(result) ? result[0] : result;
+				if (snapshot) {
+					const { request, response, ...data } = snapshot.data;
+					if (Array.isArray(result)) {
+						const { stepIndex, step: completedStepDetail } = result[1].data;
+						step[COMPLETED_STEPS_SYMBOL] = step[COMPLETED_STEPS_SYMBOL] || /* @__PURE__ */ new Map();
+						step[COMPLETED_STEPS_SYMBOL].set(stepIndex, completedStepDetail);
+					}
 					step.task = data;
+					const completedSteps = step[COMPLETED_STEPS_SYMBOL];
+					if (completedSteps && completedSteps.size > 0 && Array.isArray(data.steps)) {
+						for (const [stepIndex, completedStepDetail] of completedSteps) if (stepIndex < data.steps.length) data.steps[stepIndex] = {
+							...data.steps[stepIndex],
+							...completedStepDetail
+						};
+					}
 				}
 				bufferedNetworks.set(payload.runId, current);
 				return {
@@ -10350,6 +10515,124 @@ function toAISdkStream(stream, options = {
 	}));
 }
 //#endregion
+//#region src/sse-heartbeat.ts
+const SSE_HEARTBEAT_BYTES = new TextEncoder().encode(": heartbeat\n\n");
+const LF_BYTE = 10;
+const MAX_TIMEOUT_MS = 2147483647;
+/** Throws when an enabled heartbeat interval cannot be scheduled with a timer. */
+function assertValidHeartbeatMs(heartbeatMs) {
+	if (heartbeatMs !== void 0 && !(heartbeatMs <= 0) && (!Number.isFinite(heartbeatMs) || heartbeatMs > MAX_TIMEOUT_MS)) throw new RangeError(`heartbeatMs must be a finite number no greater than ${MAX_TIMEOUT_MS}`);
+}
+/**
+* Adds periodic SSE comment heartbeats to an AI SDK response body.
+* AI SDK serialization uses LF-delimited frames, which this private wrapper preserves and relies on.
+*/
+function withSseHeartbeat(response, heartbeatMs) {
+	assertValidHeartbeatMs(heartbeatMs);
+	if (heartbeatMs === void 0 || heartbeatMs <= 0 || !response.body) return response;
+	const reader = response.body.getReader();
+	let heartbeatTimeout;
+	let wakePull;
+	let readResult;
+	let readError;
+	let hasReadError = false;
+	let reading = false;
+	let finished = false;
+	let readerReleased = false;
+	let atFrameBoundary = true;
+	let lastByte;
+	let nextHeartbeatAt = performance.now() + heartbeatMs;
+	const clearHeartbeat = () => {
+		if (heartbeatTimeout !== void 0) {
+			clearTimeout(heartbeatTimeout);
+			heartbeatTimeout = void 0;
+		}
+	};
+	const releaseReader = () => {
+		if (readerReleased) return;
+		readerReleased = true;
+		reader.releaseLock();
+	};
+	const updateFrameBoundary = (chunk) => {
+		if (chunk.byteLength === 0) return;
+		atFrameBoundary = chunk.byteLength === 1 ? lastByte === LF_BYTE && chunk[0] === LF_BYTE : chunk[chunk.byteLength - 2] === LF_BYTE && chunk[chunk.byteLength - 1] === LF_BYTE;
+		lastByte = chunk[chunk.byteLength - 1];
+	};
+	const startRead = () => {
+		if (reading || readResult || hasReadError || finished) return;
+		reading = true;
+		reader.read().then((result) => {
+			reading = false;
+			readResult = result;
+			wakePull?.("read");
+		}, (error) => {
+			reading = false;
+			readError = error;
+			hasReadError = true;
+			wakePull?.("read");
+		});
+	};
+	const forwardRead = (controller) => {
+		if (hasReadError) {
+			finished = true;
+			releaseReader();
+			controller.error(readError);
+			return;
+		}
+		if (!readResult) return;
+		const result = readResult;
+		readResult = void 0;
+		if (result.done) {
+			finished = true;
+			releaseReader();
+			controller.close();
+			return;
+		}
+		updateFrameBoundary(result.value);
+		controller.enqueue(result.value);
+	};
+	const stream = new ReadableStream({
+		async pull(controller) {
+			if (finished) return;
+			startRead();
+			if (readResult || hasReadError) {
+				forwardRead(controller);
+				return;
+			}
+			const next = await new Promise((resolve) => {
+				wakePull = resolve;
+				if (atFrameBoundary) heartbeatTimeout = setTimeout(() => resolve("heartbeat"), Math.max(0, nextHeartbeatAt - performance.now()));
+			});
+			wakePull = void 0;
+			clearHeartbeat();
+			if (finished) return;
+			if (readResult || hasReadError) {
+				forwardRead(controller);
+				return;
+			}
+			if (next === "heartbeat") {
+				controller.enqueue(SSE_HEARTBEAT_BYTES.slice());
+				nextHeartbeatAt = performance.now() + heartbeatMs;
+			}
+		},
+		async cancel(reason) {
+			if (finished) return;
+			finished = true;
+			clearHeartbeat();
+			try {
+				await reader.cancel(reason);
+			} finally {
+				releaseReader();
+			}
+		}
+	});
+	return new Response(stream, {
+		status: response.status,
+		statusText: response.statusText,
+		headers: response.headers
+	});
+}
+//#endregion
 //#region src/chat-route.ts
 /**
 * Collects every approval response across all assistant messages in a v6
@@ -10552,11 +10835,13 @@ async function handleChatStream({ mastra, agentId, agentVersion, params, default
 * @param {boolean} [options.sendFinish=true] - Whether to send finish events in the stream
 * @param {boolean} [options.sendReasoning=false] - Whether to include reasoning steps in the stream
 * @param {boolean} [options.sendSources=false] - Whether to include source citations in the stream
+* @param {number} [options.heartbeatMs] - Target interval for periodic SSE comment heartbeats. Already-buffered source events and stream lifecycle signals take priority. Values up to 0 disable heartbeats. `NaN`, positive infinity, and values above 2,147,483,647 throw a `RangeError`.
 * @param {(error: unknown) => string} [options.onError] - Custom error serializer streamed to the client. When omitted, errors are passed through a default serializer that strips sensitive fields (e.g. `APICallError.requestBodyValues`, which holds the system prompt) before they reach the client.
 *
 * @returns {ReturnType<typeof registerApiRoute>} A registered API route handler
 *
 * @throws {Error} When path doesn't include `:agentId` and no fixed agent is specified
+* @throws {RangeError} When `heartbeatMs` is `NaN`, positive infinity, or greater than 2,147,483,647
 * @throws {Error} When agent ID is missing at runtime
 * @throws {Error} When specified agent is not found in Mastra instance
 *
@@ -10579,12 +10864,13 @@ async function handleChatStream({ mastra, agentId, agentVersion, params, default
 * @remarks
 * - The route handler expects a JSON body with a `messages` array
 * - Messages should follow the format: `{ role: 'user' | 'assistant' | 'system', content: string }`
-* - The response is a Server-Sent Events (SSE) stream compatible with AI SDK v5
+* - The response is a Server-Sent Events (SSE) stream compatible with the selected AI SDK version
 * - If both `agent` and `:agentId` are present, a warning is logged and the fixed `agent` takes precedence
 * - Request context from the incoming request overrides `defaultOptions.requestContext` if both are present
 */
-function chatRoute({ path = "/chat/:agentId", agent, defaultOptions, experimentalTransform, version = "v5", agentVersion, sendStart = true, sendFinish = true, sendReasoning = false, sendSources = false, onError }) {
+function chatRoute({ path = "/chat/:agentId", agent, defaultOptions, experimentalTransform, version = "v5", agentVersion, sendStart = true, sendFinish = true, sendReasoning = false, sendSources = false, heartbeatMs, onError }) {
 	if (!agent && !path.includes("/:agentId")) throw new Error("Path must include :agentId to route to the correct agent or pass the agent explicitly");
+	assertValidHeartbeatMs(heartbeatMs);
 	return registerApiRoute(path, {
 		method: "POST",
 		openapi: {
@@ -10713,11 +10999,13 @@ function chatRoute({ path = "/chat/:agentId", agent, defaultOptions, experimenta
 				sendSources,
 				onError
 			};
-			if (version === "v6") return createUIMessageStreamResponse({ stream: await handleChatStream({
+			let response;
+			if (version === "v6") response = createUIMessageStreamResponse({ stream: await handleChatStream({
 				...handlerOptions,
 				version: "v6"
 			}) });
-			return createUIMessageStreamResponse$1({ stream: await handleChatStream(handlerOptions) });
+			else response = createUIMessageStreamResponse$1({ stream: await handleChatStream(handlerOptions) });
+			return withSseHeartbeat(response, heartbeatMs);
 		}
 	});
 }