likec4 1.59.3 → 1.60.0

package/__app__/src/chunks/libs/@tanstack-ai.mjs

@@ -1,152 +1,234 @@
-import { t as e } from "../rolldown-runtime.mjs";
-import { createContext as t, useCallback as n, useEffect as r, useId as i, useMemo as a, useRef as o, useState as s } from "react";
-import { Fragment as c, jsx as l, jsxs as u } from "react/jsx-runtime";
+import { t as __commonJSMin } from "../rolldown-runtime.mjs";
+import { createContext, useCallback, useEffect, useId, useMemo, useRef, useState } from "react";
+import { Fragment as Fragment$1, jsx, jsxs } from "react/jsx-runtime";
 //#region ../../node_modules/.pnpm/@tanstack+devtools-event-client@0.4.3/node_modules/@tanstack/devtools-event-client/dist/esm/plugin.js
 var EventClient = class {
-	#e = !0;
-	#t;
-	#n;
-	#r;
-	#i;
-	#a;
-	#o;
-	#s;
-	#c = 0;
-	#l = 5;
-	#u = !1;
-	#d = !1;
-	#f = null;
-	#p = () => {
-		this.debugLog("Connected to event bus"), this.#a = !0, this.#u = !1, this.debugLog("Emitting queued events", this.#i), this.#i.forEach((e) => this.emitEventToBus(e)), this.#i = [], this.stopConnectLoop(), this.#n().removeEventListener("tanstack-connect-success", this.#p);
+	#enabled = true;
+	#pluginId;
+	#eventTarget;
+	#debug;
+	#queuedEvents;
+	#connected;
+	#connectIntervalId;
+	#connectEveryMs;
+	#retryCount = 0;
+	#maxRetries = 5;
+	#connecting = false;
+	#failedToConnect = false;
+	#internalEventTarget = null;
+	#onConnected = () => {
+		this.debugLog("Connected to event bus");
+		this.#connected = true;
+		this.#connecting = false;
+		this.debugLog("Emitting queued events", this.#queuedEvents);
+		this.#queuedEvents.forEach((event) => this.emitEventToBus(event));
+		this.#queuedEvents = [];
+		this.stopConnectLoop();
+		this.#eventTarget().removeEventListener("tanstack-connect-success", this.#onConnected);
 	};
-	#m = () => {
-		if (this.#c < this.#l) {
-			this.#c++, this.dispatchCustomEvent("tanstack-connect", {});
+	#retryConnection = () => {
+		if (this.#retryCount < this.#maxRetries) {
+			this.#retryCount++;
+			this.dispatchCustomEvent("tanstack-connect", {});
 			return;
 		}
-		this.#n().removeEventListener("tanstack-connect", this.#m), this.#d = !0, this.debugLog("Max retries reached, giving up on connection"), this.stopConnectLoop();
+		this.#eventTarget().removeEventListener("tanstack-connect", this.#retryConnection);
+		this.#failedToConnect = true;
+		this.debugLog("Max retries reached, giving up on connection");
+		this.stopConnectLoop();
 	};
-	#h = () => {
-		this.#u || (this.#u = !0, this.#n().addEventListener("tanstack-connect-success", this.#p), this.#m());
+	#connectFunction = () => {
+		if (this.#connecting) return;
+		this.#connecting = true;
+		this.#eventTarget().addEventListener("tanstack-connect-success", this.#onConnected);
+		this.#retryConnection();
 	};
-	constructor({ pluginId: e, debug: t = !1, enabled: n = !0, reconnectEveryMs: r = 300 }) {
-		this.#t = e, this.#e = n, this.#n = this.getGlobalTarget, this.#r = t, this.debugLog(" Initializing event subscription for plugin", this.#t), this.#i = [], this.#a = !1, this.#d = !1, this.#o = null, this.#s = r;
+	constructor({ pluginId, debug = false, enabled = true, reconnectEveryMs = 300 }) {
+		this.#pluginId = pluginId;
+		this.#enabled = enabled;
+		this.#eventTarget = this.getGlobalTarget;
+		this.#debug = debug;
+		this.debugLog(" Initializing event subscription for plugin", this.#pluginId);
+		this.#queuedEvents = [];
+		this.#connected = false;
+		this.#failedToConnect = false;
+		this.#connectIntervalId = null;
+		this.#connectEveryMs = reconnectEveryMs;
 	}
 	startConnectLoop() {
-		this.#o !== null || this.#a || (this.debugLog(`Starting connect loop (every ${this.#s}ms)`), this.#o = setInterval(this.#m, this.#s));
+		if (this.#connectIntervalId !== null || this.#connected) return;
+		this.debugLog(`Starting connect loop (every ${this.#connectEveryMs}ms)`);
+		this.#connectIntervalId = setInterval(this.#retryConnection, this.#connectEveryMs);
 	}
 	stopConnectLoop() {
-		this.#u = !1, this.#o !== null && (clearInterval(this.#o), this.#o = null, this.#i = [], this.debugLog("Stopped connect loop"));
+		this.#connecting = false;
+		if (this.#connectIntervalId === null) return;
+		clearInterval(this.#connectIntervalId);
+		this.#connectIntervalId = null;
+		this.#queuedEvents = [];
+		this.debugLog("Stopped connect loop");
 	}
-	debugLog(...e) {
-		this.#r && console.log(`🌴 [tanstack-devtools:${this.#t}-plugin]`, ...e);
+	debugLog(...args) {
+		if (this.#debug) console.log(`🌴 [tanstack-devtools:${this.#pluginId}-plugin]`, ...args);
 	}
 	getGlobalTarget() {
-		if (typeof globalThis < "u" && globalThis.__TANSTACK_EVENT_TARGET__) return this.debugLog("Using global event target"), globalThis.__TANSTACK_EVENT_TARGET__;
-		if (typeof window < "u" && window.addEventListener !== void 0) return this.debugLog("Using window as event target"), window;
-		let e = typeof EventTarget < "u" ? new EventTarget() : void 0;
-		return e === void 0 || e.addEventListener === void 0 ? (this.debugLog("No event mechanism available, running in non-web environment"), {
-			addEventListener: () => {},
-			removeEventListener: () => {},
-			dispatchEvent: () => !1
-		}) : (this.debugLog("Using new EventTarget as fallback"), e);
+		if (typeof globalThis !== "undefined" && globalThis.__TANSTACK_EVENT_TARGET__) {
+			this.debugLog("Using global event target");
+			return globalThis.__TANSTACK_EVENT_TARGET__;
+		}
+		if (typeof window !== "undefined" && typeof window.addEventListener !== "undefined") {
+			this.debugLog("Using window as event target");
+			return window;
+		}
+		const eventTarget = typeof EventTarget !== "undefined" ? new EventTarget() : void 0;
+		if (typeof eventTarget === "undefined" || typeof eventTarget.addEventListener === "undefined") {
+			this.debugLog("No event mechanism available, running in non-web environment");
+			return {
+				addEventListener: () => {},
+				removeEventListener: () => {},
+				dispatchEvent: () => false
+			};
+		}
+		this.debugLog("Using new EventTarget as fallback");
+		return eventTarget;
 	}
 	getPluginId() {
-		return this.#t;
+		return this.#pluginId;
 	}
-	dispatchCustomEventShim(e, t) {
+	dispatchCustomEventShim(eventName, detail) {
 		try {
-			let n = new Event(e, { detail: t });
-			this.#n().dispatchEvent(n);
-		} catch {
+			const event = new Event(eventName, { detail });
+			this.#eventTarget().dispatchEvent(event);
+		} catch (e) {
 			this.debugLog("Failed to dispatch shim event");
 		}
 	}
-	dispatchCustomEvent(e, t) {
+	dispatchCustomEvent(eventName, detail) {
 		try {
-			this.#n().dispatchEvent(new CustomEvent(e, { detail: t }));
-		} catch {
-			this.dispatchCustomEventShim(e, t);
+			this.#eventTarget().dispatchEvent(new CustomEvent(eventName, { detail }));
+		} catch (e) {
+			this.dispatchCustomEventShim(eventName, detail);
 		}
 	}
-	emitEventToBus(e) {
-		this.debugLog("Emitting event to client bus", e), this.dispatchCustomEvent("tanstack-dispatch-event", e);
+	emitEventToBus(event) {
+		this.debugLog("Emitting event to client bus", event);
+		this.dispatchCustomEvent("tanstack-dispatch-event", event);
 	}
-	createEventPayload(e, t) {
+	createEventPayload(eventSuffix, payload) {
 		return {
-			type: `${this.#t}:${e}`,
-			payload: t,
-			pluginId: this.#t
+			type: `${this.#pluginId}:${eventSuffix}`,
+			payload,
+			pluginId: this.#pluginId
 		};
 	}
-	emit(e, t) {
-		if (!this.#e) {
-			this.debugLog("Event bus client is disabled, not emitting event", e, t);
+	emit(eventSuffix, payload) {
+		if (!this.#enabled) {
+			this.debugLog("Event bus client is disabled, not emitting event", eventSuffix, payload);
 			return;
 		}
-		if (this.#f && (this.debugLog("Emitting event to internal event target", e, t), this.#f.dispatchEvent(new CustomEvent(`${this.#t}:${e}`, { detail: this.createEventPayload(e, t) }))), this.#d) {
+		if (this.#internalEventTarget) {
+			this.debugLog("Emitting event to internal event target", eventSuffix, payload);
+			this.#internalEventTarget.dispatchEvent(new CustomEvent(`${this.#pluginId}:${eventSuffix}`, { detail: this.createEventPayload(eventSuffix, payload) }));
+		}
+		if (this.#failedToConnect) {
 			this.debugLog("Previously failed to connect, not emitting to bus");
 			return;
 		}
-		if (!this.#a) {
-			this.debugLog("Bus not available, will be pushed as soon as connected"), this.#i.push(this.createEventPayload(e, t)), typeof CustomEvent < "u" && !this.#u && (this.#h(), this.startConnectLoop());
+		if (!this.#connected) {
+			this.debugLog("Bus not available, will be pushed as soon as connected");
+			this.#queuedEvents.push(this.createEventPayload(eventSuffix, payload));
+			if (typeof CustomEvent !== "undefined" && !this.#connecting) {
+				this.#connectFunction();
+				this.startConnectLoop();
+			}
 			return;
 		}
-		return this.emitEventToBus(this.createEventPayload(e, t));
-	}
-	on(e, t, n) {
-		let r = n?.withEventTarget ?? !1, i = `${this.#t}:${e}`;
-		if (r && (this.#f ||= new EventTarget(), this.#f.addEventListener(i, (e) => {
-			t(e.detail);
-		})), !this.#e) return this.debugLog("Event bus client is disabled, not registering event", i), () => {};
-		let handler = (e) => {
-			this.debugLog("Received event from bus", e.detail), t(e.detail);
+		return this.emitEventToBus(this.createEventPayload(eventSuffix, payload));
+	}
+	on(eventSuffix, cb, options) {
+		const withEventTarget = options?.withEventTarget ?? false;
+		const eventName = `${this.#pluginId}:${eventSuffix}`;
+		if (withEventTarget) {
+			if (!this.#internalEventTarget) this.#internalEventTarget = new EventTarget();
+			this.#internalEventTarget.addEventListener(eventName, (e) => {
+				cb(e.detail);
+			});
+		}
+		if (!this.#enabled) {
+			this.debugLog("Event bus client is disabled, not registering event", eventName);
+			return () => {};
+		}
+		const handler = (e) => {
+			this.debugLog("Received event from bus", e.detail);
+			cb(e.detail);
 		};
-		return this.#n().addEventListener(i, handler), this.debugLog("Registered event to bus", i), () => {
-			r && this.#f?.removeEventListener(i, handler), this.#n().removeEventListener(i, handler);
+		this.#eventTarget().addEventListener(eventName, handler);
+		this.debugLog("Registered event to bus", eventName);
+		return () => {
+			if (withEventTarget) this.#internalEventTarget?.removeEventListener(eventName, handler);
+			this.#eventTarget().removeEventListener(eventName, handler);
 		};
 	}
-	onAll(e) {
-		if (!this.#e) return this.debugLog("Event bus client is disabled, not registering event"), () => {};
-		let handler = (t) => {
-			let n = t.detail;
-			e(n);
+	onAll(cb) {
+		if (!this.#enabled) {
+			this.debugLog("Event bus client is disabled, not registering event");
+			return () => {};
+		}
+		const handler = (e) => {
+			const event = e.detail;
+			cb(event);
 		};
-		return this.#n().addEventListener("tanstack-devtools-global", handler), () => this.#n().removeEventListener("tanstack-devtools-global", handler);
+		this.#eventTarget().addEventListener("tanstack-devtools-global", handler);
+		return () => this.#eventTarget().removeEventListener("tanstack-devtools-global", handler);
 	}
-	onAllPluginEvents(e) {
-		if (!this.#e) return this.debugLog("Event bus client is disabled, not registering event"), () => {};
-		let handler = (t) => {
-			let n = t.detail;
-			this.#t && n.pluginId !== this.#t || e(n);
+	onAllPluginEvents(cb) {
+		if (!this.#enabled) {
+			this.debugLog("Event bus client is disabled, not registering event");
+			return () => {};
+		}
+		const handler = (e) => {
+			const event = e.detail;
+			if (this.#pluginId && event.pluginId !== this.#pluginId) return;
+			cb(event);
 		};
-		return this.#n().addEventListener("tanstack-devtools-global", handler), () => this.#n().removeEventListener("tanstack-devtools-global", handler);
+		this.#eventTarget().addEventListener("tanstack-devtools-global", handler);
+		return () => this.#eventTarget().removeEventListener("tanstack-devtools-global", handler);
 	}
-}, AiEventClient = class extends EventClient {
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+ai-event-client@0.2.8_@tanstack+ai@0.14.0/node_modules/@tanstack/ai-event-client/dist/esm/index.js
+var AiEventClient = class extends EventClient {
 	constructor() {
 		super({ pluginId: "tanstack-ai-devtools" });
 	}
-}, d = new AiEventClient();
+};
+var aiEventClient = new AiEventClient();
 //#endregion
 //#region ../../node_modules/.pnpm/@tanstack+ai@0.14.0/node_modules/@tanstack/ai/dist/esm/activities/chat/messages.js
-function isContentPart(e) {
-	return e.type === "text" || e.type === "image" || e.type === "audio" || e.type === "video" || e.type === "document";
+function isContentPart(part) {
+	return part.type === "text" || part.type === "image" || part.type === "audio" || part.type === "video" || part.type === "document";
 }
-function collapseContentParts(e) {
-	return e.length === 0 ? null : e.every((e) => e.type === "text") ? e.map((e) => e.content).join("") || null : e;
+function collapseContentParts(parts) {
+	if (parts.length === 0) return null;
+	if (parts.every((p) => p.type === "text")) return parts.map((p) => p.content).join("") || null;
+	return parts;
 }
-function getTextContent(e) {
-	return e === null ? "" : typeof e == "string" ? e : e.filter((e) => e.type === "text").map((e) => e.content).join("");
+function getTextContent(content) {
+	if (content === null) return "";
+	if (typeof content === "string") return content;
+	return content.filter((part) => part.type === "text").map((part) => part.content).join("");
 }
-function uiMessageToModelMessages(e) {
-	return e.role === "system" ? [] : e.role === "assistant" ? buildAssistantMessages(e) : [buildUserOrToolMessage(e)];
+function uiMessageToModelMessages(uiMessage) {
+	if (uiMessage.role === "system") return [];
+	if (uiMessage.role !== "assistant") return [buildUserOrToolMessage(uiMessage)];
+	return buildAssistantMessages(uiMessage);
 }
-function buildUserOrToolMessage(e) {
-	let t = [];
-	for (let n of e.parts) isContentPart(n) && t.push(n);
+function buildUserOrToolMessage(uiMessage) {
+	const contentParts = [];
+	for (const part of uiMessage.parts) if (isContentPart(part)) contentParts.push(part);
 	return {
-		role: e.role,
-		content: collapseContentParts(t)
+		role: uiMessage.role,
+		content: collapseContentParts(contentParts)
 	};
 }
 function createSegment() {
@@ -155,101 +237,121 @@ function createSegment() {
 		toolCalls: []
 	};
 }
-function isToolCallIncluded(e) {
-	return e.state === "input-complete" || e.state === "approval-responded" || e.output !== void 0;
+function isToolCallIncluded(part) {
+	return part.state === "input-complete" || part.state === "approval-responded" || part.output !== void 0;
 }
-function buildAssistantMessages(e) {
-	let t = [], n = createSegment(), r = /* @__PURE__ */ new Set();
+function buildAssistantMessages(uiMessage) {
+	const messageList = [];
+	let current = createSegment();
+	const emittedToolResultIds = /* @__PURE__ */ new Set();
 	function flushSegment() {
-		let e = collapseContentParts(n.contentParts), r = e !== null, i = n.toolCalls.length > 0;
-		(r || i) && t.push({
+		const content = collapseContentParts(current.contentParts);
+		const hasContent = content !== null;
+		const hasToolCalls = current.toolCalls.length > 0;
+		if (hasContent || hasToolCalls) messageList.push({
 			role: "assistant",
-			content: e,
-			...i && { toolCalls: n.toolCalls }
-		}), n = createSegment();
+			content,
+			...hasToolCalls && { toolCalls: current.toolCalls }
+		});
+		current = createSegment();
 	}
-	for (let i of e.parts) switch (i.type) {
+	for (const part of uiMessage.parts) switch (part.type) {
 		case "text":
 		case "image":
 		case "audio":
 		case "video":
 		case "document":
-			n.contentParts.push(i);
+			current.contentParts.push(part);
 			break;
 		case "tool-call":
-			isToolCallIncluded(i) && n.toolCalls.push({
-				id: i.id,
+			if (isToolCallIncluded(part)) current.toolCalls.push({
+				id: part.id,
 				type: "function",
 				function: {
-					name: i.name,
-					arguments: i.arguments
+					name: part.name,
+					arguments: part.arguments
 				}
 			});
 			break;
-		case "tool-result": flushSegment(), (i.state === "complete" || i.state === "error") && !r.has(i.toolCallId) && (t.push({
-			role: "tool",
-			content: i.content,
-			toolCallId: i.toolCallId
-		}), r.add(i.toolCallId));
+		case "tool-result":
+			flushSegment();
+			if ((part.state === "complete" || part.state === "error") && !emittedToolResultIds.has(part.toolCallId)) {
+				messageList.push({
+					role: "tool",
+					content: part.content,
+					toolCallId: part.toolCallId
+				});
+				emittedToolResultIds.add(part.toolCallId);
+			}
 	}
 	flushSegment();
-	for (let n of e.parts) if (n.type === "tool-call" && (n.output !== void 0 && !r.has(n.id) && (t.push({
-		role: "tool",
-		content: JSON.stringify(n.output),
-		toolCallId: n.id
-	}), r.add(n.id)), n.output === void 0 && n.state === "approval-responded" && n.approval?.approved !== void 0 && !r.has(n.id))) {
-		let e = n.approval.approved;
-		t.push({
-			role: "tool",
-			content: JSON.stringify({
-				approved: e,
-				...e && { pendingExecution: !0 },
-				message: e ? "User approved this action" : "User denied this action"
-			}),
-			toolCallId: n.id
-		}), r.add(n.id);
-	}
-	return t.length === 0 && t.push({
+	for (const part of uiMessage.parts) {
+		if (part.type !== "tool-call") continue;
+		if (part.output !== void 0 && !emittedToolResultIds.has(part.id)) {
+			messageList.push({
+				role: "tool",
+				content: JSON.stringify(part.output),
+				toolCallId: part.id
+			});
+			emittedToolResultIds.add(part.id);
+		}
+		if (part.output === void 0 && part.state === "approval-responded" && part.approval?.approved !== void 0 && !emittedToolResultIds.has(part.id)) {
+			const approved = part.approval.approved;
+			messageList.push({
+				role: "tool",
+				content: JSON.stringify({
+					approved,
+					...approved && { pendingExecution: true },
+					message: approved ? "User approved this action" : "User denied this action"
+				}),
+				toolCallId: part.id
+			});
+			emittedToolResultIds.add(part.id);
+		}
+	}
+	if (messageList.length === 0) messageList.push({
 		role: "assistant",
 		content: null
-	}), t;
+	});
+	return messageList;
 }
-function modelMessageToUIMessage(e, t) {
-	let n = [];
-	if (e.role === "tool" && e.toolCallId) n.push({
+function modelMessageToUIMessage(modelMessage, id) {
+	const parts = [];
+	if (modelMessage.role === "tool" && modelMessage.toolCallId) parts.push({
 		type: "tool-result",
-		toolCallId: e.toolCallId,
-		content: getTextContent(e.content),
+		toolCallId: modelMessage.toolCallId,
+		content: getTextContent(modelMessage.content),
 		state: "complete"
 	});
-	else if (Array.isArray(e.content)) for (let t of e.content) n.push(t);
+	else if (Array.isArray(modelMessage.content)) for (const part of modelMessage.content) parts.push(part);
 	else {
-		let t = getTextContent(e.content);
-		t && n.push({
+		const textContent = getTextContent(modelMessage.content);
+		if (textContent) parts.push({
 			type: "text",
-			content: t
+			content: textContent
 		});
 	}
-	if (e.toolCalls && e.toolCalls.length > 0) for (let t of e.toolCalls) n.push({
+	if (modelMessage.toolCalls && modelMessage.toolCalls.length > 0) for (const toolCall of modelMessage.toolCalls) parts.push({
 		type: "tool-call",
-		id: t.id,
-		name: t.function.name,
-		arguments: t.function.arguments,
+		id: toolCall.id,
+		name: toolCall.function.name,
+		arguments: toolCall.function.arguments,
 		state: "input-complete"
 	});
 	return {
-		id: t || generateMessageId(),
-		role: e.role === "tool" ? "assistant" : e.role,
-		parts: n
+		id: id || generateMessageId(),
+		role: modelMessage.role === "tool" ? "assistant" : modelMessage.role,
+		parts
 	};
 }
-function normalizeToUIMessage(e, t) {
-	return "parts" in e ? {
-		...e,
-		id: e.id || t(),
-		createdAt: e.createdAt || /* @__PURE__ */ new Date()
-	} : {
-		...modelMessageToUIMessage(e, t()),
+function normalizeToUIMessage(message, generateId) {
+	if ("parts" in message) return {
+		...message,
+		id: message.id || generateId(),
+		createdAt: message.createdAt || /* @__PURE__ */ new Date()
+	};
+	else return {
+		...modelMessageToUIMessage(message, generateId()),
 		createdAt: /* @__PURE__ */ new Date()
 	};
 }
@@ -258,958 +360,1667 @@ function generateMessageId() {
 }
 //#endregion
 //#region ../../node_modules/.pnpm/@tanstack+ai@0.14.0/node_modules/@tanstack/ai/dist/esm/activities/chat/tools/tool-definition.js
-function toolDefinition(e) {
+function toolDefinition(config) {
 	return {
 		__toolSide: "definition",
-		...e,
-		server(t) {
+		...config,
+		server(execute) {
 			return {
 				__toolSide: "server",
-				...e,
-				execute: t
+				...config,
+				execute
 			};
 		},
-		client(t) {
+		client(execute) {
 			return {
 				__toolSide: "client",
-				...e,
-				execute: t
+				...config,
+				execute
 			};
 		}
 	};
 }
 //#endregion
 //#region ../../node_modules/.pnpm/partial-json@0.1.7/node_modules/partial-json/dist/options.js
-var f = /* @__PURE__ */ e(((e) => {
-	Object.defineProperty(e, "__esModule", { value: !0 }), e.Allow = e.ALL = e.COLLECTION = e.ATOM = e.SPECIAL = e.INF = e._INFINITY = e.INFINITY = e.NAN = e.BOOL = e.NULL = e.OBJ = e.ARR = e.NUM = e.STR = void 0, e.STR = 1, e.NUM = 2, e.ARR = 4, e.OBJ = 8, e.NULL = 16, e.BOOL = 32, e.NAN = 64, e.INFINITY = 128, e._INFINITY = 256, e.INF = e.INFINITY | e._INFINITY, e.SPECIAL = e.NULL | e.BOOL | e.INF | e.NAN, e.ATOM = e.STR | e.NUM | e.SPECIAL, e.COLLECTION = e.ARR | e.OBJ, e.ALL = e.ATOM | e.COLLECTION, e.Allow = {
-		STR: e.STR,
-		NUM: e.NUM,
-		ARR: e.ARR,
-		OBJ: e.OBJ,
-		NULL: e.NULL,
-		BOOL: e.BOOL,
-		NAN: e.NAN,
-		INFINITY: e.INFINITY,
-		_INFINITY: e._INFINITY,
-		INF: e.INF,
-		SPECIAL: e.SPECIAL,
-		ATOM: e.ATOM,
-		COLLECTION: e.COLLECTION,
-		ALL: e.ALL
-	}, e.default = e.Allow;
-})), p = (/* @__PURE__ */ e(((e) => {
-	var t = e && e.__createBinding || (Object.create ? (function(e, t, n, r) {
-		r === void 0 && (r = n);
-		var i = Object.getOwnPropertyDescriptor(t, n);
-		(!i || ("get" in i ? !t.__esModule : i.writable || i.configurable)) && (i = {
-			enumerable: !0,
+var require_options = /* @__PURE__ */ __commonJSMin(((exports) => {
+	/**
+	* Sometimes you don't allow every type to be partially parsed.
+	* For example, you may not want a partial number because it may increase its size gradually before it's complete.
+	* In this case, you can use the `Allow` object to control what types you allow to be partially parsed.
+	* @module
+	*/
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.Allow = exports.ALL = exports.COLLECTION = exports.ATOM = exports.SPECIAL = exports.INF = exports._INFINITY = exports.INFINITY = exports.NAN = exports.BOOL = exports.NULL = exports.OBJ = exports.ARR = exports.NUM = exports.STR = void 0;
+	/**
+	* allow partial strings like `"hello \u12` to be parsed as `"hello "`
+	*/
+	exports.STR = 1;
+	/**
+	* allow partial numbers like `123.` to be parsed as `123`
+	*/
+	exports.NUM = 2;
+	/**
+	* allow partial arrays like `[1, 2,` to be parsed as `[1, 2]`
+	*/
+	exports.ARR = 4;
+	/**
+	* allow partial objects like `{"a": 1, "b":` to be parsed as `{"a": 1}`
+	*/
+	exports.OBJ = 8;
+	/**
+	* allow `nu` to be parsed as `null`
+	*/
+	exports.NULL = 16;
+	/**
+	* allow `tr` to be parsed as `true`, and `fa` to be parsed as `false`
+	*/
+	exports.BOOL = 32;
+	/**
+	* allow `Na` to be parsed as `NaN`
+	*/
+	exports.NAN = 64;
+	/**
+	* allow `Inf` to be parsed as `Infinity`
+	*/
+	exports.INFINITY = 128;
+	/**
+	* allow `-Inf` to be parsed as `-Infinity`
+	*/
+	exports._INFINITY = 256;
+	exports.INF = exports.INFINITY | exports._INFINITY;
+	exports.SPECIAL = exports.NULL | exports.BOOL | exports.INF | exports.NAN;
+	exports.ATOM = exports.STR | exports.NUM | exports.SPECIAL;
+	exports.COLLECTION = exports.ARR | exports.OBJ;
+	exports.ALL = exports.ATOM | exports.COLLECTION;
+	/**
+	* Control what types you allow to be partially parsed.
+	* The default is to allow all types to be partially parsed, which in most casees is the best option.
+	* @example
+	* If you don't want to allow partial objects, you can use the following code:
+	* ```ts
+	* import { Allow, parse } from "partial-json";
+	* parse(`[{"a": 1, "b": 2}, {"a": 3,`, Allow.ARR); // [ { a: 1, b: 2 } ]
+	* ```
+	* Or you can use `~` to disallow a type:
+	* ```ts
+	* parse(`[{"a": 1, "b": 2}, {"a": 3,`, ~Allow.OBJ); // [ { a: 1, b: 2 } ]
+	* ```
+	* @example
+	* If you don't want to allow partial strings, you can use the following code:
+	* ```ts
+	* import { Allow, parse } from "partial-json";
+	* parse(`["complete string", "incompl`, ~Allow.STR); // [ 'complete string' ]
+	* ```
+	*/
+	exports.Allow = {
+		STR: exports.STR,
+		NUM: exports.NUM,
+		ARR: exports.ARR,
+		OBJ: exports.OBJ,
+		NULL: exports.NULL,
+		BOOL: exports.BOOL,
+		NAN: exports.NAN,
+		INFINITY: exports.INFINITY,
+		_INFINITY: exports._INFINITY,
+		INF: exports.INF,
+		SPECIAL: exports.SPECIAL,
+		ATOM: exports.ATOM,
+		COLLECTION: exports.COLLECTION,
+		ALL: exports.ALL
+	};
+	exports.default = exports.Allow;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+ai@0.14.0/node_modules/@tanstack/ai/dist/esm/activities/chat/stream/json-parser.js
+var import_dist = (/* @__PURE__ */ __commonJSMin(((exports) => {
+	var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+		if (k2 === void 0) k2 = k;
+		var desc = Object.getOwnPropertyDescriptor(m, k);
+		if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) desc = {
+			enumerable: true,
 			get: function() {
-				return t[n];
+				return m[k];
 			}
-		}), Object.defineProperty(e, r, i);
-	}) : (function(e, t, n, r) {
-		r === void 0 && (r = n), e[r] = t[n];
-	})), n = e && e.__exportStar || function(e, n) {
-		for (var r in e) r !== "default" && !Object.prototype.hasOwnProperty.call(n, r) && t(n, e, r);
+		};
+		Object.defineProperty(o, k2, desc);
+	}) : (function(o, m, k, k2) {
+		if (k2 === void 0) k2 = k;
+		o[k2] = m[k];
+	}));
+	var __exportStar = exports && exports.__exportStar || function(m, exports$1) {
+		for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports$1, p)) __createBinding(exports$1, m, p);
 	};
-	Object.defineProperty(e, "__esModule", { value: !0 }), e.Allow = e.MalformedJSON = e.PartialJSON = e.parseJSON = e.parse = void 0;
-	var r = f();
-	Object.defineProperty(e, "Allow", {
-		enumerable: !0,
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.Allow = exports.MalformedJSON = exports.PartialJSON = exports.parseJSON = exports.parse = void 0;
+	var options_1 = require_options();
+	Object.defineProperty(exports, "Allow", {
+		enumerable: true,
 		get: function() {
-			return r.Allow;
+			return options_1.Allow;
 		}
-	}), n(f(), e);
+	});
+	__exportStar(require_options(), exports);
 	var PartialJSON = class extends Error {};
-	e.PartialJSON = PartialJSON;
+	exports.PartialJSON = PartialJSON;
 	var MalformedJSON = class extends Error {};
-	e.MalformedJSON = MalformedJSON;
-	function parseJSON(e, t = r.Allow.ALL) {
-		if (typeof e != "string") throw TypeError(`expecting str, got ${typeof e}`);
-		if (!e.trim()) throw Error(`${e} is empty`);
-		return _parseJSON(e.trim(), t);
-	}
-	e.parseJSON = parseJSON;
-	var _parseJSON = (e, t) => {
-		let n = e.length, i = 0, markPartialJSON = (e) => {
-			throw new PartialJSON(`${e} at position ${i}`);
-		}, throwMalformedError = (e) => {
-			throw new MalformedJSON(`${e} at position ${i}`);
-		}, parseAny = () => (skipBlank(), i >= n && markPartialJSON("Unexpected end of input"), e[i] === "\"" ? parseStr() : e[i] === "{" ? parseObj() : e[i] === "[" ? parseArr() : e.substring(i, i + 4) === "null" || r.Allow.NULL & t && n - i < 4 && "null".startsWith(e.substring(i)) ? (i += 4, null) : e.substring(i, i + 4) === "true" || r.Allow.BOOL & t && n - i < 4 && "true".startsWith(e.substring(i)) ? (i += 4, !0) : e.substring(i, i + 5) === "false" || r.Allow.BOOL & t && n - i < 5 && "false".startsWith(e.substring(i)) ? (i += 5, !1) : e.substring(i, i + 8) === "Infinity" || r.Allow.INFINITY & t && n - i < 8 && "Infinity".startsWith(e.substring(i)) ? (i += 8, Infinity) : e.substring(i, i + 9) === "-Infinity" || r.Allow._INFINITY & t && 1 < n - i && n - i < 9 && "-Infinity".startsWith(e.substring(i)) ? (i += 9, -Infinity) : e.substring(i, i + 3) === "NaN" || r.Allow.NAN & t && n - i < 3 && "NaN".startsWith(e.substring(i)) ? (i += 3, NaN) : parseNum()), parseStr = () => {
-			let a = i, o = !1;
-			for (i++; i < n && (e[i] !== "\"" || o && e[i - 1] === "\\");) o = e[i] === "\\" && !o, i++;
-			if (e.charAt(i) == "\"") try {
-				return JSON.parse(e.substring(a, ++i - Number(o)));
+	exports.MalformedJSON = MalformedJSON;
+	/**
+	* Parse incomplete JSON
+	* @param {string} jsonString Partial JSON to be parsed
+	* @param {number} allowPartial Specify what types are allowed to be partial, see {@link Allow} for details
+	* @returns The parsed JSON
+	* @throws {PartialJSON} If the JSON is incomplete (related to the `allow` parameter)
+	* @throws {MalformedJSON} If the JSON is malformed
+	*/
+	function parseJSON(jsonString, allowPartial = options_1.Allow.ALL) {
+		if (typeof jsonString !== "string") throw new TypeError(`expecting str, got ${typeof jsonString}`);
+		if (!jsonString.trim()) throw new Error(`${jsonString} is empty`);
+		return _parseJSON(jsonString.trim(), allowPartial);
+	}
+	exports.parseJSON = parseJSON;
+	var _parseJSON = (jsonString, allow) => {
+		const length = jsonString.length;
+		let index = 0;
+		const markPartialJSON = (msg) => {
+			throw new PartialJSON(`${msg} at position ${index}`);
+		};
+		const throwMalformedError = (msg) => {
+			throw new MalformedJSON(`${msg} at position ${index}`);
+		};
+		const parseAny = () => {
+			skipBlank();
+			if (index >= length) markPartialJSON("Unexpected end of input");
+			if (jsonString[index] === "\"") return parseStr();
+			if (jsonString[index] === "{") return parseObj();
+			if (jsonString[index] === "[") return parseArr();
+			if (jsonString.substring(index, index + 4) === "null" || options_1.Allow.NULL & allow && length - index < 4 && "null".startsWith(jsonString.substring(index))) {
+				index += 4;
+				return null;
+			}
+			if (jsonString.substring(index, index + 4) === "true" || options_1.Allow.BOOL & allow && length - index < 4 && "true".startsWith(jsonString.substring(index))) {
+				index += 4;
+				return true;
+			}
+			if (jsonString.substring(index, index + 5) === "false" || options_1.Allow.BOOL & allow && length - index < 5 && "false".startsWith(jsonString.substring(index))) {
+				index += 5;
+				return false;
+			}
+			if (jsonString.substring(index, index + 8) === "Infinity" || options_1.Allow.INFINITY & allow && length - index < 8 && "Infinity".startsWith(jsonString.substring(index))) {
+				index += 8;
+				return Infinity;
+			}
+			if (jsonString.substring(index, index + 9) === "-Infinity" || options_1.Allow._INFINITY & allow && 1 < length - index && length - index < 9 && "-Infinity".startsWith(jsonString.substring(index))) {
+				index += 9;
+				return -Infinity;
+			}
+			if (jsonString.substring(index, index + 3) === "NaN" || options_1.Allow.NAN & allow && length - index < 3 && "NaN".startsWith(jsonString.substring(index))) {
+				index += 3;
+				return NaN;
+			}
+			return parseNum();
+		};
+		const parseStr = () => {
+			const start = index;
+			let escape = false;
+			index++;
+			while (index < length && (jsonString[index] !== "\"" || escape && jsonString[index - 1] === "\\")) {
+				escape = jsonString[index] === "\\" ? !escape : false;
+				index++;
+			}
+			if (jsonString.charAt(index) == "\"") try {
+				return JSON.parse(jsonString.substring(start, ++index - Number(escape)));
 			} catch (e) {
 				throwMalformedError(String(e));
 			}
-			else if (r.Allow.STR & t) try {
-				return JSON.parse(e.substring(a, i - Number(o)) + "\"");
-			} catch {
-				return JSON.parse(e.substring(a, e.lastIndexOf("\\")) + "\"");
+			else if (options_1.Allow.STR & allow) try {
+				return JSON.parse(jsonString.substring(start, index - Number(escape)) + "\"");
+			} catch (e) {
+				return JSON.parse(jsonString.substring(start, jsonString.lastIndexOf("\\")) + "\"");
 			}
 			markPartialJSON("Unterminated string literal");
-		}, parseObj = () => {
-			i++, skipBlank();
-			let a = {};
+		};
+		const parseObj = () => {
+			index++;
+			skipBlank();
+			const obj = {};
 			try {
-				for (; e[i] !== "}";) {
-					if (skipBlank(), i >= n && r.Allow.OBJ & t) return a;
-					let o = parseStr();
-					skipBlank(), i++;
+				while (jsonString[index] !== "}") {
+					skipBlank();
+					if (index >= length && options_1.Allow.OBJ & allow) return obj;
+					const key = parseStr();
+					skipBlank();
+					index++;
 					try {
-						a[o] = parseAny();
+						obj[key] = parseAny();
 					} catch (e) {
-						if (r.Allow.OBJ & t) return a;
-						throw e;
+						if (options_1.Allow.OBJ & allow) return obj;
+						else throw e;
 					}
-					skipBlank(), e[i] === "," && i++;
+					skipBlank();
+					if (jsonString[index] === ",") index++;
 				}
-			} catch {
-				if (r.Allow.OBJ & t) return a;
-				markPartialJSON("Expected '}' at end of object");
+			} catch (e) {
+				if (options_1.Allow.OBJ & allow) return obj;
+				else markPartialJSON("Expected '}' at end of object");
 			}
-			return i++, a;
-		}, parseArr = () => {
-			i++;
-			let n = [];
+			index++;
+			return obj;
+		};
+		const parseArr = () => {
+			index++;
+			const arr = [];
 			try {
-				for (; e[i] !== "]";) n.push(parseAny()), skipBlank(), e[i] === "," && i++;
-			} catch {
-				if (r.Allow.ARR & t) return n;
+				while (jsonString[index] !== "]") {
+					arr.push(parseAny());
+					skipBlank();
+					if (jsonString[index] === ",") index++;
+				}
+			} catch (e) {
+				if (options_1.Allow.ARR & allow) return arr;
 				markPartialJSON("Expected ']' at end of array");
 			}
-			return i++, n;
-		}, parseNum = () => {
-			if (i === 0) {
-				e === "-" && throwMalformedError("Not sure what '-' is");
+			index++;
+			return arr;
+		};
+		const parseNum = () => {
+			if (index === 0) {
+				if (jsonString === "-") throwMalformedError("Not sure what '-' is");
 				try {
-					return JSON.parse(e);
-				} catch (n) {
-					if (r.Allow.NUM & t) try {
-						return JSON.parse(e.substring(0, e.lastIndexOf("e")));
-					} catch {}
-					throwMalformedError(String(n));
+					return JSON.parse(jsonString);
+				} catch (e) {
+					if (options_1.Allow.NUM & allow) try {
+						return JSON.parse(jsonString.substring(0, jsonString.lastIndexOf("e")));
+					} catch (e) {}
+					throwMalformedError(String(e));
 				}
 			}
-			let a = i;
-			for (e[i] === "-" && i++; e[i] && ",]}".indexOf(e[i]) === -1;) i++;
-			i == n && !(r.Allow.NUM & t) && markPartialJSON("Unterminated number literal");
+			const start = index;
+			if (jsonString[index] === "-") index++;
+			while (jsonString[index] && ",]}".indexOf(jsonString[index]) === -1) index++;
+			if (index == length && !(options_1.Allow.NUM & allow)) markPartialJSON("Unterminated number literal");
 			try {
-				return JSON.parse(e.substring(a, i));
-			} catch {
-				e.substring(a, i) === "-" && markPartialJSON("Not sure what '-' is");
+				return JSON.parse(jsonString.substring(start, index));
+			} catch (e) {
+				if (jsonString.substring(start, index) === "-") markPartialJSON("Not sure what '-' is");
 				try {
-					return JSON.parse(e.substring(a, e.lastIndexOf("e")));
+					return JSON.parse(jsonString.substring(start, jsonString.lastIndexOf("e")));
 				} catch (e) {
 					throwMalformedError(String(e));
 				}
 			}
-		}, skipBlank = () => {
-			for (; i < n && " \n\r	".includes(e[i]);) i++;
+		};
+		const skipBlank = () => {
+			while (index < length && " \n\r	".includes(jsonString[index])) index++;
 		};
 		return parseAny();
 	};
-	e.parse = parseJSON;
-})))(), PartialJSONParser = class {
-	parse(e) {
-		if (!(!e || e.trim() === "")) try {
-			return (0, p.parse)(e);
+	exports.parse = parseJSON;
+})))();
+var PartialJSONParser = class {
+	/**
+	* Parse a potentially incomplete JSON string
+	* @param jsonString - The JSON string to parse (may be incomplete)
+	* @returns The parsed object, or undefined if parsing fails
+	*/
+	parse(jsonString) {
+		if (!jsonString || jsonString.trim() === "") return;
+		try {
+			return (0, import_dist.parse)(jsonString);
 		} catch {
 			return;
 		}
 	}
-}, m = new PartialJSONParser();
+};
+var defaultJSONParser = new PartialJSONParser();
 //#endregion
 //#region ../../node_modules/.pnpm/@tanstack+ai@0.14.0/node_modules/@tanstack/ai/dist/esm/activities/chat/stream/message-updaters.js
-function updateTextPart(e, t, n) {
-	return e.map((e) => {
-		if (e.id !== t) return e;
-		let r = [...e.parts], i = r.length > 0 ? r[r.length - 1] : null;
-		return i && i.type === "text" ? r[r.length - 1] = {
+function updateTextPart(messages, messageId, content) {
+	return messages.map((msg) => {
+		if (msg.id !== messageId) return msg;
+		const parts = [...msg.parts];
+		const lastPart = parts.length > 0 ? parts[parts.length - 1] : null;
+		if (lastPart && lastPart.type === "text") parts[parts.length - 1] = {
 			type: "text",
-			content: n
-		} : r.push({
+			content
+		};
+		else parts.push({
 			type: "text",
-			content: n
-		}), {
-			...e,
-			parts: r
+			content
+		});
+		return {
+			...msg,
+			parts
 		};
 	});
 }
-function updateToolCallPart(e, t, n) {
-	return e.map((e) => {
-		if (e.id !== t) return e;
-		let r = [...e.parts], i = r.find((e) => e.type === "tool-call" && e.id === n.id), a = {
+function updateToolCallPart(messages, messageId, toolCall) {
+	return messages.map((msg) => {
+		if (msg.id !== messageId) return msg;
+		const parts = [...msg.parts];
+		const existing = parts.find((p) => p.type === "tool-call" && p.id === toolCall.id);
+		const toolCallPart = {
 			type: "tool-call",
-			id: n.id,
-			name: n.name,
-			arguments: n.arguments,
-			state: n.state,
-			...i?.approval && { approval: { ...i.approval } },
-			...i?.output !== void 0 && { output: i.output }
+			id: toolCall.id,
+			name: toolCall.name,
+			arguments: toolCall.arguments,
+			state: toolCall.state,
+			...existing?.approval && { approval: { ...existing.approval } },
+			...existing?.output !== void 0 && { output: existing.output }
 		};
-		return i ? r[r.indexOf(i)] = a : r.push(a), {
-			...e,
-			parts: r
+		if (existing) parts[parts.indexOf(existing)] = toolCallPart;
+		else parts.push(toolCallPart);
+		return {
+			...msg,
+			parts
 		};
 	});
 }
-function updateToolResultPart(e, t, n, r, i, a) {
-	return e.map((e) => {
-		if (e.id !== t) return e;
-		let o = [...e.parts], s = o.findIndex((e) => e.type === "tool-result" && e.toolCallId === n), c = {
+function updateToolResultPart(messages, messageId, toolCallId, content, state, error) {
+	return messages.map((msg) => {
+		if (msg.id !== messageId) return msg;
+		const parts = [...msg.parts];
+		const resultPartIndex = parts.findIndex((p) => p.type === "tool-result" && p.toolCallId === toolCallId);
+		const toolResultPart = {
 			type: "tool-result",
-			toolCallId: n,
-			content: r,
-			state: i,
-			...a && { error: a }
+			toolCallId,
+			content,
+			state,
+			...error && { error }
 		};
-		return s >= 0 ? o[s] = c : o.push(c), {
-			...e,
-			parts: o
+		if (resultPartIndex >= 0) parts[resultPartIndex] = toolResultPart;
+		else parts.push(toolResultPart);
+		return {
+			...msg,
+			parts
 		};
 	});
 }
-function updateToolCallApproval(e, t, n, r) {
-	return e.map((e) => {
-		if (e.id !== t) return e;
-		let i = [...e.parts], a = i.find((e) => e.type === "tool-call" && e.id === n);
-		return a && (a.state = "approval-requested", a.approval = {
-			id: r,
-			needsApproval: !0
-		}), {
-			...e,
-			parts: i
+function updateToolCallApproval(messages, messageId, toolCallId, approvalId) {
+	return messages.map((msg) => {
+		if (msg.id !== messageId) return msg;
+		const parts = [...msg.parts];
+		const toolCallPart = parts.find((p) => p.type === "tool-call" && p.id === toolCallId);
+		if (toolCallPart) {
+			toolCallPart.state = "approval-requested";
+			toolCallPart.approval = {
+				id: approvalId,
+				needsApproval: true
+			};
+		}
+		return {
+			...msg,
+			parts
 		};
 	});
 }
-function updateToolCallWithOutput(e, t, n, r, i) {
-	return e.map((e) => {
-		let a = [...e.parts], o = a.find((e) => e.type === "tool-call" && e.id === t);
-		return o && (o.output = i ? { error: i } : n, o.state = r || "input-complete"), {
-			...e,
-			parts: a
+function updateToolCallWithOutput(messages, toolCallId, output, state, errorText) {
+	return messages.map((msg) => {
+		const parts = [...msg.parts];
+		const toolCallPart = parts.find((p) => p.type === "tool-call" && p.id === toolCallId);
+		if (toolCallPart) {
+			toolCallPart.output = errorText ? { error: errorText } : output;
+			if (state) toolCallPart.state = state;
+			else toolCallPart.state = "input-complete";
+		}
+		return {
+			...msg,
+			parts
 		};
 	});
 }
-function updateToolCallApprovalResponse(e, t, n) {
-	return e.map((e) => {
-		let r = [...e.parts], i = r.find((e) => e.type === "tool-call" && e.approval?.id === t);
-		return i && i.approval && (i.approval.approved = n, i.state = "approval-responded"), {
-			...e,
-			parts: r
+function updateToolCallApprovalResponse(messages, approvalId, approved) {
+	return messages.map((msg) => {
+		const parts = [...msg.parts];
+		const toolCallPart = parts.find((p) => p.type === "tool-call" && p.approval?.id === approvalId);
+		if (toolCallPart && toolCallPart.approval) {
+			toolCallPart.approval.approved = approved;
+			toolCallPart.state = "approval-responded";
+		}
+		return {
+			...msg,
+			parts
 		};
 	});
 }
-function updateThinkingPart(e, t, n) {
-	return e.map((e) => {
-		if (e.id !== t) return e;
-		let r = [...e.parts], i = r.findIndex((e) => e.type === "thinking"), a = {
+function updateThinkingPart(messages, messageId, content) {
+	return messages.map((msg) => {
+		if (msg.id !== messageId) return msg;
+		const parts = [...msg.parts];
+		const thinkingPartIndex = parts.findIndex((p) => p.type === "thinking");
+		const thinkingPart = {
 			type: "thinking",
-			content: n
+			content
 		};
-		return i >= 0 ? r[i] = a : r.push(a), {
-			...e,
-			parts: r
+		if (thinkingPartIndex >= 0) parts[thinkingPartIndex] = thinkingPart;
+		else parts.push(thinkingPart);
+		return {
+			...msg,
+			parts
 		};
 	});
 }
 //#endregion
 //#region ../../node_modules/.pnpm/@tanstack+ai@0.14.0/node_modules/@tanstack/ai/dist/esm/activities/chat/stream/strategies.js
 var ImmediateStrategy = class {
-	shouldEmit(e, t) {
-		return !0;
-	}
-}, h = class StreamProcessor {
-	constructor(e = {}) {
-		this.messages = [], this.messageStates = /* @__PURE__ */ new Map(), this.activeMessageIds = /* @__PURE__ */ new Set(), this.toolCallToMessage = /* @__PURE__ */ new Map(), this.pendingManualMessageId = null, this.activeRuns = /* @__PURE__ */ new Set(), this.finishReason = null, this.hasError = !1, this.isDone = !1, this.recording = null, this.recordingStartTime = 0, this.chunkStrategy = e.chunkStrategy || new ImmediateStrategy(), this.events = e.events || {}, this.jsonParser = e.jsonParser || m, this.recordingEnabled = e.recording ?? !1, e.initialMessages && (this.messages = [...e.initialMessages]);
-	}
-	setMessages(e) {
-		this.messages = [...e], this.emitMessagesChange();
+	shouldEmit(_chunk, _accumulated) {
+		return true;
 	}
-	addUserMessage(e, t) {
-		let n = typeof e == "string" ? [{
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+ai@0.14.0/node_modules/@tanstack/ai/dist/esm/activities/chat/stream/processor.js
+var StreamProcessor = class StreamProcessor {
+	constructor(options = {}) {
+		this.messages = [];
+		this.messageStates = /* @__PURE__ */ new Map();
+		this.activeMessageIds = /* @__PURE__ */ new Set();
+		this.toolCallToMessage = /* @__PURE__ */ new Map();
+		this.pendingManualMessageId = null;
+		this.activeRuns = /* @__PURE__ */ new Set();
+		this.finishReason = null;
+		this.hasError = false;
+		this.isDone = false;
+		this.recording = null;
+		this.recordingStartTime = 0;
+		this.chunkStrategy = options.chunkStrategy || new ImmediateStrategy();
+		this.events = options.events || {};
+		this.jsonParser = options.jsonParser || defaultJSONParser;
+		this.recordingEnabled = options.recording ?? false;
+		if (options.initialMessages) this.messages = [...options.initialMessages];
+	}
+	/**
+	* Set the messages array (e.g., from persisted state)
+	*/
+	setMessages(messages) {
+		this.messages = [...messages];
+		this.emitMessagesChange();
+	}
+	/**
+	* Add a user message to the conversation.
+	* Supports both simple string content and multimodal content arrays.
+	*
+	* @param content - The message content (string or array of content parts)
+	* @param id - Optional custom message ID (generated if not provided)
+	* @returns The created UIMessage
+	*
+	* @example
+	* ```ts
+	* // Simple text message
+	* processor.addUserMessage('Hello!')
+	*
+	* // Multimodal message with image
+	* processor.addUserMessage([
+	*   { type: 'text', content: 'What is in this image?' },
+	*   { type: 'image', source: { type: 'url', value: 'https://example.com/photo.jpg' } }
+	* ])
+	*
+	* // With custom ID
+	* processor.addUserMessage('Hello!', 'custom-id-123')
+	* ```
+	*/
+	addUserMessage(content, id) {
+		const parts = typeof content === "string" ? [{
 			type: "text",
-			content: e
-		}] : e.map((e) => e), r = {
-			id: t ?? generateMessageId(),
+			content
+		}] : content.map((part) => {
+			return part;
+		});
+		const userMessage = {
+			id: id ?? generateMessageId(),
 			role: "user",
-			parts: n,
+			parts,
 			createdAt: /* @__PURE__ */ new Date()
 		};
-		return this.messages = [...this.messages, r], this.emitMessagesChange(), r;
-	}
+		this.messages = [...this.messages, userMessage];
+		this.emitMessagesChange();
+		return userMessage;
+	}
+	/**
+	* Prepare for a new assistant message stream.
+	* Does NOT create the message immediately -- the message is created lazily
+	* when the first content-bearing chunk arrives via ensureAssistantMessage().
+	* This prevents empty assistant messages from flickering in the UI when
+	* auto-continuation produces no content.
+	*/
 	prepareAssistantMessage() {
 		this.resetStreamState();
 	}
-	startAssistantMessage(e) {
+	/**
+	* @deprecated Use prepareAssistantMessage() instead. This eagerly creates
+	* an assistant message which can cause empty message flicker.
+	*/
+	startAssistantMessage(messageId) {
 		this.prepareAssistantMessage();
-		let { messageId: t } = this.ensureAssistantMessage(e);
-		return this.pendingManualMessageId = t, t;
-	}
+		const { messageId: id } = this.ensureAssistantMessage(messageId);
+		this.pendingManualMessageId = id;
+		return id;
+	}
+	/**
+	* Get the current assistant message ID (if one has been created).
+	* Returns null if prepareAssistantMessage() was called but no content
+	* has arrived yet.
+	*/
 	getCurrentAssistantMessageId() {
-		let e = null;
-		for (let [t, n] of this.messageStates) n.role === "assistant" && (e = t);
-		return e;
-	}
-	addToolResult(e, t, n) {
-		let r = this.messages.find((t) => t.parts.some((t) => t.type === "tool-call" && t.id === e));
-		if (!r) {
-			console.warn(`[StreamProcessor] Could not find message with tool call ${e}`);
+		let lastId = null;
+		for (const [id, state] of this.messageStates) if (state.role === "assistant") lastId = id;
+		return lastId;
+	}
+	/**
+	* Add a tool result (called by client after handling onToolCall)
+	*/
+	addToolResult(toolCallId, output, error) {
+		const messageWithToolCall = this.messages.find((msg) => msg.parts.some((p) => p.type === "tool-call" && p.id === toolCallId));
+		if (!messageWithToolCall) {
+			console.warn(`[StreamProcessor] Could not find message with tool call ${toolCallId}`);
 			return;
 		}
-		let i = updateToolCallWithOutput(this.messages, e, t, n ? "input-complete" : void 0, n), a = typeof t == "string" ? t : JSON.stringify(t), o = n ? "error" : "complete";
-		i = updateToolResultPart(i, r.id, e, a, o, n), this.messages = i, this.emitMessagesChange();
-	}
-	addToolApprovalResponse(e, t) {
-		this.messages = updateToolCallApprovalResponse(this.messages, e, t), this.emitMessagesChange();
-	}
+		let updatedMessages = updateToolCallWithOutput(this.messages, toolCallId, output, error ? "input-complete" : void 0, error);
+		const content = typeof output === "string" ? output : JSON.stringify(output);
+		const toolResultState = error ? "error" : "complete";
+		updatedMessages = updateToolResultPart(updatedMessages, messageWithToolCall.id, toolCallId, content, toolResultState, error);
+		this.messages = updatedMessages;
+		this.emitMessagesChange();
+	}
+	/**
+	* Add an approval response (called by client after handling onApprovalRequest)
+	*/
+	addToolApprovalResponse(approvalId, approved) {
+		this.messages = updateToolCallApprovalResponse(this.messages, approvalId, approved);
+		this.emitMessagesChange();
+	}
+	/**
+	* Get the conversation as ModelMessages (for sending to LLM)
+	*/
 	toModelMessages() {
-		let e = [];
-		for (let t of this.messages) e.push(...uiMessageToModelMessages(t));
-		return e;
+		const modelMessages = [];
+		for (const msg of this.messages) modelMessages.push(...uiMessageToModelMessages(msg));
+		return modelMessages;
 	}
+	/**
+	* Get current messages
+	*/
 	getMessages() {
 		return this.messages;
 	}
+	/**
+	* Check if all tool calls in the last assistant message are complete
+	* Useful for auto-continue logic
+	*/
 	areAllToolsComplete() {
-		let e = this.messages.findLast((e) => e.role === "assistant");
-		if (!e) return !0;
-		let t = e.parts.filter((e) => e.type === "tool-call");
-		if (t.length === 0) return !0;
-		let n = new Set(e.parts.filter((e) => e.type === "tool-result").map((e) => e.toolCallId));
-		return t.every((e) => e.state === "approval-responded" || e.output !== void 0 && !e.approval || n.has(e.id));
-	}
-	removeMessagesAfter(e) {
-		this.messages = this.messages.slice(0, e + 1), this.emitMessagesChange();
-	}
+		const lastAssistant = this.messages.findLast((m) => m.role === "assistant");
+		if (!lastAssistant) return true;
+		const toolParts = lastAssistant.parts.filter((p) => p.type === "tool-call");
+		if (toolParts.length === 0) return true;
+		const toolResultIds = new Set(lastAssistant.parts.filter((p) => p.type === "tool-result").map((p) => p.toolCallId));
+		return toolParts.every((part) => part.state === "approval-responded" || part.output !== void 0 && !part.approval || toolResultIds.has(part.id));
+	}
+	/**
+	* Remove messages after a certain index (for reload/retry)
+	*/
+	removeMessagesAfter(index) {
+		this.messages = this.messages.slice(0, index + 1);
+		this.emitMessagesChange();
+	}
+	/**
+	* Clear all messages
+	*/
 	clearMessages() {
-		this.messages = [], this.messageStates.clear(), this.activeMessageIds.clear(), this.toolCallToMessage.clear(), this.pendingManualMessageId = null, this.emitMessagesChange();
-	}
-	async process(e) {
-		this.resetStreamState(), this.recordingEnabled && this.startRecording();
-		for await (let t of e) this.processChunk(t);
-		return this.finalizeStream(), this.recording && (this.recording.result = this.getResult()), this.getResult();
-	}
-	processChunk(e) {
-		switch (this.recording && this.recording.chunks.push({
-			chunk: e,
+		this.messages = [];
+		this.messageStates.clear();
+		this.activeMessageIds.clear();
+		this.toolCallToMessage.clear();
+		this.pendingManualMessageId = null;
+		this.emitMessagesChange();
+	}
+	/**
+	* Process a stream and emit events through handlers
+	*/
+	async process(stream) {
+		this.resetStreamState();
+		if (this.recordingEnabled) this.startRecording();
+		for await (const chunk of stream) this.processChunk(chunk);
+		this.finalizeStream();
+		if (this.recording) this.recording.result = this.getResult();
+		return this.getResult();
+	}
+	/**
+	* Process a single chunk from the stream.
+	*
+	* Central dispatch for all AG-UI events. Each event type maps to a specific
+	* handler. Events not listed in the switch are intentionally ignored
+	* (STEP_STARTED, STATE_SNAPSHOT, STATE_DELTA).
+	*
+	* @see docs/chat-architecture.md#adapter-contract — Expected event types and ordering
+	*/
+	processChunk(chunk) {
+		if (this.recording) this.recording.chunks.push({
+			chunk,
 			timestamp: Date.now(),
 			index: this.recording.chunks.length
-		}), e.type) {
+		});
+		switch (chunk.type) {
 			case "TEXT_MESSAGE_START":
-				this.handleTextMessageStartEvent(e);
+				this.handleTextMessageStartEvent(chunk);
 				break;
 			case "TEXT_MESSAGE_CONTENT":
-				this.handleTextMessageContentEvent(e);
+				this.handleTextMessageContentEvent(chunk);
 				break;
 			case "TEXT_MESSAGE_END":
-				this.handleTextMessageEndEvent(e);
+				this.handleTextMessageEndEvent(chunk);
 				break;
 			case "TOOL_CALL_START":
-				this.handleToolCallStartEvent(e);
+				this.handleToolCallStartEvent(chunk);
 				break;
 			case "TOOL_CALL_ARGS":
-				this.handleToolCallArgsEvent(e);
+				this.handleToolCallArgsEvent(chunk);
 				break;
 			case "TOOL_CALL_END":
-				this.handleToolCallEndEvent(e);
+				this.handleToolCallEndEvent(chunk);
 				break;
 			case "RUN_FINISHED":
-				this.handleRunFinishedEvent(e);
+				this.handleRunFinishedEvent(chunk);
 				break;
 			case "RUN_ERROR":
-				this.handleRunErrorEvent(e);
+				this.handleRunErrorEvent(chunk);
 				break;
 			case "STEP_FINISHED":
-				this.handleStepFinishedEvent(e);
+				this.handleStepFinishedEvent(chunk);
 				break;
 			case "MESSAGES_SNAPSHOT":
-				this.handleMessagesSnapshotEvent(e);
+				this.handleMessagesSnapshotEvent(chunk);
 				break;
 			case "CUSTOM":
-				this.handleCustomEvent(e);
+				this.handleCustomEvent(chunk);
 				break;
 			case "RUN_STARTED":
-				this.handleRunStartedEvent(e);
+				this.handleRunStartedEvent(chunk);
 				break;
 			case "REASONING_START":
 			case "REASONING_MESSAGE_START":
 			case "REASONING_MESSAGE_END":
 			case "REASONING_END": break;
 			case "REASONING_MESSAGE_CONTENT":
-				this.handleReasoningMessageContentEvent(e);
+				this.handleReasoningMessageContentEvent(chunk);
 				break;
-			case "TOOL_CALL_RESULT": this.handleToolCallResultEvent(e);
+			case "TOOL_CALL_RESULT": this.handleToolCallResultEvent(chunk);
 		}
 	}
-	createMessageState(e, t) {
-		let n = {
-			id: e,
-			role: t,
+	/**
+	* Create a new MessageStreamState for a message
+	*/
+	createMessageState(messageId, role) {
+		const state = {
+			id: messageId,
+			role,
 			totalTextContent: "",
 			currentSegmentText: "",
 			lastEmittedText: "",
 			thinkingContent: "",
-			hasSeenReasoningEvents: !1,
+			hasSeenReasoningEvents: false,
 			toolCalls: /* @__PURE__ */ new Map(),
 			toolCallOrder: [],
-			hasToolCallsSinceTextStart: !1,
-			isComplete: !1
+			hasToolCallsSinceTextStart: false,
+			isComplete: false
 		};
-		return this.messageStates.set(e, n), n;
-	}
-	getMessageState(e) {
-		return this.messageStates.get(e);
-	}
+		this.messageStates.set(messageId, state);
+		return state;
+	}
+	/**
+	* Get the MessageStreamState for a message
+	*/
+	getMessageState(messageId) {
+		return this.messageStates.get(messageId);
+	}
+	/**
+	* Get the most recent active assistant message ID.
+	* Used as fallback for events that don't include a messageId.
+	*/
 	getActiveAssistantMessageId() {
-		let e = Array.from(this.activeMessageIds);
-		for (let t = e.length - 1; t >= 0; t--) {
-			let n = e[t], r = this.messageStates.get(n);
-			if (r && r.role === "assistant") return n;
+		const ids = Array.from(this.activeMessageIds);
+		for (let i = ids.length - 1; i >= 0; i--) {
+			const id = ids[i];
+			const state = this.messageStates.get(id);
+			if (state && state.role === "assistant") return id;
 		}
 		return null;
 	}
-	ensureAssistantMessage(e) {
-		if (e) {
-			let t = this.getMessageState(e);
-			if (t) return {
-				messageId: e,
-				state: t
+	/**
+	* Ensure an active assistant message exists, creating one if needed.
+	* Used for backward compat when events arrive without prior TEXT_MESSAGE_START.
+	*
+	* On reconnect/resume, a TEXT_MESSAGE_CONTENT may arrive for a message that
+	* already exists in this.messages (e.g. from initialMessages or a prior
+	* MESSAGES_SNAPSHOT) but whose transient state was cleared. In that case we
+	* hydrate state from the existing message rather than creating a duplicate.
+	*/
+	ensureAssistantMessage(preferredId) {
+		if (preferredId) {
+			const state2 = this.getMessageState(preferredId);
+			if (state2) return {
+				messageId: preferredId,
+				state: state2
 			};
 		}
-		let t = this.getActiveAssistantMessageId();
-		if (t) return {
-			messageId: t,
-			state: this.getMessageState(t)
+		const activeId = this.getActiveAssistantMessageId();
+		if (activeId) return {
+			messageId: activeId,
+			state: this.getMessageState(activeId)
 		};
-		if (e) {
-			let t = this.messages.find((t) => t.id === e);
-			if (t) {
-				let n = this.createMessageState(e, t.role);
-				this.activeMessageIds.add(e);
-				let r = t.parts.length > 0 ? t.parts[t.parts.length - 1] : null;
-				return r && r.type === "text" && (n.currentSegmentText = r.content, n.lastEmittedText = r.content, n.totalTextContent = r.content), {
-					messageId: e,
-					state: n
+		if (preferredId) {
+			const existingMsg = this.messages.find((m) => m.id === preferredId);
+			if (existingMsg) {
+				const state2 = this.createMessageState(preferredId, existingMsg.role);
+				this.activeMessageIds.add(preferredId);
+				const lastPart = existingMsg.parts.length > 0 ? existingMsg.parts[existingMsg.parts.length - 1] : null;
+				if (lastPart && lastPart.type === "text") {
+					state2.currentSegmentText = lastPart.content;
+					state2.lastEmittedText = lastPart.content;
+					state2.totalTextContent = lastPart.content;
+				}
+				return {
+					messageId: preferredId,
+					state: state2
 				};
 			}
 		}
-		let n = e || generateMessageId(), r = {
-			id: n,
+		const id = preferredId || generateMessageId();
+		const assistantMessage = {
+			id,
 			role: "assistant",
 			parts: [],
 			createdAt: /* @__PURE__ */ new Date()
 		};
-		this.messages = [...this.messages, r];
-		let i = this.createMessageState(n, "assistant");
-		return this.activeMessageIds.add(n), this.pendingManualMessageId = n, this.events.onStreamStart?.(), this.emitMessagesChange(), {
-			messageId: n,
-			state: i
+		this.messages = [...this.messages, assistantMessage];
+		const state = this.createMessageState(id, "assistant");
+		this.activeMessageIds.add(id);
+		this.pendingManualMessageId = id;
+		this.events.onStreamStart?.();
+		this.emitMessagesChange();
+		return {
+			messageId: id,
+			state
 		};
 	}
-	handleTextMessageStartEvent(e) {
-		let { messageId: t, role: n } = e, r = n === "user" || n === "system" ? n : "assistant";
+	/**
+	* Handle TEXT_MESSAGE_START event
+	*/
+	handleTextMessageStartEvent(chunk) {
+		const { messageId, role } = chunk;
+		const uiRole = role === "user" || role === "system" ? role : "assistant";
 		if (this.pendingManualMessageId) {
-			let e = this.pendingManualMessageId;
-			if (this.pendingManualMessageId = null, e !== t) {
-				this.messages = this.messages.map((n) => n.id === e ? {
-					...n,
-					id: t
-				} : n);
-				let n = this.messageStates.get(e);
-				n && (n.id = t, this.messageStates.delete(e), this.messageStates.set(t, n)), this.activeMessageIds.delete(e), this.activeMessageIds.add(t);
+			const pendingId = this.pendingManualMessageId;
+			this.pendingManualMessageId = null;
+			if (pendingId !== messageId) {
+				this.messages = this.messages.map((msg) => msg.id === pendingId ? {
+					...msg,
+					id: messageId
+				} : msg);
+				const existingState = this.messageStates.get(pendingId);
+				if (existingState) {
+					existingState.id = messageId;
+					this.messageStates.delete(pendingId);
+					this.messageStates.set(messageId, existingState);
+				}
+				this.activeMessageIds.delete(pendingId);
+				this.activeMessageIds.add(messageId);
+			}
+			if (!this.messageStates.has(messageId)) {
+				this.createMessageState(messageId, uiRole);
+				this.activeMessageIds.add(messageId);
 			}
-			this.messageStates.has(t) || (this.createMessageState(t, r), this.activeMessageIds.add(t)), this.emitMessagesChange();
+			this.emitMessagesChange();
 			return;
 		}
-		if (this.messages.find((e) => e.id === t)) {
-			if (this.activeMessageIds.add(t), !this.messageStates.has(t)) this.createMessageState(t, r);
+		if (this.messages.find((m) => m.id === messageId)) {
+			this.activeMessageIds.add(messageId);
+			if (!this.messageStates.has(messageId)) this.createMessageState(messageId, uiRole);
 			else {
-				let e = this.messageStates.get(t);
-				e.hasToolCallsSinceTextStart &&= (e.currentSegmentText !== e.lastEmittedText && this.emitTextUpdateForMessage(t), e.currentSegmentText = "", e.lastEmittedText = "", !1);
+				const existingState = this.messageStates.get(messageId);
+				if (existingState.hasToolCallsSinceTextStart) {
+					if (existingState.currentSegmentText !== existingState.lastEmittedText) this.emitTextUpdateForMessage(messageId);
+					existingState.currentSegmentText = "";
+					existingState.lastEmittedText = "";
+					existingState.hasToolCallsSinceTextStart = false;
+				}
 			}
 			return;
 		}
-		let i = {
-			id: t,
-			role: r,
+		const newMessage = {
+			id: messageId,
+			role: uiRole,
 			parts: [],
 			createdAt: /* @__PURE__ */ new Date()
 		};
-		this.messages = [...this.messages, i], this.createMessageState(t, r), this.activeMessageIds.add(t), this.events.onStreamStart?.(), this.emitMessagesChange();
-	}
-	handleTextMessageEndEvent(e) {
-		let { messageId: t } = e, n = this.getMessageState(t);
-		n && (n.isComplete || (n.currentSegmentText !== n.lastEmittedText && this.emitTextUpdateForMessage(t), this.completeAllToolCallsForMessage(t)));
-	}
-	handleMessagesSnapshotEvent(e) {
-		this.resetStreamState(), this.messages = [...e.messages], this.emitMessagesChange();
-	}
-	handleTextMessageContentEvent(e) {
-		let { messageId: t, state: n } = this.ensureAssistantMessage(e.messageId);
-		this.completeAllToolCallsForMessage(t);
-		let r = n.currentSegmentText;
-		n.hasToolCallsSinceTextStart && r.length > 0 && this.isNewTextSegment(e, r) && (r !== n.lastEmittedText && this.emitTextUpdateForMessage(t), n.currentSegmentText = "", n.lastEmittedText = "", n.hasToolCallsSinceTextStart = !1);
-		let i = n.currentSegmentText, a = i, o = e.delta || "";
-		o === "" ? e.content !== void 0 && e.content !== "" && (a = e.content.startsWith(i) ? e.content : i.startsWith(e.content) ? i : i + e.content) : a = i + o;
-		let s = a.slice(i.length);
-		n.currentSegmentText = a, n.totalTextContent += s;
-		let c = e.delta || e.content || "";
-		this.chunkStrategy.shouldEmit(c, n.currentSegmentText) && n.currentSegmentText !== n.lastEmittedText && this.emitTextUpdateForMessage(t);
-	}
-	handleToolCallStartEvent(e) {
-		let t = e.parentMessageId ?? this.getActiveAssistantMessageId(), { messageId: n, state: r } = this.ensureAssistantMessage(t ?? void 0);
-		r.hasToolCallsSinceTextStart = !0;
-		let i = e.toolCallId;
-		if (!r.toolCalls.get(i)) {
-			let t = "awaiting-input", a = e.toolCallName, o = {
-				id: e.toolCallId,
-				name: a,
+		this.messages = [...this.messages, newMessage];
+		this.createMessageState(messageId, uiRole);
+		this.activeMessageIds.add(messageId);
+		this.events.onStreamStart?.();
+		this.emitMessagesChange();
+	}
+	/**
+	* Handle TEXT_MESSAGE_END event
+	*/
+	handleTextMessageEndEvent(chunk) {
+		const { messageId } = chunk;
+		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
+	*/
+	handleMessagesSnapshotEvent(chunk) {
+		this.resetStreamState();
+		this.messages = [...chunk.messages];
+		this.emitMessagesChange();
+	}
+	/**
+	* Handle TEXT_MESSAGE_CONTENT event.
+	*
+	* Accumulates delta into both currentSegmentText (for UI emission) and
+	* totalTextContent (for ProcessorResult). Lazily creates the assistant
+	* UIMessage on first content. Uses updateTextPart() which replaces the
+	* last TextPart or creates a new one depending on part ordering.
+	*
+	* @see docs/chat-architecture.md#single-shot-text-response — Text accumulation step-by-step
+	* @see docs/chat-architecture.md#uimessage-part-ordering-invariants — Replace vs. push logic
+	*/
+	handleTextMessageContentEvent(chunk) {
+		const { messageId, state } = this.ensureAssistantMessage(chunk.messageId);
+		this.completeAllToolCallsForMessage(messageId);
+		const previousSegment = state.currentSegmentText;
+		if (state.hasToolCallsSinceTextStart && previousSegment.length > 0 && this.isNewTextSegment(chunk, previousSegment)) {
+			if (previousSegment !== state.lastEmittedText) this.emitTextUpdateForMessage(messageId);
+			state.currentSegmentText = "";
+			state.lastEmittedText = "";
+			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 textDelta = nextText.slice(currentText.length);
+		state.currentSegmentText = nextText;
+		state.totalTextContent += textDelta;
+		const chunkPortion = chunk.delta || chunk.content || "";
+		if (this.chunkStrategy.shouldEmit(chunkPortion, state.currentSegmentText) && state.currentSegmentText !== state.lastEmittedText) this.emitTextUpdateForMessage(messageId);
+	}
+	/**
+	* Handle TOOL_CALL_START event.
+	*
+	* Creates a new InternalToolCallState entry in the toolCalls Map and appends
+	* a ToolCallPart to the UIMessage. Duplicate toolCallId is a no-op.
+	*
+	* CRITICAL: This MUST be received before any TOOL_CALL_ARGS for the same
+	* toolCallId. Args for unknown IDs are silently dropped.
+	*
+	* @see docs/chat-architecture.md#single-shot-tool-call-response — Tool call state transitions
+	* @see docs/chat-architecture.md#parallel-tool-calls-single-shot — Parallel tracking by ID
+	* @see docs/chat-architecture.md#adapter-contract — Ordering requirements
+	*/
+	handleToolCallStartEvent(chunk) {
+		const targetMessageId = chunk.parentMessageId ?? this.getActiveAssistantMessageId();
+		const { messageId, state } = this.ensureAssistantMessage(targetMessageId ?? void 0);
+		state.hasToolCallsSinceTextStart = true;
+		const toolCallId = chunk.toolCallId;
+		if (!state.toolCalls.get(toolCallId)) {
+			const initialState = "awaiting-input";
+			const toolName = chunk.toolCallName;
+			const newToolCall = {
+				id: chunk.toolCallId,
+				name: toolName,
 				arguments: "",
-				state: t,
+				state: initialState,
 				parsedArguments: void 0,
-				index: e.index ?? r.toolCalls.size
+				index: chunk.index ?? state.toolCalls.size
 			};
-			r.toolCalls.set(i, o), r.toolCallOrder.push(i), this.toolCallToMessage.set(i, n), this.messages = updateToolCallPart(this.messages, n, {
-				id: e.toolCallId,
-				name: a,
+			state.toolCalls.set(toolCallId, newToolCall);
+			state.toolCallOrder.push(toolCallId);
+			this.toolCallToMessage.set(toolCallId, messageId);
+			this.messages = updateToolCallPart(this.messages, messageId, {
+				id: chunk.toolCallId,
+				name: toolName,
 				arguments: "",
-				state: t
-			}), this.emitMessagesChange(), this.events.onToolCallStateChange?.(n, e.toolCallId, t, "");
+				state: initialState
+			});
+			this.emitMessagesChange();
+			this.events.onToolCallStateChange?.(messageId, chunk.toolCallId, initialState, "");
 		}
 	}
-	handleToolCallArgsEvent(e) {
-		let t = e.toolCallId, n = this.toolCallToMessage.get(t);
-		if (!n) return;
-		let r = this.getMessageState(n);
-		if (!r) return;
-		let i = r.toolCalls.get(t);
-		if (!i) return;
-		let a = i.state === "awaiting-input";
-		i.arguments += e.delta || "", a && e.delta && (i.state = "input-streaming"), i.parsedArguments = this.jsonParser.parse(i.arguments), this.messages = updateToolCallPart(this.messages, n, {
-			id: i.id,
-			name: i.name,
-			arguments: i.arguments,
-			state: i.state
-		}), this.emitMessagesChange(), this.events.onToolCallStateChange?.(n, i.id, i.state, i.arguments);
-	}
-	handleToolCallEndEvent(e) {
-		let t = this.toolCallToMessage.get(e.toolCallId);
-		if (!t) return;
-		let n = this.getMessageState(t);
-		if (!n) return;
-		let r = n.toolCalls.get(e.toolCallId);
-		if (r && r.state !== "input-complete") {
-			e.input !== void 0 && !r.arguments && (r.arguments = JSON.stringify(e.input));
-			let i = n.toolCallOrder.indexOf(e.toolCallId);
-			this.completeToolCall(t, i, r), e.input !== void 0 && (r.parsedArguments = e.input);
+	/**
+	* Handle TOOL_CALL_ARGS event.
+	*
+	* Appends the delta to the tool call's accumulated arguments string.
+	* Transitions state from awaiting-input → input-streaming on first non-empty delta.
+	* Attempts partial JSON parse on each update for UI preview.
+	*
+	* If toolCallId is not found in the Map (no preceding TOOL_CALL_START),
+	* this event is silently dropped.
+	*
+	* @see docs/chat-architecture.md#single-shot-tool-call-response — Step-by-step tool call processing
+	*/
+	handleToolCallArgsEvent(chunk) {
+		const toolCallId = chunk.toolCallId;
+		const messageId = this.toolCallToMessage.get(toolCallId);
+		if (!messageId) return;
+		const state = this.getMessageState(messageId);
+		if (!state) return;
+		const existingToolCall = state.toolCalls.get(toolCallId);
+		if (!existingToolCall) return;
+		const wasAwaitingInput = existingToolCall.state === "awaiting-input";
+		existingToolCall.arguments += chunk.delta || "";
+		if (wasAwaitingInput && chunk.delta) existingToolCall.state = "input-streaming";
+		existingToolCall.parsedArguments = this.jsonParser.parse(existingToolCall.arguments);
+		this.messages = updateToolCallPart(this.messages, messageId, {
+			id: existingToolCall.id,
+			name: existingToolCall.name,
+			arguments: existingToolCall.arguments,
+			state: existingToolCall.state
+		});
+		this.emitMessagesChange();
+		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.
+	*
+	* 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 `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) {
+		const messageId = this.toolCallToMessage.get(chunk.toolCallId);
+		if (!messageId) return;
+		const msgState = this.getMessageState(messageId);
+		if (!msgState) return;
+		const existingToolCall = msgState.toolCalls.get(chunk.toolCallId);
+		if (existingToolCall && existingToolCall.state !== "input-complete") {
+			if (chunk.input !== void 0 && !existingToolCall.arguments) existingToolCall.arguments = JSON.stringify(chunk.input);
+			const index = msgState.toolCallOrder.indexOf(chunk.toolCallId);
+			this.completeToolCall(messageId, index, existingToolCall);
+			if (chunk.input !== void 0) existingToolCall.parsedArguments = chunk.input;
 		}
-		if (e.result) {
-			let n;
+		if (chunk.result) {
+			let output;
 			try {
-				n = JSON.parse(e.result);
+				output = JSON.parse(chunk.result);
 			} catch {
-				n = e.result;
+				output = chunk.result;
 			}
-			this.messages = updateToolCallWithOutput(this.messages, e.toolCallId, n), this.messages = updateToolResultPart(this.messages, t, e.toolCallId, e.result, "complete"), this.emitMessagesChange();
+			this.messages = updateToolCallWithOutput(this.messages, chunk.toolCallId, output);
+			const resultState = "complete";
+			this.messages = updateToolResultPart(this.messages, messageId, chunk.toolCallId, chunk.result, resultState);
+			this.emitMessagesChange();
 		}
 	}
-	handleToolCallResultEvent(e) {
-		let t = this.toolCallToMessage.get(e.toolCallId);
-		if (!t) return;
-		let n;
+	/**
+	* Handle TOOL_CALL_RESULT event (AG-UI spec).
+	*
+	* Creates a tool-result part and updates the tool-call output field,
+	* mirroring the logic from TOOL_CALL_END when it carries a result.
+	* This is the spec-compliant path for delivering tool results to the client.
+	*/
+	handleToolCallResultEvent(chunk) {
+		const messageId = this.toolCallToMessage.get(chunk.toolCallId);
+		if (!messageId) return;
+		let output;
 		try {
-			n = JSON.parse(e.content);
+			output = JSON.parse(chunk.content);
 		} catch {
-			n = e.content;
+			output = chunk.content;
+		}
+		this.messages = updateToolCallWithOutput(this.messages, chunk.toolCallId, output);
+		const resultState = "complete";
+		this.messages = updateToolResultPart(this.messages, messageId, chunk.toolCallId, chunk.content, resultState);
+		this.emitMessagesChange();
+	}
+	/**
+	* Handle RUN_STARTED event.
+	*
+	* Registers the run so that RUN_FINISHED can determine whether other
+	* runs are still active before finalizing.
+	*/
+	handleRunStartedEvent(chunk) {
+		this.activeRuns.add(chunk.runId);
+	}
+	/**
+	* Handle RUN_FINISHED event.
+	*
+	* Records the finishReason and removes the run from activeRuns.
+	* Only finalizes when no more runs are active, so that concurrent
+	* runs don't interfere with each other.
+	*
+	* @see docs/chat-architecture.md#single-shot-tool-call-response — finishReason semantics
+	* @see docs/chat-architecture.md#adapter-contract — Why RUN_FINISHED is mandatory
+	*/
+	handleRunFinishedEvent(chunk) {
+		this.finishReason = chunk.finishReason ?? null;
+		this.activeRuns.delete(chunk.runId);
+		if (this.activeRuns.size === 0) {
+			this.isDone = true;
+			this.completeAllToolCalls();
+			this.finalizeStream();
 		}
-		this.messages = updateToolCallWithOutput(this.messages, e.toolCallId, n), this.messages = updateToolResultPart(this.messages, t, e.toolCallId, e.content, "complete"), this.emitMessagesChange();
-	}
-	handleRunStartedEvent(e) {
-		this.activeRuns.add(e.runId);
-	}
-	handleRunFinishedEvent(e) {
-		this.finishReason = e.finishReason ?? null, this.activeRuns.delete(e.runId), this.activeRuns.size === 0 && (this.isDone = !0, this.completeAllToolCalls(), this.finalizeStream());
-	}
-	handleRunErrorEvent(e) {
-		this.hasError = !0;
-		let t = e.runId;
-		t ? this.activeRuns.delete(t) : this.activeRuns.clear(), this.ensureAssistantMessage();
-		let n = e.message || e.error?.message || "An error occurred";
-		this.events.onError?.(Error(n));
-	}
-	handleStepFinishedEvent(e) {
-		let { messageId: t, state: n } = this.ensureAssistantMessage(this.getActiveAssistantMessageId() ?? void 0);
-		if (n.hasSeenReasoningEvents) return;
-		let r = n.thinkingContent, i = r;
-		e.delta && e.delta !== "" ? i = r + e.delta : e.content && e.content !== "" && (i = e.content.startsWith(r) ? e.content : r.startsWith(e.content) ? r : r + e.content), n.thinkingContent = i, this.messages = updateThinkingPart(this.messages, t, n.thinkingContent), this.emitMessagesChange(), this.events.onThinkingUpdate?.(t, n.thinkingContent);
-	}
-	handleReasoningMessageContentEvent(e) {
-		let { messageId: t, state: n } = this.ensureAssistantMessage(this.getActiveAssistantMessageId() ?? void 0);
-		n.hasSeenReasoningEvents = !0;
-		let r = e.delta || "";
-		n.thinkingContent += r, this.messages = updateThinkingPart(this.messages, t, n.thinkingContent), this.emitMessagesChange(), this.events.onThinkingUpdate?.(t, n.thinkingContent);
-	}
-	handleCustomEvent(e) {
-		let t = this.getActiveAssistantMessageId();
-		if (e.name === "tool-input-available" && e.value) {
-			let { toolCallId: t, toolName: n, input: r } = e.value;
+	}
+	/**
+	* Handle RUN_ERROR event
+	*/
+	handleRunErrorEvent(chunk) {
+		this.hasError = true;
+		const runId = chunk.runId;
+		if (runId) this.activeRuns.delete(runId);
+		else this.activeRuns.clear();
+		this.ensureAssistantMessage();
+		const errorMessage = chunk.message || chunk.error?.message || "An error occurred";
+		this.events.onError?.(new Error(errorMessage));
+	}
+	/**
+	* Handle STEP_FINISHED event (for thinking/reasoning content).
+	*
+	* Accumulates delta into thinkingContent and updates a single ThinkingPart
+	* in the UIMessage (replaced in-place, not appended).
+	*
+	* @see docs/chat-architecture.md#thinkingreasoning-content — Thinking flow
+	*/
+	handleStepFinishedEvent(chunk) {
+		const { messageId, state } = this.ensureAssistantMessage(this.getActiveAssistantMessageId() ?? void 0);
+		if (state.hasSeenReasoningEvents) return;
+		const previous = state.thinkingContent;
+		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.thinkingContent = nextThinking;
+		this.messages = updateThinkingPart(this.messages, messageId, state.thinkingContent);
+		this.emitMessagesChange();
+		this.events.onThinkingUpdate?.(messageId, state.thinkingContent);
+	}
+	/**
+	* Handle REASONING_MESSAGE_CONTENT event (AG-UI reasoning protocol).
+	*
+	* Accumulates reasoning delta into thinkingContent and updates the ThinkingPart
+	* in the UIMessage.
+	*/
+	handleReasoningMessageContentEvent(chunk) {
+		const { messageId, state } = this.ensureAssistantMessage(this.getActiveAssistantMessageId() ?? void 0);
+		state.hasSeenReasoningEvents = true;
+		const delta = chunk.delta || "";
+		state.thinkingContent = state.thinkingContent + delta;
+		this.messages = updateThinkingPart(this.messages, messageId, state.thinkingContent);
+		this.emitMessagesChange();
+		this.events.onThinkingUpdate?.(messageId, state.thinkingContent);
+	}
+	/**
+	* Handle CUSTOM event.
+	*
+	* Handles special custom events emitted by the TextEngine (not adapters):
+	* - 'tool-input-available': Client tool needs execution. Fires onToolCall.
+	* - 'approval-requested': Tool needs user approval. Updates tool-call part
+	*   state and fires onApprovalRequest.
+	*
+	* @see docs/chat-architecture.md#client-tools-and-approval-flows — Full flow details
+	*/
+	handleCustomEvent(chunk) {
+		const messageId = this.getActiveAssistantMessageId();
+		if (chunk.name === "tool-input-available" && chunk.value) {
+			const { toolCallId, toolName, input } = chunk.value;
 			this.events.onToolCall?.({
-				toolCallId: t,
-				toolName: n,
-				input: r
+				toolCallId,
+				toolName,
+				input
 			});
 			return;
 		}
-		if (e.name === "approval-requested" && e.value) {
-			let { toolCallId: n, toolName: r, input: i, approval: a } = e.value, o = t ?? this.toolCallToMessage.get(n);
-			o && (this.messages = updateToolCallApproval(this.messages, o, n, a.id), this.emitMessagesChange()), this.events.onApprovalRequest?.({
-				toolCallId: n,
-				toolName: r,
-				input: i,
-				approvalId: a.id
+		if (chunk.name === "approval-requested" && chunk.value) {
+			const { toolCallId, toolName, input, approval } = chunk.value;
+			const resolvedMessageId = messageId ?? this.toolCallToMessage.get(toolCallId);
+			if (resolvedMessageId) {
+				this.messages = updateToolCallApproval(this.messages, resolvedMessageId, toolCallId, approval.id);
+				this.emitMessagesChange();
+			}
+			this.events.onApprovalRequest?.({
+				toolCallId,
+				toolName,
+				input,
+				approvalId: approval.id
 			});
 			return;
 		}
 		if (this.events.onCustomEvent) {
-			let t = e.value && typeof e.value == "object" ? e.value.toolCallId : void 0;
-			this.events.onCustomEvent(e.name, e.value, { toolCallId: t });
+			const toolCallId = chunk.value && typeof chunk.value === "object" ? chunk.value.toolCallId : void 0;
+			this.events.onCustomEvent(chunk.name, chunk.value, { toolCallId });
 		}
 	}
-	isNewTextSegment(e, t) {
-		return e.content !== void 0 && (e.content.length < t.length || !e.content.startsWith(t) && !t.startsWith(e.content));
-	}
+	/**
+	* 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;
+	}
+	/**
+	* Complete all tool calls across all active messages — safety net for stream termination.
+	*
+	* Called by RUN_FINISHED and finalizeStream(). Force-transitions any tool call
+	* not yet in input-complete state. Handles cases where TOOL_CALL_END was
+	* missed (adapter bug, network error, aborted stream).
+	*
+	* @see docs/chat-architecture.md#single-shot-tool-call-response — Safety net behavior
+	*/
 	completeAllToolCalls() {
-		for (let e of this.activeMessageIds) this.completeAllToolCallsForMessage(e);
-	}
-	completeAllToolCallsForMessage(e) {
-		let t = this.getMessageState(e);
-		t && t.toolCalls.forEach((n, r) => {
-			if (n.state !== "input-complete") {
-				let i = t.toolCallOrder.indexOf(r);
-				this.completeToolCall(e, i, n);
+		for (const messageId of this.activeMessageIds) this.completeAllToolCallsForMessage(messageId);
+	}
+	/**
+	* Complete all tool calls for a specific message
+	*/
+	completeAllToolCallsForMessage(messageId) {
+		const state = this.getMessageState(messageId);
+		if (!state) return;
+		state.toolCalls.forEach((toolCall, id) => {
+			if (toolCall.state !== "input-complete") {
+				const index = state.toolCallOrder.indexOf(id);
+				this.completeToolCall(messageId, index, toolCall);
 			}
 		});
 	}
-	completeToolCall(e, t, n) {
-		n.state = "input-complete", n.parsedArguments = this.jsonParser.parse(n.arguments), this.messages = updateToolCallPart(this.messages, e, {
-			id: n.id,
-			name: n.name,
-			arguments: n.arguments,
+	/**
+	* Mark a tool call as complete and emit event
+	*/
+	completeToolCall(messageId, _index, toolCall) {
+		toolCall.state = "input-complete";
+		toolCall.parsedArguments = this.jsonParser.parse(toolCall.arguments);
+		this.messages = updateToolCallPart(this.messages, messageId, {
+			id: toolCall.id,
+			name: toolCall.name,
+			arguments: toolCall.arguments,
 			state: "input-complete"
-		}), this.emitMessagesChange(), this.events.onToolCallStateChange?.(e, n.id, "input-complete", n.arguments);
-	}
-	emitTextUpdateForMessage(e) {
-		let t = this.getMessageState(e);
-		t && (t.lastEmittedText = t.currentSegmentText, this.messages = updateTextPart(this.messages, e, t.currentSegmentText), this.emitMessagesChange(), this.events.onTextUpdate?.(e, t.currentSegmentText));
-	}
+		});
+		this.emitMessagesChange();
+		this.events.onToolCallStateChange?.(messageId, toolCall.id, "input-complete", toolCall.arguments);
+	}
+	/**
+	* Emit pending text update for a specific message.
+	*
+	* Calls updateTextPart() which has critical append-vs-replace logic:
+	* - If last UIMessage part is TextPart → replaces its content (same segment).
+	* - If last part is anything else → pushes new TextPart (new segment after tools).
+	*
+	* @see docs/chat-architecture.md#uimessage-part-ordering-invariants — Replace vs. push logic
+	*/
+	emitTextUpdateForMessage(messageId) {
+		const state = this.getMessageState(messageId);
+		if (!state) return;
+		state.lastEmittedText = state.currentSegmentText;
+		this.messages = updateTextPart(this.messages, messageId, state.currentSegmentText);
+		this.emitMessagesChange();
+		this.events.onTextUpdate?.(messageId, state.currentSegmentText);
+	}
+	/**
+	* Emit messages change event
+	*/
 	emitMessagesChange() {
 		this.events.onMessagesChange?.([...this.messages]);
 	}
+	/**
+	* Finalize the stream — complete all pending operations.
+	*
+	* Called when the async iterable ends (stream closed). Acts as the final
+	* safety net: completes any remaining tool calls, flushes un-emitted text,
+	* and fires onStreamEnd.
+	*
+	* @see docs/chat-architecture.md#single-shot-text-response — Finalization step
+	*/
 	finalizeStream() {
-		let e;
-		for (let t of this.activeMessageIds) {
-			let n = this.getMessageState(t);
-			if (!n) continue;
-			this.completeAllToolCallsForMessage(t), n.currentSegmentText !== n.lastEmittedText && this.emitTextUpdateForMessage(t), n.isComplete = !0;
-			let r = this.messages.find((e) => e.id === t);
-			r && r.role === "assistant" && (e = r);
+		let lastAssistantMessage;
+		for (const messageId of this.activeMessageIds) {
+			const state = this.getMessageState(messageId);
+			if (!state) continue;
+			this.completeAllToolCallsForMessage(messageId);
+			if (state.currentSegmentText !== state.lastEmittedText) this.emitTextUpdateForMessage(messageId);
+			state.isComplete = true;
+			const msg = this.messages.find((m) => m.id === messageId);
+			if (msg && msg.role === "assistant") lastAssistantMessage = msg;
 		}
-		if (this.activeMessageIds.clear(), e && !this.hasError && this.isWhitespaceOnlyMessage(e)) {
-			this.messages = this.messages.filter((t) => t.id !== e.id), this.emitMessagesChange();
-			return;
+		this.activeMessageIds.clear();
+		if (lastAssistantMessage && !this.hasError) {
+			if (this.isWhitespaceOnlyMessage(lastAssistantMessage)) {
+				this.messages = this.messages.filter((m) => m.id !== lastAssistantMessage.id);
+				this.emitMessagesChange();
+				return;
+			}
 		}
-		e && this.events.onStreamEnd?.(e);
+		if (lastAssistantMessage) this.events.onStreamEnd?.(lastAssistantMessage);
 	}
+	/**
+	* Get completed tool calls in API format (aggregated across all messages)
+	*/
 	getCompletedToolCalls() {
-		let e = [];
-		for (let t of this.messageStates.values()) for (let n of t.toolCalls.values()) n.state === "input-complete" && e.push({
-			id: n.id,
+		const result = [];
+		for (const state of this.messageStates.values()) for (const tc of state.toolCalls.values()) if (tc.state === "input-complete") result.push({
+			id: tc.id,
 			type: "function",
 			function: {
-				name: n.name,
-				arguments: n.arguments
+				name: tc.name,
+				arguments: tc.arguments
 			}
 		});
-		return e;
+		return result;
 	}
+	/**
+	* Get current result (aggregated across all messages)
+	*/
 	getResult() {
-		let e = this.getCompletedToolCalls(), t = "", n = "";
-		for (let e of this.messageStates.values()) t += e.totalTextContent, n += e.thinkingContent;
+		const toolCalls = this.getCompletedToolCalls();
+		let content = "";
+		let thinking = "";
+		for (const state of this.messageStates.values()) {
+			content += state.totalTextContent;
+			thinking += state.thinkingContent;
+		}
 		return {
-			content: t,
-			thinking: n || void 0,
-			toolCalls: e.length > 0 ? e : void 0,
+			content,
+			thinking: thinking || void 0,
+			toolCalls: toolCalls.length > 0 ? toolCalls : void 0,
 			finishReason: this.finishReason
 		};
 	}
+	/**
+	* Get current processor state (aggregated across all messages)
+	*/
 	getState() {
-		let e = "", t = "", n = /* @__PURE__ */ new Map(), r = [];
-		for (let i of this.messageStates.values()) {
-			e += i.totalTextContent, t += i.thinkingContent;
-			for (let [e, t] of i.toolCalls) n.set(e, t);
-			r.push(...i.toolCallOrder);
+		let content = "";
+		let thinking = "";
+		const toolCalls = /* @__PURE__ */ new Map();
+		const toolCallOrder = [];
+		for (const state of this.messageStates.values()) {
+			content += state.totalTextContent;
+			thinking += state.thinkingContent;
+			for (const [id, tc] of state.toolCalls) toolCalls.set(id, tc);
+			toolCallOrder.push(...state.toolCallOrder);
 		}
 		return {
-			content: e,
-			thinking: t,
-			toolCalls: n,
-			toolCallOrder: r,
+			content,
+			thinking,
+			toolCalls,
+			toolCallOrder,
 			finishReason: this.finishReason,
 			done: this.isDone
 		};
 	}
+	/**
+	* Start recording chunks
+	*/
 	startRecording() {
-		this.recordingEnabled = !0, this.recordingStartTime = Date.now(), this.recording = {
+		this.recordingEnabled = true;
+		this.recordingStartTime = Date.now();
+		this.recording = {
 			version: "1.0",
 			timestamp: this.recordingStartTime,
 			chunks: []
 		};
 	}
+	/**
+	* Get the current recording
+	*/
 	getRecording() {
 		return this.recording;
 	}
+	/**
+	* Reset stream state (but keep messages)
+	*/
 	resetStreamState() {
-		this.messageStates.clear(), this.activeMessageIds.clear(), this.activeRuns.clear(), this.toolCallToMessage.clear(), this.pendingManualMessageId = null, this.finishReason = null, this.hasError = !1, this.isDone = !1, this.chunkStrategy.reset?.();
-	}
+		this.messageStates.clear();
+		this.activeMessageIds.clear();
+		this.activeRuns.clear();
+		this.toolCallToMessage.clear();
+		this.pendingManualMessageId = null;
+		this.finishReason = null;
+		this.hasError = false;
+		this.isDone = false;
+		this.chunkStrategy.reset?.();
+	}
+	/**
+	* Full reset (including messages)
+	*/
 	reset() {
-		this.resetStreamState(), this.messages = [];
-	}
-	isWhitespaceOnlyMessage(e) {
-		return e.parts.length !== 0 && e.parts.every((e) => e.type === "text" && e.content.trim() === "");
-	}
-	static async replay(e, t) {
-		return new StreamProcessor(t).process(createReplayStream(e));
+		this.resetStreamState();
+		this.messages = [];
+	}
+	/**
+	* Check if a message contains only whitespace text and no other meaningful parts
+	* (no tool calls, tool results, thinking, etc.)
+	*/
+	isWhitespaceOnlyMessage(message) {
+		if (message.parts.length === 0) return false;
+		return message.parts.every((part) => part.type === "text" && part.content.trim() === "");
+	}
+	/**
+	* Replay a recording through the processor
+	*/
+	static async replay(recording, options) {
+		return new StreamProcessor(options).process(createReplayStream(recording));
 	}
 };
-function createReplayStream(e) {
+function createReplayStream(recording) {
 	return { async *[Symbol.asyncIterator]() {
-		for (let { chunk: t } of e.chunks) yield t;
+		for (const { chunk } of recording.chunks) yield chunk;
 	} };
 }
 //#endregion
 //#region ../../node_modules/.pnpm/@tanstack+ai-client@0.8.0/node_modules/@tanstack/ai-client/dist/esm/events.js
 var ChatClientEventEmitter = class {
-	constructor(e) {
-		this.clientId = e;
-	}
-	clientCreated(e) {
-		this.emitEvent("client:created", { initialMessageCount: e });
-	}
-	loadingChanged(e) {
-		this.emitEvent("client:loading:changed", { isLoading: e });
-	}
-	errorChanged(e) {
-		this.emitEvent("client:error:changed", { error: e });
-	}
-	textUpdated(e, t, n) {
+	constructor(clientId) {
+		this.clientId = clientId;
+	}
+	/**
+	* Emit client created event
+	*/
+	clientCreated(initialMessageCount) {
+		this.emitEvent("client:created", { initialMessageCount });
+	}
+	/**
+	* Emit loading state changed event
+	*/
+	loadingChanged(isLoading) {
+		this.emitEvent("client:loading:changed", { isLoading });
+	}
+	/**
+	* Emit error state changed event
+	*/
+	errorChanged(error) {
+		this.emitEvent("client:error:changed", { error });
+	}
+	/**
+	* Emit text update events (combines processor and client events)
+	*/
+	textUpdated(streamId, messageId, content) {
 		this.emitEvent("text:chunk:content", {
-			streamId: e,
-			messageId: t,
-			content: n
+			streamId,
+			messageId,
+			content
 		});
 	}
-	toolCallStateChanged(e, t, n, r, i, a) {
+	/**
+	* Emit tool call state change events (combines processor and client events)
+	*/
+	toolCallStateChanged(streamId, messageId, toolCallId, toolName, state, args) {
 		this.emitEvent("tools:call:updated", {
-			streamId: e,
-			messageId: t,
-			toolCallId: n,
-			toolName: r,
-			state: i,
-			arguments: a
+			streamId,
+			messageId,
+			toolCallId,
+			toolName,
+			state,
+			arguments: args
 		});
 	}
-	thinkingUpdated(e, t, n, r) {
+	/**
+	* Emit tool result state change event
+	*/
+	/**
+	* Emit thinking update event
+	*/
+	thinkingUpdated(streamId, messageId, content, delta) {
 		this.emitEvent("text:chunk:thinking", {
-			streamId: e,
-			messageId: t,
-			content: n,
-			delta: r
+			streamId,
+			messageId,
+			content,
+			delta
 		});
 	}
-	approvalRequested(e, t, n, r, i, a) {
+	/**
+	* Emit approval requested event
+	*/
+	approvalRequested(streamId, messageId, toolCallId, toolName, input, approvalId) {
 		this.emitEvent("tools:approval:requested", {
-			streamId: e,
-			messageId: t,
-			toolCallId: n,
-			toolName: r,
-			input: i,
-			approvalId: a
+			streamId,
+			messageId,
+			toolCallId,
+			toolName,
+			input,
+			approvalId
 		});
 	}
-	messageAppended(e, t) {
-		let n = e.parts.filter((e) => e.type === "text").map((e) => e.content).join(" ");
+	/**
+	* Emit message appended event
+	*/
+	messageAppended(uiMessage, streamId) {
+		const content = uiMessage.parts.filter((part) => part.type === "text").map((part) => part.content).join(" ");
 		this.emitEvent("text:message:created", {
-			streamId: t,
-			messageId: e.id,
-			role: e.role,
-			content: n,
-			parts: e.parts
+			streamId,
+			messageId: uiMessage.id,
+			role: uiMessage.role,
+			content,
+			parts: uiMessage.parts
 		});
 	}
-	messageSent(e, t) {
-		let n = typeof t == "string" ? t : t.filter((e) => e.type === "text").map((e) => e.content).join("");
+	/**
+	* Emit message sent event.
+	* Supports both simple string content and multimodal content arrays.
+	*
+	* @param messageId - The ID of the sent message
+	* @param content - The message content (string or array of ContentPart for multimodal)
+	*/
+	messageSent(messageId, content) {
+		const textContent = typeof content === "string" ? content : content.filter((part) => part.type === "text").map((part) => part.content).join("");
 		this.emitEvent("text:message:created", {
-			messageId: e,
+			messageId,
 			role: "user",
-			content: n,
-			...Array.isArray(t) && { parts: t }
-		}), this.emitEvent("text:message:user", {
-			messageId: e,
+			content: textContent,
+			...Array.isArray(content) && { parts: content }
+		});
+		this.emitEvent("text:message:user", {
+			messageId,
 			role: "user",
-			content: n,
-			...Array.isArray(t) && { parts: t }
+			content: textContent,
+			...Array.isArray(content) && { parts: content }
 		});
 	}
-	reloaded(e) {
-		this.emitEvent("client:reloaded", { fromMessageIndex: e });
+	/**
+	* Emit reloaded event
+	*/
+	reloaded(fromMessageIndex) {
+		this.emitEvent("client:reloaded", { fromMessageIndex });
 	}
+	/**
+	* Emit stopped event
+	*/
 	stopped() {
 		this.emitEvent("client:stopped");
 	}
+	/**
+	* Emit messages cleared event
+	*/
 	messagesCleared() {
 		this.emitEvent("client:messages:cleared");
 	}
-	toolResultAdded(e, t, n, r) {
+	/**
+	* Emit tool result added event
+	*/
+	toolResultAdded(toolCallId, toolName, output, state) {
 		this.emitEvent("tools:result:added", {
-			toolCallId: e,
-			toolName: t,
-			output: n,
-			state: r
+			toolCallId,
+			toolName,
+			output,
+			state
 		});
 	}
-	toolApprovalResponded(e, t, n) {
+	/**
+	* Emit tool approval responded event
+	*/
+	toolApprovalResponded(approvalId, toolCallId, approved) {
 		this.emitEvent("tools:approval:responded", {
-			approvalId: e,
-			toolCallId: t,
-			approved: n
+			approvalId,
+			toolCallId,
+			approved
 		});
 	}
-}, DefaultChatClientEventEmitter = class extends ChatClientEventEmitter {
-	emitEvent(e, t) {
-		e.startsWith("client:") || e.startsWith("tools:") || e.startsWith("text:") ? d.emit(e, {
-			...t,
+};
+var DefaultChatClientEventEmitter = class extends ChatClientEventEmitter {
+	/**
+	* Emit an event with automatic clientId and timestamp for client/tool events
+	*/
+	emitEvent(eventName, data) {
+		if (eventName.startsWith("client:") || eventName.startsWith("tools:") || eventName.startsWith("text:")) aiEventClient.emit(eventName, {
+			...data,
 			clientId: this.clientId,
 			source: "client",
 			timestamp: Date.now()
-		}) : d.emit(e, {
-			...t,
+		});
+		else aiEventClient.emit(eventName, {
+			...data,
 			timestamp: Date.now()
 		});
 	}
 };
 //#endregion
 //#region ../../node_modules/.pnpm/@tanstack+ai-client@0.8.0/node_modules/@tanstack/ai-client/dist/esm/connection-adapters.js
-function mergeHeaders(e) {
-	if (!e) return {};
-	if (e instanceof Headers) {
-		let t = {};
-		return e.forEach((e, n) => {
-			t[n] = e;
-		}), t;
-	}
-	return e;
+function mergeHeaders(customHeaders) {
+	if (!customHeaders) return {};
+	if (customHeaders instanceof Headers) {
+		const result = {};
+		customHeaders.forEach((value, key) => {
+			result[key] = value;
+		});
+		return result;
+	}
+	return customHeaders;
 }
-async function* readStreamLines(e, t) {
+async function* readStreamLines(reader, abortSignal) {
 	try {
-		let n = new TextDecoder(), r = "";
-		for (; !t?.aborted;) {
-			let { done: t, value: i } = await e.read();
-			if (t) break;
-			r += n.decode(i, { stream: !0 });
-			let a = r.split("\n");
-			r = a.pop() || "";
-			for (let e of a) e.trim() && (yield e);
+		const decoder = new TextDecoder();
+		let buffer = "";
+		while (true) {
+			if (abortSignal?.aborted) break;
+			const { done, value } = await reader.read();
+			if (done) break;
+			buffer += decoder.decode(value, { stream: true });
+			const lines = buffer.split("\n");
+			buffer = lines.pop() || "";
+			for (const line of lines) if (line.trim()) yield line;
 		}
-		r.trim() && (yield r);
+		if (buffer.trim()) yield buffer;
 	} finally {
-		e.releaseLock();
+		reader.releaseLock();
 	}
 }
-function normalizeConnectionAdapter(e) {
-	if (!e) throw Error("Connection adapter is required");
-	let t = "connect" in e, n = "subscribe" in e, r = "send" in e;
-	if (t && (n || r)) throw Error("Connection adapter must provide either connect or both subscribe and send, not both modes");
-	if (n && r) return {
-		subscribe: e.subscribe.bind(e),
-		send: e.send.bind(e)
+function normalizeConnectionAdapter(connection) {
+	if (!connection) throw new Error("Connection adapter is required");
+	const hasConnect = "connect" in connection;
+	const hasSubscribe = "subscribe" in connection;
+	const hasSend = "send" in connection;
+	if (hasConnect && (hasSubscribe || hasSend)) throw new Error("Connection adapter must provide either connect or both subscribe and send, not both modes");
+	if (hasSubscribe && hasSend) return {
+		subscribe: connection.subscribe.bind(connection),
+		send: connection.send.bind(connection)
 	};
-	if (!t) throw Error("Connection adapter must provide either connect or both subscribe and send");
-	let i = [], a = [];
-	function push(e) {
-		let t = a.shift();
-		t ? t(e) : i.push(e);
+	if (!hasConnect) throw new Error("Connection adapter must provide either connect or both subscribe and send");
+	let activeBuffer = [];
+	let activeWaiters = [];
+	function push(chunk) {
+		const waiter = activeWaiters.shift();
+		if (waiter) waiter(chunk);
+		else activeBuffer.push(chunk);
 	}
 	return {
-		subscribe(e) {
-			let t = i.splice(0), n = [];
-			return i = t, a = n, (async function* () {
-				for (; !e?.aborted;) {
-					let r;
-					r = t.length > 0 ? t.shift() : await new Promise((t) => {
-						let onAbort = () => t(null);
-						n.push((n) => {
-							e?.removeEventListener("abort", onAbort), t(n);
-						}), e?.addEventListener("abort", onAbort, { once: !0 });
-					}), r !== null && (yield r);
+		subscribe(abortSignal) {
+			const myBuffer = activeBuffer.splice(0);
+			const myWaiters = [];
+			activeBuffer = myBuffer;
+			activeWaiters = myWaiters;
+			return (async function* () {
+				while (!abortSignal?.aborted) {
+					let chunk;
+					if (myBuffer.length > 0) chunk = myBuffer.shift();
+					else chunk = await new Promise((resolve) => {
+						const onAbort = () => resolve(null);
+						myWaiters.push((c) => {
+							abortSignal?.removeEventListener("abort", onAbort);
+							resolve(c);
+						});
+						abortSignal?.addEventListener("abort", onAbort, { once: true });
+					});
+					if (chunk !== null) yield chunk;
 				}
 			})();
 		},
-		async send(t, n, r) {
-			let i = !1;
+		async send(messages, data, abortSignal) {
+			let hasTerminalEvent = false;
 			try {
-				let a = e.connect(t, n, r);
-				for await (let e of a) (e.type === "RUN_FINISHED" || e.type === "RUN_ERROR") && (i = !0), push(e);
-				!r?.aborted && !i && push({
+				const stream2 = connection.connect(messages, data, abortSignal);
+				for await (const chunk of stream2) {
+					if (chunk.type === "RUN_FINISHED" || chunk.type === "RUN_ERROR") hasTerminalEvent = true;
+					push(chunk);
+				}
+				if (!abortSignal?.aborted && !hasTerminalEvent) push({
 					type: "RUN_FINISHED",
 					runId: `run-${Date.now()}`,
 					model: "connect-wrapper",
 					timestamp: Date.now(),
 					finishReason: "stop"
 				});
-			} catch (e) {
-				throw !r?.aborted && !i && push({
+			} catch (err) {
+				if (!abortSignal?.aborted && !hasTerminalEvent) push({
 					type: "RUN_ERROR",
 					timestamp: Date.now(),
-					message: e instanceof Error ? e.message : "Unknown error in connect()",
-					error: { message: e instanceof Error ? e.message : "Unknown error in connect()" }
-				}), e;
+					message: err instanceof Error ? err.message : "Unknown error in connect()",
+					error: { message: err instanceof Error ? err.message : "Unknown error in connect()" }
+				});
+				throw err;
 			}
 		}
 	};
 }
-function fetchServerSentEvents(e, t = {}) {
-	return { async *connect(n, r, i) {
-		let a = typeof e == "function" ? e() : e, o = typeof t == "function" ? await t() : t, s = {
+function fetchServerSentEvents(url, options = {}) {
+	return { async *connect(messages, data, abortSignal) {
+		const resolvedUrl = typeof url === "function" ? url() : url;
+		const resolvedOptions = typeof options === "function" ? await options() : options;
+		const requestHeaders = {
 			"Content-Type": "application/json",
-			...mergeHeaders(o.headers)
-		}, c = {
-			messages: n,
-			data: r,
-			...o.body
-		}, l = await (o.fetchClient ?? fetch)(a, {
+			...mergeHeaders(resolvedOptions.headers)
+		};
+		const requestBody = {
+			messages,
+			data,
+			...resolvedOptions.body
+		};
+		const response = await (resolvedOptions.fetchClient ?? fetch)(resolvedUrl, {
 			method: "POST",
-			headers: s,
-			body: JSON.stringify(c),
-			credentials: o.credentials || "same-origin",
-			signal: i || o.signal
+			headers: requestHeaders,
+			body: JSON.stringify(requestBody),
+			credentials: resolvedOptions.credentials || "same-origin",
+			signal: abortSignal || resolvedOptions.signal
 		});
-		if (!l.ok) throw Error(`HTTP error! status: ${l.status} ${l.statusText}`);
-		let u = l.body?.getReader();
-		if (!u) throw Error("Response body is not readable");
-		for await (let e of readStreamLines(u, i)) {
-			let t = e.startsWith("data: ") ? e.slice(6) : e;
-			if (t === "[DONE]") {
+		if (!response.ok) throw new Error(`HTTP error! status: ${response.status} ${response.statusText}`);
+		const reader = response.body?.getReader();
+		if (!reader) throw new Error("Response body is not readable");
+		for await (const line of readStreamLines(reader, abortSignal)) {
+			const data2 = line.startsWith("data: ") ? line.slice(6) : line;
+			if (data2 === "[DONE]") {
 				console.warn("[@tanstack/ai-client] Received [DONE] sentinel. This is deprecated — upgrade your @tanstack/ai server package. RUN_FINISHED is the stream terminator.");
 				continue;
 			}
 			try {
-				yield JSON.parse(t);
-			} catch {
-				console.warn("Failed to parse SSE chunk:", t);
+				yield JSON.parse(data2);
+			} catch (parseError) {
+				console.warn("Failed to parse SSE chunk:", data2);
 			}
 		}
 	} };
@@ -1217,176 +2028,315 @@ function fetchServerSentEvents(e, t = {}) {
 //#endregion
 //#region ../../node_modules/.pnpm/@tanstack+ai-client@0.8.0/node_modules/@tanstack/ai-client/dist/esm/chat-client.js
 var ChatClient = class {
-	constructor(e) {
-		if (this.body = {}, this.pendingMessageBody = void 0, this.isLoading = !1, this.isSubscribed = !1, this.error = void 0, this.status = "ready", this.connectionStatus = "disconnected", this.abortController = null, this.currentStreamId = null, this.currentMessageId = null, this.postStreamActions = [], this.pendingToolExecutions = /* @__PURE__ */ new Map(), this.continuationPending = !1, this.subscriptionAbortController = null, this.processingResolve = null, this.errorReportedGeneration = null, this.streamGeneration = 0, this.continuationSkipped = !1, this.draining = !1, this.sessionGenerating = !1, this.activeRunIds = /* @__PURE__ */ new Set(), this.uniqueId = e.id || this.generateUniqueId("chat"), this.body = e.body || {}, this.connection = normalizeConnectionAdapter(e.connection), this.events = new DefaultChatClientEventEmitter(this.uniqueId), this.clientToolsRef = { current: /* @__PURE__ */ new Map() }, e.tools) for (let t of e.tools) this.clientToolsRef.current.set(t.name, t);
+	constructor(options) {
+		this.body = {};
+		this.pendingMessageBody = void 0;
+		this.isLoading = false;
+		this.isSubscribed = false;
+		this.error = void 0;
+		this.status = "ready";
+		this.connectionStatus = "disconnected";
+		this.abortController = null;
+		this.currentStreamId = null;
+		this.currentMessageId = null;
+		this.postStreamActions = [];
+		this.pendingToolExecutions = /* @__PURE__ */ new Map();
+		this.continuationPending = false;
+		this.subscriptionAbortController = null;
+		this.processingResolve = null;
+		this.errorReportedGeneration = null;
+		this.streamGeneration = 0;
+		this.continuationSkipped = false;
+		this.draining = false;
+		this.sessionGenerating = false;
+		this.activeRunIds = /* @__PURE__ */ new Set();
+		this.uniqueId = options.id || this.generateUniqueId("chat");
+		this.body = options.body || {};
+		this.connection = normalizeConnectionAdapter(options.connection);
+		this.events = new DefaultChatClientEventEmitter(this.uniqueId);
+		this.clientToolsRef = { current: /* @__PURE__ */ new Map() };
+		if (options.tools) for (const tool of options.tools) this.clientToolsRef.current.set(tool.name, tool);
 		this.callbacksRef = { current: {
-			onResponse: e.onResponse || (() => {}),
-			onChunk: e.onChunk || (() => {}),
-			onFinish: e.onFinish || (() => {}),
-			onError: e.onError || (() => {}),
-			onMessagesChange: e.onMessagesChange || (() => {}),
-			onLoadingChange: e.onLoadingChange || (() => {}),
-			onErrorChange: e.onErrorChange || (() => {}),
-			onStatusChange: e.onStatusChange || (() => {}),
-			onSubscriptionChange: e.onSubscriptionChange || (() => {}),
-			onConnectionStatusChange: e.onConnectionStatusChange || (() => {}),
-			onSessionGeneratingChange: e.onSessionGeneratingChange || (() => {}),
-			onCustomEvent: e.onCustomEvent || (() => {})
-		} }, this.processor = new h({
-			chunkStrategy: e.streamProcessor?.chunkStrategy,
-			initialMessages: e.initialMessages,
+			onResponse: options.onResponse || (() => {}),
+			onChunk: options.onChunk || (() => {}),
+			onFinish: options.onFinish || (() => {}),
+			onError: options.onError || (() => {}),
+			onMessagesChange: options.onMessagesChange || (() => {}),
+			onLoadingChange: options.onLoadingChange || (() => {}),
+			onErrorChange: options.onErrorChange || (() => {}),
+			onStatusChange: options.onStatusChange || (() => {}),
+			onSubscriptionChange: options.onSubscriptionChange || (() => {}),
+			onConnectionStatusChange: options.onConnectionStatusChange || (() => {}),
+			onSessionGeneratingChange: options.onSessionGeneratingChange || (() => {}),
+			onCustomEvent: options.onCustomEvent || (() => {})
+		} };
+		this.processor = new StreamProcessor({
+			chunkStrategy: options.streamProcessor?.chunkStrategy,
+			initialMessages: options.initialMessages,
 			events: {
-				onMessagesChange: (e) => {
-					this.callbacksRef.current.onMessagesChange(e);
+				onMessagesChange: (messages) => {
+					this.callbacksRef.current.onMessagesChange(messages);
 				},
 				onStreamStart: () => {
 					this.setStatus("streaming");
-					let e = this.processor.getCurrentAssistantMessageId();
-					if (!e) return;
-					let t = this.processor.getMessages().find((t) => t.id === e);
-					t && (this.currentMessageId = t.id, this.events.messageAppended(t, this.currentStreamId || void 0));
+					const assistantMessageId = this.processor.getCurrentAssistantMessageId();
+					if (!assistantMessageId) return;
+					const assistantMessage = this.processor.getMessages().find((m) => m.id === assistantMessageId);
+					if (assistantMessage) {
+						this.currentMessageId = assistantMessage.id;
+						this.events.messageAppended(assistantMessage, this.currentStreamId || void 0);
+					}
 				},
-				onStreamEnd: (e) => {
-					this.callbacksRef.current.onFinish(e), this.setStatus("ready"), this.resolveProcessing();
+				onStreamEnd: (message) => {
+					this.callbacksRef.current.onFinish(message);
+					this.setStatus("ready");
+					this.resolveProcessing();
 				},
-				onError: (e) => {
-					this.reportStreamError(e);
+				onError: (error) => {
+					this.reportStreamError(error);
 				},
-				onTextUpdate: (e, t) => {
-					this.currentStreamId && this.events.textUpdated(this.currentStreamId, e, t);
+				onTextUpdate: (messageId, content) => {
+					if (this.currentStreamId) this.events.textUpdated(this.currentStreamId, messageId, content);
 				},
-				onThinkingUpdate: (e, t) => {
-					this.currentStreamId && this.events.thinkingUpdated(this.currentStreamId, e, t);
+				onThinkingUpdate: (messageId, content) => {
+					if (this.currentStreamId) this.events.thinkingUpdated(this.currentStreamId, messageId, content);
 				},
-				onToolCallStateChange: (e, t, n, r) => {
-					let i = this.processor.getMessages().find((t) => t.id === e)?.parts.find((e) => e.type === "tool-call" && e.id === t)?.name || "unknown";
-					this.currentStreamId && this.events.toolCallStateChanged(this.currentStreamId, e, t, i, n, r);
+				onToolCallStateChange: (messageId, toolCallId, state, args) => {
+					const toolName = (this.processor.getMessages().find((m) => m.id === messageId)?.parts.find((p) => p.type === "tool-call" && p.id === toolCallId))?.name || "unknown";
+					if (this.currentStreamId) this.events.toolCallStateChanged(this.currentStreamId, messageId, toolCallId, toolName, state, args);
 				},
-				onToolCall: (e) => {
-					let t = this.clientToolsRef.current.get(e.toolName)?.execute;
-					if (t) {
-						let n = (async () => {
+				onToolCall: (args) => {
+					const executeFunc = this.clientToolsRef.current.get(args.toolName)?.execute;
+					if (executeFunc) {
+						const executionPromise = (async () => {
 							try {
-								let n = await t(e.input);
+								const output = await executeFunc(args.input);
 								await this.addToolResult({
-									toolCallId: e.toolCallId,
-									tool: e.toolName,
-									output: n,
+									toolCallId: args.toolCallId,
+									tool: args.toolName,
+									output,
 									state: "output-available"
 								});
-							} catch (t) {
+							} catch (error) {
 								await this.addToolResult({
-									toolCallId: e.toolCallId,
-									tool: e.toolName,
+									toolCallId: args.toolCallId,
+									tool: args.toolName,
 									output: null,
 									state: "output-error",
-									errorText: t.message
+									errorText: error.message
 								});
 							} finally {
-								this.pendingToolExecutions.delete(e.toolCallId);
+								this.pendingToolExecutions.delete(args.toolCallId);
 							}
 						})();
-						this.pendingToolExecutions.set(e.toolCallId, n);
+						this.pendingToolExecutions.set(args.toolCallId, executionPromise);
 					}
 				},
-				onApprovalRequest: (e) => {
-					this.currentStreamId && this.events.approvalRequested(this.currentStreamId, this.currentMessageId || "", e.toolCallId, e.toolName, e.input, e.approvalId);
+				onApprovalRequest: (args) => {
+					if (this.currentStreamId) this.events.approvalRequested(this.currentStreamId, this.currentMessageId || "", args.toolCallId, args.toolName, args.input, args.approvalId);
 				},
-				onCustomEvent: (e, t, n) => {
-					this.callbacksRef.current.onCustomEvent(e, t, n);
+				onCustomEvent: (eventType, data, context) => {
+					this.callbacksRef.current.onCustomEvent(eventType, data, context);
 				}
 			}
-		}), this.events.clientCreated(this.processor.getMessages().length);
+		});
+		this.events.clientCreated(this.processor.getMessages().length);
 	}
-	generateUniqueId(e) {
-		return `${e}-${Date.now()}-${Math.random().toString(36).substring(7)}`;
+	generateUniqueId(prefix) {
+		return `${prefix}-${Date.now()}-${Math.random().toString(36).substring(7)}`;
 	}
-	setIsLoading(e) {
-		this.isLoading = e, this.callbacksRef.current.onLoadingChange(e), this.events.loadingChanged(e);
+	setIsLoading(isLoading) {
+		this.isLoading = isLoading;
+		this.callbacksRef.current.onLoadingChange(isLoading);
+		this.events.loadingChanged(isLoading);
 	}
-	setStatus(e) {
-		this.status = e, this.callbacksRef.current.onStatusChange(e);
+	setStatus(status) {
+		this.status = status;
+		this.callbacksRef.current.onStatusChange(status);
 	}
-	setIsSubscribed(e) {
-		this.isSubscribed = e, this.callbacksRef.current.onSubscriptionChange(e);
+	setIsSubscribed(isSubscribed) {
+		this.isSubscribed = isSubscribed;
+		this.callbacksRef.current.onSubscriptionChange(isSubscribed);
 	}
-	setConnectionStatus(e) {
-		this.connectionStatus = e, this.callbacksRef.current.onConnectionStatusChange(e);
+	setConnectionStatus(status) {
+		this.connectionStatus = status;
+		this.callbacksRef.current.onConnectionStatusChange(status);
 	}
-	setSessionGenerating(e) {
-		this.sessionGenerating !== e && (this.sessionGenerating = e, this.callbacksRef.current.onSessionGeneratingChange(e));
+	setSessionGenerating(isGenerating) {
+		if (this.sessionGenerating === isGenerating) return;
+		this.sessionGenerating = isGenerating;
+		this.callbacksRef.current.onSessionGeneratingChange(isGenerating);
 	}
 	resetSessionGenerating() {
-		this.activeRunIds.clear(), this.setSessionGenerating(!1);
+		this.activeRunIds.clear();
+		this.setSessionGenerating(false);
 	}
-	setError(e) {
-		this.error = e, this.callbacksRef.current.onErrorChange(e), this.events.errorChanged(e?.message || null);
+	setError(error) {
+		this.error = error;
+		this.callbacksRef.current.onErrorChange(error);
+		this.events.errorChanged(error?.message || null);
 	}
 	abortSubscriptionLoop() {
-		this.subscriptionAbortController?.abort(), this.subscriptionAbortController = null;
+		this.subscriptionAbortController?.abort();
+		this.subscriptionAbortController = null;
 	}
 	resolveProcessing() {
-		this.processingResolve?.(), this.processingResolve = null;
-	}
-	cancelInFlightStream(e) {
-		this.abortController?.abort(), this.abortController = null, e?.abortSubscription && this.abortSubscriptionLoop(), this.resolveProcessing(), this.setIsLoading(!1), e?.setReadyStatus && this.setStatus("ready");
-	}
-	reportStreamError(e) {
-		let t = this.errorReportedGeneration === this.streamGeneration;
-		this.setError(e), (this.isLoading || this.status === "submitted" || this.status === "streaming") && this.setStatus("error"), t || (this.errorReportedGeneration = this.streamGeneration, this.callbacksRef.current.onError(e));
+		this.processingResolve?.();
+		this.processingResolve = null;
+	}
+	cancelInFlightStream(options) {
+		this.abortController?.abort();
+		this.abortController = null;
+		if (options?.abortSubscription) this.abortSubscriptionLoop();
+		this.resolveProcessing();
+		this.setIsLoading(false);
+		if (options?.setReadyStatus) this.setStatus("ready");
+	}
+	reportStreamError(error) {
+		const alreadyReported = this.errorReportedGeneration === this.streamGeneration;
+		this.setError(error);
+		if (this.isLoading || this.status === "submitted" || this.status === "streaming") this.setStatus("error");
+		if (!alreadyReported) {
+			this.errorReportedGeneration = this.streamGeneration;
+			this.callbacksRef.current.onError(error);
+		}
 	}
+	/**
+	* Start the background subscription loop.
+	*/
 	startSubscription() {
 		this.subscriptionAbortController = new AbortController();
-		let e = this.subscriptionAbortController.signal;
-		this.consumeSubscription(e).catch((e) => {
-			e instanceof Error && e.name !== "AbortError" && (this.setConnectionStatus("error"), this.resetSessionGenerating(), this.setIsSubscribed(!1), this.reportStreamError(e)), this.resolveProcessing();
+		const signal = this.subscriptionAbortController.signal;
+		this.consumeSubscription(signal).catch((err) => {
+			if (err instanceof Error && err.name !== "AbortError") {
+				this.setConnectionStatus("error");
+				this.resetSessionGenerating();
+				this.setIsSubscribed(false);
+				this.reportStreamError(err);
+			}
+			this.resolveProcessing();
 		}).finally(() => {
-			this.subscriptionAbortController?.signal === e && (this.subscriptionAbortController = null, !e.aborted && this.isSubscribed && (this.setIsSubscribed(!1), this.connectionStatus !== "error" && this.setConnectionStatus("disconnected")));
+			if (this.subscriptionAbortController?.signal !== signal) return;
+			this.subscriptionAbortController = null;
+			if (!signal.aborted && this.isSubscribed) {
+				this.setIsSubscribed(false);
+				if (this.connectionStatus !== "error") this.setConnectionStatus("disconnected");
+			}
 		});
 	}
-	async consumeSubscription(e) {
-		let t = this.connection.subscribe(e);
-		for await (let n of t) {
-			if (e.aborted) break;
-			if (this.connectionStatus === "connecting" && this.setConnectionStatus("connected"), this.callbacksRef.current.onChunk(n), this.processor.processChunk(n), n.type === "RUN_STARTED" && (this.activeRunIds.add(n.runId), this.setSessionGenerating(!0)), n.type === "RUN_FINISHED" || n.type === "RUN_ERROR") {
-				let e = n.type === "RUN_FINISHED" ? n.runId : void 0;
-				e ? this.activeRunIds.delete(e) : n.type === "RUN_ERROR" && this.activeRunIds.clear(), this.setSessionGenerating(this.activeRunIds.size > 0), this.resolveProcessing();
+	/**
+	* Consume chunks from the connection subscription.
+	*/
+	async consumeSubscription(signal) {
+		const stream = this.connection.subscribe(signal);
+		for await (const chunk of stream) {
+			if (signal.aborted) break;
+			if (this.connectionStatus === "connecting") this.setConnectionStatus("connected");
+			this.callbacksRef.current.onChunk(chunk);
+			this.processor.processChunk(chunk);
+			if (chunk.type === "RUN_STARTED") {
+				this.activeRunIds.add(chunk.runId);
+				this.setSessionGenerating(true);
 			}
-			await new Promise((e) => setTimeout(e, 0));
+			if (chunk.type === "RUN_FINISHED" || chunk.type === "RUN_ERROR") {
+				const runId = chunk.type === "RUN_FINISHED" ? chunk.runId : void 0;
+				if (runId) this.activeRunIds.delete(runId);
+				else if (chunk.type === "RUN_ERROR") this.activeRunIds.clear();
+				this.setSessionGenerating(this.activeRunIds.size > 0);
+				this.resolveProcessing();
+			}
+			await new Promise((resolve) => setTimeout(resolve, 0));
 		}
 	}
+	/**
+	* Ensure subscription loop is running, starting it if needed.
+	*/
 	ensureSubscription() {
 		if (!this.isSubscribed) {
 			this.subscribe();
 			return;
 		}
-		(!this.subscriptionAbortController || this.subscriptionAbortController.signal.aborted) && this.subscribe({ restart: !0 });
+		if (!this.subscriptionAbortController || this.subscriptionAbortController.signal.aborted) this.subscribe({ restart: true });
 	}
+	/**
+	* Create a promise that resolves when onStreamEnd fires.
+	* Used by streamResponse to await processing completion.
+	*/
 	waitForProcessing() {
-		return this.resolveProcessing(), new Promise((e) => {
-			this.processingResolve = e;
+		this.resolveProcessing();
+		return new Promise((resolve) => {
+			this.processingResolve = resolve;
 		});
 	}
-	async sendMessage(e, t) {
-		if (typeof e == "string" && !e.trim() || this.isLoading) return;
-		let n = this.normalizeMessageInput(e);
-		this.pendingMessageBody = t;
-		let r = this.processor.addUserMessage(n.content, n.id);
-		this.events.messageSent(r.id, n.content), await this.streamResponse();
-	}
-	normalizeMessageInput(e) {
-		return typeof e == "string" ? { content: e.trim() } : {
-			content: e.content,
-			id: e.id
+	/**
+	* Send a message and stream the response.
+	* Supports both simple string content and multimodal content (images, audio, video, documents).
+	*
+	* @param content - The message content. Can be:
+	*   - A simple string for text-only messages
+	*   - A MultimodalContent object with content array and optional custom ID
+	* @param body - Optional body parameters to merge with the client's base body for this request.
+	*               Uses shallow merge with per-message body taking priority.
+	*
+	* @example
+	* ```ts
+	* // Simple text message
+	* await client.sendMessage('Hello!')
+	*
+	* // Text message with custom body params
+	* await client.sendMessage('Hello!', { temperature: 0.7 })
+	*
+	* // Multimodal message with image
+	* await client.sendMessage({
+	*   content: [
+	*     { type: 'text', content: 'What is in this image?' },
+	*     { type: 'image', source: { type: 'url', value: 'https://example.com/photo.jpg' } }
+	*   ]
+	* })
+	*
+	* // Multimodal message with custom ID and body params
+	* await client.sendMessage(
+	*   {
+	*     content: [
+	*       { type: 'text', content: 'Describe this audio' },
+	*       { type: 'audio', source: { type: 'data', value: 'base64...' } }
+	*     ],
+	*     id: 'custom-message-id'
+	*   },
+	*   { model: 'gpt-4-audio' }
+	* )
+	* ```
+	*/
+	async sendMessage(content, body) {
+		if (typeof content === "string" && !content.trim() || this.isLoading) return;
+		const normalizedContent = this.normalizeMessageInput(content);
+		this.pendingMessageBody = body;
+		const userMessage = this.processor.addUserMessage(normalizedContent.content, normalizedContent.id);
+		this.events.messageSent(userMessage.id, normalizedContent.content);
+		await this.streamResponse();
+	}
+	/**
+	* Normalize the message input to extract content and optional id.
+	* Trims string content automatically.
+	*/
+	normalizeMessageInput(input) {
+		if (typeof input === "string") return { content: input.trim() };
+		return {
+			content: input.content,
+			id: input.id
 		};
 	}
-	async append(e) {
-		let t = normalizeToUIMessage(e, generateMessageId);
-		if (t.role === "system") return;
-		let n = t;
-		this.events.messageAppended(n);
-		let r = this.processor.getMessages();
-		if (this.processor.setMessages([...r, n]), this.isLoading) {
+	/**
+	* Append a message and stream the response
+	*/
+	async append(message) {
+		const normalizedMessage = normalizeToUIMessage(message, generateMessageId);
+		if (normalizedMessage.role === "system") return;
+		const uiMessage = normalizedMessage;
+		this.events.messageAppended(uiMessage);
+		const messages = this.processor.getMessages();
+		this.processor.setMessages([...messages, uiMessage]);
+		if (this.isLoading) {
 			this.queuePostStreamAction(async () => {
 				await this.streamResponse();
 			});
@@ -1394,375 +2344,545 @@ var ChatClient = class {
 		}
 		await this.streamResponse();
 	}
+	/**
+	* Stream a response from the LLM.
+	* Returns true if the stream completed successfully, false on abort or error.
+	*/
 	async streamResponse() {
-		if (this.isLoading) return !1;
-		let e = ++this.streamGeneration;
-		this.setIsLoading(!0), this.setStatus("submitted"), this.setError(void 0), this.errorReportedGeneration = null, this.abortController = new AbortController(), this.pendingToolExecutions.clear();
-		let t = !1;
+		if (this.isLoading) return false;
+		const generation = ++this.streamGeneration;
+		this.setIsLoading(true);
+		this.setStatus("submitted");
+		this.setError(void 0);
+		this.errorReportedGeneration = null;
+		this.abortController = new AbortController();
+		this.pendingToolExecutions.clear();
+		let streamCompletedSuccessfully = false;
 		try {
-			let n = this.processor.getMessages();
+			const messages = this.processor.getMessages();
 			await this.callbacksRef.current.onResponse();
-			let r = {
+			const mergedBody = {
 				...this.body,
 				...this.pendingMessageBody,
 				conversationId: this.uniqueId
 			};
-			this.pendingMessageBody = void 0, this.currentStreamId = this.generateUniqueId("stream"), this.currentMessageId = null, this.processor.prepareAssistantMessage(), this.ensureSubscription();
-			let i = this.waitForProcessing();
-			if (await this.connection.send(n, r, this.abortController.signal), await i, e !== this.streamGeneration || this.status === "error") return !1;
-			this.pendingToolExecutions.size > 0 && await Promise.all(this.pendingToolExecutions.values()), this.processor.finalizeStream(), t = !0;
-		} catch (t) {
-			if (t instanceof Error) {
-				if (t.name === "AbortError") return !1;
-				e === this.streamGeneration && this.reportStreamError(t);
+			this.pendingMessageBody = void 0;
+			this.currentStreamId = this.generateUniqueId("stream");
+			this.currentMessageId = null;
+			this.processor.prepareAssistantMessage();
+			this.ensureSubscription();
+			const processingComplete = this.waitForProcessing();
+			await this.connection.send(messages, mergedBody, this.abortController.signal);
+			await processingComplete;
+			if (generation !== this.streamGeneration) return false;
+			if (this.status === "error") return false;
+			if (this.pendingToolExecutions.size > 0) await Promise.all(this.pendingToolExecutions.values());
+			this.processor.finalizeStream();
+			streamCompletedSuccessfully = true;
+		} catch (err) {
+			if (err instanceof Error) {
+				if (err.name === "AbortError") return false;
+				if (generation === this.streamGeneration) this.reportStreamError(err);
 			}
 		} finally {
-			if (e === this.streamGeneration && (this.currentStreamId = null, this.currentMessageId = null, this.abortController = null, this.setIsLoading(!1), this.pendingMessageBody = void 0, await this.drainPostStreamActions(), t)) {
-				let e = this.processor.getMessages().at(-1)?.parts.at(-1), { finishReason: t } = this.processor.getState();
-				if (e?.type === "tool-result" && t !== "stop" && this.shouldAutoSend()) try {
-					await this.checkForContinuation();
-				} catch (e) {
-					console.error("Failed to continue flow after tool result:", e);
+			if (generation === this.streamGeneration) {
+				this.currentStreamId = null;
+				this.currentMessageId = null;
+				this.abortController = null;
+				this.setIsLoading(false);
+				this.pendingMessageBody = void 0;
+				await this.drainPostStreamActions();
+				if (streamCompletedSuccessfully) {
+					const lastPart = this.processor.getMessages().at(-1)?.parts.at(-1);
+					const { finishReason } = this.processor.getState();
+					if (lastPart?.type === "tool-result" && finishReason !== "stop" && this.shouldAutoSend()) try {
+						await this.checkForContinuation();
+					} catch (error) {
+						console.error("Failed to continue flow after tool result:", error);
+					}
 				}
 			}
 		}
-		return t;
-	}
-	subscribe(e) {
-		let t = e?.restart === !0;
-		this.isSubscribed && !t || (this.isSubscribed && t && this.abortSubscriptionLoop(), this.setIsSubscribed(!0), this.setConnectionStatus("connecting"), this.startSubscription());
-	}
+		return streamCompletedSuccessfully;
+	}
+	/**
+	* Start the client subscription loop.
+	* This controls the connection lifecycle independently from request lifecycle.
+	*/
+	subscribe(options) {
+		const restart = options?.restart === true;
+		if (this.isSubscribed && !restart) return;
+		if (this.isSubscribed && restart) this.abortSubscriptionLoop();
+		this.setIsSubscribed(true);
+		this.setConnectionStatus("connecting");
+		this.startSubscription();
+	}
+	/**
+	* Unsubscribe and fully tear down live behavior.
+	* This aborts an in-flight request and the subscription loop.
+	*/
 	unsubscribe() {
 		this.cancelInFlightStream({
-			setReadyStatus: !0,
-			abortSubscription: !0
-		}), this.resetSessionGenerating(), this.setIsSubscribed(!1), this.setConnectionStatus("disconnected");
+			setReadyStatus: true,
+			abortSubscription: true
+		});
+		this.resetSessionGenerating();
+		this.setIsSubscribed(false);
+		this.setConnectionStatus("disconnected");
 	}
+	/**
+	* Reload the last assistant message
+	*/
 	async reload() {
-		let e = this.processor.getMessages();
-		if (e.length === 0) return;
-		let t = e.findLastIndex((e) => e.role === "user");
-		t !== -1 && (this.isLoading && this.cancelInFlightStream(), this.events.reloaded(t), this.processor.removeMessagesAfter(t), await this.streamResponse());
+		const messages = this.processor.getMessages();
+		if (messages.length === 0) return;
+		const lastUserMessageIndex = messages.findLastIndex((m) => m.role === "user");
+		if (lastUserMessageIndex === -1) return;
+		if (this.isLoading) this.cancelInFlightStream();
+		this.events.reloaded(lastUserMessageIndex);
+		this.processor.removeMessagesAfter(lastUserMessageIndex);
+		await this.streamResponse();
 	}
+	/**
+	* Stop the current stream
+	*/
 	stop() {
-		this.cancelInFlightStream({ setReadyStatus: !0 }), this.events.stopped();
+		this.cancelInFlightStream({ setReadyStatus: true });
+		this.events.stopped();
 	}
+	/**
+	* Clear all messages
+	*/
 	clear() {
-		this.processor.clearMessages(), this.setError(void 0), this.events.messagesCleared();
-	}
-	async addToolResult(e) {
-		if (this.events.toolResultAdded(e.toolCallId, e.tool, e.output, e.state || "output-available"), this.processor.addToolResult(e.toolCallId, e.output, e.errorText), this.isLoading) {
+		this.processor.clearMessages();
+		this.setError(void 0);
+		this.events.messagesCleared();
+	}
+	/**
+	* Add the result of a client-side tool execution
+	*/
+	async addToolResult(result) {
+		this.events.toolResultAdded(result.toolCallId, result.tool, result.output, result.state || "output-available");
+		this.processor.addToolResult(result.toolCallId, result.output, result.errorText);
+		if (this.isLoading) {
 			this.queuePostStreamAction(() => this.checkForContinuation());
 			return;
 		}
 		await this.checkForContinuation();
 	}
-	async addToolApprovalResponse(e) {
-		let t = this.processor.getMessages(), n;
-		for (let r of t) {
-			let t = r.parts.find((t) => t.type === "tool-call" && t.approval?.id === e.id);
-			if (t) {
-				n = t.id;
+	/**
+	* Respond to a tool approval request
+	*/
+	async addToolApprovalResponse(response) {
+		const messages = this.processor.getMessages();
+		let foundToolCallId;
+		for (const msg of messages) {
+			const toolCallPart = msg.parts.find((p) => p.type === "tool-call" && p.approval?.id === response.id);
+			if (toolCallPart) {
+				foundToolCallId = toolCallPart.id;
 				break;
 			}
 		}
-		if (n && this.events.toolApprovalResponded(e.id, n, e.approved), this.processor.addToolApprovalResponse(e.id, e.approved), this.isLoading) {
+		if (foundToolCallId) this.events.toolApprovalResponded(response.id, foundToolCallId, response.approved);
+		this.processor.addToolApprovalResponse(response.id, response.approved);
+		if (this.isLoading) {
 			this.queuePostStreamAction(() => this.checkForContinuation());
 			return;
 		}
 		await this.checkForContinuation();
 	}
-	queuePostStreamAction(e) {
-		this.postStreamActions.push(e);
+	/**
+	* Queue an action to be executed after the current stream ends
+	*/
+	queuePostStreamAction(action) {
+		this.postStreamActions.push(action);
 	}
+	/**
+	* Drain and execute all queued post-stream actions
+	*/
 	async drainPostStreamActions() {
-		if (!this.draining) {
-			this.draining = !0;
-			try {
-				for (; this.postStreamActions.length > 0;) await this.postStreamActions.shift()();
-			} finally {
-				this.draining = !1;
-			}
+		if (this.draining) return;
+		this.draining = true;
+		try {
+			while (this.postStreamActions.length > 0) await this.postStreamActions.shift()();
+		} finally {
+			this.draining = false;
 		}
 	}
+	/**
+	* Check if we should continue the flow and do so if needed
+	*/
 	async checkForContinuation() {
 		if (this.continuationPending || this.isLoading) {
-			this.continuationSkipped = !0;
+			this.continuationSkipped = true;
 			return;
 		}
 		if (this.shouldAutoSend()) {
-			this.continuationPending = !0, this.continuationSkipped = !1;
-			let e = !1;
+			this.continuationPending = true;
+			this.continuationSkipped = false;
+			let succeeded = false;
 			try {
-				e = await this.streamResponse();
+				succeeded = await this.streamResponse();
 			} finally {
-				this.continuationPending = !1;
+				this.continuationPending = false;
+			}
+			if (this.continuationSkipped && succeeded) {
+				this.continuationSkipped = false;
+				await this.checkForContinuation();
 			}
-			this.continuationSkipped && e && (this.continuationSkipped = !1, await this.checkForContinuation());
 		}
 	}
+	/**
+	* Check if all tool calls are complete and we should auto-send.
+	* Requires that there is at least one tool call in the last assistant message;
+	* a text-only response has nothing to auto-send.
+	*/
 	shouldAutoSend() {
-		let e = this.processor.getMessages().findLast((e) => e.role === "assistant");
-		return !e || !e.parts.some((e) => e.type === "tool-call") ? !1 : this.processor.areAllToolsComplete();
-	}
+		const lastAssistant = this.processor.getMessages().findLast((m) => m.role === "assistant");
+		if (!lastAssistant) return false;
+		if (!lastAssistant.parts.some((p) => p.type === "tool-call")) return false;
+		return this.processor.areAllToolsComplete();
+	}
+	/**
+	* Get current messages
+	*/
 	getMessages() {
 		return this.processor.getMessages();
 	}
+	/**
+	* Get loading state
+	*/
 	getIsLoading() {
 		return this.isLoading;
 	}
+	/**
+	* Get current status
+	*/
 	getStatus() {
 		return this.status;
 	}
+	/**
+	* Get whether the subscription loop is active
+	*/
 	getIsSubscribed() {
 		return this.isSubscribed;
 	}
+	/**
+	* Get current connection lifecycle status
+	*/
 	getConnectionStatus() {
 		return this.connectionStatus;
 	}
+	/**
+	* Whether the shared session is actively generating.
+	* Derived from stream run events (RUN_STARTED / RUN_FINISHED / RUN_ERROR).
+	* Unlike `isLoading` (request-local), this reflects shared generation
+	* activity visible to all subscribers (e.g. across tabs/devices).
+	*/
 	getSessionGenerating() {
 		return this.sessionGenerating;
 	}
+	/**
+	* Get current error
+	*/
 	getError() {
 		return this.error;
 	}
-	setMessagesManually(e) {
-		this.processor.setMessages(e);
-	}
-	updateOptions(e) {
-		if (e.connection !== void 0) {
-			let t = this.isSubscribed;
-			this.isLoading ? this.cancelInFlightStream({
-				setReadyStatus: !0,
-				abortSubscription: !0
-			}) : t && this.abortSubscriptionLoop(), this.resetSessionGenerating(), this.setIsSubscribed(!1), this.setConnectionStatus("disconnected"), this.connection = normalizeConnectionAdapter(e.connection), t && this.subscribe();
+	/**
+	* Manually set messages
+	*/
+	setMessagesManually(messages) {
+		this.processor.setMessages(messages);
+	}
+	/**
+	* Update options refs (for use in React hooks to avoid recreating client)
+	*/
+	updateOptions(options) {
+		if (options.connection !== void 0) {
+			const wasSubscribed = this.isSubscribed;
+			if (this.isLoading) this.cancelInFlightStream({
+				setReadyStatus: true,
+				abortSubscription: true
+			});
+			else if (wasSubscribed) this.abortSubscriptionLoop();
+			this.resetSessionGenerating();
+			this.setIsSubscribed(false);
+			this.setConnectionStatus("disconnected");
+			this.connection = normalizeConnectionAdapter(options.connection);
+			if (wasSubscribed) this.subscribe();
 		}
-		if (e.body !== void 0 && (this.body = e.body), e.tools !== void 0) {
+		if (options.body !== void 0) this.body = options.body;
+		if (options.tools !== void 0) {
 			this.clientToolsRef.current = /* @__PURE__ */ new Map();
-			for (let t of e.tools) this.clientToolsRef.current.set(t.name, t);
+			for (const tool of options.tools) this.clientToolsRef.current.set(tool.name, tool);
 		}
-		e.onResponse !== void 0 && (this.callbacksRef.current.onResponse = e.onResponse), e.onChunk !== void 0 && (this.callbacksRef.current.onChunk = e.onChunk), e.onFinish !== void 0 && (this.callbacksRef.current.onFinish = e.onFinish), e.onError !== void 0 && (this.callbacksRef.current.onError = e.onError), e.onSubscriptionChange !== void 0 && (this.callbacksRef.current.onSubscriptionChange = e.onSubscriptionChange), e.onConnectionStatusChange !== void 0 && (this.callbacksRef.current.onConnectionStatusChange = e.onConnectionStatusChange), e.onSessionGeneratingChange !== void 0 && (this.callbacksRef.current.onSessionGeneratingChange = e.onSessionGeneratingChange), e.onCustomEvent !== void 0 && (this.callbacksRef.current.onCustomEvent = e.onCustomEvent);
+		if (options.onResponse !== void 0) this.callbacksRef.current.onResponse = options.onResponse;
+		if (options.onChunk !== void 0) this.callbacksRef.current.onChunk = options.onChunk;
+		if (options.onFinish !== void 0) this.callbacksRef.current.onFinish = options.onFinish;
+		if (options.onError !== void 0) this.callbacksRef.current.onError = options.onError;
+		if (options.onSubscriptionChange !== void 0) this.callbacksRef.current.onSubscriptionChange = options.onSubscriptionChange;
+		if (options.onConnectionStatusChange !== void 0) this.callbacksRef.current.onConnectionStatusChange = options.onConnectionStatusChange;
+		if (options.onSessionGeneratingChange !== void 0) this.callbacksRef.current.onSessionGeneratingChange = options.onSessionGeneratingChange;
+		if (options.onCustomEvent !== void 0) this.callbacksRef.current.onCustomEvent = options.onCustomEvent;
 	}
 };
 //#endregion
 //#region ../../node_modules/.pnpm/@tanstack+ai-client@0.8.0/node_modules/@tanstack/ai-client/dist/esm/types.js
-function clientTools(...e) {
-	return e;
+function clientTools(...tools) {
+	return tools;
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@tanstack+ai-react@0.8.0_@tanstack+ai@0.14.0_@types+react@19.2.18_react@19.2.8/node_modules/@tanstack/ai-react/dist/esm/use-chat.js
-function useChat(e) {
-	let t = i(), c = e.id || t, [l, u] = s(e.initialMessages || []), [d, f] = s(!1), [p, m] = s(void 0), [h, g] = s("ready"), [_, v] = s(!1), [y, b] = s("disconnected"), [x, S] = s(!1), C = o(e.initialMessages || []), w = o(!0);
-	C.current = l;
-	let T = o(e);
-	T.current = e;
-	let E = a(() => {
-		let t = w.current ? e.initialMessages || [] : C.current;
-		return w.current = !1, new ChatClient({
-			connection: T.current.connection,
-			id: c,
-			initialMessages: t,
-			body: T.current.body,
-			onResponse: (e) => T.current.onResponse?.(e),
-			onChunk: (e) => T.current.onChunk?.(e),
-			onFinish: (e) => {
-				T.current.onFinish?.(e);
+//#region ../../node_modules/.pnpm/@tanstack+ai-react@0.8.0_@tanstack+ai@0.14.0_@types+react@19.3.0_react@19.3.0/node_modules/@tanstack/ai-react/dist/esm/use-chat.js
+function useChat(options) {
+	const hookId = useId();
+	const clientId = options.id || hookId;
+	const [messages, setMessages] = useState(options.initialMessages || []);
+	const [isLoading, setIsLoading] = useState(false);
+	const [error, setError] = useState(void 0);
+	const [status, setStatus] = useState("ready");
+	const [isSubscribed, setIsSubscribed] = useState(false);
+	const [connectionStatus, setConnectionStatus] = useState("disconnected");
+	const [sessionGenerating, setSessionGenerating] = useState(false);
+	const messagesRef = useRef(options.initialMessages || []);
+	const isFirstMountRef = useRef(true);
+	messagesRef.current = messages;
+	const optionsRef = useRef(options);
+	optionsRef.current = options;
+	const client = useMemo(() => {
+		const messagesToUse = isFirstMountRef.current ? options.initialMessages || [] : messagesRef.current;
+		isFirstMountRef.current = false;
+		return new ChatClient({
+			connection: optionsRef.current.connection,
+			id: clientId,
+			initialMessages: messagesToUse,
+			body: optionsRef.current.body,
+			onResponse: (response) => optionsRef.current.onResponse?.(response),
+			onChunk: (chunk) => optionsRef.current.onChunk?.(chunk),
+			onFinish: (message) => {
+				optionsRef.current.onFinish?.(message);
 			},
-			onError: (e) => {
-				T.current.onError?.(e);
+			onError: (error2) => {
+				optionsRef.current.onError?.(error2);
 			},
-			tools: T.current.tools,
-			onCustomEvent: (e, t, n) => T.current.onCustomEvent?.(e, t, n),
-			streamProcessor: e.streamProcessor,
-			onMessagesChange: (e) => {
-				u(e);
+			tools: optionsRef.current.tools,
+			onCustomEvent: (eventType, data, context) => optionsRef.current.onCustomEvent?.(eventType, data, context),
+			streamProcessor: options.streamProcessor,
+			onMessagesChange: (newMessages) => {
+				setMessages(newMessages);
 			},
-			onLoadingChange: (e) => {
-				f(e);
+			onLoadingChange: (newIsLoading) => {
+				setIsLoading(newIsLoading);
 			},
-			onErrorChange: (e) => {
-				m(e);
+			onErrorChange: (newError) => {
+				setError(newError);
 			},
-			onStatusChange: (e) => {
-				g(e);
+			onStatusChange: (status2) => {
+				setStatus(status2);
 			},
-			onSubscriptionChange: (e) => {
-				v(e);
+			onSubscriptionChange: (nextIsSubscribed) => {
+				setIsSubscribed(nextIsSubscribed);
 			},
-			onConnectionStatusChange: (e) => {
-				b(e);
+			onConnectionStatusChange: (nextStatus) => {
+				setConnectionStatus(nextStatus);
 			},
-			onSessionGeneratingChange: (e) => {
-				S(e);
+			onSessionGeneratingChange: (isGenerating) => {
+				setSessionGenerating(isGenerating);
 			}
 		});
-	}, [c]);
-	r(() => {
-		E.updateOptions({ body: e.body });
-	}, [E, e.body]), r(() => {
-		e.initialMessages && e.initialMessages.length > 0 && l.length === 0 && E.setMessagesManually(e.initialMessages);
-	}, []), r(() => {
-		e.live ? E.subscribe() : E.unsubscribe();
-	}, [E, e.live]), r(() => () => {
-		e.live ? E.unsubscribe() : E.stop();
-	}, [E, e.live]);
-	let D = n(async (e) => {
-		await E.sendMessage(e);
-	}, [E]), O = n(async (e) => {
-		await E.append(e);
-	}, [E]), k = n(async () => {
-		await E.reload();
-	}, [E]), A = n(() => {
-		E.stop();
-	}, [E]), j = n(() => {
-		E.clear();
-	}, [E]);
+	}, [clientId]);
+	useEffect(() => {
+		client.updateOptions({ body: options.body });
+	}, [client, options.body]);
+	useEffect(() => {
+		if (options.initialMessages && options.initialMessages.length > 0) {
+			if (messages.length === 0) client.setMessagesManually(options.initialMessages);
+		}
+	}, []);
+	useEffect(() => {
+		if (options.live) client.subscribe();
+		else client.unsubscribe();
+	}, [client, options.live]);
+	useEffect(() => {
+		return () => {
+			if (options.live) client.unsubscribe();
+			else client.stop();
+		};
+	}, [client, options.live]);
+	const sendMessage = useCallback(async (content) => {
+		await client.sendMessage(content);
+	}, [client]);
+	const append = useCallback(async (message) => {
+		await client.append(message);
+	}, [client]);
+	const reload = useCallback(async () => {
+		await client.reload();
+	}, [client]);
+	const stop = useCallback(() => {
+		client.stop();
+	}, [client]);
+	const clear = useCallback(() => {
+		client.clear();
+	}, [client]);
 	return {
-		messages: l,
-		sendMessage: D,
-		append: O,
-		reload: k,
-		stop: A,
-		isLoading: d,
-		error: p,
-		status: h,
-		isSubscribed: _,
-		connectionStatus: y,
-		sessionGenerating: x,
-		setMessages: n((e) => {
-			E.setMessagesManually(e);
-		}, [E]),
-		clear: j,
-		addToolResult: n(async (e) => {
-			await E.addToolResult(e);
-		}, [E]),
-		addToolApprovalResponse: n(async (e) => {
-			await E.addToolApprovalResponse(e);
-		}, [E])
+		messages,
+		sendMessage,
+		append,
+		reload,
+		stop,
+		isLoading,
+		error,
+		status,
+		isSubscribed,
+		connectionStatus,
+		sessionGenerating,
+		setMessages: useCallback((newMessages) => {
+			client.setMessagesManually(newMessages);
+		}, [client]),
+		clear,
+		addToolResult: useCallback(async (result) => {
+			await client.addToolResult(result);
+		}, [client]),
+		addToolApprovalResponse: useCallback(async (response) => {
+			await client.addToolApprovalResponse(response);
+		}, [client])
 	};
 }
-(/* @__PURE__ */ new Uint8Array(128)).fill(128), t(null);
+(/* @__PURE__ */ new Uint8Array(128)).fill(128);
+createContext(null);
 //#endregion
-//#region ../../node_modules/.pnpm/@tanstack+ai-react-ui@0.6.2_@tanstack+ai-client@0.8.0_@tanstack+ai-react@0.8.0_@tanstac_faab93d927ce4b35707b996a3d98975c/node_modules/@tanstack/ai-react-ui/dist/esm/thinking-part.js
-function ThinkingPart({ content: e, className: t = "", isComplete: n = !1 }) {
-	let [i, a] = s(!1);
-	return r(() => {
-		n && a(!0);
-	}, [n]), /* @__PURE__ */ u("div", {
-		className: t || void 0,
+//#region ../../node_modules/.pnpm/@tanstack+ai-react-ui@0.6.2_@tanstack+ai-client@0.8.0_@tanstack+ai-react@0.8.0_@tanstac_f31ad401e8e50c178d70c0e33691bf47/node_modules/@tanstack/ai-react-ui/dist/esm/thinking-part.js
+function ThinkingPart({ content, className = "", isComplete = false }) {
+	const [isCollapsed, setIsCollapsed] = useState(false);
+	useEffect(() => {
+		if (isComplete) setIsCollapsed(true);
+	}, [isComplete]);
+	return /* @__PURE__ */ jsxs("div", {
+		className: className || void 0,
 		"data-part-type": "thinking",
-		"data-part-content": !0,
-		children: [/* @__PURE__ */ u("button", {
-			onClick: () => a(!i),
+		"data-part-content": true,
+		children: [/* @__PURE__ */ jsxs("button", {
+			onClick: () => setIsCollapsed(!isCollapsed),
 			className: "flex items-center gap-2 text-sm text-gray-400 hover:text-gray-300 transition-colors mb-2",
-			"aria-expanded": !i,
-			"aria-label": i ? "Expand thinking" : "Collapse thinking",
+			"aria-expanded": !isCollapsed,
+			"aria-label": isCollapsed ? "Expand thinking" : "Collapse thinking",
 			children: [
-				/* @__PURE__ */ l("span", {
+				/* @__PURE__ */ jsx("span", {
 					className: "text-xs",
-					children: i ? "▶" : "▼"
+					children: isCollapsed ? "▶" : "▼"
 				}),
-				/* @__PURE__ */ l("span", {
+				/* @__PURE__ */ jsx("span", {
 					className: "italic",
 					children: "💭 Thinking..."
 				}),
-				n && /* @__PURE__ */ l("span", {
+				isComplete && /* @__PURE__ */ jsx("span", {
 					className: "text-xs text-gray-500",
 					children: "(complete)"
 				})
 			]
-		}), !i && /* @__PURE__ */ l("div", {
+		}), !isCollapsed && /* @__PURE__ */ jsx("div", {
 			className: "text-gray-300 whitespace-pre-wrap font-mono text-sm",
-			children: e
+			children: content
 		})]
 	});
 }
 //#endregion
-//#region ../../node_modules/.pnpm/@tanstack+ai-react-ui@0.6.2_@tanstack+ai-client@0.8.0_@tanstack+ai-react@0.8.0_@tanstac_faab93d927ce4b35707b996a3d98975c/node_modules/@tanstack/ai-react-ui/dist/esm/chat-message.js
-function ChatMessage({ message: e, className: t = "", userClassName: n = "", assistantClassName: r = "", textPartRenderer: i, thinkingPartRenderer: a, toolsRenderer: o, defaultToolRenderer: s, toolResultRenderer: c }) {
-	let u = [t, e.role === "user" ? n : r].filter(Boolean).join(" ");
-	return /* @__PURE__ */ l("div", {
-		className: u || void 0,
-		"data-message-id": e.id,
-		"data-message-role": e.role,
-		"data-message-created": e.createdAt?.toISOString(),
-		children: e.parts.map((t, n) => {
-			let r = t.type === "thinking" && e.parts.slice(n + 1).some((e) => e.type === "text");
-			return /* @__PURE__ */ l(MessagePart, {
-				part: t,
-				isThinkingComplete: r,
-				textPartRenderer: i,
-				thinkingPartRenderer: a,
-				toolsRenderer: o,
-				defaultToolRenderer: s,
-				toolResultRenderer: c
-			}, `${e.id}-part-${n}`);
+//#region ../../node_modules/.pnpm/@tanstack+ai-react-ui@0.6.2_@tanstack+ai-client@0.8.0_@tanstack+ai-react@0.8.0_@tanstac_f31ad401e8e50c178d70c0e33691bf47/node_modules/@tanstack/ai-react-ui/dist/esm/chat-message.js
+function ChatMessage({ message, className = "", userClassName = "", assistantClassName = "", textPartRenderer, thinkingPartRenderer, toolsRenderer, defaultToolRenderer, toolResultRenderer }) {
+	const combinedClassName = [className, message.role === "user" ? userClassName : assistantClassName].filter(Boolean).join(" ");
+	return /* @__PURE__ */ jsx("div", {
+		className: combinedClassName || void 0,
+		"data-message-id": message.id,
+		"data-message-role": message.role,
+		"data-message-created": message.createdAt?.toISOString(),
+		children: message.parts.map((part, index) => {
+			const isThinkingComplete = part.type === "thinking" && message.parts.slice(index + 1).some((p) => p.type === "text");
+			return /* @__PURE__ */ jsx(MessagePart, {
+				part,
+				isThinkingComplete,
+				textPartRenderer,
+				thinkingPartRenderer,
+				toolsRenderer,
+				defaultToolRenderer,
+				toolResultRenderer
+			}, `${message.id}-part-${index}`);
 		})
 	});
 }
-function MessagePart({ part: e, isThinkingComplete: t, textPartRenderer: n, thinkingPartRenderer: r, toolsRenderer: i, defaultToolRenderer: a, toolResultRenderer: o }) {
-	if (e.type === "text") return n ? /* @__PURE__ */ l(c, { children: n({ content: e.content }) }) : /* @__PURE__ */ l("div", {
-		"data-part-type": "text",
-		"data-part-content": !0,
-		children: e.content
-	});
-	if (e.type === "thinking") return r ? /* @__PURE__ */ l(c, { children: r({
-		content: e.content,
-		isComplete: t
-	}) }) : /* @__PURE__ */ l(ThinkingPart, {
-		content: e.content,
-		isComplete: t
-	});
-	if (e.type === "tool-call") {
-		let t = {
-			id: e.id,
-			name: e.name,
-			arguments: e.arguments,
-			state: e.state,
-			approval: e.approval,
-			output: e.output
+function MessagePart({ part, isThinkingComplete, textPartRenderer, thinkingPartRenderer, toolsRenderer, defaultToolRenderer, toolResultRenderer }) {
+	if (part.type === "text") {
+		if (textPartRenderer) return /* @__PURE__ */ jsx(Fragment$1, { children: textPartRenderer({ content: part.content }) });
+		return /* @__PURE__ */ jsx("div", {
+			"data-part-type": "text",
+			"data-part-content": true,
+			children: part.content
+		});
+	}
+	if (part.type === "thinking") {
+		if (thinkingPartRenderer) return /* @__PURE__ */ jsx(Fragment$1, { children: thinkingPartRenderer({
+			content: part.content,
+			isComplete: isThinkingComplete
+		}) });
+		return /* @__PURE__ */ jsx(ThinkingPart, {
+			content: part.content,
+			isComplete: isThinkingComplete
+		});
+	}
+	if (part.type === "tool-call") {
+		const toolProps = {
+			id: part.id,
+			name: part.name,
+			arguments: part.arguments,
+			state: part.state,
+			approval: part.approval,
+			output: part.output
 		};
-		return i?.[e.name] ? /* @__PURE__ */ l(c, { children: i[e.name]?.(t) }) : a ? /* @__PURE__ */ l(c, { children: a(t) }) : /* @__PURE__ */ u("div", {
+		if (toolsRenderer?.[part.name]) return /* @__PURE__ */ jsx(Fragment$1, { children: toolsRenderer[part.name]?.(toolProps) });
+		if (defaultToolRenderer) return /* @__PURE__ */ jsx(Fragment$1, { children: defaultToolRenderer(toolProps) });
+		return /* @__PURE__ */ jsxs("div", {
 			"data-part-type": "tool-call",
-			"data-tool-name": e.name,
-			"data-tool-state": e.state,
-			"data-tool-id": e.id,
+			"data-tool-name": part.name,
+			"data-tool-state": part.state,
+			"data-tool-id": part.id,
 			children: [
-				/* @__PURE__ */ u("div", {
-					"data-tool-header": !0,
-					children: [/* @__PURE__ */ l("strong", { children: e.name }), /* @__PURE__ */ l("span", {
-						"data-tool-state-badge": !0,
-						children: e.state
+				/* @__PURE__ */ jsxs("div", {
+					"data-tool-header": true,
+					children: [/* @__PURE__ */ jsx("strong", { children: part.name }), /* @__PURE__ */ jsx("span", {
+						"data-tool-state-badge": true,
+						children: part.state
 					})]
 				}),
-				e.arguments && /* @__PURE__ */ l("div", {
-					"data-tool-arguments": !0,
-					children: /* @__PURE__ */ l("pre", { children: e.arguments })
+				part.arguments && /* @__PURE__ */ jsx("div", {
+					"data-tool-arguments": true,
+					children: /* @__PURE__ */ jsx("pre", { children: part.arguments })
 				}),
-				e.approval && /* @__PURE__ */ l("div", {
-					"data-tool-approval": !0,
-					children: e.approval.approved === void 0 ? "⏳ Awaiting approval..." : e.approval.approved ? "✓ Approved" : "✗ Denied"
+				part.approval && /* @__PURE__ */ jsx("div", {
+					"data-tool-approval": true,
+					children: part.approval.approved !== void 0 ? part.approval.approved ? "✓ Approved" : "✗ Denied" : "⏳ Awaiting approval..."
 				}),
-				e.output && /* @__PURE__ */ l("div", {
-					"data-tool-output": !0,
-					children: /* @__PURE__ */ l("pre", { children: JSON.stringify(e.output, null, 2) })
+				part.output && /* @__PURE__ */ jsx("div", {
+					"data-tool-output": true,
+					children: /* @__PURE__ */ jsx("pre", { children: JSON.stringify(part.output, null, 2) })
 				})
 			]
 		});
 	}
-	return e.type === "tool-result" ? o ? /* @__PURE__ */ l(c, { children: o({
-		toolCallId: e.toolCallId,
-		content: e.content,
-		state: e.state
-	}) }) : /* @__PURE__ */ l("div", {
-		"data-part-type": "tool-result",
-		"data-tool-call-id": e.toolCallId,
-		"data-tool-result-state": e.state,
-		children: /* @__PURE__ */ l("div", {
-			"data-tool-result-content": !0,
-			children: e.content
-		})
-	}) : null;
+	if (part.type === "tool-result") {
+		if (toolResultRenderer) return /* @__PURE__ */ jsx(Fragment$1, { children: toolResultRenderer({
+			toolCallId: part.toolCallId,
+			content: part.content,
+			state: part.state
+		}) });
+		return /* @__PURE__ */ jsx("div", {
+			"data-part-type": "tool-result",
+			"data-tool-call-id": part.toolCallId,
+			"data-tool-result-state": part.state,
+			children: /* @__PURE__ */ jsx("div", {
+				"data-tool-result-content": true,
+				children: part.content
+			})
+		});
+	}
+	return null;
 }
 //#endregion
 export { toolDefinition as a, fetchServerSentEvents as i, useChat as n, clientTools as r, ChatMessage as t };