likec4 1.57.0 → 1.58.0

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

@@ -0,0 +1,1768 @@
+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";
+//#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);
+	};
+	#m = () => {
+		if (this.#c < this.#l) {
+			this.#c++, 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();
+	};
+	#h = () => {
+		this.#u || (this.#u = !0, this.#n().addEventListener("tanstack-connect-success", this.#p), this.#m());
+	};
+	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;
+	}
+	startConnectLoop() {
+		this.#o !== null || this.#a || (this.debugLog(`Starting connect loop (every ${this.#s}ms)`), this.#o = setInterval(this.#m, this.#s));
+	}
+	stopConnectLoop() {
+		this.#u = !1, this.#o !== null && (clearInterval(this.#o), this.#o = null, this.#i = [], this.debugLog("Stopped connect loop"));
+	}
+	debugLog(...e) {
+		this.#r && console.log(`🌴 [tanstack-devtools:${this.#t}-plugin]`, ...e);
+	}
+	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);
+	}
+	getPluginId() {
+		return this.#t;
+	}
+	dispatchCustomEventShim(e, t) {
+		try {
+			let n = new Event(e, { detail: t });
+			this.#n().dispatchEvent(n);
+		} catch {
+			this.debugLog("Failed to dispatch shim event");
+		}
+	}
+	dispatchCustomEvent(e, t) {
+		try {
+			this.#n().dispatchEvent(new CustomEvent(e, { detail: t }));
+		} catch {
+			this.dispatchCustomEventShim(e, t);
+		}
+	}
+	emitEventToBus(e) {
+		this.debugLog("Emitting event to client bus", e), this.dispatchCustomEvent("tanstack-dispatch-event", e);
+	}
+	createEventPayload(e, t) {
+		return {
+			type: `${this.#t}:${e}`,
+			payload: t,
+			pluginId: this.#t
+		};
+	}
+	emit(e, t) {
+		if (!this.#e) {
+			this.debugLog("Event bus client is disabled, not emitting event", e, t);
+			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) {
+			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());
+			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.#n().addEventListener(i, handler), this.debugLog("Registered event to bus", i), () => {
+			r && this.#f?.removeEventListener(i, handler), this.#n().removeEventListener(i, 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);
+		};
+		return this.#n().addEventListener("tanstack-devtools-global", handler), () => this.#n().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);
+		};
+		return this.#n().addEventListener("tanstack-devtools-global", handler), () => this.#n().removeEventListener("tanstack-devtools-global", handler);
+	}
+}, AiEventClient = class extends EventClient {
+	constructor() {
+		super({ pluginId: "tanstack-ai-devtools" });
+	}
+}, d = 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 collapseContentParts(e) {
+	return e.length === 0 ? null : e.every((e) => e.type === "text") ? e.map((e) => e.content).join("") || null : e;
+}
+function getTextContent(e) {
+	return e === null ? "" : typeof e == "string" ? e : e.filter((e) => e.type === "text").map((e) => e.content).join("");
+}
+function uiMessageToModelMessages(e) {
+	return e.role === "system" ? [] : e.role === "assistant" ? buildAssistantMessages(e) : [buildUserOrToolMessage(e)];
+}
+function buildUserOrToolMessage(e) {
+	let t = [];
+	for (let n of e.parts) isContentPart(n) && t.push(n);
+	return {
+		role: e.role,
+		content: collapseContentParts(t)
+	};
+}
+function createSegment() {
+	return {
+		contentParts: [],
+		toolCalls: []
+	};
+}
+function isToolCallIncluded(e) {
+	return e.state === "input-complete" || e.state === "approval-responded" || e.output !== void 0;
+}
+function buildAssistantMessages(e) {
+	let t = [], n = createSegment(), r = /* @__PURE__ */ new Set();
+	function flushSegment() {
+		let e = collapseContentParts(n.contentParts), r = e !== null, i = n.toolCalls.length > 0;
+		(r || i) && t.push({
+			role: "assistant",
+			content: e,
+			...i && { toolCalls: n.toolCalls }
+		}), n = createSegment();
+	}
+	for (let i of e.parts) switch (i.type) {
+		case "text":
+		case "image":
+		case "audio":
+		case "video":
+		case "document":
+			n.contentParts.push(i);
+			break;
+		case "tool-call":
+			isToolCallIncluded(i) && n.toolCalls.push({
+				id: i.id,
+				type: "function",
+				function: {
+					name: i.name,
+					arguments: i.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));
+			break;
+	}
+	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({
+		role: "assistant",
+		content: null
+	}), t;
+}
+function modelMessageToUIMessage(e, t) {
+	let n = [];
+	if (e.role === "tool" && e.toolCallId) n.push({
+		type: "tool-result",
+		toolCallId: e.toolCallId,
+		content: getTextContent(e.content),
+		state: "complete"
+	});
+	else if (Array.isArray(e.content)) for (let t of e.content) n.push(t);
+	else {
+		let t = getTextContent(e.content);
+		t && n.push({
+			type: "text",
+			content: t
+		});
+	}
+	if (e.toolCalls && e.toolCalls.length > 0) for (let t of e.toolCalls) n.push({
+		type: "tool-call",
+		id: t.id,
+		name: t.function.name,
+		arguments: t.function.arguments,
+		state: "input-complete"
+	});
+	return {
+		id: t || generateMessageId(),
+		role: e.role === "tool" ? "assistant" : e.role,
+		parts: n
+	};
+}
+function normalizeToUIMessage(e, t) {
+	return "parts" in e ? {
+		...e,
+		id: e.id || t(),
+		createdAt: e.createdAt || /* @__PURE__ */ new Date()
+	} : {
+		...modelMessageToUIMessage(e, t()),
+		createdAt: /* @__PURE__ */ new Date()
+	};
+}
+function generateMessageId() {
+	return `msg-${Date.now()}-${Math.random().toString(36).substring(7)}`;
+}
+//#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) {
+	return {
+		__toolSide: "definition",
+		...e,
+		server(t) {
+			return {
+				__toolSide: "server",
+				...e,
+				execute: t
+			};
+		},
+		client(t) {
+			return {
+				__toolSide: "client",
+				...e,
+				execute: t
+			};
+		}
+	};
+}
+//#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,
+			get: function() {
+				return t[n];
+			}
+		}), 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(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,
+		get: function() {
+			return r.Allow;
+		}
+	}), n(f(), e);
+	var PartialJSON = class extends Error {};
+	e.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 : !1, i++;
+			if (e.charAt(i) == "\"") try {
+				return JSON.parse(e.substring(a, ++i - Number(o)));
+			} 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("\\")) + "\"");
+			}
+			markPartialJSON("Unterminated string literal");
+		}, parseObj = () => {
+			i++, skipBlank();
+			let a = {};
+			try {
+				for (; e[i] !== "}";) {
+					if (skipBlank(), i >= n && r.Allow.OBJ & t) return a;
+					let o = parseStr();
+					skipBlank(), i++;
+					try {
+						a[o] = parseAny();
+					} catch (e) {
+						if (r.Allow.OBJ & t) return a;
+						throw e;
+					}
+					skipBlank(), e[i] === "," && i++;
+				}
+			} catch {
+				if (r.Allow.OBJ & t) return a;
+				markPartialJSON("Expected '}' at end of object");
+			}
+			return i++, a;
+		}, parseArr = () => {
+			i++;
+			let n = [];
+			try {
+				for (; e[i] !== "]";) n.push(parseAny()), skipBlank(), e[i] === "," && i++;
+			} catch {
+				if (r.Allow.ARR & t) return n;
+				markPartialJSON("Expected ']' at end of array");
+			}
+			return i++, n;
+		}, parseNum = () => {
+			if (i === 0) {
+				e === "-" && 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));
+				}
+			}
+			let a = i;
+			for (e[i] === "-" && i++; e[i] && ",]}".indexOf(e[i]) === -1;) i++;
+			i == n && !(r.Allow.NUM & t) && markPartialJSON("Unterminated number literal");
+			try {
+				return JSON.parse(e.substring(a, i));
+			} catch {
+				e.substring(a, i) === "-" && markPartialJSON("Not sure what '-' is");
+				try {
+					return JSON.parse(e.substring(a, e.lastIndexOf("e")));
+				} catch (e) {
+					throwMalformedError(String(e));
+				}
+			}
+		}, skipBlank = () => {
+			for (; i < n && " \n\r	".includes(e[i]);) i++;
+		};
+		return parseAny();
+	};
+	e.parse = parseJSON;
+})))(), PartialJSONParser = class {
+	parse(e) {
+		if (!(!e || e.trim() === "")) try {
+			return (0, p.parse)(e);
+		} catch {
+			return;
+		}
+	}
+}, m = 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] = {
+			type: "text",
+			content: n
+		} : r.push({
+			type: "text",
+			content: n
+		}), {
+			...e,
+			parts: r
+		};
+	});
+}
+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 = {
+			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 }
+		};
+		return i ? r[r.indexOf(i)] = a : r.push(a), {
+			...e,
+			parts: r
+		};
+	});
+}
+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 = {
+			type: "tool-result",
+			toolCallId: n,
+			content: r,
+			state: i,
+			...a && { error: a }
+		};
+		return s >= 0 ? o[s] = c : o.push(c), {
+			...e,
+			parts: o
+		};
+	});
+}
+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 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, r ? o.state = r : o.state = "input-complete"), {
+			...e,
+			parts: a
+		};
+	});
+}
+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 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 = {
+			type: "thinking",
+			content: n
+		};
+		return i >= 0 ? r[i] = a : r.push(a), {
+			...e,
+			parts: r
+		};
+	});
+}
+//#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();
+	}
+	addUserMessage(e, t) {
+		let n = typeof e == "string" ? [{
+			type: "text",
+			content: e
+		}] : e.map((e) => e), r = {
+			id: t ?? generateMessageId(),
+			role: "user",
+			parts: n,
+			createdAt: /* @__PURE__ */ new Date()
+		};
+		return this.messages = [...this.messages, r], this.emitMessagesChange(), r;
+	}
+	prepareAssistantMessage() {
+		this.resetStreamState();
+	}
+	startAssistantMessage(e) {
+		this.prepareAssistantMessage();
+		let { messageId: t } = this.ensureAssistantMessage(e);
+		return this.pendingManualMessageId = t, t;
+	}
+	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}`);
+			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();
+	}
+	toModelMessages() {
+		let e = [];
+		for (let t of this.messages) e.push(...uiMessageToModelMessages(t));
+		return e;
+	}
+	getMessages() {
+		return this.messages;
+	}
+	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();
+	}
+	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,
+			timestamp: Date.now(),
+			index: this.recording.chunks.length
+		}), e.type) {
+			case "TEXT_MESSAGE_START":
+				this.handleTextMessageStartEvent(e);
+				break;
+			case "TEXT_MESSAGE_CONTENT":
+				this.handleTextMessageContentEvent(e);
+				break;
+			case "TEXT_MESSAGE_END":
+				this.handleTextMessageEndEvent(e);
+				break;
+			case "TOOL_CALL_START":
+				this.handleToolCallStartEvent(e);
+				break;
+			case "TOOL_CALL_ARGS":
+				this.handleToolCallArgsEvent(e);
+				break;
+			case "TOOL_CALL_END":
+				this.handleToolCallEndEvent(e);
+				break;
+			case "RUN_FINISHED":
+				this.handleRunFinishedEvent(e);
+				break;
+			case "RUN_ERROR":
+				this.handleRunErrorEvent(e);
+				break;
+			case "STEP_FINISHED":
+				this.handleStepFinishedEvent(e);
+				break;
+			case "MESSAGES_SNAPSHOT":
+				this.handleMessagesSnapshotEvent(e);
+				break;
+			case "CUSTOM":
+				this.handleCustomEvent(e);
+				break;
+			case "RUN_STARTED":
+				this.handleRunStartedEvent(e);
+				break;
+			case "REASONING_START":
+			case "REASONING_MESSAGE_START":
+			case "REASONING_MESSAGE_END":
+			case "REASONING_END": break;
+			case "REASONING_MESSAGE_CONTENT":
+				this.handleReasoningMessageContentEvent(e);
+				break;
+			case "TOOL_CALL_RESULT":
+				this.handleToolCallResultEvent(e);
+				break;
+		}
+	}
+	createMessageState(e, t) {
+		let n = {
+			id: e,
+			role: t,
+			totalTextContent: "",
+			currentSegmentText: "",
+			lastEmittedText: "",
+			thinkingContent: "",
+			hasSeenReasoningEvents: !1,
+			toolCalls: /* @__PURE__ */ new Map(),
+			toolCallOrder: [],
+			hasToolCallsSinceTextStart: !1,
+			isComplete: !1
+		};
+		return this.messageStates.set(e, n), n;
+	}
+	getMessageState(e) {
+		return this.messageStates.get(e);
+	}
+	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;
+		}
+		return null;
+	}
+	ensureAssistantMessage(e) {
+		if (e) {
+			let t = this.getMessageState(e);
+			if (t) return {
+				messageId: e,
+				state: t
+			};
+		}
+		let t = this.getActiveAssistantMessageId();
+		if (t) return {
+			messageId: t,
+			state: this.getMessageState(t)
+		};
+		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
+				};
+			}
+		}
+		let n = e || generateMessageId(), r = {
+			id: n,
+			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
+		};
+	}
+	handleTextMessageStartEvent(e) {
+		let { messageId: t, role: n } = e, r = n === "user" || n === "system" ? n : "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);
+			}
+			this.messageStates.has(t) || (this.createMessageState(t, r), this.activeMessageIds.add(t)), this.emitMessagesChange();
+			return;
+		}
+		if (this.messages.find((e) => e.id === t)) {
+			if (this.activeMessageIds.add(t), !this.messageStates.has(t)) this.createMessageState(t, r);
+			else {
+				let e = this.messageStates.get(t);
+				e.hasToolCallsSinceTextStart &&= (e.currentSegmentText !== e.lastEmittedText && this.emitTextUpdateForMessage(t), e.currentSegmentText = "", e.lastEmittedText = "", !1);
+			}
+			return;
+		}
+		let i = {
+			id: t,
+			role: r,
+			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,
+				arguments: "",
+				state: t,
+				parsedArguments: void 0,
+				index: e.index ?? r.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,
+				arguments: "",
+				state: t
+			}), this.emitMessagesChange(), this.events.onToolCallStateChange?.(n, e.toolCallId, t, "");
+		}
+	}
+	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);
+		}
+		if (e.result) {
+			let n;
+			try {
+				n = JSON.parse(e.result);
+			} catch {
+				n = e.result;
+			}
+			this.messages = updateToolCallWithOutput(this.messages, e.toolCallId, n), this.messages = updateToolResultPart(this.messages, t, e.toolCallId, e.result, "complete"), this.emitMessagesChange();
+		}
+	}
+	handleToolCallResultEvent(e) {
+		let t = this.toolCallToMessage.get(e.toolCallId);
+		if (!t) return;
+		let n;
+		try {
+			n = JSON.parse(e.content);
+		} catch {
+			n = e.content;
+		}
+		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;
+			this.events.onToolCall?.({
+				toolCallId: t,
+				toolName: n,
+				input: r
+			});
+			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
+			});
+			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 });
+		}
+	}
+	isNewTextSegment(e, t) {
+		return e.content !== void 0 && (e.content.length < t.length || !e.content.startsWith(t) && !t.startsWith(e.content));
+	}
+	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);
+			}
+		});
+	}
+	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,
+			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));
+	}
+	emitMessagesChange() {
+		this.events.onMessagesChange?.([...this.messages]);
+	}
+	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);
+		}
+		if (this.activeMessageIds.clear(), e && !this.hasError && this.isWhitespaceOnlyMessage(e)) {
+			this.messages = this.messages.filter((t) => t.id !== e.id), this.emitMessagesChange();
+			return;
+		}
+		e && this.events.onStreamEnd?.(e);
+	}
+	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,
+			type: "function",
+			function: {
+				name: n.name,
+				arguments: n.arguments
+			}
+		});
+		return e;
+	}
+	getResult() {
+		let e = this.getCompletedToolCalls(), t = "", n = "";
+		for (let e of this.messageStates.values()) t += e.totalTextContent, n += e.thinkingContent;
+		return {
+			content: t,
+			thinking: n || void 0,
+			toolCalls: e.length > 0 ? e : void 0,
+			finishReason: this.finishReason
+		};
+	}
+	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);
+		}
+		return {
+			content: e,
+			thinking: t,
+			toolCalls: n,
+			toolCallOrder: r,
+			finishReason: this.finishReason,
+			done: this.isDone
+		};
+	}
+	startRecording() {
+		this.recordingEnabled = !0, this.recordingStartTime = Date.now(), this.recording = {
+			version: "1.0",
+			timestamp: this.recordingStartTime,
+			chunks: []
+		};
+	}
+	getRecording() {
+		return this.recording;
+	}
+	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?.();
+	}
+	reset() {
+		this.resetStreamState(), this.messages = [];
+	}
+	isWhitespaceOnlyMessage(e) {
+		return e.parts.length === 0 ? !1 : e.parts.every((e) => e.type === "text" && e.content.trim() === "");
+	}
+	static async replay(e, t) {
+		return new StreamProcessor(t).process(createReplayStream(e));
+	}
+};
+function createReplayStream(e) {
+	return { async *[Symbol.asyncIterator]() {
+		for (let { chunk: t } of e.chunks) yield t;
+	} };
+}
+//#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) {
+		this.emitEvent("text:chunk:content", {
+			streamId: e,
+			messageId: t,
+			content: n
+		});
+	}
+	toolCallStateChanged(e, t, n, r, i, a) {
+		this.emitEvent("tools:call:updated", {
+			streamId: e,
+			messageId: t,
+			toolCallId: n,
+			toolName: r,
+			state: i,
+			arguments: a
+		});
+	}
+	thinkingUpdated(e, t, n, r) {
+		this.emitEvent("text:chunk:thinking", {
+			streamId: e,
+			messageId: t,
+			content: n,
+			delta: r
+		});
+	}
+	approvalRequested(e, t, n, r, i, a) {
+		this.emitEvent("tools:approval:requested", {
+			streamId: e,
+			messageId: t,
+			toolCallId: n,
+			toolName: r,
+			input: i,
+			approvalId: a
+		});
+	}
+	messageAppended(e, t) {
+		let n = e.parts.filter((e) => e.type === "text").map((e) => e.content).join(" ");
+		this.emitEvent("text:message:created", {
+			streamId: t,
+			messageId: e.id,
+			role: e.role,
+			content: n,
+			parts: e.parts
+		});
+	}
+	messageSent(e, t) {
+		let n = typeof t == "string" ? t : t.filter((e) => e.type === "text").map((e) => e.content).join("");
+		this.emitEvent("text:message:created", {
+			messageId: e,
+			role: "user",
+			content: n,
+			...Array.isArray(t) && { parts: t }
+		}), this.emitEvent("text:message:user", {
+			messageId: e,
+			role: "user",
+			content: n,
+			...Array.isArray(t) && { parts: t }
+		});
+	}
+	reloaded(e) {
+		this.emitEvent("client:reloaded", { fromMessageIndex: e });
+	}
+	stopped() {
+		this.emitEvent("client:stopped");
+	}
+	messagesCleared() {
+		this.emitEvent("client:messages:cleared");
+	}
+	toolResultAdded(e, t, n, r) {
+		this.emitEvent("tools:result:added", {
+			toolCallId: e,
+			toolName: t,
+			output: n,
+			state: r
+		});
+	}
+	toolApprovalResponded(e, t, n) {
+		this.emitEvent("tools:approval:responded", {
+			approvalId: e,
+			toolCallId: t,
+			approved: n
+		});
+	}
+}, DefaultChatClientEventEmitter = class extends ChatClientEventEmitter {
+	emitEvent(e, t) {
+		e.startsWith("client:") || e.startsWith("tools:") || e.startsWith("text:") ? d.emit(e, {
+			...t,
+			clientId: this.clientId,
+			source: "client",
+			timestamp: Date.now()
+		}) : d.emit(e, {
+			...t,
+			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;
+}
+async function* readStreamLines(e, t) {
+	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);
+		}
+		r.trim() && (yield r);
+	} finally {
+		e.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)
+	};
+	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);
+	}
+	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);
+				}
+			})();
+		},
+		async send(t, n, r) {
+			let i = !1;
+			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({
+					type: "RUN_FINISHED",
+					runId: `run-${Date.now()}`,
+					model: "connect-wrapper",
+					timestamp: Date.now(),
+					finishReason: "stop"
+				});
+			} catch (e) {
+				throw !r?.aborted && !i && 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;
+			}
+		}
+	};
+}
+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 = {
+			"Content-Type": "application/json",
+			...mergeHeaders(o.headers)
+		}, c = {
+			messages: n,
+			data: r,
+			...o.body
+		}, l = await (o.fetchClient ?? fetch)(a, {
+			method: "POST",
+			headers: s,
+			body: JSON.stringify(c),
+			credentials: o.credentials || "same-origin",
+			signal: i || o.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]") {
+				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);
+			}
+		}
+	} };
+}
+//#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);
+		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,
+			events: {
+				onMessagesChange: (e) => {
+					this.callbacksRef.current.onMessagesChange(e);
+				},
+				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));
+				},
+				onStreamEnd: (e) => {
+					this.callbacksRef.current.onFinish(e), this.setStatus("ready"), this.resolveProcessing();
+				},
+				onError: (e) => {
+					this.reportStreamError(e);
+				},
+				onTextUpdate: (e, t) => {
+					this.currentStreamId && this.events.textUpdated(this.currentStreamId, e, t);
+				},
+				onThinkingUpdate: (e, t) => {
+					this.currentStreamId && this.events.thinkingUpdated(this.currentStreamId, e, t);
+				},
+				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);
+				},
+				onToolCall: (e) => {
+					let t = this.clientToolsRef.current.get(e.toolName)?.execute;
+					if (t) {
+						let n = (async () => {
+							try {
+								let n = await t(e.input);
+								await this.addToolResult({
+									toolCallId: e.toolCallId,
+									tool: e.toolName,
+									output: n,
+									state: "output-available"
+								});
+							} catch (t) {
+								await this.addToolResult({
+									toolCallId: e.toolCallId,
+									tool: e.toolName,
+									output: null,
+									state: "output-error",
+									errorText: t.message
+								});
+							} finally {
+								this.pendingToolExecutions.delete(e.toolCallId);
+							}
+						})();
+						this.pendingToolExecutions.set(e.toolCallId, n);
+					}
+				},
+				onApprovalRequest: (e) => {
+					this.currentStreamId && this.events.approvalRequested(this.currentStreamId, this.currentMessageId || "", e.toolCallId, e.toolName, e.input, e.approvalId);
+				},
+				onCustomEvent: (e, t, n) => {
+					this.callbacksRef.current.onCustomEvent(e, t, n);
+				}
+			}
+		}), this.events.clientCreated(this.processor.getMessages().length);
+	}
+	generateUniqueId(e) {
+		return `${e}-${Date.now()}-${Math.random().toString(36).substring(7)}`;
+	}
+	setIsLoading(e) {
+		this.isLoading = e, this.callbacksRef.current.onLoadingChange(e), this.events.loadingChanged(e);
+	}
+	setStatus(e) {
+		this.status = e, this.callbacksRef.current.onStatusChange(e);
+	}
+	setIsSubscribed(e) {
+		this.isSubscribed = e, this.callbacksRef.current.onSubscriptionChange(e);
+	}
+	setConnectionStatus(e) {
+		this.connectionStatus = e, this.callbacksRef.current.onConnectionStatusChange(e);
+	}
+	setSessionGenerating(e) {
+		this.sessionGenerating !== e && (this.sessionGenerating = e, this.callbacksRef.current.onSessionGeneratingChange(e));
+	}
+	resetSessionGenerating() {
+		this.activeRunIds.clear(), this.setSessionGenerating(!1);
+	}
+	setError(e) {
+		this.error = e, this.callbacksRef.current.onErrorChange(e), this.events.errorChanged(e?.message || null);
+	}
+	abortSubscriptionLoop() {
+		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));
+	}
+	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();
+		}).finally(() => {
+			this.subscriptionAbortController?.signal === e && (this.subscriptionAbortController = null, !e.aborted && this.isSubscribed && (this.setIsSubscribed(!1), 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();
+			}
+			await new Promise((e) => setTimeout(e, 0));
+		}
+	}
+	ensureSubscription() {
+		if (!this.isSubscribed) {
+			this.subscribe();
+			return;
+		}
+		(!this.subscriptionAbortController || this.subscriptionAbortController.signal.aborted) && this.subscribe({ restart: !0 });
+	}
+	waitForProcessing() {
+		return this.resolveProcessing(), new Promise((e) => {
+			this.processingResolve = e;
+		});
+	}
+	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
+		};
+	}
+	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) {
+			this.queuePostStreamAction(async () => {
+				await this.streamResponse();
+			});
+			return;
+		}
+		await this.streamResponse();
+	}
+	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;
+		try {
+			let n = this.processor.getMessages();
+			await this.callbacksRef.current.onResponse();
+			let r = {
+				...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);
+			}
+		} 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);
+				}
+			}
+		}
+		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());
+	}
+	unsubscribe() {
+		this.cancelInFlightStream({
+			setReadyStatus: !0,
+			abortSubscription: !0
+		}), this.resetSessionGenerating(), this.setIsSubscribed(!1), this.setConnectionStatus("disconnected");
+	}
+	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());
+	}
+	stop() {
+		this.cancelInFlightStream({ setReadyStatus: !0 }), this.events.stopped();
+	}
+	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.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;
+				break;
+			}
+		}
+		if (n && this.events.toolApprovalResponded(e.id, n, e.approved), this.processor.addToolApprovalResponse(e.id, e.approved), this.isLoading) {
+			this.queuePostStreamAction(() => this.checkForContinuation());
+			return;
+		}
+		await this.checkForContinuation();
+	}
+	queuePostStreamAction(e) {
+		this.postStreamActions.push(e);
+	}
+	async drainPostStreamActions() {
+		if (!this.draining) {
+			this.draining = !0;
+			try {
+				for (; this.postStreamActions.length > 0;) await this.postStreamActions.shift()();
+			} finally {
+				this.draining = !1;
+			}
+		}
+	}
+	async checkForContinuation() {
+		if (this.continuationPending || this.isLoading) {
+			this.continuationSkipped = !0;
+			return;
+		}
+		if (this.shouldAutoSend()) {
+			this.continuationPending = !0, this.continuationSkipped = !1;
+			let e = !1;
+			try {
+				e = await this.streamResponse();
+			} finally {
+				this.continuationPending = !1;
+			}
+			this.continuationSkipped && e && (this.continuationSkipped = !1, await this.checkForContinuation());
+		}
+	}
+	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();
+	}
+	getMessages() {
+		return this.processor.getMessages();
+	}
+	getIsLoading() {
+		return this.isLoading;
+	}
+	getStatus() {
+		return this.status;
+	}
+	getIsSubscribed() {
+		return this.isSubscribed;
+	}
+	getConnectionStatus() {
+		return this.connectionStatus;
+	}
+	getSessionGenerating() {
+		return this.sessionGenerating;
+	}
+	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();
+		}
+		if (e.body !== void 0 && (this.body = e.body), e.tools !== void 0) {
+			this.clientToolsRef.current = /* @__PURE__ */ new Map();
+			for (let t of e.tools) this.clientToolsRef.current.set(t.name, t);
+		}
+		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);
+	}
+};
+//#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;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@tanstack+ai-react@0.8.0_@tanstack+ai@0.14.0_@types+react@19.2.16_react@19.2.7/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);
+			},
+			onError: (e) => {
+				T.current.onError?.(e);
+			},
+			tools: T.current.tools,
+			onCustomEvent: (e, t, n) => T.current.onCustomEvent?.(e, t, n),
+			streamProcessor: e.streamProcessor,
+			onMessagesChange: (e) => {
+				u(e);
+			},
+			onLoadingChange: (e) => {
+				f(e);
+			},
+			onErrorChange: (e) => {
+				m(e);
+			},
+			onStatusChange: (e) => {
+				g(e);
+			},
+			onSubscriptionChange: (e) => {
+				v(e);
+			},
+			onConnectionStatusChange: (e) => {
+				b(e);
+			},
+			onSessionGeneratingChange: (e) => {
+				S(e);
+			}
+		});
+	}, [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]);
+	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])
+	};
+}
+new Uint8Array(128).fill(128), t(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_8d26c9713f9262cc53d0ebd12334c287/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,
+		"data-part-type": "thinking",
+		"data-part-content": !0,
+		children: [/* @__PURE__ */ u("button", {
+			onClick: () => a(!i),
+			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",
+			children: [
+				/* @__PURE__ */ l("span", {
+					className: "text-xs",
+					children: i ? "▶" : "▼"
+				}),
+				/* @__PURE__ */ l("span", {
+					className: "italic",
+					children: "💭 Thinking..."
+				}),
+				n && /* @__PURE__ */ l("span", {
+					className: "text-xs text-gray-500",
+					children: "(complete)"
+				})
+			]
+		}), !i && /* @__PURE__ */ l("div", {
+			className: "text-gray-300 whitespace-pre-wrap font-mono text-sm",
+			children: e
+		})]
+	});
+}
+//#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_8d26c9713f9262cc53d0ebd12334c287/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 }) {
+	return /* @__PURE__ */ l("div", {
+		className: [t, e.role === "user" ? n : r].filter(Boolean).join(" ") || void 0,
+		"data-message-id": e.id,
+		"data-message-role": e.role,
+		"data-message-created": e.createdAt?.toISOString(),
+		children: e.parts.map((t, n) => /* @__PURE__ */ l(MessagePart, {
+			part: t,
+			isThinkingComplete: t.type === "thinking" && e.parts.slice(n + 1).some((e) => e.type === "text"),
+			textPartRenderer: i,
+			thinkingPartRenderer: a,
+			toolsRenderer: o,
+			defaultToolRenderer: s,
+			toolResultRenderer: c
+		}, `${e.id}-part-${n}`))
+	});
+}
+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
+		};
+		return i?.[e.name] ? /* @__PURE__ */ l(c, { children: i[e.name]?.(t) }) : a ? /* @__PURE__ */ l(c, { children: a(t) }) : /* @__PURE__ */ u("div", {
+			"data-part-type": "tool-call",
+			"data-tool-name": e.name,
+			"data-tool-state": e.state,
+			"data-tool-id": e.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
+					})]
+				}),
+				e.arguments && /* @__PURE__ */ l("div", {
+					"data-tool-arguments": !0,
+					children: /* @__PURE__ */ l("pre", { children: e.arguments })
+				}),
+				e.approval && /* @__PURE__ */ l("div", {
+					"data-tool-approval": !0,
+					children: e.approval.approved === void 0 ? "⏳ Awaiting approval..." : e.approval.approved ? "✓ Approved" : "✗ Denied"
+				}),
+				e.output && /* @__PURE__ */ l("div", {
+					"data-tool-output": !0,
+					children: /* @__PURE__ */ l("pre", { children: JSON.stringify(e.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;
+}
+//#endregion
+export { toolDefinition as a, fetchServerSentEvents as i, useChat as n, clientTools as r, ChatMessage as t };