@tanstack/ai 0.47.2 → 0.48.0

package/dist/esm/activities/chat/stream/processor.js

@@ -1,7 +1,10 @@
+import { mergeMetadata, tanstackMetadata } from "../../../utilities/merge-metadata.js";
+import { runErrorEventToError } from "../../../utilities/errors.js";
 import { INTERRUPT_BINDING_METADATA_KEY } from "../../../interrupt-resume.js";
 import { normalizeToolResult } from "../../../utilities/tool-result.js";
 import { isProviderExecutedToolCall } from "../../../utilities/provider-executed.js";
 import { aguiSnapshotMessageToUIMessage, generateMessageId, uiMessageToModelMessages } from "../messages.js";
+import { getChunkRunId } from "../../../utilities/chunk-ids.js";
 import { defaultJSONParser } from "./json-parser.js";
 import { appendStructuredOutputDelta, completeStructuredOutputPart, errorStructuredOutputPart, updateTextPart, updateThinkingPart, updateToolCallApproval, updateToolCallApprovalResponse, updateToolCallPart, updateToolCallWithOutput, updateToolResultPart } from "./message-updaters.js";
 import { ImmediateStrategy } from "./strategies.js";
@@ -89,6 +92,7 @@ var StreamProcessor = class StreamProcessor {
 	*
 	* @param content - The message content (string or array of content parts)
 	* @param id - Optional custom message ID (generated if not provided)
+	* @param metadata - Optional AG-UI metadata bag
 	* @returns The created UIMessage
 	*
 	* @example
@@ -106,7 +110,7 @@ var StreamProcessor = class StreamProcessor {
 	* processor.addUserMessage('Hello!', 'custom-id-123')
 	* ```
 	*/
-	addUserMessage(content, id) {
+	addUserMessage(content, id, metadata) {
 		const parts = typeof content === "string" ? [{
 			type: "text",
 			content
@@ -117,7 +121,8 @@ var StreamProcessor = class StreamProcessor {
 			id: id ?? generateMessageId(),
 			role: "user",
 			parts,
-			createdAt: /* @__PURE__ */ new Date()
+			createdAt: /* @__PURE__ */ new Date(),
+			...metadata != null ? { metadata } : {}
 		};
 		this.messages = [...this.messages, userMessage];
 		this.emitMessagesChange();
@@ -298,6 +303,9 @@ var StreamProcessor = class StreamProcessor {
 			case "REASONING_MESSAGE_CONTENT":
 				this.handleReasoningMessageContentEvent(chunk);
 				break;
+			case "REASONING_ENCRYPTED_VALUE":
+				this.handleReasoningEncryptedValueEvent(chunk);
+				break;
 			case "TOOL_CALL_RESULT":
 				this.handleToolCallResultEvent(chunk);
 				break;
@@ -422,6 +430,33 @@ var StreamProcessor = class StreamProcessor {
 		};
 	}
 	/**
+	* Merge event metadata onto a UIMessage. `tanstack` is deep-merged so a
+	* later delta does not wipe `tanstack.model`. High-frequency leftover
+	* keys (`content`, `args`) never stamp onto the message.
+	* Rebuilds `createdAt` when `tanstack.createdAt` is an ISO string.
+	*/
+	mergeMessageMetadata(messageId, incoming) {
+		if (incoming == null || typeof incoming !== "object" || Array.isArray(incoming)) return;
+		const message = this.messages.find((msg) => msg.id === messageId);
+		if (!message) return;
+		const incomingRecord = incoming;
+		const incomingTanstack = tanstackMetadata(incomingRecord);
+		const toMerge = incomingTanstack != null && ("content" in incomingTanstack || "args" in incomingTanstack) ? {
+			...incomingRecord,
+			tanstack: Object.fromEntries(Object.entries(incomingTanstack).filter(([key]) => key !== "content" && key !== "args"))
+		} : incomingRecord;
+		const metadata = mergeMetadata(message.metadata, toMerge);
+		const createdAtRaw = tanstackMetadata(incomingRecord)?.createdAt;
+		const createdAt = typeof createdAtRaw === "string" ? new Date(createdAtRaw) : void 0;
+		const createdAtValid = createdAt !== void 0 && !Number.isNaN(createdAt.getTime());
+		this.messages = this.messages.map((msg) => msg.id === messageId ? {
+			...msg,
+			...metadata !== void 0 ? { metadata } : {},
+			...createdAtValid ? { createdAt } : {}
+		} : msg);
+		this.emitMessagesChange();
+	}
+	/**
 	* Handle TEXT_MESSAGE_START event
 	*/
 	handleTextMessageStartEvent(chunk) {
@@ -443,11 +478,13 @@ var StreamProcessor = class StreamProcessor {
 				}
 				this.activeMessageIds.delete(pendingId);
 				this.activeMessageIds.add(messageId);
+				for (const [toolCallId, mappedMessageId] of this.toolCallToMessage) if (mappedMessageId === pendingId) this.toolCallToMessage.set(toolCallId, messageId);
 			}
 			if (!this.messageStates.has(messageId)) {
 				this.createMessageState(messageId, uiRole);
 				this.activeMessageIds.add(messageId);
 			}
+			this.mergeMessageMetadata(messageId, chunk.metadata);
 			this.emitMessagesChange();
 			return;
 		}
@@ -461,6 +498,7 @@ var StreamProcessor = class StreamProcessor {
 				existingState.lastEmittedText = "";
 				existingState.hasToolCallsSinceTextStart = false;
 			}
+			this.mergeMessageMetadata(messageId, chunk.metadata);
 			return;
 		}
 		const newMessage = {
@@ -472,6 +510,7 @@ var StreamProcessor = class StreamProcessor {
 		this.messages = [...this.messages, newMessage];
 		this.createMessageState(messageId, uiRole);
 		this.activeMessageIds.add(messageId);
+		this.mergeMessageMetadata(messageId, chunk.metadata);
 		this.events.onStreamStart?.();
 		this.emitMessagesChange();
 	}
@@ -480,11 +519,11 @@ var StreamProcessor = class StreamProcessor {
 	*/
 	handleTextMessageEndEvent(chunk) {
 		const { messageId } = chunk;
+		this.mergeMessageMetadata(messageId, chunk.metadata);
 		const state = this.getMessageState(messageId);
 		if (!state) return;
 		if (state.isComplete) return;
 		if (state.currentSegmentText !== state.lastEmittedText) this.emitTextUpdateForMessage(messageId);
-		this.completeAllToolCallsForMessage(messageId);
 	}
 	/**
 	* Handle MESSAGES_SNAPSHOT event
@@ -492,8 +531,17 @@ var StreamProcessor = class StreamProcessor {
 	handleMessagesSnapshotEvent(chunk) {
 		this.resetStreamState();
 		const prevMessages = this.messages;
-		const normalized = chunk.messages.map(aguiSnapshotMessageToUIMessage);
-		this.messages = this.reconcileSnapshotToolCalls(normalized, prevMessages);
+		const prevById = new Map(prevMessages.map((msg) => [msg.id, msg]));
+		const normalized = this.mergeReasoningFanOut(chunk.messages.map(aguiSnapshotMessageToUIMessage));
+		this.messages = this.reconcileSnapshotToolCalls(normalized, prevMessages).map((msg) => {
+			if (msg.metadata != null) return msg;
+			const prev = prevById.get(msg.id);
+			if (prev?.metadata == null) return msg;
+			return {
+				...msg,
+				metadata: prev.metadata
+			};
+		});
 		this.emitMessagesChange();
 	}
 	/**
@@ -519,6 +567,42 @@ var StreamProcessor = class StreamProcessor {
 	* matching `tool-call` (and prefer pre-snapshot complete/output when the
 	* snapshot is poorer) so server tools keep the same UI shape as client tools.
 	*/
+	/**
+	* Wire order is reasoning fan-outs, then the assistant anchor.
+	* Snapshot conversion turns each reasoning row into its own assistant
+	* message. Fold leading thinking-only messages into the next real
+	* assistant. Do not fold into a tool-result-only message (`role: 'tool'`
+	* on the wire). `reconcileSnapshotToolCalls` anchors those results.
+	*/
+	mergeReasoningFanOut(messages) {
+		const out = [];
+		let pending = [];
+		const thinkingParts = (msg) => msg.parts.filter((part) => part.type === "thinking");
+		const isThinkingOnly = (msg) => msg.role === "assistant" && msg.parts.length > 0 && msg.parts.every((part) => part.type === "thinking");
+		const isToolResultOnly = (msg) => msg.role === "assistant" && msg.parts.length === 1 && msg.parts[0]?.type === "tool-result";
+		const flushPending = () => {
+			out.push(...pending);
+			pending = [];
+		};
+		for (const msg of messages) {
+			if (isThinkingOnly(msg)) {
+				pending.push(msg);
+				continue;
+			}
+			if (msg.role === "assistant" && pending.length > 0 && !isToolResultOnly(msg)) {
+				out.push({
+					...msg,
+					parts: [...pending.flatMap(thinkingParts), ...msg.parts]
+				});
+				pending = [];
+				continue;
+			}
+			flushPending();
+			out.push(msg);
+		}
+		flushPending();
+		return out;
+	}
 	reconcileSnapshotToolCalls(snapshot, prevMessages) {
 		const prevToolCalls = /* @__PURE__ */ new Map();
 		for (const msg of prevMessages) for (const part of msg.parts) if (part.type === "tool-call") prevToolCalls.set(part.id, part);
@@ -607,15 +691,9 @@ var StreamProcessor = class StreamProcessor {
 	*/
 	handleTextMessageContentEvent(chunk) {
 		const { messageId, state } = this.ensureAssistantMessage(chunk.messageId);
-		this.completeAllToolCallsForMessage(messageId);
+		this.mergeMessageMetadata(messageId, chunk.metadata);
 		if (this.structuredMessageIds.has(messageId)) {
-			let delta = chunk.delta || "";
-			if (delta === "" && chunk.content !== void 0 && chunk.content !== "") {
-				const existingRaw = (this.messages.find((m) => m.id === messageId)?.parts.find((p) => p.type === "structured-output") ?? { raw: "" }).raw;
-				if (chunk.content.startsWith(existingRaw)) delta = chunk.content.slice(existingRaw.length);
-				else if (existingRaw.startsWith(chunk.content)) delta = "";
-				else delta = chunk.content;
-			}
+			const delta = chunk.delta || "";
 			if (delta !== "") {
 				this.messages = appendStructuredOutputDelta(this.messages, messageId, delta);
 				state.totalTextContent += delta;
@@ -632,18 +710,12 @@ var StreamProcessor = class StreamProcessor {
 			state.hasToolCallsSinceTextStart = false;
 		}
 		const currentText = state.currentSegmentText;
-		let nextText = currentText;
 		const delta = chunk.delta || "";
-		if (delta !== "") nextText = currentText + delta;
-		else if (chunk.content !== void 0 && chunk.content !== "") {
-			if (chunk.content.startsWith(currentText)) nextText = chunk.content;
-			else if (currentText.startsWith(chunk.content)) nextText = currentText;
-			else nextText = currentText + chunk.content;
-		}
+		const nextText = delta !== "" ? currentText + delta : currentText;
 		const textDelta = nextText.slice(currentText.length);
 		state.currentSegmentText = nextText;
 		state.totalTextContent += textDelta;
-		const chunkPortion = chunk.delta || chunk.content || "";
+		const chunkPortion = chunk.delta || "";
 		if (this.chunkStrategy.shouldEmit(chunkPortion, state.currentSegmentText) && state.currentSegmentText !== state.lastEmittedText) this.emitTextUpdateForMessage(messageId);
 	}
 	/**
@@ -666,7 +738,7 @@ var StreamProcessor = class StreamProcessor {
 		const toolCallId = chunk.toolCallId;
 		if (!state.toolCalls.get(toolCallId)) {
 			const initialState = "awaiting-input";
-			const toolName = chunk.toolCallName ?? chunk.toolName;
+			const toolName = chunk.toolCallName;
 			const chunkMetadata = chunk.metadata;
 			const newToolCall = {
 				id: chunk.toolCallId,
@@ -674,7 +746,7 @@ var StreamProcessor = class StreamProcessor {
 				arguments: "",
 				state: initialState,
 				parsedArguments: void 0,
-				index: chunk.index ?? state.toolCalls.size,
+				index: state.toolCalls.size,
 				...chunkMetadata !== void 0 && { metadata: chunkMetadata }
 			};
 			state.toolCalls.set(toolCallId, newToolCall);
@@ -725,17 +797,15 @@ var StreamProcessor = class StreamProcessor {
 		this.events.onToolCallStateChange?.(messageId, existingToolCall.id, existingToolCall.state, existingToolCall.arguments);
 	}
 	/**
-	* Handle TOOL_CALL_END event — authoritative signal that a tool call's input is finalized.
+	* Handle TOOL_CALL_END event — arguments are finalized (input-complete).
+	* Tool output arrives on TOOL_CALL_RESULT, not on this event.
 	*
-	* This event has a DUAL ROLE:
-	* - Without `result`: Signals arguments are done (from adapter). Transitions to input-complete.
-	* - With `result`: Signals tool was executed and result is available (from TextEngine).
-	*   Creates both output on the tool-call part AND a tool-result part.
+	* If TOOL_CALL_END carries parsed `input`, use it as the canonical arguments:
+	* back-fill the accumulated string when no TOOL_CALL_ARGS deltas were seen
+	* (adapters that deliver the whole input on END — e.g. Anthropic
+	* server_tool_use / web_search — issue #839) and override the rendered part's
+	* `input` with the canonical value.
 	*
-	* If `input` is provided, it overrides the accumulated string parse as the
-	* canonical parsed arguments.
-	*
-	* @see docs/chat-architecture.md#tool-results-and-the-tool_call_end-dual-role — Full explanation
 	* @see docs/chat-architecture.md#single-shot-tool-call-response — End-to-end flow
 	*/
 	handleToolCallEndEvent(chunk) {
@@ -743,39 +813,27 @@ var StreamProcessor = class StreamProcessor {
 		if (!messageId) return;
 		const msgState = this.getMessageState(messageId);
 		if (!msgState) return;
+		const input = chunk.input !== void 0 ? chunk.input : tanstackMetadata(chunk)?.input;
 		const existingToolCall = msgState.toolCalls.get(chunk.toolCallId);
 		if (existingToolCall && existingToolCall.state !== "input-complete") {
-			if (chunk.input !== void 0 && !existingToolCall.arguments) try {
-				existingToolCall.arguments = JSON.stringify(chunk.input);
+			if (input !== void 0 && !existingToolCall.arguments) try {
+				existingToolCall.arguments = JSON.stringify(input);
 			} catch {}
 			const index = msgState.toolCallOrder.indexOf(chunk.toolCallId);
 			this.completeToolCall(messageId, index, existingToolCall);
-			if (chunk.input !== void 0) {
-				existingToolCall.parsedArguments = chunk.input;
+			if (input !== void 0) {
+				existingToolCall.parsedArguments = input;
 				this.messages = updateToolCallPart(this.messages, messageId, {
 					id: existingToolCall.id,
 					name: existingToolCall.name,
 					arguments: existingToolCall.arguments,
 					state: "input-complete",
-					input: chunk.input,
+					input,
 					...existingToolCall.metadata !== void 0 && { metadata: existingToolCall.metadata }
 				});
 				this.emitMessagesChange();
 			}
 		}
-		if (chunk.result) {
-			let output;
-			if (Array.isArray(chunk.result)) output = chunk.result;
-			else try {
-				output = JSON.parse(chunk.result);
-			} catch {
-				output = chunk.result;
-			}
-			this.messages = updateToolCallWithOutput(this.messages, chunk.toolCallId, output, chunk.state === "output-error" ? "error" : void 0);
-			const resultState = chunk.state === "output-error" ? "error" : "complete";
-			this.messages = updateToolResultPart(this.messages, messageId, chunk.toolCallId, chunk.result, resultState, resultState === "error" ? this.extractToolResultError(output) : void 0);
-			this.emitMessagesChange();
-		}
 	}
 	extractToolResultError(output) {
 		if (output && typeof output === "object" && "error" in output && typeof output.error === "string") return output.error;
@@ -789,16 +847,17 @@ var StreamProcessor = class StreamProcessor {
 	* This is the spec-compliant path for delivering tool results to the client.
 	*/
 	handleToolCallResultEvent(chunk) {
-		const messageId = this.toolCallToMessage.get(chunk.toolCallId);
+		const messageId = this.toolCallToMessage.get(chunk.toolCallId) ?? this.messages.find((m) => m.parts.some((p) => p.type === "tool-call" && p.id === chunk.toolCallId))?.id;
 		if (!messageId) return;
+		const isOutputError = chunk.state === "output-error" || tanstackMetadata(chunk)?.state === "output-error";
 		let output;
 		try {
 			output = JSON.parse(chunk.content);
 		} catch {
 			output = chunk.content;
 		}
-		this.messages = updateToolCallWithOutput(this.messages, chunk.toolCallId, output, chunk.state === "output-error" ? "error" : void 0);
-		const resultState = chunk.state === "output-error" ? "error" : "complete";
+		this.messages = updateToolCallWithOutput(this.messages, chunk.toolCallId, output, isOutputError ? "error" : void 0);
+		const resultState = isOutputError ? "error" : "complete";
 		this.messages = updateToolResultPart(this.messages, messageId, chunk.toolCallId, chunk.content, resultState, resultState === "error" ? this.extractToolResultError(output) : void 0);
 		this.emitMessagesChange();
 	}
@@ -822,7 +881,8 @@ var StreamProcessor = class StreamProcessor {
 	* @see docs/chat-architecture.md#adapter-contract — Why RUN_FINISHED is mandatory
 	*/
 	handleRunFinishedEvent(chunk) {
-		this.finishReason = chunk.finishReason ?? null;
+		const extra = chunk;
+		this.finishReason = extra.finishReason !== void 0 ? extra.finishReason : tanstackMetadata(chunk)?.finishReason ?? null;
 		this.activeRuns.delete(chunk.runId);
 		if (chunk.outcome?.type === "interrupt") this.handleInterrupts(chunk.outcome.interrupts);
 		if (this.activeRuns.size === 0) {
@@ -876,12 +936,12 @@ var StreamProcessor = class StreamProcessor {
 	*/
 	handleRunErrorEvent(chunk) {
 		this.hasError = true;
-		const runId = "runId" in chunk && typeof chunk.runId === "string" ? chunk.runId : void 0;
+		const runId = getChunkRunId(chunk);
 		if (runId) this.activeRuns.delete(runId);
 		else this.activeRuns.clear();
 		const { messageId } = this.ensureAssistantMessage();
-		const errorMessage = chunk.message || chunk.error?.message || "An error occurred";
-		if (!chunk.message && !chunk.error?.message) console.error("[StreamProcessor] RUN_ERROR with no message; original chunk:", chunk);
+		const errorMessage = chunk.message || "An error occurred";
+		if (!chunk.message) console.error("[StreamProcessor] RUN_ERROR with no message; original chunk:", chunk);
 		if (this.structuredMessageIds.has(messageId)) {
 			this.flushStructuredOutputUpdate(messageId);
 			this.messages = errorStructuredOutputPart(this.messages, messageId, errorMessage);
@@ -889,21 +949,17 @@ var StreamProcessor = class StreamProcessor {
 			this.emitStructuredOutputChange(messageId, "error");
 			this.emitMessagesChange();
 		}
-		const error = new Error(errorMessage);
-		const code = chunk.code ?? chunk.error?.code;
-		if (code !== void 0) Object.assign(error, { code });
-		if (chunk.rawEvent !== void 0) Object.assign(error, { rawEvent: chunk.rawEvent });
-		this.events.onError?.(error);
+		this.events.onError?.(runErrorEventToError(chunk));
 	}
 	/**
 	* Handle STEP_STARTED event (for thinking/reasoning content).
 	*
-	* Records the stepId so that subsequent STEP_FINISHED deltas accumulate
+	* Records the stepId so later REASONING_MESSAGE_CONTENT deltas accumulate
 	* into their own ThinkingPart. Does not create a message — the message
-	* is lazily created when the first STEP_FINISHED content arrives.
+	* is lazily created when the first REASONING_MESSAGE_CONTENT arrives.
 	*/
 	handleStepStartedEvent(chunk) {
-		const stepId = chunk.stepId ?? generateMessageId();
+		const stepId = chunk.stepName || generateMessageId();
 		const activeId = this.getActiveAssistantMessageId();
 		if (activeId) {
 			const state = this.getMessageState(activeId);
@@ -920,48 +976,25 @@ var StreamProcessor = class StreamProcessor {
 		this.pendingThinkingStepId = stepId;
 	}
 	/**
-	* Handle STEP_FINISHED event (for thinking/reasoning content).
+	* Handle STEP_FINISHED event.
 	*
-	* Accumulates delta into the current thinking step's content and updates
-	* the corresponding ThinkingPart in the UIMessage.
-	*
-	* @see docs/chat-architecture.md#thinkingreasoning-content — Thinking flow
+	* Thinking *content* comes from REASONING_MESSAGE_CONTENT, not STEP_FINISHED.
+	* But some adapters (e.g. BytePlus thinking-summary) carry the provider
+	* signature blob ONLY on the STEP_FINISHED event, so still extract that here
+	* and attach it to the thinking step the reasoning events already built.
 	*/
 	handleStepFinishedEvent(chunk) {
+		const extra = chunk;
+		const signature = extra.signature;
+		if (!signature) return;
 		const { messageId, state } = this.ensureAssistantMessage(this.getActiveAssistantMessageId() ?? void 0);
-		if (state.hasSeenReasoningEvents) {
-			if (chunk.signature) {
-				const stepId = state.currentThinkingStepId ?? chunk.stepId;
-				if (!stepId) return;
-				const thinking = state.thinkingSteps.get(stepId);
-				if (thinking !== void 0) {
-					state.thinkingStepSignatures.set(stepId, chunk.signature);
-					this.messages = updateThinkingPart(this.messages, messageId, stepId, thinking, chunk.signature);
-					this.emitMessagesChange();
-				}
-			}
-			return;
-		}
-		this.consumePendingThinkingStep(state);
-		const stepId = state.currentThinkingStepId ?? chunk.stepId ?? generateMessageId();
-		if (!state.thinkingSteps.has(stepId)) {
-			state.thinkingSteps.set(stepId, "");
-			state.thinkingStepOrder.push(stepId);
-			state.currentThinkingStepId = stepId;
-		}
-		const previous = state.thinkingSteps.get(stepId) ?? "";
-		let nextThinking = previous;
-		if (chunk.delta && chunk.delta !== "") nextThinking = previous + chunk.delta;
-		else if (chunk.content && chunk.content !== "") {
-			if (chunk.content.startsWith(previous)) nextThinking = chunk.content;
-			else if (previous.startsWith(chunk.content)) nextThinking = previous;
-			else nextThinking = previous + chunk.content;
-		}
-		state.thinkingSteps.set(stepId, nextThinking);
-		if (chunk.signature) state.thinkingStepSignatures.set(stepId, chunk.signature);
-		this.messages = updateThinkingPart(this.messages, messageId, stepId, nextThinking, state.thinkingStepSignatures.get(stepId));
+		const stepId = state.currentThinkingStepId ?? extra.stepId;
+		if (!stepId) return;
+		const thinking = state.thinkingSteps.get(stepId);
+		if (thinking === void 0) return;
+		state.thinkingStepSignatures.set(stepId, signature);
+		this.messages = updateThinkingPart(this.messages, messageId, stepId, thinking, signature);
 		this.emitMessagesChange();
-		this.events.onThinkingUpdate?.(messageId, stepId, nextThinking);
 	}
 	/**
 	* Handle REASONING_MESSAGE_CONTENT event (AG-UI reasoning protocol).
@@ -987,6 +1020,58 @@ var StreamProcessor = class StreamProcessor {
 		this.events.onThinkingUpdate?.(messageId, stepId, nextThinking);
 	}
 	/**
+	* Attach a provider signature blob from REASONING_ENCRYPTED_VALUE.
+	* `subtype: 'message'` updates ThinkingPart.signature.
+	* `subtype: 'tool-call'` stores Gemini thoughtSignature on the tool-call part.
+	*/
+	handleReasoningEncryptedValueEvent(chunk) {
+		const encryptedValue = chunk.encryptedValue;
+		if (typeof encryptedValue !== "string" || encryptedValue === "") return;
+		if (chunk.subtype === "tool-call") {
+			this.attachToolCallSignature(chunk.entityId, encryptedValue);
+			return;
+		}
+		const { messageId, state } = this.ensureAssistantMessage(this.getActiveAssistantMessageId() ?? void 0);
+		const stepId = state.currentThinkingStepId ?? chunk.entityId;
+		state.thinkingStepSignatures.set(stepId, encryptedValue);
+		const content = state.thinkingSteps.get(stepId) ?? "";
+		if (!state.thinkingSteps.has(stepId)) {
+			state.thinkingSteps.set(stepId, content);
+			state.thinkingStepOrder.push(stepId);
+		}
+		this.messages = updateThinkingPart(this.messages, messageId, stepId, content, encryptedValue);
+		this.emitMessagesChange();
+	}
+	attachToolCallSignature(toolCallId, thoughtSignature) {
+		this.messages = this.messages.map((msg) => {
+			let changed = false;
+			const parts = msg.parts.map((part) => {
+				if (part.type !== "tool-call" || part.id !== toolCallId) return part;
+				changed = true;
+				return {
+					...part,
+					metadata: {
+						...part.metadata != null && typeof part.metadata === "object" ? part.metadata : {},
+						thoughtSignature
+					}
+				};
+			});
+			return changed ? {
+				...msg,
+				parts
+			} : msg;
+		});
+		for (const state of this.messageStates.values()) {
+			const call = state.toolCalls.get(toolCallId);
+			if (!call) continue;
+			call.metadata = {
+				...call.metadata ?? {},
+				thoughtSignature
+			};
+		}
+		this.emitMessagesChange();
+	}
+	/**
 	* Handle CUSTOM event.
 	*
 	* Handles custom events consumed by the processor:
@@ -1081,12 +1166,8 @@ var StreamProcessor = class StreamProcessor {
 	/**
 	* Detect if an incoming content chunk represents a NEW text segment
 	*/
-	isNewTextSegment(chunk, previous) {
-		if (chunk.content !== void 0) {
-			if (chunk.content.length < previous.length) return true;
-			if (!chunk.content.startsWith(previous) && !previous.startsWith(chunk.content)) return true;
-		}
-		return false;
+	isNewTextSegment(_chunk, _previous) {
+		return true;
 	}
 	/**
 	* Complete all tool calls across all active messages — safety net for stream termination.
@@ -1118,7 +1199,13 @@ var StreamProcessor = class StreamProcessor {
 	*/
 	completeToolCall(messageId, _index, toolCall) {
 		toolCall.state = "input-complete";
-		toolCall.parsedArguments = this.jsonParser.parse(toolCall.arguments);
+		let strictParseSucceeded = false;
+		try {
+			toolCall.parsedArguments = JSON.parse(toolCall.arguments);
+			strictParseSucceeded = true;
+		} catch {
+			toolCall.parsedArguments = void 0;
+		}
 		if (this.isToolCallPartErrored(toolCall.id)) return;
 		if (this.isToolCallPartAwaitingUserAction(toolCall.id)) return;
 		this.messages = updateToolCallPart(this.messages, messageId, {
@@ -1126,7 +1213,7 @@ var StreamProcessor = class StreamProcessor {
 			name: toolCall.name,
 			arguments: toolCall.arguments,
 			state: "input-complete",
-			...toolCall.parsedArguments !== void 0 && { input: toolCall.parsedArguments },
+			...strictParseSucceeded && { input: toolCall.parsedArguments },
 			...toolCall.metadata !== void 0 && { metadata: toolCall.metadata }
 		});
 		this.emitMessagesChange();