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

package/dist/follow-Dug-Afeu.cjs

@@ -0,0 +1,705 @@
+//#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
+Object.defineProperty(exports, "TurnRunningError", {
+	enumerable: true,
+	get: function() {
+		return TurnRunningError;
+	}
+});
+Object.defineProperty(exports, "WindmillApiError", {
+	enumerable: true,
+	get: function() {
+		return WindmillApiError;
+	}
+});
+Object.defineProperty(exports, "WindmillChatApi", {
+	enumerable: true,
+	get: function() {
+		return WindmillChatApi;
+	}
+});
+Object.defineProperty(exports, "_assertClassBrand", {
+	enumerable: true,
+	get: function() {
+		return _assertClassBrand;
+	}
+});
+Object.defineProperty(exports, "_classPrivateFieldGet2", {
+	enumerable: true,
+	get: function() {
+		return _classPrivateFieldGet2;
+	}
+});
+Object.defineProperty(exports, "_classPrivateFieldInitSpec", {
+	enumerable: true,
+	get: function() {
+		return _classPrivateFieldInitSpec;
+	}
+});
+Object.defineProperty(exports, "_classPrivateFieldSet2", {
+	enumerable: true,
+	get: function() {
+		return _classPrivateFieldSet2;
+	}
+});
+Object.defineProperty(exports, "_classPrivateMethodInitSpec", {
+	enumerable: true,
+	get: function() {
+		return _classPrivateMethodInitSpec;
+	}
+});
+Object.defineProperty(exports, "abortError", {
+	enumerable: true,
+	get: function() {
+		return abortError;
+	}
+});
+Object.defineProperty(exports, "conversationIdFor", {
+	enumerable: true,
+	get: function() {
+		return conversationIdFor;
+	}
+});
+Object.defineProperty(exports, "conversationTitle", {
+	enumerable: true,
+	get: function() {
+		return conversationTitle;
+	}
+});
+Object.defineProperty(exports, "createStreamEventParser", {
+	enumerable: true,
+	get: function() {
+		return createStreamEventParser;
+	}
+});
+Object.defineProperty(exports, "errorResultMessage", {
+	enumerable: true,
+	get: function() {
+		return errorResultMessage;
+	}
+});
+Object.defineProperty(exports, "extractChatAnswer", {
+	enumerable: true,
+	get: function() {
+		return extractChatAnswer;
+	}
+});
+Object.defineProperty(exports, "followJob", {
+	enumerable: true,
+	get: function() {
+		return followJob;
+	}
+});
+Object.defineProperty(exports, "isAbortError", {
+	enumerable: true,
+	get: function() {
+		return isAbortError;
+	}
+});
+Object.defineProperty(exports, "isErrorResult", {
+	enumerable: true,
+	get: function() {
+		return isErrorResult;
+	}
+});
+Object.defineProperty(exports, "now", {
+	enumerable: true,
+	get: function() {
+		return now;
+	}
+});
+Object.defineProperty(exports, "parseJsonOr", {
+	enumerable: true,
+	get: function() {
+		return parseJsonOr;
+	}
+});
+Object.defineProperty(exports, "parseStreamEvents", {
+	enumerable: true,
+	get: function() {
+		return parseStreamEvents;
+	}
+});
+Object.defineProperty(exports, "randomId", {
+	enumerable: true,
+	get: function() {
+		return randomId;
+	}
+});
+Object.defineProperty(exports, "readServerSentEvents", {
+	enumerable: true,
+	get: function() {
+		return readServerSentEvents;
+	}
+});
+Object.defineProperty(exports, "sleep", {
+	enumerable: true,
+	get: function() {
+		return sleep;
+	}
+});
+Object.defineProperty(exports, "truncateTitle", {
+	enumerable: true,
+	get: function() {
+		return truncateTitle;
+	}
+});
+Object.defineProperty(exports, "turnRunningError", {
+	enumerable: true,
+	get: function() {
+		return turnRunningError;
+	}
+});