@windmill-labs/chat-sdk 0.0.0-stage → 1.831.0

package/dist/chat-DgINfcUU.js

@@ -0,0 +1,1182 @@
+import { C as _assertClassBrand, S as _classPrivateFieldSet2, T as _classPrivateMethodInitSpec, _ as WindmillApiError, a as errorResultMessage, c as isErrorResult, d as randomId, f as sleep, g as TurnRunningError, i as conversationTitle, l as now, n as abortError, o as extractChatAnswer, p as truncateTitle, s as isAbortError, t as followJob, v as WindmillChatApi, w as _classPrivateFieldInitSpec, x as _classPrivateFieldGet2 } from "./follow-DXfmfPfr.js";
+//#region src/config.ts
+/**
+* The Windmill a raw app bundle runs in. A sandboxed app gets `window.process.env`
+* from its wrapper once the viewer consented to the declared SDK scopes; an
+* unsandboxed one runs on the Windmill origin with the viewer's session and only
+* has `window.ctx`.
+*/
+function detectRawApp() {
+	const g = globalThis;
+	const env = g.process?.env;
+	if (env?.WM_RAW_APP === "true" && env.WM_TOKEN && env.BASE_URL && env.WM_WORKSPACE) return {
+		baseUrl: env.BASE_URL,
+		workspace: env.WM_WORKSPACE,
+		token: env.WM_TOKEN
+	};
+	const workspace = g.ctx?.workspace;
+	const origin = g.location?.origin;
+	if (typeof workspace === "string" && workspace && origin && origin !== "null") return {
+		baseUrl: origin,
+		workspace
+	};
+}
+function resolveConfig(options) {
+	if (!options.flowPath) throw new Error("windmill-chat: flowPath is required");
+	const explicitToken = options.token !== void 0;
+	const detected = options.baseUrl && options.workspace && explicitToken ? void 0 : detectRawApp();
+	const baseUrl = options.baseUrl ?? detected?.baseUrl;
+	const workspace = options.workspace ?? detected?.workspace;
+	if (!baseUrl || !workspace) throw new Error("windmill-chat: pass baseUrl and workspace. They are only detected inside a raw app: an unsandboxed one on the Windmill origin, or a sandboxed one whose policy declares frontend SDK scopes.");
+	const token = options.token ?? (options.baseUrl === void 0 || options.baseUrl === detected?.baseUrl ? detected?.token : void 0);
+	return {
+		flowPath: options.flowPath,
+		baseUrl,
+		workspace,
+		token,
+		history: options.history ?? (explicitToken ? "local" : "server"),
+		historyExplicit: options.history !== void 0,
+		inputs: options.inputs ?? {},
+		fetch: options.fetch,
+		storage: options.storage,
+		storageKey: options.storageKey,
+		pageSize: options.pageSize ?? 50,
+		pollDelayMs: options.pollDelayMs,
+		run: options.run,
+		onFinish: options.onFinish,
+		onError: options.onError
+	};
+}
+//#endregion
+//#region src/history.ts
+const MAX_CONVERSATIONS = 100;
+/**
+* Conversation history in the browser, for a credential shared by every visitor
+* (server history would show them each other's chats). One key per flow, and per
+* `storageKey` when the caller sets one; every operation re-reads the store so
+* several tabs stay consistent.
+*/
+function createLocalHistory(storage, key) {
+	const store = storage ?? defaultStorage();
+	const read = () => {
+		try {
+			const raw = store.getItem(key);
+			if (raw) {
+				const parsed = JSON.parse(raw);
+				if (parsed && parsed.v === 1) return parsed;
+			}
+		} catch {}
+		return {
+			v: 1,
+			conversations: [],
+			messages: {}
+		};
+	};
+	const write = (snapshot) => {
+		try {
+			store.setItem(key, JSON.stringify(snapshot));
+		} catch {}
+	};
+	return {
+		listConversations: () => read().conversations,
+		getMessages: (id) => read().messages[id] ?? [],
+		upsertConversation(conversation) {
+			const s = read();
+			s.conversations = [conversation, ...s.conversations.filter((c) => c.id !== conversation.id)];
+			for (const dropped of s.conversations.splice(MAX_CONVERSATIONS)) delete s.messages[dropped.id];
+			write(s);
+		},
+		renameConversation(id, title) {
+			const s = read();
+			s.conversations = s.conversations.map((c) => c.id === id ? {
+				...c,
+				title
+			} : c);
+			write(s);
+		},
+		saveMessages(id, messages) {
+			const s = read();
+			s.messages[id] = messages.map((m) => ({
+				...m,
+				pending: false
+			}));
+			write(s);
+		},
+		deleteConversation(id) {
+			const s = read();
+			s.conversations = s.conversations.filter((c) => c.id !== id);
+			delete s.messages[id];
+			write(s);
+		}
+	};
+}
+function defaultStorage() {
+	try {
+		const ls = globalThis.localStorage;
+		if (ls) {
+			const probe = "__windmill_chat_probe__";
+			ls.setItem(probe, "1");
+			ls.removeItem(probe);
+			return ls;
+		}
+	} catch {}
+	const memory = /* @__PURE__ */ new Map();
+	return {
+		getItem: (k) => memory.get(k) ?? null,
+		setItem: (k, v) => void memory.set(k, v),
+		removeItem: (k) => void memory.delete(k)
+	};
+}
+//#endregion
+//#region src/attachments.ts
+/**
+* Where a chat's uploads live in the workspace's object storage. Under `windmill_uploads/`
+* because the default Enterprise storage permissions grant every user write and read there
+* and deny any other top-level prefix: a key outside it is refused for non-admins, both on
+* upload and when the agent's job reads the file back.
+*/
+const CHAT_UPLOADS_PREFIX = "windmill_uploads/chat";
+/**
+* The extension each type must be stored under. The worker reads an attachment's media type
+* from the key's extension only (`mime_guess` in `windmill-ai/src/image_handler.rs`, falling
+* back to `image/png`), never from the stored content type, so the extension must be true.
+*/
+const EXTENSION_BY_MEDIA_TYPE = {
+	"image/png": "png",
+	"image/jpeg": "jpg",
+	"application/pdf": "pdf"
+};
+/**
+* The name an attachment is stored under: the picked name with the extension its media type
+* needs, e.g. a `photo.webp` re-encoded to PNG becomes `photo.png`. Other types keep their name.
+*/
+function storedAttachmentName(filename, mediaType) {
+	const extension = EXTENSION_BY_MEDIA_TYPE[mediaType];
+	if (!extension) return filename;
+	return `${filename.replace(/\.[^./]+$/, "") || filename}.${extension}`;
+}
+/** The bytes of an attachment as a Blob carrying its media type. */
+function attachmentBlob(attachment) {
+	const data = typeof attachment.data === "string" ? dataUrlToBlob(attachment.data, "application/octet-stream") : attachment.data;
+	return attachment.mediaType && attachment.mediaType !== data.type ? new Blob([data], { type: attachment.mediaType }) : data;
+}
+function dataUrlToBlob(dataUrl, fallbackType) {
+	const comma = dataUrl.indexOf(",");
+	if (!dataUrl.startsWith("data:") || comma === -1) throw new Error("windmill-chat: an attachment given as a string must be a data: URL");
+	const header = dataUrl.slice(5, comma);
+	const isBase64 = header.endsWith(";base64");
+	const mediaType = (isBase64 ? header.slice(0, -7) : header) || fallbackType;
+	const payload = dataUrl.slice(comma + 1);
+	if (!isBase64) return new Blob([decodeURIComponent(payload)], { type: mediaType });
+	const binary = atob(payload);
+	const bytes = new Uint8Array(binary.length);
+	for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+	return new Blob([bytes], { type: mediaType });
+}
+/**
+* Put each attachment in the workspace's object storage and hand back what the agent reads.
+* The key's turn prefix and per-file index keep two files with the same name, in this turn or
+* an earlier one, from overwriting each other; the name stays the last segment.
+*/
+async function uploadAttachments(api, attachments, turnId, signal) {
+	const prefix = `${CHAT_UPLOADS_PREFIX}/${turnId}`;
+	if (signal?.aborted) throw abortError();
+	const batch = new AbortController();
+	const abortBatch = () => batch.abort();
+	signal?.addEventListener("abort", abortBatch, { once: true });
+	try {
+		const results = await Promise.allSettled(attachments.map(async (attachment, index) => {
+			try {
+				const blob = attachmentBlob(attachment);
+				const filename = storedAttachmentName(attachment.name || `attachment-${index + 1}`, blob.type);
+				const { file_key } = await api.uploadFile(`${prefix}/${index}/${filename}`, blob, {
+					contentType: blob.type,
+					signal: batch.signal
+				});
+				return {
+					s3: file_key,
+					filename
+				};
+			} catch (e) {
+				batch.abort();
+				throw e;
+			}
+		}));
+		const reasons = results.flatMap((r) => r.status === "rejected" ? [r.reason] : []);
+		if (reasons.length === 0 && !signal?.aborted) return results.flatMap((r) => r.status === "fulfilled" ? [r.value] : []);
+		throw reasons.find((reason) => !isAbortError(reason)) ?? reasons[0] ?? abortError();
+	} finally {
+		signal?.removeEventListener("abort", abortBatch);
+	}
+}
+//#endregion
+//#region src/chat.ts
+const POLL_INTERVAL_MS = 1e3;
+/** Local history mirrors the state; a stream of deltas is coalesced into one write. */
+const PERSIST_DEBOUNCE_MS = 250;
+/** Messages persist from spawned tasks that can land just after the flow completes. */
+const RECONCILE_ATTEMPTS = 3;
+const RECONCILE_DELAY_MS = 400;
+/** Rows per read of what a turn wrote; a fuller page is read on from its last row. */
+const ROWS_PAGE = 100;
+function createChat(options) {
+	return new ChatImpl(options);
+}
+var _config = /* @__PURE__ */ new WeakMap();
+var _api = /* @__PURE__ */ new WeakMap();
+var _local = /* @__PURE__ */ new WeakMap();
+var _listeners = /* @__PURE__ */ new WeakMap();
+var _state = /* @__PURE__ */ new WeakMap();
+var _turn = /* @__PURE__ */ new WeakMap();
+var _page = /* @__PURE__ */ new WeakMap();
+var _conversationKind = /* @__PURE__ */ new WeakMap();
+var _persistTimer = /* @__PURE__ */ new WeakMap();
+var _selecting = /* @__PURE__ */ new WeakMap();
+var _epoch = /* @__PURE__ */ new WeakMap();
+var _ChatImpl_brand = /* @__PURE__ */ new WeakSet();
+var ChatImpl = class {
+	constructor(options) {
+		_classPrivateMethodInitSpec(this, _ChatImpl_brand);
+		_classPrivateFieldInitSpec(this, _config, void 0);
+		_classPrivateFieldInitSpec(this, _api, void 0);
+		_classPrivateFieldInitSpec(this, _local, void 0);
+		_classPrivateFieldInitSpec(this, _listeners, /* @__PURE__ */ new Set());
+		_classPrivateFieldInitSpec(this, _state, void 0);
+		_classPrivateFieldInitSpec(this, _turn, void 0);
+		_classPrivateFieldInitSpec(this, _page, 1);
+		_classPrivateFieldInitSpec(this, _conversationKind, void 0);
+		_classPrivateFieldInitSpec(this, _persistTimer, void 0);
+		_classPrivateFieldInitSpec(this, _selecting, Promise.resolve());
+		_classPrivateFieldInitSpec(this, _epoch, 0);
+		this.getState = () => _classPrivateFieldGet2(_state, this);
+		this.subscribe = (listener) => {
+			_classPrivateFieldGet2(_listeners, this).add(listener);
+			listener(_classPrivateFieldGet2(_state, this));
+			return () => {
+				_classPrivateFieldGet2(_listeners, this).delete(listener);
+			};
+		};
+		this.sendMessage = async (text, options = {}) => {
+			var _this$epoch;
+			const content = text.trim();
+			if (!content) {
+				if (options.attachments?.length) throw new Error("windmill-chat: attachments need a message to go with them");
+				return;
+			}
+			if (_classPrivateFieldGet2(_turn, this)) throw new Error("windmill-chat: a message is already being answered; call stop() first");
+			const attachments = options.attachments ?? [];
+			const attachmentsInput = options.attachmentsInput;
+			if (attachments.length > 0 && !attachmentsInput) throw new Error("windmill-chat: attachments need `attachmentsInput`, the flow input that takes them");
+			if (attachmentsInput && !attachmentsInput.multiple && attachments.length > 1) throw new Error(`windmill-chat: \`${attachmentsInput.name}\` holds one file; got ${attachments.length}`);
+			const isNew = _classPrivateFieldGet2(_state, this).conversationId === void 0;
+			const conversationId = _classPrivateFieldGet2(_state, this).conversationId ?? randomId();
+			const turn = {
+				controller: new AbortController(),
+				conversationId,
+				userMessageId: `pending-${randomId()}`,
+				isNew,
+				started: false,
+				withdrawn: false,
+				streamedText: false
+			};
+			_classPrivateFieldSet2(_turn, this, turn);
+			_classPrivateFieldSet2(_epoch, this, (_this$epoch = _classPrivateFieldGet2(_epoch, this), _this$epoch++, _this$epoch));
+			const timestamp = now();
+			const touched = {
+				..._classPrivateFieldGet2(_state, this).conversations.find((c) => c.id === conversationId) ?? {
+					id: conversationId,
+					title: conversationTitle(content),
+					createdAt: timestamp,
+					updatedAt: timestamp
+				},
+				updatedAt: timestamp
+			};
+			_assertClassBrand(_ChatImpl_brand, this, _set).call(this, {
+				conversationId,
+				messages: [..._classPrivateFieldGet2(_state, this).messages, {
+					id: turn.userMessageId,
+					role: "user",
+					content,
+					success: true,
+					createdAt: timestamp,
+					pending: true
+				}],
+				status: "submitted",
+				error: void 0
+			});
+			try {
+				const args = {
+					..._classPrivateFieldGet2(_config, this).inputs,
+					...options.inputs,
+					user_message: content
+				};
+				if (attachmentsInput && attachments.length > 0) {
+					const uploaded = await uploadAttachments(_classPrivateFieldGet2(_api, this), attachments, randomId(), turn.controller.signal);
+					args[attachmentsInput.name] = attachmentsInput.multiple ? uploaded : uploaded[0];
+					const carried = uploaded.map((u) => ({
+						input: attachmentsInput.name,
+						s3: u.s3,
+						filename: u.filename
+					}));
+					if (_assertClassBrand(_ChatImpl_brand, this, _turnActive).call(this, turn)) _assertClassBrand(_ChatImpl_brand, this, _set).call(this, { messages: _classPrivateFieldGet2(_state, this).messages.map((m) => m.id === turn.userMessageId ? {
+						...m,
+						attachments: carried
+					} : m) });
+				}
+				if (turn.controller.signal.aborted) throw abortError();
+				turn.started = true;
+				_assertClassBrand(_ChatImpl_brand, this, _set).call(this, { conversations: [touched, ..._classPrivateFieldGet2(_state, this).conversations.filter((c) => c.id !== conversationId)] });
+				_assertClassBrand(_ChatImpl_brand, this, _rememberConversation).call(this);
+				const context = {
+					memoryId: conversationId,
+					conversationId,
+					signal: turn.controller.signal
+				};
+				turn.jobId = _classPrivateFieldGet2(_config, this).run ? await _classPrivateFieldGet2(_config, this).run(args, context) : await _classPrivateFieldGet2(_api, this).runFlow(_classPrivateFieldGet2(_config, this).flowPath, args, context);
+			} catch (e) {
+				try {
+					if (e instanceof TurnRunningError || !turn.started) {
+						_assertClassBrand(_ChatImpl_brand, this, _withdrawTurn).call(this, turn);
+						throw e;
+					}
+					if (turn.controller.signal.aborted || isAbortError(e)) return;
+					_assertClassBrand(_ChatImpl_brand, this, _failTurn).call(this, turn, e);
+					return;
+				} finally {
+					if (_classPrivateFieldGet2(_turn, this) === turn) _classPrivateFieldSet2(_turn, this, void 0);
+				}
+			}
+			await _assertClassBrand(_ChatImpl_brand, this, _followTurn).call(this, turn, isNew);
+		};
+		this.resumeTurn = async ({ jobId, userSeq }) => {
+			var _this$epoch3;
+			const conversationId = _classPrivateFieldGet2(_state, this).conversationId;
+			if (!conversationId || _classPrivateFieldGet2(_turn, this)) return;
+			if (_classPrivateFieldGet2(_state, this).history !== "server") {
+				if (_classPrivateFieldGet2(_state, this).status === "submitted") _assertClassBrand(_ChatImpl_brand, this, _set).call(this, { status: "idle" });
+				return;
+			}
+			const turn = {
+				controller: new AbortController(),
+				conversationId,
+				userMessageId: "",
+				jobId,
+				isNew: false,
+				started: true,
+				withdrawn: false,
+				streamedText: false
+			};
+			_classPrivateFieldSet2(_turn, this, turn);
+			_classPrivateFieldSet2(_epoch, this, (_this$epoch3 = _classPrivateFieldGet2(_epoch, this), _this$epoch3++, _this$epoch3));
+			_assertClassBrand(_ChatImpl_brand, this, _set).call(this, {
+				status: "submitted",
+				error: void 0
+			});
+			try {
+				await _classPrivateFieldGet2(_selecting, this);
+				if (!_assertClassBrand(_ChatImpl_brand, this, _turnActive).call(this, turn)) return;
+				const newest = _assertClassBrand(_ChatImpl_brand, this, _latestUserAfter).call(this, userSeq);
+				if (newest) {
+					if (!newest.jobId) {
+						if (_classPrivateFieldGet2(_turn, this) === turn) _classPrivateFieldSet2(_turn, this, void 0);
+						_assertClassBrand(_ChatImpl_brand, this, _set).call(this, { status: "idle" });
+						return;
+					}
+					turn.jobId = newest.jobId;
+					userSeq = newest.seq;
+				}
+				const held = _classPrivateFieldGet2(_state, this).messages;
+				const at = held.findIndex((m) => m.seq === userSeq);
+				let user = at === -1 ? void 0 : held[at];
+				let messages = held.filter((m, i) => {
+					if (m.seq !== void 0) return m.seq < userSeq;
+					if (m.pending || m.jobId === turn.jobId) return false;
+					return m.jobId !== void 0 || at !== -1 && i < at;
+				});
+				if (user) messages = [...messages, user];
+				if (!user) {
+					const [row] = await _classPrivateFieldGet2(_api, this).listMessages(conversationId, {
+						afterSeq: userSeq - 1,
+						perPage: 1,
+						signal: turn.controller.signal
+					});
+					if (!_assertClassBrand(_ChatImpl_brand, this, _turnActive).call(this, turn)) return;
+					if (row?.created_seq !== userSeq || row.message_type !== "user") throw new Error("windmill-chat: the message that started the running turn is gone");
+					user = fromRow(row);
+					messages = [...messages, user];
+				}
+				turn.userMessageId = user.id;
+				_assertClassBrand(_ChatImpl_brand, this, _set).call(this, { messages });
+			} catch (e) {
+				if (!(turn.controller.signal.aborted || isAbortError(e))) _assertClassBrand(_ChatImpl_brand, this, _failTurn).call(this, turn, e);
+				if (_classPrivateFieldGet2(_turn, this) === turn) _classPrivateFieldSet2(_turn, this, void 0);
+				return;
+			}
+			await _assertClassBrand(_ChatImpl_brand, this, _followTurn).call(this, turn, false);
+		};
+		this.stop = async () => {
+			const turn = _classPrivateFieldGet2(_turn, this);
+			if (!turn) return;
+			_assertClassBrand(_ChatImpl_brand, this, _detachTurn).call(this);
+			if (!turn.started) {
+				_assertClassBrand(_ChatImpl_brand, this, _withdrawTurn).call(this, turn);
+				return;
+			}
+			if (_classPrivateFieldGet2(_state, this).conversationId === turn.conversationId) {
+				_assertClassBrand(_ChatImpl_brand, this, _set).call(this, {
+					messages: finalized(_classPrivateFieldGet2(_state, this).messages),
+					status: "idle"
+				});
+				_assertClassBrand(_ChatImpl_brand, this, _persistLocal).call(this);
+			}
+			if (turn.jobId) await _classPrivateFieldGet2(_api, this).cancelJob(turn.jobId).catch(() => {});
+			if (_classPrivateFieldGet2(_state, this).history !== "server") return;
+			await sleep(RECONCILE_DELAY_MS).catch(() => {});
+			if (_classPrivateFieldGet2(_turn, this) || _classPrivateFieldGet2(_state, this).conversationId !== turn.conversationId) return;
+			await _assertClassBrand(_ChatImpl_brand, this, _syncFromServer).call(this, turn.conversationId).catch(() => {});
+		};
+		this.newConversation = () => {
+			_assertClassBrand(_ChatImpl_brand, this, _leaveConversation).call(this);
+			_classPrivateFieldSet2(_page, this, 1);
+			_assertClassBrand(_ChatImpl_brand, this, _set).call(this, {
+				conversationId: void 0,
+				messages: [],
+				status: "idle",
+				error: void 0,
+				loadingMessages: false,
+				hasMoreMessages: false
+			});
+		};
+		this.selectConversation = (conversationId) => {
+			if (conversationId === _classPrivateFieldGet2(_state, this).conversationId) return _classPrivateFieldGet2(_selecting, this);
+			const selecting = _assertClassBrand(_ChatImpl_brand, this, _select).call(this, conversationId);
+			_classPrivateFieldSet2(_selecting, this, selecting.catch(() => {}));
+			return selecting;
+		};
+		this.loadConversations = async (options = {}) => {
+			const page = options.page ?? 1;
+			const kindChanged = "kind" in options && options.kind !== _classPrivateFieldGet2(_conversationKind, this);
+			if ("kind" in options) _classPrivateFieldSet2(_conversationKind, this, options.kind);
+			const kind = _classPrivateFieldGet2(_conversationKind, this);
+			let conversations;
+			if (_classPrivateFieldGet2(_state, this).history === "server") try {
+				conversations = (await _classPrivateFieldGet2(_api, this).listConversations(_classPrivateFieldGet2(_config, this).flowPath, {
+					page,
+					perPage: options.perPage ?? _classPrivateFieldGet2(_config, this).pageSize,
+					kind
+				})).map(fromConversation);
+			} catch (e) {
+				if (!_assertClassBrand(_ChatImpl_brand, this, _fallBackToLocal).call(this, e)) throw e;
+				conversations = _classPrivateFieldGet2(_local, this).listConversations();
+			}
+			else conversations = _classPrivateFieldGet2(_state, this).history === "local" ? _classPrivateFieldGet2(_local, this).listConversations() : [];
+			if (kind !== _classPrivateFieldGet2(_conversationKind, this)) return conversations;
+			const known = new Set(_classPrivateFieldGet2(_state, this).conversations.map((c) => c.id));
+			_assertClassBrand(_ChatImpl_brand, this, _set).call(this, { conversations: page === 1 || kindChanged ? conversations : [..._classPrivateFieldGet2(_state, this).conversations, ...conversations.filter((c) => !known.has(c.id))] });
+			return conversations;
+		};
+		this.deleteConversation = async (conversationId) => {
+			if (_classPrivateFieldGet2(_state, this).conversationId === conversationId) {
+				_assertClassBrand(_ChatImpl_brand, this, _detachTurn).call(this);
+				clearTimeout(_classPrivateFieldGet2(_persistTimer, this));
+				_classPrivateFieldSet2(_persistTimer, this, void 0);
+				this.newConversation();
+			}
+			if (_classPrivateFieldGet2(_state, this).history === "server") await _classPrivateFieldGet2(_api, this).deleteConversation(conversationId);
+			else if (_classPrivateFieldGet2(_state, this).history === "local") _classPrivateFieldGet2(_local, this).deleteConversation(conversationId);
+			_assertClassBrand(_ChatImpl_brand, this, _set).call(this, { conversations: _classPrivateFieldGet2(_state, this).conversations.filter((c) => c.id !== conversationId) });
+		};
+		this.renameConversation = async (conversationId, title) => {
+			const trimmed = truncateTitle(title.trim());
+			if (!trimmed) return;
+			if (_classPrivateFieldGet2(_state, this).history === "server") await _classPrivateFieldGet2(_api, this).renameConversation(conversationId, trimmed);
+			else if (_classPrivateFieldGet2(_state, this).history === "local") _classPrivateFieldGet2(_local, this).renameConversation(conversationId, trimmed);
+			_assertClassBrand(_ChatImpl_brand, this, _set).call(this, { conversations: _classPrivateFieldGet2(_state, this).conversations.map((c) => c.id === conversationId ? {
+				...c,
+				title: trimmed
+			} : c) });
+		};
+		this.loadOlderMessages = async () => {
+			const conversationId = _classPrivateFieldGet2(_state, this).conversationId;
+			if (!conversationId || _classPrivateFieldGet2(_state, this).history !== "server" || !_classPrivateFieldGet2(_state, this).hasMoreMessages || _classPrivateFieldGet2(_state, this).loadingMessages) return;
+			const page = _classPrivateFieldGet2(_page, this) + 1;
+			_assertClassBrand(_ChatImpl_brand, this, _set).call(this, { loadingMessages: true });
+			try {
+				const rows = await _classPrivateFieldGet2(_api, this).listMessages(conversationId, {
+					page,
+					perPage: _classPrivateFieldGet2(_config, this).pageSize
+				});
+				if (_classPrivateFieldGet2(_state, this).conversationId !== conversationId) return;
+				const known = new Set(_classPrivateFieldGet2(_state, this).messages.map((m) => m.serverId ?? m.id));
+				const oldest = _classPrivateFieldGet2(_state, this).messages.reduce((min, m) => m.seq !== void 0 && (min === void 0 || m.seq < min) ? m.seq : min, void 0);
+				const older = rows.map(fromRow).filter((m) => !known.has(m.id) && (oldest === void 0 || m.seq < oldest));
+				_classPrivateFieldSet2(_page, this, page);
+				_assertClassBrand(_ChatImpl_brand, this, _set).call(this, {
+					messages: [...older, ..._classPrivateFieldGet2(_state, this).messages],
+					hasMoreMessages: rows.length === _classPrivateFieldGet2(_config, this).pageSize
+				});
+			} finally {
+				if (_classPrivateFieldGet2(_state, this).conversationId === conversationId) _assertClassBrand(_ChatImpl_brand, this, _set).call(this, { loadingMessages: false });
+			}
+		};
+		this.refreshMessages = async () => {
+			const conversationId = _classPrivateFieldGet2(_state, this).conversationId;
+			if (!conversationId || _classPrivateFieldGet2(_turn, this) || _classPrivateFieldGet2(_state, this).history !== "server" || _classPrivateFieldGet2(_state, this).loadingMessages) return;
+			const newestBefore = latestSeq(_classPrivateFieldGet2(_state, this).messages);
+			const failure = lastFailureShown(_classPrivateFieldGet2(_state, this).messages);
+			const epoch = _classPrivateFieldGet2(_epoch, this);
+			await _assertClassBrand(_ChatImpl_brand, this, _syncFromServer).call(this, conversationId, () => _classPrivateFieldGet2(_epoch, this) === epoch);
+			if (_classPrivateFieldGet2(_epoch, this) !== epoch) return;
+			if (!failure || _classPrivateFieldGet2(_state, this).conversationId !== conversationId) return;
+			if (!_classPrivateFieldGet2(_state, this).messages.some((m) => m.id === failure.id)) return;
+			const jobs = failure.jobId ? await _assertClassBrand(_ChatImpl_brand, this, _turnJobIds).call(this, failure.jobId) : void 0;
+			if (_classPrivateFieldGet2(_state, this).conversationId !== conversationId) return;
+			const held = _classPrivateFieldGet2(_state, this).messages;
+			if (!held.some((m) => m.id === failure.id)) return;
+			if (!held.some((m) => m.seq !== void 0 && m.seq > newestBefore && m.role === "assistant" && m.success && (jobs === void 0 || m.jobId === void 0 || jobs.has(m.jobId)))) return;
+			const settles = _classPrivateFieldGet2(_state, this).status === "error" && lastFailureShown(held)?.id === failure.id;
+			_assertClassBrand(_ChatImpl_brand, this, _set).call(this, {
+				messages: held.filter((m) => m.id !== failure.id),
+				...settles ? {
+					status: "idle",
+					error: void 0
+				} : {}
+			});
+		};
+		this.destroy = () => {
+			_assertClassBrand(_ChatImpl_brand, this, _leaveConversation).call(this);
+		};
+		_classPrivateFieldSet2(_config, this, resolveConfig(options));
+		_classPrivateFieldSet2(_api, this, new WindmillChatApi({
+			baseUrl: _classPrivateFieldGet2(_config, this).baseUrl,
+			workspace: _classPrivateFieldGet2(_config, this).workspace,
+			token: _classPrivateFieldGet2(_config, this).token,
+			fetch: _classPrivateFieldGet2(_config, this).fetch,
+			pollDelayMs: _classPrivateFieldGet2(_config, this).pollDelayMs
+		}));
+		_classPrivateFieldSet2(_local, this, createLocalHistory(_classPrivateFieldGet2(_config, this).storage, `windmill-chat:${_classPrivateFieldGet2(_config, this).baseUrl}:${_classPrivateFieldGet2(_config, this).workspace}:${_classPrivateFieldGet2(_config, this).flowPath}` + (_classPrivateFieldGet2(_config, this).storageKey ? `:${_classPrivateFieldGet2(_config, this).storageKey}` : "")));
+		_classPrivateFieldSet2(_state, this, {
+			conversationId: void 0,
+			messages: [],
+			status: "idle",
+			error: void 0,
+			conversations: [],
+			history: _classPrivateFieldGet2(_config, this).history,
+			loadingMessages: false,
+			hasMoreMessages: false
+		});
+	}
+};
+async function _followTurn(turn, isNew) {
+	let nextTurn;
+	try {
+		const stopPolling = _classPrivateFieldGet2(_state, this).history === "server" ? _assertClassBrand(_ChatImpl_brand, this, _startPolling).call(this, turn) : () => {};
+		let result;
+		try {
+			result = await _assertClassBrand(_ChatImpl_brand, this, _follow).call(this, turn, stopPolling);
+		} finally {
+			stopPolling();
+		}
+		nextTurn = await _assertClassBrand(_ChatImpl_brand, this, _finishTurn).call(this, turn, result, isNew);
+	} catch (e) {
+		if (!turn.started) {
+			if (_classPrivateFieldGet2(_turn, this) === turn) _classPrivateFieldSet2(_turn, this, void 0);
+			_assertClassBrand(_ChatImpl_brand, this, _withdrawTurn).call(this, turn);
+			throw e;
+		}
+		if (turn.controller.signal.aborted || isAbortError(e)) return;
+		_assertClassBrand(_ChatImpl_brand, this, _failTurn).call(this, turn, e);
+	} finally {
+		if (_classPrivateFieldGet2(_turn, this) === turn) _classPrivateFieldSet2(_turn, this, void 0);
+	}
+	if (nextTurn) await this.resumeTurn(nextTurn);
+}
+async function _select(conversationId) {
+	_assertClassBrand(_ChatImpl_brand, this, _leaveConversation).call(this);
+	_classPrivateFieldSet2(_page, this, 1);
+	_assertClassBrand(_ChatImpl_brand, this, _set).call(this, {
+		conversationId,
+		messages: [],
+		status: "idle",
+		error: void 0,
+		loadingMessages: true,
+		hasMoreMessages: false
+	});
+	if (_classPrivateFieldGet2(_state, this).history !== "server") {
+		_assertClassBrand(_ChatImpl_brand, this, _set).call(this, {
+			messages: _classPrivateFieldGet2(_state, this).history === "local" ? _classPrivateFieldGet2(_local, this).getMessages(conversationId) : [],
+			loadingMessages: false
+		});
+		return;
+	}
+	try {
+		const rows = await _classPrivateFieldGet2(_api, this).listMessages(conversationId, { perPage: _classPrivateFieldGet2(_config, this).pageSize });
+		if (_classPrivateFieldGet2(_state, this).conversationId !== conversationId) return;
+		_assertClassBrand(_ChatImpl_brand, this, _set).call(this, {
+			messages: rows.map(fromRow),
+			loadingMessages: false,
+			hasMoreMessages: rows.length === _classPrivateFieldGet2(_config, this).pageSize
+		});
+	} catch (e) {
+		if (_classPrivateFieldGet2(_state, this).conversationId !== conversationId) return;
+		if (_assertClassBrand(_ChatImpl_brand, this, _fallBackToLocal).call(this, e)) {
+			_assertClassBrand(_ChatImpl_brand, this, _set).call(this, {
+				messages: _classPrivateFieldGet2(_local, this).getMessages(conversationId),
+				loadingMessages: false
+			});
+			return;
+		}
+		_assertClassBrand(_ChatImpl_brand, this, _set).call(this, {
+			loadingMessages: false,
+			status: "error",
+			error: toError(e)
+		});
+	}
+}
+async function _follow(turn, onStreamStart) {
+	let started = false;
+	for await (const event of followJob(_classPrivateFieldGet2(_api, this), turn.jobId, { signal: turn.controller.signal })) {
+		if (event.type === "completed") {
+			if (event.streamLost) _assertClassBrand(_ChatImpl_brand, this, _dropCutRound).call(this, turn);
+			return event.result;
+		}
+		if (!started) {
+			started = true;
+			onStreamStart();
+		}
+		_assertClassBrand(_ChatImpl_brand, this, _applyEvents).call(this, turn, event.events);
+	}
+	throw new Error("windmill-chat: the job stream ended before the flow completed");
+}
+/**
+* The stream failed while a round's text was arriving, so that text stops wherever the
+* connection did. It goes: the persisted rows or, without them, the flow result give
+* the whole answer instead. Rounds a tool call closed were complete and stay.
+*/
+function _dropCutRound(turn) {
+	if (!_assertClassBrand(_ChatImpl_brand, this, _turnActive).call(this, turn)) return;
+	const cut = turn.assistantId;
+	turn.assistantId = void 0;
+	turn.streamedText = false;
+	if (cut) _assertClassBrand(_ChatImpl_brand, this, _set).call(this, { messages: _classPrivateFieldGet2(_state, this).messages.filter((m) => m.id !== cut) });
+}
+function _applyEvents(turn, events) {
+	if (events.length === 0 || !_assertClassBrand(_ChatImpl_brand, this, _turnActive).call(this, turn)) return;
+	let messages = [..._classPrivateFieldGet2(_state, this).messages];
+	const upsertTool = (callId, name, patch) => {
+		const { content, success, ...toolPatch } = patch;
+		const i = messages.findIndex((m) => m.pending && m.role === "tool" && m.tool?.callId === callId);
+		if (i >= 0) {
+			const existing = messages[i];
+			messages[i] = {
+				...existing,
+				content: content ?? existing.content,
+				success: success ?? existing.success,
+				tool: {
+					...existing.tool,
+					...toolPatch
+				}
+			};
+		} else {
+			const a = turn.assistantId ? messages.findIndex((m) => m.id === turn.assistantId) : -1;
+			const reasoning = a >= 0 && messages[a].content === "" ? messages.splice(a, 1)[0].reasoning : void 0;
+			messages.push({
+				id: `pending-${randomId()}`,
+				role: "tool",
+				content: content ?? "",
+				reasoning,
+				success: success ?? true,
+				createdAt: now(),
+				pending: true,
+				tool: {
+					callId,
+					name,
+					status: "running",
+					...toolPatch
+				}
+			});
+		}
+		turn.assistantId = void 0;
+	};
+	const appendAssistant = (text, reasoning) => {
+		const i = turn.assistantId ? messages.findIndex((m) => m.id === turn.assistantId) : -1;
+		if (i >= 0) {
+			const m = messages[i];
+			messages[i] = {
+				...m,
+				content: m.content + text,
+				reasoning: reasoning ? (m.reasoning ?? "") + reasoning : m.reasoning
+			};
+		} else {
+			turn.assistantId = `pending-${randomId()}`;
+			messages.push({
+				id: turn.assistantId,
+				role: "assistant",
+				content: text,
+				reasoning: reasoning || void 0,
+				success: true,
+				createdAt: now(),
+				pending: true
+			});
+		}
+	};
+	for (const event of events) switch (event.type) {
+		case "token_delta":
+			turn.streamedText = true;
+			appendAssistant(event.content, "");
+			break;
+		case "reasoning_token_delta":
+			appendAssistant("", event.content);
+			break;
+		case "tool_call":
+			upsertTool(event.call_id, event.function_name, { status: "running" });
+			break;
+		case "tool_call_arguments":
+			upsertTool(event.call_id, event.function_name, { arguments: event.arguments });
+			break;
+		case "tool_execution":
+			upsertTool(event.call_id, event.function_name, { status: "running" });
+			break;
+		case "tool_result": upsertTool(event.call_id, event.function_name, {
+			status: event.success ? "success" : "error",
+			result: event.result,
+			success: event.success,
+			content: event.success ? `Used ${event.function_name} tool` : `Error executing ${event.function_name}`
+		});
+	}
+	_assertClassBrand(_ChatImpl_brand, this, _set).call(this, {
+		messages,
+		status: "streaming"
+	});
+}
+async function _finishTurn(turn, result, isNew) {
+	if (!_assertClassBrand(_ChatImpl_brand, this, _turnActive).call(this, turn)) return;
+	if (_classPrivateFieldGet2(_state, this).history === "server") {
+		turn.jobIds = await _assertClassBrand(_ChatImpl_brand, this, _turnJobIds).call(this, turn.jobId, turn.controller.signal);
+		if (!_assertClassBrand(_ChatImpl_brand, this, _turnActive).call(this, turn)) return;
+		const reconciled = await _assertClassBrand(_ChatImpl_brand, this, _reconcileTurn).call(this, turn);
+		if (!_assertClassBrand(_ChatImpl_brand, this, _turnActive).call(this, turn)) return;
+		if (reconciled) {
+			const nextTurn = _assertClassBrand(_ChatImpl_brand, this, _nextTurnAfter).call(this, turn);
+			_assertClassBrand(_ChatImpl_brand, this, _set).call(this, { status: nextTurn ? "submitted" : "idle" });
+			_classPrivateFieldGet2(_config, this).onFinish?.({
+				conversationId: turn.conversationId,
+				jobId: turn.jobId,
+				messages: _classPrivateFieldGet2(_state, this).messages
+			});
+			if (isNew) await this.loadConversations().catch(() => {});
+			if (!_assertClassBrand(_ChatImpl_brand, this, _turnActive).call(this, turn)) return;
+			return nextTurn;
+		}
+	}
+	let messages = _classPrivateFieldGet2(_state, this).messages;
+	let failed = false;
+	if (isErrorResult(result)) {
+		failed = await _classPrivateFieldGet2(_api, this).getCompletedResult(turn.jobId, turn.controller.signal).then((r) => r.success === false).catch(() => true);
+		if (!_assertClassBrand(_ChatImpl_brand, this, _turnActive).call(this, turn)) return;
+		if (failed) messages = [...messages, assistantMessage(errorResultMessage(result), false, turn.jobId)];
+	}
+	if (!failed && !turn.streamedText) {
+		const answer = extractChatAnswer(result);
+		if (answer !== void 0) messages = [...messages, assistantMessage(answer, true, turn.jobId)];
+	}
+	const nextTurn = _classPrivateFieldGet2(_state, this).history === "server" ? _assertClassBrand(_ChatImpl_brand, this, _nextTurnAfter).call(this, turn) : void 0;
+	_assertClassBrand(_ChatImpl_brand, this, _set).call(this, {
+		messages: finalized(messages),
+		status: nextTurn ? "submitted" : "idle"
+	});
+	_assertClassBrand(_ChatImpl_brand, this, _persistLocal).call(this);
+	_classPrivateFieldGet2(_config, this).onFinish?.({
+		conversationId: turn.conversationId,
+		jobId: turn.jobId,
+		messages: _classPrivateFieldGet2(_state, this).messages
+	});
+	if (!_assertClassBrand(_ChatImpl_brand, this, _turnActive).call(this, turn)) return;
+	return nextTurn;
+}
+/**
+* Folds what the server persisted for the turn into the message list. The rows
+* are written by the worker in their own transactions, each of which can trail
+* the flow's completion, so a streamed message whose row hasn't landed stays and
+* the list is re-read a few times before the rest is kept as streamed.
+* Returns false when the server holds no answer for the turn: history fell back to
+* local, the read was refused or kept failing, or no assistant row has landed. The
+* caller then finishes the turn from the flow result, so an answer is never lost
+* to history. Whether a row counts is read from the message list, not from what
+* this read returned: the turn's polling may have merged the answer already.
+*/
+async function _reconcileTurn(turn) {
+	const answered = () => _assertClassBrand(_ChatImpl_brand, this, _answered).call(this, turn);
+	for (let attempt = 1; attempt <= RECONCILE_ATTEMPTS; attempt++) {
+		let rows;
+		try {
+			rows = await _assertClassBrand(_ChatImpl_brand, this, _rowsAfterLastSeq).call(this, turn.conversationId, turn.controller.signal);
+		} catch (e) {
+			if (isAbortError(e)) throw e;
+			if (_assertClassBrand(_ChatImpl_brand, this, _fallBackToLocal).call(this, e)) return false;
+			if (e instanceof WindmillApiError && (e.status === 401 || e.status === 403) || attempt === RECONCILE_ATTEMPTS) return answered();
+			await sleep(RECONCILE_DELAY_MS, turn.controller.signal);
+			continue;
+		}
+		if (!_assertClassBrand(_ChatImpl_brand, this, _turnActive).call(this, turn)) return true;
+		_assertClassBrand(_ChatImpl_brand, this, _mergeRows).call(this, rows);
+		if (answered() && !_classPrivateFieldGet2(_state, this).messages.some((m) => m.pending && m.content)) break;
+		if (attempt < RECONCILE_ATTEMPTS) await sleep(RECONCILE_DELAY_MS, turn.controller.signal);
+	}
+	if (!_assertClassBrand(_ChatImpl_brand, this, _turnActive).call(this, turn)) return true;
+	_assertClassBrand(_ChatImpl_brand, this, _set).call(this, { messages: finalized(_classPrivateFieldGet2(_state, this).messages) });
+	return answered();
+}
+/**
+* The latest row the turn persisted after its user message is an assistant
+* message. An agent issues each round's text row before that round's tool rows,
+* and a tool row when the tool finishes, so an earlier round's text is followed
+* by a tool row and only the answer closes the turn (the inserts are spawned, so
+* a badly delayed one can invert that order at the cost of the reconcile
+* retries). The content is not compared with the flow result: an image answer, a
+* structured one and a forwarded agent result are all persisted in a shape the
+* result does not reproduce. A row belongs to the turn when it was created after
+* the user message and, when it carries a job id, the job is one of the turn's. The
+* server refuses a turn while the previous run is queued, but an agent writes its
+* answer row from a task the run does not wait for, so that row can still land after
+* the next user message; its job says whose it is. A tool row without a job (an MCP
+* call runs inside the agent step) belongs to the turn under way. Until the user
+* message's own row has been read, its position in the list stands in for its seq.
+*/
+function _answered(turn) {
+	const messages = _classPrivateFieldGet2(_state, this).messages;
+	const from = messages.findIndex((m) => m.id === turn.userMessageId);
+	const userSeq = messages[from]?.seq;
+	const ownJob = (m) => turn.jobIds === void 0 || (m.jobId === void 0 ? m.role === "tool" : turn.jobIds.has(m.jobId));
+	let latest;
+	messages.forEach((m, i) => {
+		if (m.seq === void 0 || m.role === "user" || !ownJob(m)) return;
+		if (userSeq !== void 0 ? m.seq <= userSeq : i <= from) return;
+		if (latest === void 0 || m.seq > latest.seq) latest = m;
+	});
+	return latest?.role === "assistant";
+}
+/**
+* The flow job plus every step job it ran, the failure and preprocessor steps
+* included (a failure handler's answer is persisted under its own job), and the
+* jobs an agent step's tool calls ran as (a tool row is persisted under its own
+* job too). A failed read is retried like the rows are; unknown when it keeps
+* failing or the credential may not read jobs. Unknown accepts every row after the
+* question: refusing them would leave a token without job access with no turn ever
+* answered, each one finished a second time from its result.
+*/
+async function _turnJobIds(jobId, signal) {
+	for (let attempt = 1;; attempt++) try {
+		const job = await _classPrivateFieldGet2(_api, this).getFlowJob(jobId, signal);
+		const ids = /* @__PURE__ */ new Set([jobId]);
+		const status = job.flow_status;
+		for (const m of [
+			...status?.modules ?? [],
+			status?.failure_module,
+			status?.preprocessor_module
+		]) {
+			if (m?.job) ids.add(m.job);
+			for (const j of m?.flow_jobs ?? []) ids.add(j);
+			for (const a of m?.agent_actions ?? []) if (a.job_id) ids.add(a.job_id);
+		}
+		return ids;
+	} catch (e) {
+		if (isAbortError(e)) throw e;
+		if (e instanceof WindmillApiError && e.status >= 400 && e.status < 500 || attempt === RECONCILE_ATTEMPTS) return void 0;
+		await sleep(RECONCILE_DELAY_MS, signal);
+	}
+}
+/**
+* Take back the user message of a turn that never ran. A conversation it would have opened
+* was never listed (see `sendMessage`), so only the message goes, and, while it is the turn
+* on screen, the busy status. A switch away mid-upload has already written the message to
+* local history, so it is removed there too.
+*/
+function _withdrawTurn(turn) {
+	if (turn.withdrawn) return;
+	turn.withdrawn = true;
+	const id = turn.conversationId;
+	const withoutTurn = (messages) => messages.filter((m) => m.id !== turn.userMessageId);
+	if (_classPrivateFieldGet2(_state, this).conversationId === id) {
+		const messages = withoutTurn(_classPrivateFieldGet2(_state, this).messages);
+		if (_classPrivateFieldGet2(_turn, this) !== void 0 && _classPrivateFieldGet2(_turn, this) !== turn) _assertClassBrand(_ChatImpl_brand, this, _set).call(this, { messages });
+		else {
+			const unopened = turn.isNew && messages.length === 0;
+			_assertClassBrand(_ChatImpl_brand, this, _set).call(this, {
+				messages,
+				status: "idle",
+				error: void 0,
+				...unopened ? { conversationId: void 0 } : {}
+			});
+		}
+		_assertClassBrand(_ChatImpl_brand, this, _persistLocal).call(this);
+	}
+	if (_classPrivateFieldGet2(_state, this).history === "local" && _classPrivateFieldGet2(_state, this).conversationId !== id) {
+		const stored = withoutTurn(_classPrivateFieldGet2(_local, this).getMessages(id));
+		if (stored.length > 0) _classPrivateFieldGet2(_local, this).saveMessages(id, stored);
+		else if (!_classPrivateFieldGet2(_state, this).conversations.some((c) => c.id === id)) _classPrivateFieldGet2(_local, this).deleteConversation(id);
+	}
+}
+function _failTurn(turn, e) {
+	if (!_assertClassBrand(_ChatImpl_brand, this, _turnActive).call(this, turn)) return;
+	const error = toError(e);
+	_assertClassBrand(_ChatImpl_brand, this, _set).call(this, {
+		messages: [...finalized(_classPrivateFieldGet2(_state, this).messages), assistantMessage(error.message, false, turn.jobId)],
+		status: "error",
+		error
+	});
+	_assertClassBrand(_ChatImpl_brand, this, _persistLocal).call(this);
+	_classPrivateFieldGet2(_config, this).onError?.(error, {
+		conversationId: turn.conversationId,
+		jobId: turn.jobId
+	});
+}
+/** Before the answer streams, earlier steps may already have persisted messages. */
+function _startPolling(turn) {
+	let stopped = false;
+	const { signal } = turn.controller;
+	const loop = async () => {
+		while (!stopped) {
+			try {
+				await sleep(POLL_INTERVAL_MS, signal);
+			} catch {
+				return;
+			}
+			if (stopped) return;
+			try {
+				const rows = await _assertClassBrand(_ChatImpl_brand, this, _rowsAfterLastSeq).call(this, turn.conversationId, signal);
+				if (!stopped && _assertClassBrand(_ChatImpl_brand, this, _turnActive).call(this, turn)) _assertClassBrand(_ChatImpl_brand, this, _mergeRows).call(this, rows);
+			} catch {}
+		}
+	};
+	loop();
+	return () => {
+		stopped = true;
+	};
+}
+/** Every row created after the newest one held, however many pages that takes. */
+async function _rowsAfterLastSeq(conversationId, signal) {
+	const rows = [];
+	let afterSeq = _assertClassBrand(_ChatImpl_brand, this, _lastSeq).call(this);
+	while (true) {
+		const page = await _classPrivateFieldGet2(_api, this).listMessages(conversationId, {
+			afterSeq,
+			perPage: ROWS_PAGE,
+			signal
+		});
+		rows.push(...page);
+		if (page.length < ROWS_PAGE) return rows;
+		afterSeq = page[page.length - 1].created_seq;
+	}
+}
+async function _syncFromServer(conversationId, stillCurrent) {
+	const rows = await _assertClassBrand(_ChatImpl_brand, this, _rowsAfterLastSeq).call(this, conversationId);
+	if (_classPrivateFieldGet2(_turn, this) || _classPrivateFieldGet2(_state, this).conversationId !== conversationId) return;
+	if (stillCurrent && !stillCurrent()) return;
+	_assertClassBrand(_ChatImpl_brand, this, _mergeRows).call(this, rows);
+	_assertClassBrand(_ChatImpl_brand, this, _set).call(this, { messages: finalized(_classPrivateFieldGet2(_state, this).messages) });
+}
+/**
+* Folds persisted rows into the message list. A row standing for a message the
+* client already shows (same role and text; for a tool, the same tool name, since
+* the server words a failure differently) takes its place under the client's id
+* and keeps what only the stream knew: reasoning, call id, arguments, result.
+* Other rows append in server order. Nothing is dropped: a streamed message
+* outlives a row that never lands.
+*/
+function _mergeRows(rows) {
+	if (rows.length === 0) return;
+	const messages = [..._classPrivateFieldGet2(_state, this).messages];
+	const known = new Set(messages.map((m) => m.serverId ?? m.id));
+	for (const row of rows.map(fromRow)) {
+		if (known.has(row.id)) continue;
+		known.add(row.id);
+		let i = messages.findIndex((m) => m.seq === void 0 && m.role === row.role && (m.content === row.content || row.tool !== void 0 && m.tool?.name === row.tool.name));
+		if (i < 0 && row.role === "assistant") {
+			let j = messages.length - 1;
+			while (j >= 0 && messages[j].role !== "user") {
+				const m = messages[j];
+				if (m.seq === void 0 && m.role === "tool" && m.tool?.arguments === row.content) i = j;
+				j--;
+			}
+		}
+		if (i >= 0) {
+			const m = messages[i];
+			messages[i] = {
+				...row,
+				id: m.id,
+				reasoning: m.reasoning ?? row.reasoning,
+				tool: row.role === "tool" && m.tool ? {
+					...m.tool,
+					arguments: m.tool.arguments ?? row.tool?.arguments,
+					result: m.tool.result ?? row.tool?.result,
+					status: row.tool?.status ?? m.tool.status
+				} : row.tool
+			};
+		} else {
+			let at = messages.length;
+			for (let j = messages.length - 1; row.role === "tool" && j >= 0; j--) {
+				const seq = messages[j].seq;
+				if (seq !== void 0 && seq < row.seq) {
+					at = j + 1;
+					break;
+				}
+			}
+			messages.splice(at, 0, row);
+		}
+	}
+	_assertClassBrand(_ChatImpl_brand, this, _set).call(this, { messages });
+}
+function _lastSeq() {
+	let last;
+	for (const m of _classPrivateFieldGet2(_state, this).messages) if (m.seq !== void 0 && (last === void 0 || m.seq > last)) last = m.seq;
+	return last;
+}
+/** Writes the current messages to local history; the conversation entry itself is `#rememberConversation`'s. */
+function _persistLocal() {
+	clearTimeout(_classPrivateFieldGet2(_persistTimer, this));
+	_classPrivateFieldSet2(_persistTimer, this, void 0);
+	const id = _classPrivateFieldGet2(_state, this).conversationId;
+	if (_classPrivateFieldGet2(_state, this).history !== "local" || !id) return;
+	_classPrivateFieldGet2(_local, this).saveMessages(id, _classPrivateFieldGet2(_state, this).messages);
+}
+/**
+* Puts the current conversation at the head of local history. Only a turn moves
+* a conversation there: merely viewing one must not reorder the list.
+*/
+function _rememberConversation() {
+	const id = _classPrivateFieldGet2(_state, this).conversationId;
+	if (_classPrivateFieldGet2(_state, this).history !== "local" || !id) return;
+	const conversation = _classPrivateFieldGet2(_state, this).conversations.find((c) => c.id === id);
+	if (conversation) _classPrivateFieldGet2(_local, this).upsertConversation(conversation);
+}
+/** Whether an unreadable server history should silently become local history. */
+function _fallBackToLocal(e) {
+	if (_classPrivateFieldGet2(_state, this).history !== "server" || _classPrivateFieldGet2(_config, this).historyExplicit) return false;
+	if (e instanceof WindmillApiError && (e.status === 401 || e.status === 403)) {
+		_assertClassBrand(_ChatImpl_brand, this, _set).call(this, { history: "local" });
+		_assertClassBrand(_ChatImpl_brand, this, _rememberConversation).call(this);
+		return true;
+	}
+	return false;
+}
+function _turnActive(turn) {
+	return _classPrivateFieldGet2(_turn, this) === turn && _classPrivateFieldGet2(_state, this).conversationId === turn.conversationId;
+}
+function _latestUserAfter(userSeq) {
+	return _classPrivateFieldGet2(_state, this).messages.reduce((found, message) => message.role === "user" && message.seq !== void 0 && message.seq > (found?.seq ?? userSeq) ? message : found, void 0);
+}
+function _nextTurnAfter(turn) {
+	const userSeq = _classPrivateFieldGet2(_state, this).messages.find((message) => message.id === turn.userMessageId)?.seq;
+	if (userSeq === void 0) return void 0;
+	const next = _assertClassBrand(_ChatImpl_brand, this, _latestUserAfter).call(this, userSeq);
+	return next?.jobId && next.seq !== void 0 ? {
+		jobId: next.jobId,
+		userSeq: next.seq
+	} : void 0;
+}
+/** Stops following the current answer; the flow itself keeps running. */
+function _detachTurn() {
+	const turn = _classPrivateFieldGet2(_turn, this);
+	if (!turn) return;
+	_classPrivateFieldSet2(_turn, this, void 0);
+	turn.controller.abort();
+}
+/**
+* Leaves the current conversation (for another one, or because the page goes
+* away). A turn still in flight is detached and what it showed so far is kept,
+* written out now rather than on the debounce that may never fire.
+*/
+function _leaveConversation() {
+	var _this$epoch5;
+	_classPrivateFieldSet2(_epoch, this, (_this$epoch5 = _classPrivateFieldGet2(_epoch, this), _this$epoch5++, _this$epoch5));
+	if (_classPrivateFieldGet2(_turn, this)) {
+		_assertClassBrand(_ChatImpl_brand, this, _detachTurn).call(this);
+		_assertClassBrand(_ChatImpl_brand, this, _set).call(this, {
+			messages: finalized(_classPrivateFieldGet2(_state, this).messages),
+			status: "idle"
+		});
+	}
+	if (_classPrivateFieldGet2(_persistTimer, this)) _assertClassBrand(_ChatImpl_brand, this, _persistLocal).call(this);
+}
+function _set(patch) {
+	_classPrivateFieldSet2(_state, this, {
+		..._classPrivateFieldGet2(_state, this),
+		...patch
+	});
+	for (const listener of _classPrivateFieldGet2(_listeners, this)) listener(_classPrivateFieldGet2(_state, this));
+	if (_classPrivateFieldGet2(_state, this).history === "local" && _classPrivateFieldGet2(_state, this).conversationId) {
+		clearTimeout(_classPrivateFieldGet2(_persistTimer, this));
+		_classPrivateFieldSet2(_persistTimer, this, setTimeout(() => _assertClassBrand(_ChatImpl_brand, this, _persistLocal).call(this), PERSIST_DEBOUNCE_MS));
+	}
+}
+/** The failure this chat is showing: the message `#failTurn` left, which is never a row. */
+function lastFailureShown(messages) {
+	for (let i = messages.length - 1; i >= 0; i--) {
+		const m = messages[i];
+		if (m.seq === void 0 && m.success === false) return m;
+	}
+}
+/** The newest row seq a list holds; 0 when it holds none. */
+function latestSeq(messages) {
+	return messages.reduce((newest, m) => m.seq !== void 0 && m.seq > newest ? m.seq : newest, 0);
+}
+function fromRow(row) {
+	const toolName = row.message_type === "tool" ? /^Used (.+) tool$/.exec(row.content)?.[1] ?? /^Error executing (.+)$/.exec(row.content)?.[1] : void 0;
+	const success = row.success ?? true;
+	return {
+		id: row.id,
+		serverId: row.id,
+		role: row.message_type,
+		content: row.content,
+		success,
+		createdAt: row.created_at,
+		jobId: row.job_id ?? void 0,
+		stepName: row.step_name ?? void 0,
+		pending: false,
+		seq: row.created_seq,
+		reasoning: row.reasoning ?? void 0,
+		attachments: row.attachments ?? void 0,
+		tool: toolName ? {
+			name: toolName,
+			status: success ? "success" : "error",
+			arguments: row.tool_arguments ?? void 0,
+			result: row.tool_result ?? void 0
+		} : void 0
+	};
+}
+function fromConversation(row) {
+	return {
+		id: row.id,
+		title: row.title ?? void 0,
+		createdAt: row.created_at,
+		updatedAt: row.updated_at,
+		isTest: row.is_test,
+		runningTurn: row.running_turn ? {
+			jobId: row.running_turn.job_id,
+			userSeq: row.running_turn.user_seq
+		} : void 0
+	};
+}
+function assistantMessage(content, success, jobId) {
+	return {
+		id: `local-${randomId()}`,
+		role: "assistant",
+		content,
+		success,
+		createdAt: now(),
+		jobId,
+		pending: false
+	};
+}
+function finalized(messages) {
+	return messages.some((m) => m.pending) ? messages.map((m) => m.pending ? {
+		...m,
+		pending: false
+	} : m) : messages;
+}
+function toError(e) {
+	return e instanceof Error ? e : new Error(String(e));
+}
+//#endregion
+export { detectRawApp as a, uploadAttachments as i, CHAT_UPLOADS_PREFIX as n, storedAttachmentName as r, createChat as t };