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

package/dist/chat.d.ts

@@ -0,0 +1,2 @@
+import type { Chat, ChatOptions } from './types';
+export declare function createChat(options: ChatOptions): Chat;

package/dist/config.d.ts

@@ -0,0 +1,33 @@
+import type { ChatOptions, FetchLike, HistoryMode, StorageLike, TokenSource } from './types';
+export interface ResolvedConfig {
+    flowPath: string;
+    baseUrl: string;
+    workspace: string;
+    token: TokenSource | undefined;
+    history: HistoryMode;
+    /** The caller chose `history`; a failing server history is then an error, not a fallback. */
+    historyExplicit: boolean;
+    inputs: Record<string, unknown>;
+    fetch: FetchLike | undefined;
+    storage: StorageLike | undefined;
+    storageKey: string | undefined;
+    pageSize: number;
+    pollDelayMs: number | undefined;
+    run: ChatOptions['run'];
+    onFinish: ChatOptions['onFinish'];
+    onError: ChatOptions['onError'];
+}
+export interface RawAppContext {
+    baseUrl: string;
+    workspace: string;
+    /** The viewer's SDK token in a sandboxed raw app; the session cookie otherwise. */
+    token?: string;
+}
+/**
+ * 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`.
+ */
+export declare function detectRawApp(): RawAppContext | undefined;
+export declare function resolveConfig(options: ChatOptions): ResolvedConfig;

package/dist/follow-DXfmfPfr.js

