@tanstack/ai 0.47.3 → 0.48.0

package/dist/esm/activities/chat/index.js

@@ -1,10 +1,12 @@
-import { stripToSpecMiddleware } from "../../strip-to-spec-middleware.js";
 import { isCancelRequestedReason } from "./cancel.js";
 import { CapabilityRegistry } from "./middleware/capabilities.js";
 import { getRunDetached } from "./middleware/run-store.js";
 import { publishRunDetachedSignal } from "../../delivery-detach.js";
 import { publishRunDisconnectHandler } from "../../delivery-disconnect.js";
 import { EventType } from "../../types.js";
+import { rebuildTokenUsage } from "../../utilities/ag-ui-usage.js";
+import { tanstackMetadata, withTanstackMetadata } from "../../utilities/merge-metadata.js";
+import { normalizeStreamChunk } from "../../utilities/normalize-stream-chunk.js";
 import { resolveDebugOption } from "../../logger/resolve.js";
 import { streamToText } from "../../stream-to-response.js";
 import { canonicalInterruptJson, digestInterruptJson } from "../../interrupt-serialization.js";
@@ -14,13 +16,15 @@ import { hashSchemaInput, normalizeApprovalSchema } from "./tools/approval-schem
 import { INTERRUPT_BINDING_METADATA_KEY, InterruptResumeValidationError, readInterruptBinding, readUnopenedInterruptBinding, validateInterruptResumeBatch } from "../../interrupt-resume.js";
 import { INTERRUPT_PAYLOAD_METADATA_KEY, createInterruptBinding, rehydrateInterruptRequest } from "../../interrupt-definition.js";
 import { readGenericInterruptContinuation } from "../../generic-interrupt-continuation.js";
+import { uiMessagesToWire } from "../../utilities/ag-ui-wire.js";
+import { restorePublicUsage } from "../../utilities/restore-inbound-chunk.js";
 import { normalizeToolResult } from "../../utilities/tool-result.js";
 import { isProviderExecutedToolCall } from "../../utilities/provider-executed.js";
 import { LazyToolManager } from "./tools/lazy-tool-manager.js";
 import { assertUniqueToolNames } from "./tools/unique-tool-names.js";
 import { MiddlewareAbortError, ToolCallManager, executeToolCalls } from "./tools/tool-calls.js";
 import { maxIterations } from "./agent-loop-strategies.js";
-import { convertMessagesToModelMessages, generateMessageId, modelMessageToUIMessage, safeJsonStringify } from "./messages.js";
+import { convertMessagesToModelMessages, generateMessageId, modelMessagesToUIMessages, safeJsonStringify } from "./messages.js";
 import { MiddlewareRunner } from "./middleware/compose.js";
 import { provideSandboxRuntime } from "./middleware/sandbox-runtime.js";
 import { provideRunDisconnect } from "./middleware/run-disconnect.js";
@@ -128,7 +132,6 @@ var TextEngine = class {
 	accumulatedThinking = [];
 	currentThinkingContent = "";
 	currentThinkingSignature = "";
-	hasSeenReasoningEvents = false;
 	eventOptions;
 	eventToolNames;
 	finishedEvent = null;
@@ -201,11 +204,7 @@ var TextEngine = class {
 		this.threadId = config.params.threadId || config.params.conversationId || this.createId("thread");
 		this.runIdOverride = config.params.runId;
 		this.parentRunIdOverride = config.params.parentRunId;
-		const allMiddleware = [
-			devtoolsMiddleware(),
-			...config.middleware || [],
-			stripToSpecMiddleware()
-		];
+		const allMiddleware = [devtoolsMiddleware(), ...config.middleware || []];
 		this.middlewareRunner = new MiddlewareRunner(allMiddleware, logger);
 		this.middlewareAbortController = new AbortController();
 		this.toolAbortSignal = combineAbortSignals(this.effectiveSignal, this.middlewareAbortController.signal);
@@ -321,7 +320,7 @@ var TextEngine = class {
 						finishReason: this.lastFinishReason,
 						duration: Date.now() - this.streamStartTime,
 						content: this.accumulatedContent,
-						usage: this.finishedEvent?.usage
+						usage: rebuildTokenUsage(this.finishedEvent?.usage, tanstackMetadata(this.finishedEvent ?? void 0)?.usage)
 					});
 				}
 				return;