@@ -0,0 +1,556 @@
+//#region \0@oxc-project+runtime@0.149.0/helpers/esm/checkPrivateRedeclaration.js
+function _checkPrivateRedeclaration(e, t) {
+	if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object");
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.149.0/helpers/esm/classPrivateMethodInitSpec.js
+function _classPrivateMethodInitSpec(e, a) {
+	_checkPrivateRedeclaration(e, a), a.add(e);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.149.0/helpers/esm/classPrivateFieldInitSpec.js
+function _classPrivateFieldInitSpec(e, t, a) {
+	_checkPrivateRedeclaration(e, t), t.set(e, a);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.149.0/helpers/esm/assertClassBrand.js
+function _assertClassBrand(e, t, n) {
+	if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n;
+	throw new TypeError("Private element is not present on this object");
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.149.0/helpers/esm/classPrivateFieldSet2.js
+function _classPrivateFieldSet2(s, a, r) {
+	return s.set(_assertClassBrand(s, a), r), r;
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.149.0/helpers/esm/classPrivateFieldGet2.js
+function _classPrivateFieldGet2(s, a) {
+	return s.get(_assertClassBrand(s, a));
+}
+//#endregion
+//#region src/api.ts
+var WindmillApiError = class extends Error {
+	constructor(message, status, body) {
+		super(message);
+		this.status = status;
+		this.body = body;
+		this.name = "WindmillApiError";
+	}
+};
+/**
+* A message was sent to a conversation whose turn is still running. The server refuses
+* it (409) so two runs never write one agent memory; `turn` is the run to follow instead.
+*/
+var TurnRunningError = class extends Error {
+	constructor(message, turn) {
+		super(message);
+		this.turn = turn;
+		this.name = "TurnRunningError";
+	}
+};
+/**
+* The running turn named by a run's 409 body, or undefined for any other body. Exported
+* for a custom `run` that calls Windmill through its own client: it rethrows the refusal
+* as a `TurnRunningError` so the chat can follow the running turn.
+*/
+function turnRunningError(body) {
+	try {
+		const parsed = JSON.parse(body);
+		const turn = parsed?.running_turn;
+		if (!turn || typeof turn.job_id !== "string" || typeof turn.user_seq !== "number") return void 0;
+		return new TurnRunningError(typeof parsed.error === "string" ? parsed.error : "this conversation is still answering a message", {
+			jobId: turn.job_id,
+			userSeq: turn.user_seq
+		});
+	} catch {
+		return;
+	}
+}
+var _baseUrl = /* @__PURE__ */ new WeakMap();
+var _workspace = /* @__PURE__ */ new WeakMap();
+var _token = /* @__PURE__ */ new WeakMap();
+var _fetch = /* @__PURE__ */ new WeakMap();
+var _pollDelayMs = /* @__PURE__ */ new WeakMap();
+var _WindmillChatApi_brand = /* @__PURE__ */ new WeakSet();
+/** Thin client over the Windmill endpoints a chat-mode flow uses. */
+var WindmillChatApi = class {
+	constructor(options) {
+		_classPrivateMethodInitSpec(this, _WindmillChatApi_brand);
+		_classPrivateFieldInitSpec(this, _baseUrl, void 0);
+		_classPrivateFieldInitSpec(this, _workspace, void 0);
+		_classPrivateFieldInitSpec(this, _token, void 0);
+		_classPrivateFieldInitSpec(this, _fetch, void 0);
+		_classPrivateFieldInitSpec(this, _pollDelayMs, void 0);
+		_classPrivateFieldSet2(_baseUrl, this, normalizeBaseUrl(options.baseUrl));
+		_classPrivateFieldSet2(_workspace, this, options.workspace);
+		_classPrivateFieldSet2(_token, this, options.token);
+		_classPrivateFieldSet2(_fetch, this, options.fetch ?? ((input, init) => globalThis.fetch(input, init)));
+		_classPrivateFieldSet2(_pollDelayMs, this, options.pollDelayMs);
+	}
+	/**
+	* Starts a turn: runs the flow with `memory_id` set to the conversation id. Returns the
+	* job id. Throws `TurnRunningError` when the conversation is still answering.
+	*/
+	async runFlow(flowPath, args, options) {
+		let res;
+		try {
+			res = await _assertClassBrand(_WindmillChatApi_brand, this, _request).call(this, `jobs/run/f/${encodePath(flowPath)}`, {
+				method: "POST",
+				query: {
+					memory_id: options.memoryId,
+					skip_preprocessor: "true"
+				},
+				body: args,
+				signal: options.signal
+			});
+		} catch (e) {
+			if (e instanceof WindmillApiError && e.status === 409) throw turnRunningError(e.body ?? "") ?? e;
+			throw e;
+		}
+		return (await res.text()).trim();
+	}
+	/**
+	* One server-sent-events connection to a job's updates. The server closes it after
+	* `TIMEOUT_SSE_STREAM` (a `timeout` event); resume by calling again with the last
+	* `stream_offset`, never by re-running the flow.
+	*/
+	async *streamJob(jobId, options = {}) {
+		const query = {
+			fast: "true",
+			only_result: "true"
+		};
+		if (_classPrivateFieldGet2(_pollDelayMs, this) !== void 0) query.poll_delay_ms = String(_classPrivateFieldGet2(_pollDelayMs, this));
+		if (options.streamOffset !== void 0) query.stream_offset = String(options.streamOffset);
+		const res = await _assertClassBrand(_WindmillChatApi_brand, this, _request).call(this, `jobs_u/getupdate_sse/${encodeURIComponent(jobId)}`, {
+			query,
+			accept: "text/event-stream",
+			signal: options.signal
+		});
+		if (!res.body) throw new WindmillApiError("The job update stream has no body", 0);
+		for await (const data of readServerSentEvents(res.body)) try {
+			yield JSON.parse(data);
+		} catch {}
+	}
+	async getCompletedResult(jobId, signal) {
+		return await (await _assertClassBrand(_WindmillChatApi_brand, this, _request).call(this, `jobs_u/completed/get_result_maybe/${encodeURIComponent(jobId)}`, { signal })).json();
+	}
+	/** A flow job with its status: the step job ids are what persisted messages carry as `job_id`. */
+	async getFlowJob(jobId, signal) {
+		return await (await _assertClassBrand(_WindmillChatApi_brand, this, _request).call(this, `jobs_u/get/${encodeURIComponent(jobId)}`, {
+			query: { no_logs: "true" },
+			signal
+		})).json();
+	}
+	/**
+	* Where a message's attachment downloads from. The endpoint authenticates like every other
+	* request: a consumer holding a token must fetch it with that token, not put the URL in an
+	* `img src`, which would send only the Windmill session cookie.
+	*/
+	attachmentUrl(attachment) {
+		const query = new URLSearchParams({ file_key: attachment.s3 });
+		if (attachment.storage) query.set("storage", attachment.storage);
+		return `${_classPrivateFieldGet2(_baseUrl, this)}/api/w/${encodeURIComponent(_classPrivateFieldGet2(_workspace, this))}/job_helpers/download_s3_file?${query}`;
+	}
+	async cancelJob(jobId, reason = "Stopped from the chat") {
+		await _assertClassBrand(_WindmillChatApi_brand, this, _request).call(this, `jobs_u/queue/cancel/${encodeURIComponent(jobId)}`, {
+			method: "POST",
+			body: { reason }
+		});
+	}
+	async listConversations(flowPath, options = {}) {
+		const extra = { flow_path: flowPath };
+		if (options.kind !== void 0) extra.kind = options.kind;
+		return await (await _assertClassBrand(_WindmillChatApi_brand, this, _request).call(this, "flow_conversations/list", {
+			query: pagination(options, extra),
+			signal: options.signal
+		})).json();
+	}
+	/** Sets a conversation's title. Its place in the list is kept: only a turn moves one. */
+	async renameConversation(conversationId, title) {
+		await _assertClassBrand(_WindmillChatApi_brand, this, _request).call(this, `flow_conversations/update/${encodeURIComponent(conversationId)}`, {
+			method: "POST",
+			body: { title }
+		});
+	}
+	/**
+	* Without `afterSeq`: one page counted from the newest message, returned oldest first.
+	* With `afterSeq`: the messages created after that cursor, oldest first.
+	*/
+	async listMessages(conversationId, options = {}) {
+		const extra = {};
+		if (options.afterSeq !== void 0) extra.after_seq = String(options.afterSeq);
+		return await (await _assertClassBrand(_WindmillChatApi_brand, this, _request).call(this, `flow_conversations/${encodeURIComponent(conversationId)}/messages`, {
+			query: pagination(options, extra),
+			signal: options.signal
+		})).json();
+	}
+	/**
+	* Puts bytes in the workspace's object storage under `fileKey` and returns the key they were
+	* stored under (the server may rewrite it). Needs the workspace to have object storage set.
+	*/
+	async uploadFile(fileKey, body, options = {}) {
+		const query = { file_key: fileKey };
+		if (options.contentType) query.content_type = options.contentType;
+		return await (await _assertClassBrand(_WindmillChatApi_brand, this, _request).call(this, "job_helpers/upload_s3_file", {
+			method: "POST",
+			query,
+			raw: body,
+			contentType: options.contentType || "application/octet-stream",
+			signal: options.signal
+		})).json();
+	}
+	async deleteConversation(conversationId) {
+		await _assertClassBrand(_WindmillChatApi_brand, this, _request).call(this, `flow_conversations/delete/${encodeURIComponent(conversationId)}`, { method: "DELETE" });
+	}
+};
+async function _request(path, init = {}) {
+	const url = new URL(`${_classPrivateFieldGet2(_baseUrl, this)}/api/w/${encodeURIComponent(_classPrivateFieldGet2(_workspace, this))}/${path}`);
+	for (const [k, v] of Object.entries(init.query ?? {})) url.searchParams.set(k, v);
+	const headers = {};
+	if (init.accept) headers["Accept"] = init.accept;
+	if (init.body !== void 0) headers["Content-Type"] = "application/json";
+	else if (init.raw !== void 0) headers["Content-Type"] = init.contentType ?? "application/octet-stream";
+	const token = typeof _classPrivateFieldGet2(_token, this) === "function" ? await _classPrivateFieldGet2(_token, this).call(this) : _classPrivateFieldGet2(_token, this);
+	if (token) headers["Authorization"] = `Bearer ${token}`;
+	const res = await _classPrivateFieldGet2(_fetch, this).call(this, url.toString(), {
+		method: init.method ?? "GET",
+		headers,
+		body: init.body === void 0 ? init.raw : JSON.stringify(init.body),
+		credentials: token ? "omit" : "same-origin",
+		signal: init.signal
+	});
+	if (!res.ok) {
+		const text = await res.text().catch(() => "");
+		throw new WindmillApiError(`${init.method ?? "GET"} ${path} failed (${res.status})${text ? `: ${text}` : ""}`, res.status, text);
+	}
+	return res;
+}
+function normalizeBaseUrl(baseUrl) {
+	return baseUrl.replace(/\/+$/, "").replace(/\/api$/, "");
+}
+function encodePath(path) {
+	return path.split("/").map(encodeURIComponent).join("/");
+}
+function pagination(options, extra) {
+	const query = { ...extra };
+	if (options.page !== void 0) query.page = String(options.page);
+	if (options.perPage !== void 0) query.per_page = String(options.perPage);
+	return query;
+}
+/** Yields the `data` payload of each event in a `text/event-stream` body. */
+async function* readServerSentEvents(body) {
+	const reader = body.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
+	let carry = "";
+	try {
+		while (true) {
+			const { value, done } = await reader.read();
+			if (done) break;
+			let text = carry + decoder.decode(value, { stream: true });
+			carry = "";
+			if (text.endsWith("\r")) {
+				carry = "\r";
+				text = text.slice(0, -1);
+			}
+			buffer += text.replace(/\r\n?/g, "\n");
+			let end;
+			while ((end = buffer.indexOf("\n\n")) !== -1) {
+				const data = eventData(buffer.slice(0, end));
+				buffer = buffer.slice(end + 2);
+				if (data !== void 0) yield data;
+			}
+		}
+		if (carry) buffer += "\n";
+		const data = eventData(buffer);
+		if (data !== void 0) yield data;
+	} finally {
+		reader.cancel().catch(() => {});
+	}
+}
+function eventData(block) {
+	const lines = block.split("\n").filter((line) => line.startsWith("data:")).map((line) => line.slice(line.startsWith("data: ") ? 6 : 5));
+	return lines.length > 0 ? lines.join("\n") : void 0;
+}
+//#endregion
+//#region src/stream.ts
+const KNOWN_TYPES = /* @__PURE__ */ new Set([
+	"token_delta",
+	"reasoning_token_delta",
+	"tool_call",
+	"tool_call_arguments",
+	"tool_execution",
+	"tool_result"
+]);
+/**
+* Incremental parser for the `new_result_stream` chunks of a job update. A chunk is
+* not guaranteed to end on a line boundary, so an incomplete last line waits for the
+* next `push` (or `flush` once the job completes).
+*/
+function createStreamEventParser() {
+	let pending = "";
+	return {
+		push(chunk) {
+			pending += chunk;
+			const lastNewline = pending.lastIndexOf("\n");
+			if (lastNewline === -1) return [];
+			const complete = pending.slice(0, lastNewline);
+			pending = pending.slice(lastNewline + 1);
+			return parseStreamEvents(complete);
+		},
+		flush() {
+			const rest = pending;
+			pending = "";
+			return parseStreamEvents(rest);
+		}
+	};
+}
+/** Parses complete NDJSON lines; lines that aren't agent events are skipped. */
+function parseStreamEvents(ndjson) {
+	const events = [];
+	for (const line of ndjson.split("\n")) {
+		const trimmed = line.trim();
+		if (!trimmed) continue;
+		try {
+			const parsed = JSON.parse(trimmed);
+			if (parsed && typeof parsed === "object" && KNOWN_TYPES.has(parsed.type)) events.push(parsed);
+		} catch {}
+	}
+	return events;
+}
+//#endregion
+//#region src/utils.ts
+function randomId() {
+	const c = globalThis.crypto;
+	if (c?.randomUUID) return c.randomUUID();
+	const bytes = /* @__PURE__ */ new Uint8Array(16);
+	c.getRandomValues(bytes);
+	return formatUuid(bytes, 4);
+}
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function isUuid(value) {
+	return UUID_RE.test(value);
+}
+/**
+* The Windmill conversation id for an arbitrary chat id. A UUID is used as is;
+* anything else (an AI SDK chat id, for instance) maps to the same UUID every time,
+* so a page can reopen its conversation without storing a second id. Hashed in plain
+* JS: `crypto.subtle` only exists in secure contexts, and the mapping must not depend
+* on the origin's scheme.
+*/
+function conversationIdFor(chatId) {
+	if (isUuid(chatId)) return chatId.toLowerCase();
+	const bytes = new TextEncoder().encode(`windmill-chat:${chatId}`);
+	const out = /* @__PURE__ */ new Uint8Array(16);
+	for (const [i, seed] of [14695981039346656037n, 9521211207457086692n].entries()) {
+		let h = fnv1a64(bytes, seed);
+		for (let b = 7; b >= 0; b--) {
+			out[i * 8 + b] = Number(h & 255n);
+			h >>= 8n;
+		}
+	}
+	return formatUuid(out, 5);
+}
+function fnv1a64(bytes, seed) {
+	let h = seed;
+	for (const byte of bytes) {
+		h ^= BigInt(byte);
+		h = h * 1099511628211n & 18446744073709551615n;
+	}
+	return h;
+}
+function formatUuid(bytes, version) {
+	bytes[6] = bytes[6] & 15 | version << 4;
+	bytes[8] = bytes[8] & 63 | 128;
+	const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+	return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+function parseJsonOr(text) {
+	if (text === void 0) return void 0;
+	try {
+		return JSON.parse(text);
+	} catch {
+		return text;
+	}
+}
+function now() {
+	return (/* @__PURE__ */ new Date()).toISOString();
+}
+/** Same rule as the server: the first message, cut to 25 characters. */
+function conversationTitle(firstMessage) {
+	const chars = Array.from(firstMessage);
+	return chars.length > 25 ? `${chars.slice(0, 25).join("")}...` : firstMessage;
+}
+/** The server's bound on a typed title: 252 characters plus an ellipsis fits its 255-char column. */
+function truncateTitle(title) {
+	const chars = Array.from(title);
+	return chars.length > 252 ? `${chars.slice(0, 252).join("")}...` : title;
+}
+function sleep(ms, signal) {
+	return new Promise((resolve, reject) => {
+		if (signal?.aborted) return reject(abortError());
+		const onAbort = () => {
+			clearTimeout(timer);
+			reject(abortError());
+		};
+		const timer = setTimeout(() => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		signal?.addEventListener("abort", onAbort, { once: true });
+	});
+}
+function abortError() {
+	return new DOMException("The operation was aborted", "AbortError");
+}
+function isAbortError(e) {
+	return e instanceof Error && e.name === "AbortError";
+}
+/**
+* The text a chat shows for a flow result, following what Windmill persists as the
+* assistant message when the last step is not an AI agent: `windmill_chat_answer`
+* when the result carries one (null means no message), an agent result's `output`,
+* a string as is, anything else as JSON.
+*/
+function extractChatAnswer(result) {
+	if (result === null || result === void 0) return void 0;
+	if (typeof result === "string") return result;
+	if (typeof result === "object" && !Array.isArray(result)) {
+		const obj = result;
+		if ("windmill_chat_answer" in obj) return formatAnswer(obj.windmill_chat_answer);
+		if ("output" in obj && Array.isArray(obj.messages)) return formatAnswer(obj.output);
+	}
+	return JSON.stringify(result, null, 2);
+}
+function formatAnswer(value) {
+	if (value === null || value === void 0) return void 0;
+	return typeof value === "string" ? value : JSON.stringify(value, null, 2);
+}
+/** A completed job whose result is Windmill's error envelope. */
+function isErrorResult(result) {
+	return typeof result === "object" && result !== null && "error" in result && typeof result.error === "object" && result.error !== null;
+}
+function errorResultMessage(result) {
+	const { message, name } = result.error;
+	if (typeof message === "string" && message) return typeof name === "string" && name && name !== "Error" ? `${name}: ${message}` : message;
+	return JSON.stringify(result.error, null, 2);
+}
+//#endregion
+//#region src/follow.ts
+const RECONNECT_DELAY_MS = 300;
+const MAX_RECONNECT_DELAY_MS = 5e3;
+/** Consecutive failed connections before the job is polled instead. */
+const MAX_CONNECTION_FAILURES = 3;
+const RESULT_POLL_MS = 2e3;
+/**
+* Follows a job to completion across the server's stream timeouts: every
+* connection resumes from the last `stream_offset`, so no delta is repeated and
+* the flow is never re-run. `onOffset` reports each offset, and its loss, so a
+* caller can resume later from another connection (see the AI SDK transport).
+*
+* The offset indexes the stream of one sub-job (`flow_stream_job_id`, the flow's
+* streaming step). A retried step gets a new one, so when the id changes the
+* offset is dropped and the connection reopened from that sub-job's start.
+*
+* A connection that fails (a proxy restarting, the network dropping) is retried with
+* backoff. The run is still going, so after a few failures in a row the job's result is
+* polled instead: the rest of the answer is not streamed, but the turn still ends.
+*/
+async function* followJob(api, jobId, options = {}) {
+	let parser = createStreamEventParser();
+	let offset = options.streamOffset;
+	let streamJobId;
+	let failures = 0;
+	while (failures < MAX_CONNECTION_FAILURES) {
+		let reopen = false;
+		try {
+			for await (const update of api.streamJob(jobId, {
+				streamOffset: offset,
+				signal: options.signal
+			})) {
+				if (update.type === "ping") continue;
+				if (update.type === "timeout") {
+					reopen = true;
+					break;
+				}
+				if (update.type === "error") throw new Error(update.error);
+				if (update.type === "notfound") throw new Error(`Job ${jobId} not found`);
+				if (update.flow_stream_job_id && update.flow_stream_job_id !== streamJobId) {
+					const switched = streamJobId !== void 0 && offset !== void 0;
+					streamJobId = update.flow_stream_job_id;
+					if (switched) {
+						failures = 0;
+						offset = void 0;
+						options.onOffset?.(void 0);
+						parser = createStreamEventParser();
+						reopen = true;
+						break;
+					}
+				}
+				if (update.stream_offset !== void 0) {
+					if (update.stream_offset !== offset) failures = 0;
+					offset = update.stream_offset;
+					options.onOffset?.(offset);
+				}
+				if (update.new_result_stream) {
+					failures = 0;
+					yield {
+						type: "stream",
+						events: parser.push(update.new_result_stream)
+					};
+				}
+				if (update.completed) {
+					const rest = parser.flush();
+					if (rest.length > 0) yield {
+						type: "stream",
+						events: rest
+					};
+					yield {
+						type: "completed",
+						result: update.only_result
+					};
+					return;
+				}
+			}
+		} catch (e) {
+			if (options.signal?.aborted || isAbortError(e) || !isConnectionFailure(e)) throw e;
+			failures++;
+			if (failures >= MAX_CONNECTION_FAILURES) break;
+			await sleep(Math.min(RECONNECT_DELAY_MS * 2 ** failures, MAX_RECONNECT_DELAY_MS), options.signal);
+			continue;
+		}
+		if (options.signal?.aborted) throw abortError();
+		if (!reopen) {
+			failures++;
+			if (failures >= MAX_CONNECTION_FAILURES) break;
+			await sleep(RECONNECT_DELAY_MS, options.signal);
+		}
+	}
+	while (true) {
+		await sleep(RESULT_POLL_MS, options.signal);
+		try {
+			const { completed, result } = await api.getCompletedResult(jobId, options.signal);
+			if (completed) {
+				yield {
+					type: "completed",
+					result,
+					streamLost: true
+				};
+				return;
+			}
+		} catch (e) {
+			if (options.signal?.aborted || isAbortError(e) || !isConnectionFailure(e)) throw e;
+		}
+	}
+}
+/**
+* A failure that says nothing about the job: the request never reached Windmill, or a
+* gateway in front of it answered. A 4xx from Windmill itself (not found, refused) does.
+*/
+function isConnectionFailure(e) {
+	if (e instanceof WindmillApiError) return e.status >= 500 || e.status === 0;
+	return e instanceof TypeError;
+}
+//#endregion
+export { _assertClassBrand as C, _classPrivateFieldSet2 as S, _classPrivateMethodInitSpec as T, WindmillApiError as _, errorResultMessage as a, turnRunningError as b, isErrorResult as c, randomId as d, sleep as f, TurnRunningError as g, parseStreamEvents as h, conversationTitle as i, now as l, createStreamEventParser as m, abortError as n, extractChatAnswer as o, truncateTitle as p, conversationIdFor as r, isAbortError as s, followJob as t, parseJsonOr as u, WindmillChatApi as v, _classPrivateFieldInitSpec as w, _classPrivateFieldGet2 as x, readServerSentEvents as y };