@@ -379,25 +378,24 @@ var TextEngine = class {
 						finishReason: this.lastFinishReason,
 						duration: Date.now() - this.streamStartTime,
 						content: this.accumulatedContent,
-						usage: this.finishedEvent?.usage
+						usage: rebuildTokenUsage(this.finishedEvent?.usage, tanstackMetadata(this.finishedEvent ?? void 0)?.usage)
 					});
 				}
 			}
 		} catch (error) {
 			if (error instanceof Error && error.name === "InterruptReplaySignal" && "continuationRunId" in error && typeof error.continuationRunId === "string") {
 				this.terminalHookCalled = true;
-				yield {
+				yield* this.pipeThroughMiddleware({
 					type: EventType.RUN_FINISHED,
 					timestamp: Date.now(),
 					threadId: this.threadId,
 					runId: this.runIdOverride ?? this.requestId,
-					finishReason: "stop",
 					outcome: { type: "success" },
 					result: {
 						replayed: true,
 						continuationRunId: error.continuationRunId
 					}
-				};
+				});
 				return;
 			}
 			const interruptFailure = structuralInterruptFailure(error);
@@ -477,7 +475,6 @@ var TextEngine = class {
 		this.accumulatedThinking = [];
 		this.currentThinkingContent = "";
 		this.currentThinkingSignature = "";
-		this.hasSeenReasoningEvents = false;
 		this.finishedEvent = null;
 		this.streamedToolErrorResults.clear();
 		this.middlewareCtx.currentMessageId = this.currentMessageId;
@@ -506,7 +503,7 @@ var TextEngine = class {
 		const { approvals } = this.collectClientState();
 		const adapterApprovals = /* @__PURE__ */ new Map();
 		for (const [approvalId, resolution] of approvals) adapterApprovals.set(approvalId, typeof resolution === "boolean" ? resolution : resolution.approved);
-		for await (const chunk of this.adapter.chatStream({
+		for await (const raw of this.adapter.chatStream({
 			model: this.params.model,
 			messages: this.messages,
 			tools: toolsWithJsonSchemas,
@@ -524,18 +521,18 @@ var TextEngine = class {
 		})) {
 			if (this.isCancelled()) break;
 			this.totalChunkCount++;
-			this.handleStreamChunk(chunk);
-			if (chunk.type === EventType.CUSTOM && chunk.name === "structured-output.start") {
+			this.handleStreamChunk(raw);
+			if (raw.type === EventType.CUSTOM && raw.name === "structured-output.start") {
 				this.combinedStartEmitted = true;
-				const startValue = chunk.value;
+				const startValue = raw.value;
 				if (startValue && typeof startValue === "object" && "messageId" in startValue && typeof startValue.messageId === "string") {
 					this.combinedStructuredMessageId = startValue.messageId;
 					this.captureStructuredOutputMessageIdentity(startValue.messageId);
 				}
 			}
-			let outboundChunk = chunk;
-			if (this.finalStructuredOutput?.source === "event" && chunk.type === EventType.CUSTOM && chunk.name === "structured-output.complete") {
-				const parsed = readStructuredOutputCompleteValue(chunk.value);
+			let outboundChunk = raw;
+			if (this.finalStructuredOutput?.source === "event" && raw.type === EventType.CUSTOM && raw.name === "structured-output.complete") {
+				const parsed = readStructuredOutputCompleteValue(raw.value);
 				if (parsed) {
 					const object = this.finalStructuredOutput.normalize ? this.finalStructuredOutput.normalize(parsed.object) : parsed.object;
 					this.structuredOutputResult = {
@@ -543,14 +540,14 @@ var TextEngine = class {
 						rawText: parsed.raw
 					};
 					this.combinedCompleteEmitted = true;
-					const value = chunk.value;
+					const value = raw.value;
 					const completeMessageId = readCustomEventMessageId(value);
 					if (completeMessageId) {
 						this.combinedStructuredMessageId = completeMessageId;
 						this.captureStructuredOutputMessageIdentity(completeMessageId);
 					}
 					if (object !== parsed.object && value && typeof value === "object") outboundChunk = {
-						...chunk,
+						...raw,
 						value: {
 							...value,
 							object
@@ -558,43 +555,38 @@ var TextEngine = class {
 					};
 				}
 			}
-			if (this.finalStructuredOutput?.nativeCombined === true && this.finalStructuredOutput.yieldChunks && this.finalStructuredOutput.source !== "event" && !this.combinedStartEmitted && chunk.type === EventType.TEXT_MESSAGE_START) {
+			if (this.finalStructuredOutput?.nativeCombined === true && this.finalStructuredOutput.yieldChunks && this.finalStructuredOutput.source !== "event" && !this.combinedStartEmitted && raw.type === EventType.TEXT_MESSAGE_START) {
 				this.combinedStartEmitted = true;
-				const messageId = typeof chunk.messageId === "string" && chunk.messageId !== "" ? chunk.messageId : generateMessageId();
+				const messageId = typeof raw.messageId === "string" && raw.messageId !== "" ? raw.messageId : generateMessageId();
 				this.combinedStructuredMessageId = messageId;
 				const synthStart = {
 					type: EventType.CUSTOM,
 					name: "structured-output.start",
 					value: { messageId },
-					model: this.params.model,
-					timestamp: Date.now(),
-					threadId: this.threadId,
-					...this.runIdOverride ? { runId: this.runIdOverride } : {}
+					timestamp: Date.now()
 				};
 				const synthOutputs = await this.middlewareRunner.runOnChunk(this.middlewareCtx, synthStart);
-				for (const outputChunk of synthOutputs) {
-					yield outputChunk;
-					this.middlewareCtx.chunkIndex++;
-				}
+				yield* this.emitPublicChunks(synthOutputs);
 			}
 			const outputChunks = await this.middlewareRunner.runOnChunk(this.middlewareCtx, outboundChunk);
 			const suppressAgentLifecycle = !!this.finalStructuredOutput && this.finalStructuredOutput.yieldChunks && this.finalStructuredOutput.nativeCombined !== true;
-			for (const outputChunk of outputChunks) {
-				if (suppressAgentLifecycle && (outputChunk.type === EventType.RUN_STARTED || outputChunk.type === EventType.RUN_FINISHED)) continue;
-				if (outputChunk.type === EventType.RUN_FINISHED) {
-					this.deferredModelRunFinishedChunks.push(outputChunk);
+			for (const outputChunk of outputChunks) for (const spec of normalizeStreamChunk(outputChunk)) {
+				restorePublicUsage(spec);
+				if (suppressAgentLifecycle && (spec.type === EventType.RUN_STARTED || spec.type === EventType.RUN_FINISHED)) continue;
+				if (spec.type === EventType.RUN_FINISHED) {
+					this.deferredModelRunFinishedChunks.push(spec);
 					continue;
 				}
-				if (this.shouldDeferToolCallRunFinished(outputChunk)) {
-					this.deferredToolCallRunFinishedChunks.push(outputChunk);
+				if (this.shouldDeferToolCallRunFinished(spec)) {
+					this.deferredToolCallRunFinishedChunks.push(spec);
 					continue;
 				}
-				if (outputChunk.type === EventType.RUN_STARTED) this.hasPublicRunStarted = true;
-				this.logger.output(`type=${outputChunk.type}`, { chunk: outputChunk });
-				yield outputChunk;
+				if (spec.type === EventType.RUN_STARTED) this.hasPublicRunStarted = true;
+				this.logger.output(`type=${spec.type}`, { chunk: spec });
+				yield spec;
 				this.middlewareCtx.chunkIndex++;
 			}
-			if (chunk.type === "RUN_FINISHED" && chunk.usage) await this.middlewareRunner.runOnUsage(this.middlewareCtx, chunk.usage);
+			if (raw.type === EventType.RUN_FINISHED) await this.runOnUsageFromChunk(raw);
 			yield* this.drainSandboxFileQueue();
 			if (this.earlyTermination) break;
 		}
@@ -617,6 +609,9 @@ var TextEngine = class {
 			case "TOOL_CALL_END":
 				this.handleToolCallEndEvent(chunk);
 				break;
+			case "TOOL_CALL_RESULT":
+				this.handleToolCallResultEvent(chunk);
+				break;
 			case "RUN_FINISHED":
 				this.handleRunFinishedEvent(chunk);
 				break;
@@ -629,11 +624,15 @@ var TextEngine = class {
 			case "STEP_FINISHED":
 				this.handleStepFinishedEvent(chunk);
 				break;
-			case "REASONING_MESSAGE_CONTENT": this.handleReasoningMessageContentEvent(chunk);
+			case "REASONING_MESSAGE_CONTENT":
+				this.handleReasoningMessageContentEvent(chunk);
+				break;
+			case "REASONING_ENCRYPTED_VALUE": this.handleReasoningEncryptedValueEvent(chunk);
 		}
 	}
 	handleTextMessageContentEvent(chunk) {
-		if (chunk.content) this.accumulatedContent = chunk.content;
+		const extra = chunk;
+		if (typeof extra.content === "string" && extra.content !== "") this.accumulatedContent = extra.content;
 		else this.accumulatedContent += chunk.delta;
 		this.middlewareCtx.accumulatedContent = this.accumulatedContent;
 	}
@@ -652,34 +651,58 @@ var TextEngine = class {
 	handleToolCallStartEvent(chunk) {
 		if (typeof chunk.parentMessageId === "string" && chunk.parentMessageId !== "") this.captureStreamMessageIdentity(chunk.parentMessageId);
 		this.toolCallManager.addToolCallStartEvent(chunk);
+		const metadata = chunk.metadata;
+		const thoughtSignature = metadata != null && typeof metadata === "object" && "thoughtSignature" in metadata && typeof metadata.thoughtSignature === "string" && metadata.thoughtSignature !== "" ? metadata.thoughtSignature : void 0;
+		if (thoughtSignature === void 0) return;
+		const call = this.toolCallManager.getToolCalls().find((candidate) => candidate.id === chunk.toolCallId);
+		if (!call) return;
+		call.metadata = {
+			...call.metadata != null && typeof call.metadata === "object" ? call.metadata : {},
+			thoughtSignature
+		};
 	}
 	handleToolCallArgsEvent(chunk) {
 		this.toolCallManager.addToolCallArgsEvent(chunk);
 	}
 	handleToolCallEndEvent(chunk) {
 		this.toolCallManager.completeToolCall(chunk);
-		if (chunk.state !== "output-error" || chunk.result === void 0) return;
+		const end = chunk;
+		if ((end.state ?? tanstackMetadata(end)?.state) !== "output-error" || end.result === void 0) return;
+		this.handleToolCallResultEvent({
+			type: EventType.TOOL_CALL_RESULT,
+			toolCallId: chunk.toolCallId,
+			content: Array.isArray(end.result) ? JSON.stringify(end.result) : end.result,
+			messageId: chunk.toolCallId,
+			metadata: { tanstack: { state: "output-error" } }
+		});
+	}
+	handleToolCallResultEvent(chunk) {
+		if (!(tanstackMetadata(chunk)?.state === "output-error")) return;
 		const toolCall = this.toolCallManager.getToolCalls().find((candidate) => candidate.id === chunk.toolCallId);
 		if (!toolCall) return;
 		this.streamedToolErrorResults.set(chunk.toolCallId, {
 			toolCallId: chunk.toolCallId,
 			toolName: toolCall.function.name,
-			result: chunk.result,
-			...chunk.input !== void 0 && { input: chunk.input },
+			result: chunk.content,
 			state: "output-error"
 		});
 	}
 	handleRunFinishedEvent(chunk) {
 		this.finishedEvent = chunk;
-		this.lastFinishReason = chunk.finishReason ?? null;
+		const top = chunk.finishReason;
+		this.lastFinishReason = top === "stop" || top === "length" || top === "content_filter" || top === "tool_calls" || top === null ? top : tanstackMetadata(chunk)?.finishReason ?? null;
+	}
+	async runOnUsageFromChunk(chunk) {
+		const rebuilt = rebuildTokenUsage(chunk.usage, tanstackMetadata(chunk)?.usage);
+		if (rebuilt) await this.middlewareRunner.runOnUsage(this.middlewareCtx, rebuilt);
 	}
 	handleRunErrorEvent(chunk) {
 		this.earlyTermination = true;
 		if (this.finalizationError === null) {
-			const message = chunk.message || chunk.error?.message || "Run failed";
+			const message = chunk.message || "Run failed";
 			this.finalizationError = {
 				message,
-				...chunk.code !== void 0 ? { code: chunk.code } : chunk.error?.code !== void 0 ? { code: chunk.error.code } : {}
+				...chunk.code !== void 0 ? { code: chunk.code } : {}
 			};
 		}
 	}
@@ -697,19 +720,22 @@ var TextEngine = class {
 		this.finalizeCurrentThinkingStep();
 	}
 	handleStepFinishedEvent(chunk) {
-		if (!this.hasSeenReasoningEvents) {
-			if (chunk.delta) this.currentThinkingContent += chunk.delta;
-			else if (chunk.content) {
-				if (chunk.content.startsWith(this.currentThinkingContent)) this.currentThinkingContent = chunk.content;
-				else if (!this.currentThinkingContent.startsWith(chunk.content)) this.currentThinkingContent += chunk.content;
-			}
-		}
-		if (chunk.signature) this.currentThinkingSignature = chunk.signature;
+		if (typeof chunk.signature === "string" && chunk.signature !== "") this.currentThinkingSignature = chunk.signature;
 	}
 	handleReasoningMessageContentEvent(chunk) {
-		this.hasSeenReasoningEvents = true;
 		this.currentThinkingContent += chunk.delta;
 	}
+	handleReasoningEncryptedValueEvent(chunk) {
+		if (chunk.subtype === "tool-call") {
+			const call = this.messages.flatMap((message) => message.toolCalls ?? []).find((toolCall) => toolCall.id === chunk.entityId);
+			if (call) call.metadata = {
+				...call.metadata != null && typeof call.metadata === "object" ? call.metadata : {},
+				thoughtSignature: chunk.encryptedValue
+			};
+			return;
+		}
+		this.currentThinkingSignature = chunk.encryptedValue;
+	}
 	/**
 	* Tools available for execution this turn. The discovery tool is dropped
 	* from the advertised set (`this.tools`) once every lazy tool is discovered,
@@ -910,7 +936,7 @@ var TextEngine = class {
 		this.setToolPhase("continue");
 	}
 	shouldDeferToolCallRunFinished(chunk) {
-		return chunk.type === EventType.RUN_FINISHED && this.finishedEvent?.finishReason === "tool_calls" && this.tools.length > 0 && this.toolCallManager.hasToolCalls();
+		return chunk.type === EventType.RUN_FINISHED && this.lastFinishReason === "tool_calls" && this.tools.length > 0 && this.toolCallManager.hasToolCalls();
 	}
 	*flushDeferredToolCallRunFinishedChunks() {
 		for (const chunk of this.deferredToolCallRunFinishedChunks) {
@@ -934,16 +960,12 @@ var TextEngine = class {
 			type: EventType.RUN_STARTED,
 			runId: finishEvent.runId,
 			threadId: finishEvent.threadId,
-			model: finishEvent.model,
 			timestamp: Date.now()
 		});
 	}
 	async *emitSuccessfulEarlyTermination() {
 		this.lastFinishReason = "stop";
-		const finishEvent = {
-			...this.createSyntheticFinishedEvent(),
-			finishReason: "stop"
-		};
+		const finishEvent = this.createSyntheticFinishedEvent("stop");
 		yield* this.emitSyntheticRunStarted(finishEvent);
 		yield* this.pipeThroughMiddleware({
 			...finishEvent,
@@ -955,7 +977,7 @@ var TextEngine = class {
 		this.deferredToolCallRunFinishedChunks = [];
 	}
 	shouldExecuteToolPhase() {
-		return this.finishedEvent?.finishReason === "tool_calls" && this.tools.length > 0 && this.toolCallManager.hasToolCalls();
+		return this.lastFinishReason === "tool_calls" && this.tools.length > 0 && this.toolCallManager.hasToolCalls();
 	}
 	addAssistantToolCallMessage(toolCalls) {
 		this.finalizeCurrentThinkingStep();
@@ -1168,24 +1190,14 @@ var TextEngine = class {
 		};
 	}
 	buildMessagesSnapshotChunk() {
-		const messages = this.messages.map((message, index) => {
-			const content = typeof message.content === "string" ? message.content : message.content === null ? void 0 : JSON.stringify(message.content);
-			const id = message.id || `snapshot_${this.runIdOverride ?? this.requestId}_${index}`;
-			const parts = message.role === "assistant" && (message.thinking?.length || message.structuredOutput) ? modelMessageToUIMessage(message, id).parts : void 0;
-			return {
-				id,
-				role: message.role,
-				...content !== void 0 ? { content } : {},
-				...parts ? { parts } : {},
-				..."toolCalls" in message && message.toolCalls ? { toolCalls: message.toolCalls } : {},
-				..."toolCallId" in message && message.toolCallId ? { toolCallId: message.toolCallId } : {}
-			};
-		});
+		const withIds = this.messages.map((message, index) => ({
+			...message,
+			id: message.id || `snapshot_${this.runIdOverride ?? this.requestId}_${index}`
+		}));
 		return {
 			type: EventType.MESSAGES_SNAPSHOT,
 			timestamp: Date.now(),
-			model: this.params.model,
-			messages
+			messages: uiMessagesToWire(modelMessagesToUIMessages(withIds))
 		};
 	}
 	publicInterruptTerminal(chunk) {
@@ -1232,19 +1244,16 @@ var TextEngine = class {
 	}
 	buildInterruptRunErrorChunk(error) {
 		const failure = this.interruptFailure(error);
-		return {
+		return withTanstackMetadata({
 			type: EventType.RUN_ERROR,
 			timestamp: Date.now(),
+			message: failure.message,
+			code: failure.code
+		}, {
 			runId: this.runIdOverride ?? this.requestId,
 			threadId: this.threadId,
-			message: failure.message,
-			code: failure.code,
-			error: {
-				message: failure.message,
-				code: failure.code
-			},
-			...failure.errors !== void 0 ? { "tanstack:interruptErrors": failure.errors } : {}
-		};
+			...failure.errors !== void 0 ? { interruptErrors: failure.errors } : {}
+		});
 	}
 	async *emitInterruptRunError(error) {
 		const failure = this.interruptFailure(error);
@@ -1261,7 +1270,7 @@ var TextEngine = class {
 		const terminal = this.completeEphemeralInterruptBindings(this.buildInterruptFinishedChunk(finishEvent, approvals, clientRequests, genericRequests, genericInterruptIds));
 		let terminalOutputs;
 		try {
-			terminalOutputs = await this.middlewareRunner.runOnChunk(this.middlewareCtx, terminal);
+			terminalOutputs = [...this.emitPublicChunks(await this.middlewareRunner.runOnChunk(this.middlewareCtx, terminal))];
 		} catch (error) {
 			yield* this.emitInterruptRunError(error);
 			return false;
@@ -1270,13 +1279,9 @@ var TextEngine = class {
 		if (this.params.state !== void 0) yield* this.pipeThroughMiddleware({
 			type: EventType.STATE_SNAPSHOT,
 			timestamp: Date.now(),
-			model: this.params.model,
 			snapshot: this.params.state
 		});
-		for (const output of terminalOutputs) {
-			yield this.publicInterruptTerminal(output);
-			this.middlewareCtx.chunkIndex++;
-		}
+		for (const output of terminalOutputs) yield this.publicInterruptTerminal(output);
 		return true;
 	}
 	async *emitBoundaryInterrupts(phase, finishEvent, toolCalls = [], requests) {
@@ -1357,52 +1362,42 @@ var TextEngine = class {
 			}
 		};
 	}
-	buildToolResultChunks(results, finishEvent, argsMap) {
+	buildToolResultChunks(results, _finishEvent, argsMap) {
 		const chunks = [];
 		for (const result of results) {
 			const content = normalizeToolResult(result.result);
 			const wireContent = typeof content === "string" ? content : JSON.stringify(content);
 			if (argsMap) {
 				chunks.push({
-					type: "TOOL_CALL_START",
+					type: EventType.TOOL_CALL_START,
 					timestamp: Date.now(),
-					model: finishEvent.model,
 					toolCallId: result.toolCallId,
 					toolCallName: result.toolName,
 					toolName: result.toolName
 				});
 				const args = argsMap.get(result.toolCallId) ?? "{}";
 				chunks.push({
-					type: "TOOL_CALL_ARGS",
+					type: EventType.TOOL_CALL_ARGS,
 					timestamp: Date.now(),
-					model: finishEvent.model,
 					toolCallId: result.toolCallId,
-					delta: args,
-					args
+					delta: args
 				});
 				chunks.push({
-					type: "TOOL_CALL_END",
+					type: EventType.TOOL_CALL_END,
 					timestamp: Date.now(),
-					model: finishEvent.model,
-					toolCallId: result.toolCallId,
-					toolCallName: result.toolName,
-					toolName: result.toolName,
-					result: wireContent,
-					...result.input !== void 0 && { input: result.input },
-					...result.output !== void 0 && { output: result.output },
-					...result.state !== void 0 && { state: result.state }
+					toolCallId: result.toolCallId
 				});
 			}
-			chunks.push({
-				type: "TOOL_CALL_RESULT",
+			const parentMessageId = [...this.messages].reverse().find((message) => message.role === "assistant")?.id;
+			const resultChunk = {
+				type: EventType.TOOL_CALL_RESULT,
 				timestamp: Date.now(),
-				model: finishEvent.model,
-				messageId: this.createId("tool-result"),
+				messageId: parentMessageId || result.toolCallId,
 				toolCallId: result.toolCallId,
 				content: wireContent,
-				role: "tool",
-				...result.state !== void 0 && { state: result.state }
-			});
+				role: "tool"
+			};
+			chunks.push(result.state === "output-error" ? withTanstackMetadata(resultChunk, { state: result.state }) : resultChunk);
 			const placeholderIdx = this.messages.findIndex((m) => {
 				if (m.role !== "tool" || m.toolCallId !== result.toolCallId) return false;
 				if (typeof m.content !== "string") return false;
@@ -1475,15 +1470,16 @@ var TextEngine = class {
 		}
 		return pending;
 	}
-	createSyntheticFinishedEvent() {
-		return {
-			type: "RUN_FINISHED",
+	createSyntheticFinishedEvent(finishReason = "tool_calls") {
+		return withTanstackMetadata({
+			type: EventType.RUN_FINISHED,
 			runId: this.runIdOverride ?? this.requestId,
 			threadId: this.threadId,
-			model: this.params.model,
-			timestamp: Date.now(),
-			finishReason: "tool_calls"
-		};
+			timestamp: Date.now()
+		}, {
+			finishReason,
+			model: this.params.model
+		});
 	}
 	async shouldContinue() {
 		if (this.cyclePhase === "executeToolCalls") return true;
@@ -1669,75 +1665,69 @@ var TextEngine = class {
 				type: EventType.CUSTOM,
 				name: "structured-output.start",
 				value: { messageId: idForStart },
-				model: this.params.model,
-				timestamp,
-				threadId: this.threadId,
-				...this.runIdOverride ? { runId: this.runIdOverride } : {}
+				timestamp
 			};
 		};
-		const pipeThroughMiddleware = async (synthChunk) => this.middlewareRunner.runOnChunk(this.middlewareCtx, synthChunk);
+		const runChunkMiddleware = (synthChunk) => this.middlewareRunner.runOnChunk(this.middlewareCtx, synthChunk);
 		let runErrorYielded = false;
-		for await (const chunk of providerStream) {
+		for await (const raw of providerStream) {
 			if (this.isCancelled()) break;
-			if (!startEmitted && chunk.type === EventType.CUSTOM && chunk.name === "structured-output.start") startEmitted = true;
-			if (!structuredMessageId) {
-				const extracted = extractMessageId(chunk);
-				if (extracted) {
-					structuredMessageId = extracted;
-					this.captureStructuredOutputMessageIdentity(extracted);
+			{
+				const chunk = raw;
+				if (!startEmitted && chunk.type === EventType.CUSTOM && chunk.name === "structured-output.start") startEmitted = true;
+				if (!structuredMessageId) {
+					const extracted = extractMessageId(chunk);
+					if (extracted) {
+						structuredMessageId = extracted;
+						this.captureStructuredOutputMessageIdentity(extracted);
+					}
 				}
-			}
-			if (this.finalStructuredOutput.yieldChunks) {
-				if (!startEmitted && (chunk.type === EventType.TEXT_MESSAGE_START || chunk.type === EventType.TEXT_MESSAGE_CONTENT || chunk.type === EventType.TEXT_MESSAGE_END)) {
-					startEmitted = true;
-					const synthOutputs = await pipeThroughMiddleware(buildSynthesizedStart(chunk.timestamp));
-					for (const outputChunk of synthOutputs) {
-						yield outputChunk;
-						this.middlewareCtx.chunkIndex++;
+				if (this.finalStructuredOutput.yieldChunks) {
+					if (!startEmitted && (chunk.type === EventType.TEXT_MESSAGE_START || chunk.type === EventType.TEXT_MESSAGE_CONTENT || chunk.type === EventType.TEXT_MESSAGE_END)) {
+						startEmitted = true;
+						const synthStart = buildSynthesizedStart(chunk.timestamp);
+						yield* this.emitPublicChunks(await runChunkMiddleware(synthStart));
+					}
+					if (!startEmitted && chunk.type === EventType.RUN_ERROR) {
+						startEmitted = true;
+						const synthStart = buildSynthesizedStart(chunk.timestamp);
+						yield* this.emitPublicChunks(await runChunkMiddleware(synthStart));
 					}
 				}
-				if (!startEmitted && chunk.type === EventType.RUN_ERROR) {
-					startEmitted = true;
-					const synthOutputs = await pipeThroughMiddleware(buildSynthesizedStart(chunk.timestamp));
-					for (const outputChunk of synthOutputs) {
-						yield outputChunk;
-						this.middlewareCtx.chunkIndex++;
+				let outboundChunk = chunk;
+				if (chunk.type === EventType.CUSTOM && chunk.name === "structured-output.complete") {
+					const parsed = readStructuredOutputCompleteValue(chunk.value);
+					if (parsed) {
+						const object = this.finalStructuredOutput.normalize ? this.finalStructuredOutput.normalize(parsed.object) : parsed.object;
+						this.structuredOutputResult = {
+							data: object,
+							rawText: parsed.raw,
+							...parsed.reasoning !== void 0 ? { reasoning: parsed.reasoning } : {}
+						};
+						const value = chunk.value;
+						if (object !== parsed.object && value && typeof value === "object") outboundChunk = {
+							...chunk,
+							value: {
+								...value,
+								object
+							}
+						};
 					}
 				}
-			}
-			let outboundChunk = chunk;
-			if (chunk.type === EventType.CUSTOM && chunk.name === "structured-output.complete") {
-				const parsed = readStructuredOutputCompleteValue(chunk.value);
-				if (parsed) {
-					const object = this.finalStructuredOutput.normalize ? this.finalStructuredOutput.normalize(parsed.object) : parsed.object;
-					this.structuredOutputResult = {
-						data: object,
-						rawText: parsed.raw,
-						...parsed.reasoning !== void 0 ? { reasoning: parsed.reasoning } : {}
-					};
-					const value = chunk.value;
-					if (object !== parsed.object && value && typeof value === "object") outboundChunk = {
-						...chunk,
-						value: {
-							...value,
-							object
-						}
-					};
+				if (chunk.type === EventType.RUN_FINISHED) await this.runOnUsageFromChunk(chunk);
+				if (chunk.type === EventType.RUN_ERROR) this.finalizationError = {
+					message: chunk.message,
+					...chunk.code ? { code: chunk.code } : {},
+					...fallbackAdapterError !== void 0 ? { cause: fallbackAdapterError } : {}
+				};
+				const outputChunks = await this.middlewareRunner.runOnChunk(this.middlewareCtx, outboundChunk);
+				if (this.finalStructuredOutput.yieldChunks) for (const spec of this.emitPublicChunks(outputChunks)) {
+					if (spec.type === EventType.RUN_ERROR) runErrorYielded = true;
+					yield spec;
 				}
+				if (this.finalizationError) break;
 			}
-			if (chunk.type === EventType.RUN_FINISHED && chunk.usage) await this.middlewareRunner.runOnUsage(this.middlewareCtx, chunk.usage);
-			if (chunk.type === EventType.RUN_ERROR) this.finalizationError = {
-				message: chunk.message,
-				...chunk.code ? { code: chunk.code } : {},
-				...fallbackAdapterError !== void 0 ? { cause: fallbackAdapterError } : {}
-			};
-			const outputChunks = await this.middlewareRunner.runOnChunk(this.middlewareCtx, outboundChunk);
-			if (this.finalStructuredOutput.yieldChunks) for (const outputChunk of outputChunks) {
-				if (outputChunk.type === EventType.RUN_ERROR) runErrorYielded = true;
-				yield outputChunk;
-				this.middlewareCtx.chunkIndex++;
-			}
-			if (this.finalizationError) break;
+			if (this.isCancelled() || this.finalizationError) break;
 		}
 		if (this.isCancelled()) return;
 		if (!this.structuredOutputResult && !this.finalizationError) this.finalizationError = {
@@ -1758,31 +1748,17 @@ var TextEngine = class {
 		}
 		if (this.finalizationError && this.finalStructuredOutput.yieldChunks && !runErrorYielded) {
 			if (!startEmitted) {
-				const startOutputs = await pipeThroughMiddleware(buildSynthesizedStart());
-				for (const outputChunk of startOutputs) {
-					yield outputChunk;
-					this.middlewareCtx.chunkIndex++;
-				}
+				const synthStart = buildSynthesizedStart();
+				yield* this.emitPublicChunks(await runChunkMiddleware(synthStart));
 				startEmitted = true;
 			}
 			const errChunk = {
 				type: EventType.RUN_ERROR,
-				runId: this.runIdOverride ?? this.requestId,
-				model: this.params.model,
 				timestamp: Date.now(),
-				threadId: this.threadId,
 				message: this.finalizationError.message,
-				...this.finalizationError.code ? { code: this.finalizationError.code } : {},
-				error: {
-					message: this.finalizationError.message,
-					...this.finalizationError.code ? { code: this.finalizationError.code } : {}
-				}
+				...this.finalizationError.code ? { code: this.finalizationError.code } : {}
 			};
-			const outputChunks = await this.middlewareRunner.runOnChunk(this.middlewareCtx, errChunk);
-			for (const outputChunk of outputChunks) {
-				yield outputChunk;
-				this.middlewareCtx.chunkIndex++;
-			}
+			yield* this.emitPublicChunks(await this.middlewareRunner.runOnChunk(this.middlewareCtx, errChunk));
 		}
 	}
 	/**
@@ -1853,16 +1829,9 @@ var TextEngine = class {
 				type: EventType.CUSTOM,
 				name: "structured-output.start",
 				value: { messageId },
-				model: this.params.model,
-				timestamp: Date.now(),
-				threadId: this.threadId,
-				...this.runIdOverride ? { runId: this.runIdOverride } : {}
+				timestamp: Date.now()
 			};
-			const startOutputs = await this.middlewareRunner.runOnChunk(this.middlewareCtx, synthStart);
-			for (const outputChunk of startOutputs) {
-				yield outputChunk;
-				this.middlewareCtx.chunkIndex++;
-			}
+			yield* this.emitPublicChunks(await this.middlewareRunner.runOnChunk(this.middlewareCtx, synthStart));
 		}
 		if (this.structuredOutputResult && !this.finalizationError && !this.combinedCompleteEmitted) {
 			const completeChunk = {
@@ -1873,36 +1842,18 @@ var TextEngine = class {
 					raw: this.structuredOutputResult.rawText,
 					...this.combinedStructuredMessageId ? { messageId: this.combinedStructuredMessageId } : {}
 				},
-				model: this.params.model,
-				timestamp: Date.now(),
-				threadId: this.threadId,
-				...this.runIdOverride ? { runId: this.runIdOverride } : {}
+				timestamp: Date.now()
 			};
-			const completeOutputs = await this.middlewareRunner.runOnChunk(this.middlewareCtx, completeChunk);
-			for (const outputChunk of completeOutputs) {
-				yield outputChunk;
-				this.middlewareCtx.chunkIndex++;
-			}
+			yield* this.emitPublicChunks(await this.middlewareRunner.runOnChunk(this.middlewareCtx, completeChunk));
 		}
 		if (this.finalizationError) {
 			const errChunk = {
 				type: EventType.RUN_ERROR,
-				runId: this.runIdOverride ?? this.requestId,
-				model: this.params.model,
 				timestamp: Date.now(),
-				threadId: this.threadId,
 				message: this.finalizationError.message,
-				...this.finalizationError.code ? { code: this.finalizationError.code } : {},
-				error: {
-					message: this.finalizationError.message,
-					...this.finalizationError.code ? { code: this.finalizationError.code } : {}
-				}
+				...this.finalizationError.code ? { code: this.finalizationError.code } : {}
 			};
-			const errOutputs = await this.middlewareRunner.runOnChunk(this.middlewareCtx, errChunk);
-			for (const outputChunk of errOutputs) {
-				yield outputChunk;
-				this.middlewareCtx.chunkIndex++;
-			}
+			yield* this.emitPublicChunks(await this.middlewareRunner.runOnChunk(this.middlewareCtx, errChunk));
 		}
 	}
 	buildMiddlewareConfig() {
@@ -2139,18 +2090,26 @@ var TextEngine = class {
 		this.toolPhase = phase;
 	}
 	/**
-	* Pipe a single chunk through the middleware pipeline (strip-to-spec, devtools, etc.)
-	* and yield all resulting output chunks.
+	* Spec-normalize middleware output, then yield to the public iterable.
+	* Engine state and `onChunk` already saw the raw chunk.
 	*/
-	async *pipeThroughMiddleware(chunk) {
-		const outputChunks = await this.middlewareRunner.runOnChunk(this.middlewareCtx, chunk);
-		for (const outputChunk of outputChunks) {
-			if (outputChunk.type === EventType.RUN_STARTED) this.hasPublicRunStarted = true;
-			yield outputChunk;
+	*emitPublicChunks(outputs) {
+		for (const output of outputs) for (const spec of normalizeStreamChunk(output)) {
+			restorePublicUsage(spec);
+			if (spec.type === EventType.RUN_STARTED) this.hasPublicRunStarted = true;
+			yield spec;
 			this.middlewareCtx.chunkIndex++;
 		}
 	}
 	/**
+	* Pipe a single internal chunk through middleware, then spec-normalize
+	* before the public `for await` stream.
+	*/
+	async *pipeThroughMiddleware(chunk) {
+		const afterMw = await this.middlewareRunner.runOnChunk(this.middlewareCtx, chunk);
+		yield* this.emitPublicChunks(afterMw);
+	}
+	/**
 	* Drain queued `sandbox.file` chunks (emitted via the SandboxRuntime sink)
 	* through the middleware pipeline and into the public stream.
 	*/
@@ -2174,9 +2133,8 @@ var TextEngine = class {
 	}
 	createCustomEventChunk(eventName, value) {
 		return {
-			type: "CUSTOM",
+			type: EventType.CUSTOM,
 			timestamp: Date.now(),
-			model: this.params.model,
 			name: eventName,
 			value
 		};