@ably/ai-transport 0.0.1

package/dist/vercel/ably-ai-transport-vercel.js

@@ -0,0 +1,2331 @@
+import * as e from "ably";
+import { isDataUIPart as t } from "ai";
+//#region src/constants.ts
+var n = "x-ably-stream", r = "x-ably-status", i = "x-ably-stream-id", a = "x-ably-turn-id", o = "x-ably-msg-id", s = "x-ably-turn-client-id", c = "x-ably-role", l = "x-ably-cancel-turn-id", u = "x-ably-cancel-own", d = "x-ably-cancel-all", f = "x-ably-cancel-client-id", p = "x-ably-parent", m = "x-ably-fork-of", h = "x-ably-turn-reason", g = "x-ably-cancel", _ = "x-ably-turn-start", v = "x-ably-turn-end", y = "x-domain-", b = (e) => {
+	let t = e.extras;
+	if (!t || typeof t != "object") return {};
+	let n = t.headers;
+	return !n || typeof n != "object" ? {} : n;
+}, ee = (e) => {
+	if (e !== void 0) try {
+		return JSON.parse(e);
+	} catch {
+		return;
+	}
+}, x = (e, t) => ({
+	...e,
+	...t
+}), te = (e) => {
+	if (e !== void 0) return e === "true";
+}, S = (e, t) => e[y + t], C = (e) => {
+	let t = {};
+	for (let n in e) Object.prototype.hasOwnProperty.call(e, n) && e[n] !== void 0 && (t[n] = e[n]);
+	return t;
+}, ne = (e) => ({
+	str: (t) => S(e, t),
+	strOr: (t, n) => S(e, t) ?? n,
+	bool: (t) => te(S(e, t)),
+	json: (t) => ee(S(e, t))
+}), w = () => {
+	let e = {}, t = {
+		str: (n, r) => (r !== void 0 && (e[y + n] = r), t),
+		bool: (n, r) => (r !== void 0 && (e[y + n] = String(r)), t),
+		json: (n, r) => (r != null && (e[y + n] = JSON.stringify(r)), t),
+		build: () => e
+	};
+	return t;
+}, T = (e) => C({
+	type: "dynamic-tool",
+	toolCallId: e.toolCallId,
+	toolName: e.toolName,
+	title: e.title,
+	providerExecuted: e.providerExecuted
+}), E = class {
+	constructor(e) {
+		this._activeIndex = /* @__PURE__ */ new Map(), this._partType = e;
+	}
+	start(e, t, n) {
+		this._activeIndex.set(e, t.parts.length), t.parts.push({
+			type: this._partType,
+			text: ""
+		}), n.set(e, "streaming");
+	}
+	delta(e, t, n) {
+		let r = this._activeIndex.get(e);
+		if (r === void 0) return;
+		let i = t.parts[r];
+		i?.type === this._partType && (i.text += n);
+	}
+	end(e, t) {
+		t.set(e, "finished"), this._activeIndex.delete(e);
+	}
+	reset() {
+		this._activeIndex = /* @__PURE__ */ new Map();
+	}
+}, D = class {
+	constructor() {
+		this._messageList = [], this._activeMessages = /* @__PURE__ */ new Map();
+	}
+	get messages() {
+		return this._messageList;
+	}
+	get completedMessages() {
+		let e = /* @__PURE__ */ new Set();
+		for (let t of this._activeMessages.values()) e.add(t.message);
+		return this._messageList.filter((t) => !e.has(t));
+	}
+	get hasActiveStream() {
+		for (let e of this._activeMessages.values()) for (let t of e.streamStatus.values()) if (t === "streaming") return !0;
+		return !1;
+	}
+	processOutputs(e) {
+		for (let t of e) t.kind === "message" ? this._messageList.push(t.message) : t.messageId !== void 0 && this._processEvent(t.event, t.messageId);
+	}
+	updateMessage(e) {
+		let t = this._messageList.findIndex((t) => t.id === e.id);
+		t !== -1 && (this._messageList[t] = e);
+	}
+	_ensureActiveMessage(e) {
+		let t = this._activeMessages.get(e);
+		if (t) return t;
+		let n = {
+			message: {
+				id: e,
+				role: "assistant",
+				parts: []
+			},
+			textStreams: new E("text"),
+			reasoningStreams: new E("reasoning"),
+			toolTrackers: {},
+			streamStatus: /* @__PURE__ */ new Map()
+		};
+		return this._activeMessages.set(e, n), this._messageList.push(n.message), n;
+	}
+	_getToolPart(e, t) {
+		let n = t.toolTrackers[e];
+		if (!n) return;
+		let r = t.message.parts[n.partIndex];
+		if (r?.type === "dynamic-tool") return {
+			tracker: n,
+			part: r
+		};
+	}
+	_processEvent(e, t) {
+		switch (e.type) {
+			case "start":
+			case "start-step":
+			case "finish-step":
+			case "finish":
+			case "abort":
+			case "error":
+			case "message-metadata":
+				this._processLifecycle(e, t);
+				break;
+			case "text-start":
+			case "text-delta":
+			case "text-end":
+			case "reasoning-start":
+			case "reasoning-delta":
+			case "reasoning-end":
+				this._processTextOrReasoning(e, t);
+				break;
+			case "tool-input-start":
+			case "tool-input-delta":
+			case "tool-input-available":
+			case "tool-input-error":
+				this._processToolInput(e, t);
+				break;
+			case "tool-output-available":
+			case "tool-output-error":
+			case "tool-output-denied":
+			case "tool-approval-request":
+				this._processToolOutput(e, t);
+				break;
+			case "file":
+			case "source-url":
+			case "source-document":
+				this._processContentPart(e, t);
+				break;
+			default:
+				if (e.type.startsWith("data-")) {
+					if (e.transient) break;
+					let n = this._ensureActiveMessage(t), r = C({
+						type: e.type,
+						id: e.id,
+						data: e.data
+					});
+					if (e.id !== void 0) {
+						let t = n.message.parts.findIndex((t) => t.type === e.type && "id" in t && t.id === e.id);
+						if (t !== -1) {
+							n.message.parts[t] = r;
+							break;
+						}
+					}
+					n.message.parts.push(r);
+				}
+				break;
+		}
+	}
+	_processLifecycle(e, t) {
+		switch (e.type) {
+			case "start": {
+				let n = this._ensureActiveMessage(t);
+				e.messageId && (n.message.id = e.messageId), e.messageMetadata !== void 0 && (n.message.metadata = e.messageMetadata);
+				break;
+			}
+			case "start-step":
+				this._ensureActiveMessage(t).message.parts.push({ type: "step-start" });
+				break;
+			case "finish-step": {
+				let e = this._activeMessages.get(t);
+				e && (e.textStreams.reset(), e.reasoningStreams.reset());
+				break;
+			}
+			case "finish": {
+				let n = this._activeMessages.get(t);
+				n && e.messageMetadata !== void 0 && (n.message.metadata = e.messageMetadata), this._activeMessages.delete(t);
+				break;
+			}
+			case "abort": {
+				let e = this._activeMessages.get(t);
+				if (e) for (let [t, n] of e.streamStatus) n === "streaming" && e.streamStatus.set(t, "aborted");
+				this._activeMessages.delete(t);
+				break;
+			}
+			case "error": break;
+			case "message-metadata": {
+				let n = this._activeMessages.get(t);
+				n && e.messageMetadata !== void 0 && (n.message.metadata = e.messageMetadata);
+				break;
+			}
+		}
+	}
+	_processTextOrReasoning(e, t) {
+		let n = this._ensureActiveMessage(t);
+		switch (e.type) {
+			case "text-start":
+				n.textStreams.start(e.id, n.message, n.streamStatus);
+				break;
+			case "text-delta":
+				n.textStreams.delta(e.id, n.message, e.delta);
+				break;
+			case "text-end":
+				n.textStreams.end(e.id, n.streamStatus);
+				break;
+			case "reasoning-start":
+				n.reasoningStreams.start(e.id, n.message, n.streamStatus);
+				break;
+			case "reasoning-delta":
+				n.reasoningStreams.delta(e.id, n.message, e.delta);
+				break;
+			case "reasoning-end":
+				n.reasoningStreams.end(e.id, n.streamStatus);
+				break;
+		}
+	}
+	_processToolInput(e, t) {
+		switch (e.type) {
+			case "tool-input-start": {
+				let n = this._ensureActiveMessage(t), r = n.message.parts.length;
+				n.message.parts.push({
+					...T(e),
+					state: "input-streaming",
+					input: void 0
+				}), n.toolTrackers[e.toolCallId] = {
+					partIndex: r,
+					inputText: ""
+				}, n.streamStatus.set(e.toolCallId, "streaming");
+				break;
+			}
+			case "tool-input-delta": {
+				let n = this._ensureActiveMessage(t), r = n.toolTrackers[e.toolCallId];
+				if (!r) break;
+				r.inputText += e.inputTextDelta;
+				let i;
+				try {
+					i = JSON.parse(r.inputText);
+				} catch {
+					i = void 0;
+				}
+				let a = this._getToolPart(e.toolCallId, n);
+				if (!a) break;
+				n.message.parts[a.tracker.partIndex] = {
+					...T(a.part),
+					state: "input-streaming",
+					input: i
+				};
+				break;
+			}
+			case "tool-input-available": {
+				let n = this._ensureActiveMessage(t), r = this._getToolPart(e.toolCallId, n);
+				if (!r) break;
+				n.message.parts[r.tracker.partIndex] = {
+					...T(r.part),
+					state: "input-available",
+					input: e.input
+				}, n.streamStatus.set(e.toolCallId, "finished");
+				break;
+			}
+			case "tool-input-error": {
+				let n = this._ensureActiveMessage(t), r = this._getToolPart(e.toolCallId, n);
+				if (r) n.message.parts[r.tracker.partIndex] = {
+					...T(r.part),
+					state: "output-error",
+					input: e.input,
+					errorText: e.errorText
+				};
+				else {
+					let t = n.message.parts.length;
+					n.message.parts.push({
+						...T(e),
+						state: "output-error",
+						input: e.input,
+						errorText: e.errorText
+					}), n.toolTrackers[e.toolCallId] = {
+						partIndex: t,
+						inputText: ""
+					};
+				}
+				n.streamStatus.set(e.toolCallId, "finished");
+				break;
+			}
+		}
+	}
+	_processToolOutput(e, t) {
+		let n = this._ensureActiveMessage(t), r = this._getToolPart(e.toolCallId, n);
+		if (r) switch (e.type) {
+			case "tool-output-available":
+				n.message.parts[r.tracker.partIndex] = C({
+					...T(r.part),
+					state: "output-available",
+					input: r.part.input,
+					output: e.output,
+					preliminary: e.preliminary
+				});
+				break;
+			case "tool-output-error":
+				n.message.parts[r.tracker.partIndex] = {
+					...T(r.part),
+					state: "output-error",
+					input: r.part.input,
+					errorText: e.errorText
+				};
+				break;
+			case "tool-output-denied":
+				n.message.parts[r.tracker.partIndex] = {
+					...T(r.part),
+					state: "output-denied",
+					input: r.part.input,
+					approval: {
+						id: "",
+						approved: !1
+					}
+				};
+				break;
+			case "tool-approval-request":
+				n.message.parts[r.tracker.partIndex] = {
+					...T(r.part),
+					state: "approval-requested",
+					input: r.part.input,
+					approval: { id: e.approvalId }
+				};
+				break;
+		}
+	}
+	_processContentPart(e, t) {
+		let n = this._ensureActiveMessage(t);
+		switch (e.type) {
+			case "file":
+				n.message.parts.push({
+					type: "file",
+					mediaType: e.mediaType,
+					url: e.url
+				});
+				break;
+			case "source-url":
+				n.message.parts.push(C({
+					type: "source-url",
+					sourceId: e.sourceId,
+					url: e.url,
+					title: e.title
+				}));
+				break;
+			case "source-document":
+				n.message.parts.push(C({
+					type: "source-document",
+					sourceId: e.sourceId,
+					mediaType: e.mediaType,
+					title: e.title,
+					filename: e.filename
+				}));
+				break;
+		}
+	}
+}, re = () => new D(), ie = (e) => [{
+	kind: "event",
+	event: e
+}], ae = class {
+	constructor(e, t = {}) {
+		this._serialState = /* @__PURE__ */ new Map(), this._hooks = e, this._onStreamUpdate = t.onStreamUpdate, this._onStreamDelete = t.onStreamDelete, this._logger = t.logger?.withContext({ component: "DecoderCore" });
+	}
+	decode(e) {
+		let t = e.action;
+		this._logger?.trace("DefaultDecoderCore.decode();", {
+			action: t,
+			serial: e.serial,
+			name: e.name
+		});
+		let n;
+		switch (t) {
+			case "message.create": {
+				let t = this._toPayload(e);
+				n = t.headers?.["x-ably-stream"] === "true" ? this._decodeStreamedCreate(t, e.serial) : this._hooks.decodeDiscrete(t);
+				break;
+			}
+			case "message.append":
+				n = this._decodeAppend(e);
+				break;
+			case "message.update":
+				n = this._decodeUpdate(e);
+				break;
+			case "message.delete":
+				n = this._decodeDelete(e);
+				break;
+			default: return [];
+		}
+		let r = b(e)[o];
+		if (r) for (let e of n) e.kind === "event" && (e.messageId = r);
+		return n;
+	}
+	_toPayload(e) {
+		return {
+			name: e.name ?? "",
+			data: e.data,
+			headers: b(e)
+		};
+	}
+	_stringData(e) {
+		return typeof e.data == "string" ? e.data : "";
+	}
+	_invokeOnStreamUpdate(e) {
+		if (this._onStreamUpdate) try {
+			this._onStreamUpdate(e);
+		} catch (e) {
+			this._logger?.error("DefaultDecoderCore._invokeOnStreamUpdate(); callback threw", { error: e });
+		}
+	}
+	_invokeOnStreamDelete(e, t) {
+		if (this._onStreamDelete) try {
+			this._onStreamDelete(e, t);
+		} catch (e) {
+			this._logger?.error("DefaultDecoderCore._invokeOnStreamDelete(); callback threw", { error: e });
+		}
+	}
+	_decodeStreamedCreate(e, t) {
+		if (!t) return [];
+		let n = e.headers?.["x-ably-stream-id"] ?? "", r = e.headers ?? {}, i = {
+			name: e.name,
+			streamId: n,
+			accumulated: "",
+			headers: { ...r },
+			closed: !1
+		};
+		return this._serialState.set(t, i), this._logger?.debug("DefaultDecoderCore._decodeStreamedCreate(); new stream", {
+			name: e.name,
+			streamId: n,
+			serial: t
+		}), this._hooks.buildStartEvents(i);
+	}
+	_decodeAppend(e) {
+		let t = e.serial;
+		if (!t) return [];
+		let n = this._serialState.get(t);
+		if (!n) return this._decodeUpdate(e);
+		let i = b(e), a = typeof e.data == "string" ? e.data : "", o = i[r], s = [];
+		return a.length > 0 && (n.accumulated += a, s.push(...this._hooks.buildDeltaEvents(n, a))), o === "finished" && !n.closed ? (n.closed = !0, s.push(...this._hooks.buildEndEvents(n, i)), this._logger?.debug("DefaultDecoderCore._decodeAppend(); stream finished", { streamId: n.streamId })) : o === "aborted" && !n.closed && (n.closed = !0, this._logger?.debug("DefaultDecoderCore._decodeAppend(); stream aborted", { streamId: n.streamId })), s;
+	}
+	_decodeUpdate(e) {
+		let t = e.serial;
+		if (!t) return [];
+		let i = this._toPayload(e), a = i.headers ?? {}, o = a[n] === "true", s = a[r], c = this._serialState.get(t);
+		if (!c) return this._decodeFirstContact(i, o, s, t);
+		let l = this._stringData(e);
+		if (l.startsWith(c.accumulated)) {
+			let e = l.slice(c.accumulated.length), t = [];
+			return e.length > 0 && (c.accumulated = l, t.push(...this._hooks.buildDeltaEvents(c, e))), s === "finished" && !c.closed ? (c.closed = !0, t.push(...this._hooks.buildEndEvents(c, a))) : s === "aborted" && !c.closed && (c.closed = !0), t;
+		}
+		return c.accumulated = l, c.headers = { ...a }, this._invokeOnStreamUpdate(c), [];
+	}
+	_decodeFirstContact(e, t, n, r) {
+		if (!t) return this._hooks.decodeDiscrete(e);
+		let i = e.headers?.["x-ably-stream-id"] ?? "", a = e.headers ?? {}, o = typeof e.data == "string" ? e.data : "";
+		this._logger?.debug("DefaultDecoderCore._decodeFirstContact(); first-contact stream", {
+			name: e.name,
+			streamId: i,
+			serial: r
+		});
+		let s = {
+			name: e.name,
+			streamId: i,
+			accumulated: o,
+			headers: { ...a },
+			closed: n === "finished" || n === "aborted"
+		};
+		this._serialState.set(r, s);
+		let c = this._hooks.buildStartEvents(s);
+		return o.length > 0 && c.push(...this._hooks.buildDeltaEvents(s, o)), n === "finished" && c.push(...this._hooks.buildEndEvents(s, a)), c;
+	}
+	_decodeDelete(e) {
+		let t = e.serial;
+		if (!t) return [];
+		let n = this._serialState.get(t);
+		return this._invokeOnStreamDelete(t, n), n && (n.accumulated = "", n.closed = !0), this._logger?.debug("DefaultDecoderCore._decodeDelete();", { serial: t }), [];
+	}
+}, oe = (e, t = {}) => new ae(e, t), se = class {
+	constructor(e) {
+		this._emitted = /* @__PURE__ */ new Map(), this._phases = e;
+	}
+	ensurePhases(e, t) {
+		let n = this._getOrCreate(e), r = [];
+		for (let e of this._phases) n.has(e.key) || (n.add(e.key), r.push(...e.build(t)));
+		return r;
+	}
+	markEmitted(e, t) {
+		this._getOrCreate(e).add(t);
+	}
+	resetPhase(e, t) {
+		this._emitted.get(e)?.delete(t);
+	}
+	clearScope(e) {
+		this._emitted.delete(e);
+	}
+	_getOrCreate(e) {
+		let t = this._emitted.get(e);
+		return t || (t = /* @__PURE__ */ new Set(), this._emitted.set(e, t)), t;
+	}
+}, ce = (e) => new se(e), O = (e) => {
+	let t = ne(e);
+	return {
+		...t,
+		providerMetadata: () => t.json("providerMetadata")
+	};
+}, k = (e) => ie(e), le = (e, t) => e === "stop" || e === "length" || e === "content-filter" || e === "tool-calls" || e === "error" || e === "other" ? e : t, A = (e) => e.startsWith("data-"), ue = (e) => {
+	if (e) try {
+		return JSON.parse(e);
+	} catch {
+		return e;
+	}
+}, j = (e) => {
+	let t = O(e.headers);
+	switch (e.name) {
+		case "text": return C({
+			type: "text-start",
+			id: e.streamId,
+			providerMetadata: t.providerMetadata()
+		});
+		case "reasoning": return C({
+			type: "reasoning-start",
+			id: e.streamId,
+			providerMetadata: t.providerMetadata()
+		});
+		case "tool-input": return C({
+			type: "tool-input-start",
+			toolCallId: e.streamId,
+			toolName: t.strOr("toolName", ""),
+			dynamic: t.bool("dynamic"),
+			title: t.str("title"),
+			providerExecuted: t.bool("providerExecuted"),
+			providerMetadata: t.providerMetadata()
+		});
+		default: return {
+			type: "text-start",
+			id: e.streamId
+		};
+	}
+}, M = (e, t) => {
+	switch (e.name) {
+		case "text": return {
+			type: "text-delta",
+			id: e.streamId,
+			delta: t
+		};
+		case "reasoning": return {
+			type: "reasoning-delta",
+			id: e.streamId,
+			delta: t
+		};
+		case "tool-input": return {
+			type: "tool-input-delta",
+			toolCallId: e.streamId,
+			inputTextDelta: t
+		};
+		default: return {
+			type: "text-delta",
+			id: e.streamId,
+			delta: t
+		};
+	}
+}, N = (e, t) => {
+	let n = O(t);
+	switch (e.name) {
+		case "text": return C({
+			type: "text-end",
+			id: e.streamId,
+			providerMetadata: n.providerMetadata()
+		});
+		case "reasoning": return C({
+			type: "reasoning-end",
+			id: e.streamId,
+			providerMetadata: n.providerMetadata()
+		});
+		case "tool-input": return C({
+			type: "tool-input-available",
+			toolCallId: e.streamId,
+			toolName: n.strOr("toolName", O(e.headers).strOr("toolName", "")),
+			input: ue(e.accumulated),
+			providerMetadata: n.providerMetadata()
+		});
+		default: return {
+			type: "text-end",
+			id: e.streamId
+		};
+	}
+}, P = () => ce([{
+	key: "start",
+	build: (e) => [C({
+		type: "start",
+		messageId: e.messageId
+	})]
+}, {
+	key: "start-step",
+	build: () => [{ type: "start-step" }]
+}]), F = (e, t, n) => e.ensurePhases(t, n).map((e) => ({
+	kind: "event",
+	event: e
+})), I = (e, t, n) => (n.markEmitted(t, "start"), k(C({
+	type: "start",
+	messageId: e.str("messageId"),
+	messageMetadata: e.json("messageMetadata")
+}))), L = (e, t) => (t.markEmitted(e, "start-step"), k({ type: "start-step" })), R = (e, t) => (t.resetPhase(e, "start-step"), k({ type: "finish-step" })), z = (e, t, n) => (n.clearScope(t), k(C({
+	type: "finish",
+	finishReason: le(e.str("finishReason"), "stop"),
+	messageMetadata: e.json("messageMetadata")
+}))), B = (e) => k({
+	type: "error",
+	errorText: typeof e == "string" ? e : ""
+}), V = (e, t, n) => (n.clearScope(t), k(C({
+	type: "abort",
+	reason: typeof e == "string" && e ? e : void 0
+}))), H = (e) => k({
+	type: "message-metadata",
+	messageMetadata: e.json("messageMetadata")
+}), U = (e, t) => k(C({
+	type: "file",
+	url: typeof t == "string" ? t : "",
+	mediaType: e.strOr("mediaType", ""),
+	providerMetadata: e.providerMetadata()
+})), de = (e, t) => k(C({
+	type: "source-url",
+	sourceId: e.strOr("sourceId", ""),
+	url: typeof t == "string" ? t : "",
+	title: e.str("title"),
+	providerMetadata: e.providerMetadata()
+})), fe = (e) => k(C({
+	type: "source-document",
+	sourceId: e.strOr("sourceId", ""),
+	mediaType: e.strOr("mediaType", ""),
+	title: e.strOr("title", ""),
+	filename: e.str("filename"),
+	providerMetadata: e.providerMetadata()
+})), pe = (e, t) => {
+	let n = t;
+	return k(C({
+		type: "tool-input-error",
+		toolCallId: e.strOr("toolCallId", ""),
+		toolName: e.strOr("toolName", ""),
+		errorText: n?.errorText ?? "",
+		input: n?.input,
+		dynamic: e.bool("dynamic"),
+		title: e.str("title"),
+		providerExecuted: e.bool("providerExecuted"),
+		providerMetadata: e.providerMetadata()
+	}));
+}, me = (e, t) => {
+	let n = t;
+	return k(C({
+		type: "tool-output-available",
+		toolCallId: e.strOr("toolCallId", ""),
+		output: n?.output,
+		dynamic: e.bool("dynamic"),
+		providerExecuted: e.bool("providerExecuted"),
+		preliminary: e.bool("preliminary")
+	}));
+}, he = (e, t) => {
+	let n = t;
+	return k(C({
+		type: "tool-output-error",
+		toolCallId: e.strOr("toolCallId", ""),
+		errorText: n?.errorText ?? "",
+		dynamic: e.bool("dynamic"),
+		providerExecuted: e.bool("providerExecuted")
+	}));
+}, ge = (e) => k({
+	type: "tool-approval-request",
+	toolCallId: e.strOr("toolCallId", ""),
+	approvalId: e.strOr("approvalId", "")
+}), _e = (e) => k({
+	type: "tool-output-denied",
+	toolCallId: e.strOr("toolCallId", "")
+}), ve = (e, t, n) => k(C({
+	type: e,
+	data: n,
+	id: t.str("id"),
+	transient: t.bool("transient")
+})), ye = (e, t, n, r) => {
+	let i = F(r, n, { messageId: e.str("messageId") });
+	return i.push({
+		kind: "event",
+		event: C({
+			type: "tool-input-start",
+			toolCallId: e.strOr("toolCallId", ""),
+			toolName: e.strOr("toolName", ""),
+			dynamic: e.bool("dynamic"),
+			title: e.str("title"),
+			providerExecuted: e.bool("providerExecuted"),
+			providerMetadata: e.providerMetadata()
+		})
+	}, {
+		kind: "event",
+		event: C({
+			type: "tool-input-available",
+			toolCallId: e.strOr("toolCallId", ""),
+			toolName: e.strOr("toolName", ""),
+			input: t,
+			providerMetadata: e.providerMetadata()
+		})
+	}), i;
+}, be = (e) => {
+	let t = e.headers ?? {}, n = O(t), r = t["x-ably-role"] ?? "user", i = n.str("messageId") ?? "", a;
+	switch (e.name) {
+		case "text":
+			a = {
+				type: "text",
+				text: typeof e.data == "string" ? e.data : ""
+			};
+			break;
+		case "file":
+			a = {
+				type: "file",
+				mediaType: n.strOr("mediaType", ""),
+				url: typeof e.data == "string" ? e.data : ""
+			};
+			break;
+		default:
+			A(e.name) && (a = C({
+				type: e.name,
+				id: n.str("id"),
+				data: e.data
+			}));
+			break;
+	}
+	return a ? [{
+		kind: "message",
+		message: {
+			id: i,
+			role: r,
+			parts: [a]
+		}
+	}] : [];
+}, xe = (e, t) => (e === "text" || e === "file" || A(e)) && "x-ably-role" in t, Se = (e, t) => {
+	let n = e.headers ?? {}, r = O(n), i = n["x-ably-turn-id"] ?? "";
+	if (xe(e.name, n)) return be(e);
+	if (e.name === "tool-input") return ye(r, e.data, i, t);
+	switch (e.name) {
+		case "start": return I(r, i, t);
+		case "start-step": return L(i, t);
+		case "finish-step": return R(i, t);
+		case "finish": return z(r, i, t);
+		case "error": return B(e.data);
+		case "abort": return V(e.data, i, t);
+		case "message-metadata": return H(r);
+		case "file": return U(r, e.data);
+		case "source-url": return de(r, e.data);
+		case "source-document": return fe(r);
+		case "tool-input-error": return pe(r, e.data);
+		case "tool-output-available": return me(r, e.data);
+		case "tool-output-error": return he(r, e.data);
+		case "tool-approval-request": return ge(r);
+		case "tool-output-denied": return _e(r);
+		default: return A(e.name) ? ve(e.name, r, e.data) : [];
+	}
+}, Ce = (e) => ({
+	buildStartEvents: (t) => {
+		let n = F(e, t.headers["x-ably-turn-id"] ?? "", { messageId: O(t.headers).str("messageId") });
+		return n.push({
+			kind: "event",
+			event: j(t)
+		}), n;
+	},
+	buildDeltaEvents: (e, t) => k(M(e, t)),
+	buildEndEvents: (e, t) => k(N(e, t)),
+	decodeDiscrete: (t) => Se(t, e)
+}), we = class {
+	constructor(e = {}) {
+		this._core = oe(Ce(P()), e);
+	}
+	decode(e) {
+		return this._core.decode(e);
+	}
+}, Te = (e = {}) => new we(e), W = /* @__PURE__ */ function(e) {
+	return e[e.BadRequest = 4e4] = "BadRequest", e[e.InvalidArgument = 40003] = "InvalidArgument", e[e.EncoderRecoveryFailed = 104e3] = "EncoderRecoveryFailed", e[e.TransportSubscriptionError = 104001] = "TransportSubscriptionError", e[e.CancelListenerError = 104002] = "CancelListenerError", e[e.TurnLifecycleError = 104003] = "TurnLifecycleError", e[e.TransportClosed = 104004] = "TransportClosed", e[e.TransportSendFailed = 104005] = "TransportSendFailed", e;
+}({}), Ee = (e, t) => e.code === t, De = class {
+	constructor(e, t = {}) {
+		this._trackers = /* @__PURE__ */ new Map(), this._pending = [], this._closed = !1, this._writer = e, this._defaultClientId = t.clientId, this._defaultExtras = t.extras, this._onMessageHook = t.onMessage ?? (() => {}), this._logger = t.logger?.withContext({ component: "EncoderCore" });
+	}
+	async publishDiscrete(e, t) {
+		this._assertNotClosed(), this._logger?.trace("DefaultEncoderCore.publishDiscrete();", { name: e.name });
+		let n = this._buildDiscreteMessage(e, t);
+		return this._writer.publish(n);
+	}
+	async publishDiscreteBatch(e, t) {
+		this._assertNotClosed(), this._logger?.trace("DefaultEncoderCore.publishDiscreteBatch();", { count: e.length });
+		let n = e.map((e) => this._buildDiscreteMessage(e, t));
+		return this._writer.publish(n);
+	}
+	async startStream(t, a, o) {
+		this._assertNotClosed(), this._logger?.trace("DefaultEncoderCore.startStream();", {
+			name: a.name,
+			streamId: t
+		});
+		let s = this._buildHeaders(a.headers ?? {}, o);
+		s[n] = "true", s[r] = "streaming", s[i] = t;
+		let c = this._resolveClientId(o), l = {
+			name: a.name,
+			data: a.data,
+			extras: { headers: s },
+			...c ? { clientId: c } : {}
+		};
+		this._invokeOnMessage(l);
+		let u = (await this._writer.publish(l)).serials[0];
+		if (!u) throw new e.ErrorInfo(`unable to start stream; no serial returned for stream '${a.name}' (streamId: ${t})`, W.BadRequest, 400);
+		this._trackers.set(t, {
+			serial: u,
+			name: a.name,
+			streamId: t,
+			accumulated: a.data,
+			persistentHeaders: s,
+			aborted: !1
+		}), this._logger?.debug("DefaultEncoderCore.startStream(); stream started", {
+			name: a.name,
+			streamId: t,
+			serial: u
+		});
+	}
+	appendStream(t, n) {
+		this._assertNotClosed();
+		let r = this._trackers.get(t);
+		if (!r) throw new e.ErrorInfo(`unable to append to stream; no active stream for streamId '${t}'`, W.InvalidArgument, 400);
+		r.accumulated += n;
+		let i = {
+			serial: r.serial,
+			data: n,
+			extras: { headers: { ...r.persistentHeaders } }
+		};
+		this._invokeOnMessage(i);
+		let a = this._writer.appendMessage(i);
+		this._pending.push({
+			promise: a,
+			streamId: t
+		});
+	}
+	async closeStream(t, n) {
+		this._assertNotClosed(), this._logger?.trace("DefaultEncoderCore.closeStream();", { streamId: t });
+		let i = this._trackers.get(t);
+		if (!i) throw new e.ErrorInfo(`unable to close stream; no active stream for streamId '${t}'`, W.InvalidArgument, 400);
+		i.accumulated += n.data;
+		let a = this._buildClosingHeaders(i, n.headers ?? {});
+		a[r] = "finished";
+		let o = {
+			serial: i.serial,
+			data: n.data,
+			extras: { headers: a }
+		};
+		this._invokeOnMessage(o);
+		let s = this._writer.appendMessage(o);
+		this._pending.push({
+			promise: s,
+			streamId: t
+		}), await this._flushPending(), this._logger?.debug("DefaultEncoderCore.closeStream(); stream closed", { streamId: t });
+	}
+	async abortStream(t, n) {
+		this._assertNotClosed(), this._logger?.trace("DefaultEncoderCore.abortStream();", { streamId: t });
+		let i = this._trackers.get(t);
+		if (!i) throw new e.ErrorInfo(`unable to abort stream; no active stream for streamId '${t}'`, W.InvalidArgument, 400);
+		i.aborted = !0;
+		let a = this._buildClosingHeaders(i, {}, n);
+		a[r] = "aborted";
+		let o = {
+			serial: i.serial,
+			data: "",
+			extras: { headers: a }
+		};
+		this._invokeOnMessage(o);
+		let s = this._writer.appendMessage(o);
+		this._pending.push({
+			promise: s,
+			streamId: t
+		}), await this._flushPending(), this._logger?.debug("DefaultEncoderCore.abortStream(); stream aborted", { streamId: t });
+	}
+	async abortAllStreams(e) {
+		this._assertNotClosed(), this._logger?.trace("DefaultEncoderCore.abortAllStreams();", { streamCount: this._trackers.size });
+		for (let t of this._trackers.values()) {
+			t.aborted = !0;
+			let n = this._buildClosingHeaders(t, {}, e);
+			n[r] = "aborted";
+			let i = {
+				serial: t.serial,
+				data: "",
+				extras: { headers: n }
+			};
+			this._invokeOnMessage(i);
+			let a = this._writer.appendMessage(i);
+			this._pending.push({
+				promise: a,
+				streamId: t.streamId
+			});
+		}
+		await this._flushPending();
+	}
+	async _flushPending() {
+		if (this._flushPromise) return this._flushPromise;
+		let e = this._pending;
+		if (this._pending = [], e.length !== 0) {
+			this._logger?.trace("DefaultEncoderCore._flushPending();", { count: e.length }), this._flushPromise = this._doFlush(e);
+			try {
+				await this._flushPromise;
+			} finally {
+				this._flushPromise = void 0;
+			}
+		}
+	}
+	async _doFlush(t) {
+		let n = await Promise.allSettled(t.map(async (e) => e.promise)), i = /* @__PURE__ */ new Set();
+		for (let [e, r] of n.entries()) {
+			let n = t[e];
+			n && r.status === "rejected" && i.add(n.streamId);
+		}
+		if (i.size === 0) {
+			this._logger?.debug("DefaultEncoderCore._flushPending(); all appends succeeded");
+			return;
+		}
+		this._logger?.warn("DefaultEncoderCore._flushPending(); recovering failed appends", { failedStreams: [...i] });
+		let a = [];
+		for (let e of i) {
+			let t = this._trackers.get(e);
+			if (!t) continue;
+			let n = t.aborted ? "aborted" : "finished", i = {
+				serial: t.serial,
+				data: t.accumulated,
+				extras: { headers: {
+					...t.persistentHeaders,
+					[r]: n
+				} }
+			};
+			try {
+				await this._writer.updateMessage(i);
+			} catch (t) {
+				a.push({
+					streamId: e,
+					error: t
+				});
+			}
+		}
+		if (a.length > 0) {
+			let t = a.map((e) => e.streamId).join(", ");
+			throw this._logger?.error("DefaultEncoderCore._flushPending(); recovery failed", { failedStreams: t }), new e.ErrorInfo(`unable to flush pending appends; recovery failed for stream(s): ${t}`, W.EncoderRecoveryFailed, 500);
+		}
+	}
+	async close() {
+		if (!this._closed) {
+			this._logger?.trace("DefaultEncoderCore.close();"), this._closed = !0;
+			try {
+				await this._flushPending();
+			} finally {
+				this._trackers.clear();
+			}
+			this._logger?.debug("DefaultEncoderCore.close(); encoder closed");
+		}
+	}
+	_invokeOnMessage(e) {
+		try {
+			this._onMessageHook(e);
+		} catch (e) {
+			this._logger?.error("DefaultEncoderCore._invokeOnMessage(); hook threw", { error: e });
+		}
+	}
+	_assertNotClosed() {
+		if (this._closed) throw new e.ErrorInfo("unable to write to encoder; encoder has been closed", W.InvalidArgument, 400);
+	}
+	_resolveClientId(e) {
+		return e?.clientId ?? this._defaultClientId;
+	}
+	_buildHeaders(e, t) {
+		let n = {
+			...x(this._defaultExtras?.headers, t?.extras?.headers),
+			...e
+		};
+		return t?.messageId !== void 0 && (n[o] = t.messageId), n;
+	}
+	_buildDiscreteMessage(e, t) {
+		let r = this._buildHeaders(e.headers ?? {}, t);
+		r[n] = "false";
+		let i = this._resolveClientId(t), a = {
+			name: e.name,
+			data: e.data,
+			extras: {
+				headers: r,
+				...e.ephemeral ? { ephemeral: !0 } : {}
+			},
+			...i ? { clientId: i } : {}
+		};
+		return this._invokeOnMessage(a), a;
+	}
+	_buildClosingHeaders(e, t, n) {
+		let r = { ...e.persistentHeaders }, i = x(this._defaultExtras?.headers, n?.extras?.headers);
+		return Object.assign(r, i), Object.assign(r, t), r;
+	}
+}, Oe = (e, t = {}) => new De(e, t), ke = class {
+	constructor(e, t = {}) {
+		this._aborted = !1, this._core = Oe(e, t);
+	}
+	async appendEvent(t, n) {
+		switch (t.type) {
+			case "text-start": {
+				let e = w().str("id", t.id).json("providerMetadata", t.providerMetadata).build();
+				await this._core.startStream(t.id, {
+					name: "text",
+					data: "",
+					headers: e
+				}, n);
+				break;
+			}
+			case "reasoning-start": {
+				let e = w().str("id", t.id).json("providerMetadata", t.providerMetadata).build();
+				await this._core.startStream(t.id, {
+					name: "reasoning",
+					data: "",
+					headers: e
+				}, n);
+				break;
+			}
+			case "tool-input-start": {
+				let e = w().str("toolCallId", t.toolCallId).str("toolName", t.toolName).bool("dynamic", t.dynamic).str("title", t.title).bool("providerExecuted", t.providerExecuted).json("providerMetadata", t.providerMetadata).build();
+				await this._core.startStream(t.toolCallId, {
+					name: "tool-input",
+					data: "",
+					headers: e
+				}, n);
+				break;
+			}
+			case "text-delta":
+				this._core.appendStream(t.id, t.delta);
+				break;
+			case "reasoning-delta":
+				this._core.appendStream(t.id, t.delta);
+				break;
+			case "tool-input-delta":
+				this._core.appendStream(t.toolCallId, t.inputTextDelta);
+				break;
+			case "text-end": {
+				let e = w().str("id", t.id).json("providerMetadata", t.providerMetadata).build();
+				await this._core.closeStream(t.id, {
+					name: "text",
+					data: "",
+					headers: e
+				});
+				break;
+			}
+			case "reasoning-end": {
+				let e = w().str("id", t.id).json("providerMetadata", t.providerMetadata).build();
+				await this._core.closeStream(t.id, {
+					name: "reasoning",
+					data: "",
+					headers: e
+				});
+				break;
+			}
+			case "tool-input-available":
+				try {
+					let e = w().str("toolCallId", t.toolCallId).str("toolName", t.toolName).json("providerMetadata", t.providerMetadata).build();
+					await this._core.closeStream(t.toolCallId, {
+						name: "tool-input",
+						data: "",
+						headers: e
+					});
+				} catch (n) {
+					if (!(n instanceof e.ErrorInfo && Ee(n, W.InvalidArgument))) throw n;
+					let r = w().str("toolCallId", t.toolCallId).str("toolName", t.toolName).bool("dynamic", t.dynamic).str("title", t.title).bool("providerExecuted", t.providerExecuted).json("providerMetadata", t.providerMetadata).build();
+					await this._core.publishDiscrete({
+						name: "tool-input",
+						data: t.input,
+						headers: r
+					});
+				}
+				break;
+			case "start": {
+				let e = w().str("messageId", t.messageId).json("messageMetadata", t.messageMetadata).build();
+				await this._core.publishDiscrete({
+					name: "start",
+					data: "",
+					headers: e
+				}, n);
+				break;
+			}
+			case "start-step":
+				await this._core.publishDiscrete({
+					name: "start-step",
+					data: ""
+				}, n);
+				break;
+			case "finish-step":
+				await this._core.publishDiscrete({
+					name: "finish-step",
+					data: ""
+				}, n);
+				break;
+			case "finish": {
+				let e = w().str("finishReason", t.finishReason).json("messageMetadata", t.messageMetadata).build();
+				await this._core.publishDiscrete({
+					name: "finish",
+					data: "",
+					headers: e
+				}, n);
+				break;
+			}
+			case "error":
+				await this._core.publishDiscrete({
+					name: "error",
+					data: t.errorText
+				}, n);
+				break;
+			case "abort":
+				this._aborted = !0, await this._core.abortAllStreams(n), await this._core.publishDiscrete({
+					name: "abort",
+					data: t.reason ?? "",
+					headers: { [r]: "aborted" }
+				}, n);
+				break;
+			case "tool-input-error": {
+				let e = w().str("toolCallId", t.toolCallId).str("toolName", t.toolName).bool("dynamic", t.dynamic).str("title", t.title).bool("providerExecuted", t.providerExecuted).json("providerMetadata", t.providerMetadata).build();
+				await this._core.publishDiscrete({
+					name: "tool-input-error",
+					data: {
+						errorText: t.errorText,
+						input: t.input
+					},
+					headers: e
+				});
+				break;
+			}
+			case "tool-output-available": {
+				let e = w().str("toolCallId", t.toolCallId).bool("dynamic", t.dynamic).bool("providerExecuted", t.providerExecuted).bool("preliminary", t.preliminary).build();
+				await this._core.publishDiscrete({
+					name: "tool-output-available",
+					data: { output: t.output },
+					headers: e
+				});
+				break;
+			}
+			case "tool-output-error": {
+				let e = w().str("toolCallId", t.toolCallId).bool("dynamic", t.dynamic).bool("providerExecuted", t.providerExecuted).build();
+				await this._core.publishDiscrete({
+					name: "tool-output-error",
+					data: { errorText: t.errorText },
+					headers: e
+				});
+				break;
+			}
+			case "tool-approval-request": {
+				let e = w().str("toolCallId", t.toolCallId).str("approvalId", t.approvalId).build();
+				await this._core.publishDiscrete({
+					name: "tool-approval-request",
+					data: "",
+					headers: e
+				}, n);
+				break;
+			}
+			case "tool-output-denied": {
+				let e = w().str("toolCallId", t.toolCallId).build();
+				await this._core.publishDiscrete({
+					name: "tool-output-denied",
+					data: "",
+					headers: e
+				}, n);
+				break;
+			}
+			case "file": {
+				let e = w().str("mediaType", t.mediaType).json("providerMetadata", t.providerMetadata).build();
+				await this._core.publishDiscrete({
+					name: "file",
+					data: t.url,
+					headers: e
+				}, n);
+				break;
+			}
+			case "source-url": {
+				let e = w().str("sourceId", t.sourceId).str("title", t.title).json("providerMetadata", t.providerMetadata).build();
+				await this._core.publishDiscrete({
+					name: "source-url",
+					data: t.url,
+					headers: e
+				}, n);
+				break;
+			}
+			case "source-document": {
+				let e = w().str("sourceId", t.sourceId).str("mediaType", t.mediaType).str("title", t.title).str("filename", t.filename).json("providerMetadata", t.providerMetadata).build();
+				await this._core.publishDiscrete({
+					name: "source-document",
+					data: "",
+					headers: e
+				}, n);
+				break;
+			}
+			case "message-metadata": {
+				let e = w().json("messageMetadata", t.messageMetadata).build();
+				await this._core.publishDiscrete({
+					name: "message-metadata",
+					data: "",
+					headers: e
+				}, n);
+				break;
+			}
+			default:
+				if (t.type.startsWith("data-")) {
+					let e = w().str("id", t.id).bool("transient", t.transient).build(), r = t.transient === !0;
+					await this._core.publishDiscrete({
+						name: t.type,
+						data: t.data,
+						headers: e,
+						ephemeral: r
+					}, n);
+				}
+				break;
+		}
+	}
+	async writeEvent(t, n) {
+		if (!t.type.startsWith("data-")) throw new e.ErrorInfo(`unable to write event; only data-* chunk types are supported, got '${t.type}'`, W.InvalidArgument, 400);
+		let r = w().str("id", "id" in t ? t.id : void 0).bool("transient", "transient" in t ? t.transient : void 0).build(), i = "transient" in t && t.transient === !0;
+		return this._core.publishDiscrete({
+			name: t.type,
+			data: "data" in t ? t.data : void 0,
+			headers: r,
+			ephemeral: i
+		}, n);
+	}
+	async writeMessages(e, t) {
+		let n = e.flatMap((e) => Ae(e));
+		return this._core.publishDiscreteBatch(n, t);
+	}
+	async abort(e) {
+		this._aborted || (this._aborted = !0, await this._core.abortAllStreams(), await this._core.publishDiscrete({
+			name: "abort",
+			data: e ?? "",
+			headers: { [r]: "aborted" }
+		}));
+	}
+	async close() {
+		await this._core.close();
+	}
+}, Ae = (e) => {
+	let n = e.id, r = [];
+	for (let i of e.parts) switch (i.type) {
+		case "text":
+			r.push({
+				name: "text",
+				data: i.text,
+				headers: w().str("messageId", n).build()
+			});
+			break;
+		case "file":
+			r.push({
+				name: "file",
+				data: i.url,
+				headers: w().str("messageId", n).str("mediaType", i.mediaType).build()
+			});
+			break;
+		default:
+			t(i) && r.push({
+				name: i.type,
+				data: i.data,
+				headers: w().str("messageId", n).str("id", i.id).build()
+			});
+			break;
+	}
+	return r.length === 0 && r.push({
+		name: "text",
+		data: "",
+		headers: w().str("messageId", n).build()
+	}), r;
+}, G = {
+	createEncoder: (e, t = {}) => new ke(e, t),
+	createDecoder: Te,
+	createAccumulator: re,
+	getMessageKey: (e) => e.id,
+	isTerminal: (e) => e.type === "finish" || e.type === "error" || e.type === "abort"
+}, je = (t, n) => ({
+	sendMessages: async (r) => {
+		let { messages: i, abortSignal: a, trigger: o, messageId: s } = r, c, l;
+		if (o === "regenerate-message") c = [], l = i;
+		else {
+			if (i.length === 0) throw new e.ErrorInfo("unable to send messages; messages array is empty for submit-message trigger", W.InvalidArgument, 400);
+			c = [i.at(-1)], l = i.slice(0, -1);
+		}
+		let u, d;
+		if (o === "regenerate-message" && s) {
+			u = s;
+			let e = t.getTree().getNodeByKey(s);
+			e && (u = e.msgId, d = e.parentId);
+		}
+		let f, p;
+		if (n?.prepareSendMessagesRequest) {
+			let e = n.prepareSendMessagesRequest({
+				id: r.chatId,
+				trigger: o,
+				messageId: s,
+				history: l,
+				messages: c,
+				forkOf: u,
+				parent: d
+			});
+			f = e.body ?? {}, p = e.headers;
+		} else f = {
+			history: l.map((e) => ({
+				message: e,
+				headers: t.getMessageHeaders(e)
+			})),
+			id: r.chatId,
+			trigger: o,
+			...s !== void 0 && { messageId: s },
+			...u !== void 0 && { forkOf: u },
+			...d !== void 0 && { parent: d }
+		}, p = void 0;
+		let m = {
+			body: f,
+			headers: p
+		};
+		u !== void 0 && (m.forkOf = u), d !== void 0 && (m.parent = d);
+		let h = await t.send(c, m);
+		a && a.addEventListener("abort", () => void t.cancel({ all: !0 }), { once: !0 });
+		let { readable: g, writable: _ } = new TransformStream(), v = _.getWriter();
+		return h.stream.pipeTo(new WritableStream({
+			close: () => {
+				v.close().catch(() => {});
+			},
+			abort: () => {
+				v.close().catch(() => {});
+			}
+		})).catch(() => {
+			v.close().catch(() => {});
+		}), g;
+	},
+	reconnectToStream: () => Promise.resolve(null),
+	close: async (e) => t.close(e)
+}), Me = (e) => ({
+	logAction: (t, n, r) => {
+		e.error(n, { detail: r });
+	},
+	shouldLog: () => !0
+}), Ne = e.Realtime.EventEmitter, Pe = class extends Ne {
+	constructor(e) {
+		super(Me(e));
+	}
+}, K = /* @__PURE__ */ function(e) {
+	return e.Trace = "trace", e.Debug = "debug", e.Info = "info", e.Warn = "warn", e.Error = "error", e.Silent = "silent", e;
+}({}), Fe = (e, t, n) => {
+	let r = n ? `, context: ${JSON.stringify(n)}` : "", i = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${t.valueOf().toUpperCase()} ably-ai-transport: ${e}${r}`;
+	switch (t) {
+		case K.Trace:
+		case K.Debug:
+			console.log(i);
+			break;
+		case K.Info:
+			console.info(i);
+			break;
+		case K.Warn:
+			console.warn(i);
+			break;
+		case K.Error:
+			console.error(i);
+			break;
+		case K.Silent: break;
+	}
+}, Ie = (e) => new Le(e.logHandler ?? Fe, e.logLevel), q = /* @__PURE__ */ function(e) {
+	return e[e.Trace = 0] = "Trace", e[e.Debug = 1] = "Debug", e[e.Info = 2] = "Info", e[e.Warn = 3] = "Warn", e[e.Error = 4] = "Error", e[e.Silent = 5] = "Silent", e;
+}(q || {}), J = new Map([
+	[K.Trace, q.Trace],
+	[K.Debug, q.Debug],
+	[K.Info, q.Info],
+	[K.Warn, q.Warn],
+	[K.Error, q.Error],
+	[K.Silent, q.Silent]
+]), Le = class t {
+	constructor(t, n, r) {
+		this._handler = t, this._context = r;
+		let i = J.get(n);
+		if (i === void 0) throw new e.ErrorInfo(`unable to create logger; invalid log level: ${n}`, W.InvalidArgument, 400);
+		this._levelNumber = i;
+	}
+	trace(e, t) {
+		this._write(e, K.Trace, q.Trace, t);
+	}
+	debug(e, t) {
+		this._write(e, K.Debug, q.Debug, t);
+	}
+	info(e, t) {
+		this._write(e, K.Info, q.Info, t);
+	}
+	warn(e, t) {
+		this._write(e, K.Warn, q.Warn, t);
+	}
+	error(e, t) {
+		this._write(e, K.Error, q.Error, t);
+	}
+	withContext(e) {
+		let n = [...J.entries()].find(([, e]) => e === this._levelNumber)?.[0] ?? K.Error;
+		return new t(this._handler, n, this._mergeContext(e));
+	}
+	_write(e, t, n, r) {
+		n >= this._levelNumber && this._handler(e, t, this._mergeContext(r));
+	}
+	_mergeContext(e) {
+		return this._context ? e ? {
+			...this._context,
+			...e
+		} : this._context : e ?? void 0;
+	}
+}, Re = class {
+	constructor(e, t) {
+		this._nodeIndex = /* @__PURE__ */ new Map(), this._codecKeyIndex = /* @__PURE__ */ new Map(), this._sortedList = [], this._parentIndex = /* @__PURE__ */ new Map(), this._selections = /* @__PURE__ */ new Map(), this._seqCounter = 0, this._getKey = e, this._logger = t;
+	}
+	_compareNodes(e, t) {
+		let n = e.node.serial, r = t.node.serial;
+		return n === void 0 && r === void 0 ? e.insertSeq - t.insertSeq : n === void 0 ? 1 : r === void 0 || n < r ? -1 : n > r ? 1 : e.insertSeq - t.insertSeq;
+	}
+	_insertSorted(e) {
+		if (e.node.serial === void 0) {
+			this._sortedList.push(e);
+			return;
+		}
+		let t = 0, n = this._sortedList.length;
+		for (; t < n;) {
+			let r = t + n >>> 1, i = this._sortedList[r];
+			if (!i) break;
+			this._compareNodes(i, e) <= 0 ? t = r + 1 : n = r;
+		}
+		this._sortedList.splice(t, 0, e);
+	}
+	_removeSorted(e) {
+		let t = this._sortedList.indexOf(e);
+		t !== -1 && this._sortedList.splice(t, 1);
+	}
+	_addToParentIndex(e, t) {
+		let n = this._parentIndex.get(e);
+		n || (n = /* @__PURE__ */ new Set(), this._parentIndex.set(e, n)), n.add(t);
+	}
+	_removeFromParentIndex(e, t) {
+		let n = this._parentIndex.get(e);
+		n && (n.delete(t), n.size === 0 && this._parentIndex.delete(e));
+	}
+	_getSiblingGroup(e) {
+		let t = this._nodeIndex.get(e);
+		if (!t) return [];
+		let n = t.node, r = new Set([n.msgId]);
+		for (; n.forkOf && !r.has(n.forkOf);) {
+			let e = this._nodeIndex.get(n.forkOf);
+			if (!e || e.node.parentId !== n.parentId) break;
+			n = e.node, r.add(n.msgId);
+		}
+		let i = n.parentId, a = n.msgId, o = [], s = this._parentIndex.get(i);
+		if (s) for (let e of s) {
+			let t = this._nodeIndex.get(e);
+			t && this._isSiblingOf(t.node, a) && o.push(t);
+		}
+		return o.sort((e, t) => this._compareNodes(e, t)), o.map((e) => e.node);
+	}
+	_isSiblingOf(e, t) {
+		if (e.msgId === t) return !0;
+		let n = e, r = new Set([n.msgId]);
+		for (; n.forkOf;) {
+			if (n.forkOf === t) return !0;
+			if (r.has(n.forkOf)) break;
+			let e = this._nodeIndex.get(n.forkOf);
+			if (!e) break;
+			n = e.node, r.add(n.msgId);
+		}
+		return !1;
+	}
+	_getGroupRoot(e) {
+		let t = this._nodeIndex.get(e);
+		if (!t) return e;
+		let n = t.node, r = new Set([n.msgId]);
+		for (; n.forkOf && !r.has(n.forkOf);) {
+			let e = this._nodeIndex.get(n.forkOf);
+			if (!e || e.node.parentId !== n.parentId) break;
+			n = e.node, r.add(n.msgId);
+		}
+		return n.msgId;
+	}
+	flatten() {
+		let e = [], t = /* @__PURE__ */ new Set(), n = /* @__PURE__ */ new Map();
+		for (let r of this._sortedList) {
+			let i = r.node, { msgId: a, parentId: o } = i;
+			if (o !== void 0 && !t.has(o)) continue;
+			let s = this._getSiblingGroup(a);
+			if (s.length > 1) {
+				let e = this._getGroupRoot(a), t = n.get(e);
+				if (t === void 0) {
+					let r = this._selections.get(e) ?? s.length - 1, i = s[Math.max(0, Math.min(r, s.length - 1))];
+					if (!i) break;
+					t = i.msgId, n.set(e, t);
+				}
+				if (a !== t) continue;
+			}
+			t.add(a), e.push(i.message);
+		}
+		return e;
+	}
+	getSiblings(e) {
+		return this._getSiblingGroup(e).map((e) => e.message);
+	}
+	hasSiblings(e) {
+		return this._getSiblingGroup(e).length > 1;
+	}
+	getSelectedIndex(e) {
+		let t = this._getSiblingGroup(e);
+		if (t.length <= 1) return 0;
+		let n = this._getGroupRoot(e), r = this._selections.get(n);
+		return r === void 0 ? t.length - 1 : Math.max(0, Math.min(r, t.length - 1));
+	}
+	select(e, t) {
+		this._logger.debug("ConversationTree.select();", {
+			msgId: e,
+			index: t
+		});
+		let n = this._getSiblingGroup(e);
+		if (n.length <= 1) return;
+		let r = this._getGroupRoot(e);
+		this._selections.set(r, Math.max(0, Math.min(t, n.length - 1)));
+	}
+	getNode(e) {
+		return this._nodeIndex.get(e)?.node;
+	}
+	getNodeByKey(e) {
+		let t = this._codecKeyIndex.get(e);
+		if (t) return this._nodeIndex.get(t)?.node;
+	}
+	getHeaders(e) {
+		return this._nodeIndex.get(e)?.node.headers;
+	}
+	upsert(e, t, n, r) {
+		let i = n["x-ably-parent"] ?? void 0, a = n["x-ably-fork-of"] ?? void 0;
+		this._codecKeyIndex.set(this._getKey(t), e);
+		let o = this._nodeIndex.get(e);
+		if (o) {
+			o.node.message = t, Object.keys(n).length > 0 && (o.node.headers = { ...n }), r && !o.node.serial && (this._logger.debug("ConversationTree.upsert(); promoting serial", {
+				msgId: e,
+				serial: r
+			}), o.node.serial = r, this._removeSorted(o), this._insertSorted(o));
+			return;
+		}
+		this._logger.trace("ConversationTree.upsert(); inserting new node", {
+			msgId: e,
+			parentId: i,
+			forkOf: a
+		});
+		let s = {
+			node: {
+				message: t,
+				msgId: e,
+				parentId: i,
+				forkOf: a,
+				headers: { ...n },
+				serial: r
+			},
+			insertSeq: this._seqCounter++
+		};
+		this._nodeIndex.set(e, s), this._addToParentIndex(i, e), this._insertSorted(s);
+	}
+	delete(e) {
+		let t = this._nodeIndex.get(e);
+		if (!t) return;
+		this._logger.debug("ConversationTree.delete();", { msgId: e });
+		let { node: n } = t, r = this._getKey(n.message);
+		this._codecKeyIndex.get(r) === e && this._codecKeyIndex.delete(r), this._removeFromParentIndex(n.parentId, e), this._removeSorted(t), this._nodeIndex.delete(e), this._selections.delete(e);
+	}
+}, ze = (e, t) => new Re(e, t), Y = (e) => {
+	let t = [...e.rawMessages].toReversed(), n = e.codec.createDecoder(), r = /* @__PURE__ */ new Map(), i = e.codec.createAccumulator(), s = 0, c = /* @__PURE__ */ new Map(), l = /* @__PURE__ */ new Map();
+	for (let u of t) {
+		let t = n.decode(u), d = b(u), f = d[a], p = d[o], m = u.serial;
+		if (f) {
+			let n = r.get(f);
+			if (n || (n = {
+				accumulator: e.codec.createAccumulator(),
+				firstSeen: s++,
+				msgHeaders: /* @__PURE__ */ new Map(),
+				msgSerials: /* @__PURE__ */ new Map()
+			}, r.set(f, n)), p) {
+				let e = n.msgHeaders.get(p);
+				e ? Object.keys(d).length > 0 && Object.assign(e, d) : (n.msgHeaders.set(p, { ...d }), m && n.msgSerials.set(p, m));
+			}
+			n.accumulator.processOutputs(t);
+		} else i.processOutputs(t);
+		for (let n of t) if (n.kind === "message") {
+			let t = e.getMessageKey(n.message), r = c.get(t);
+			r ? Object.keys(d).length > 0 && Object.assign(r, d) : (c.set(t, { ...d }), m && l.set(t, m));
+		}
+	}
+	let u = [];
+	for (let t of i.completedMessages) {
+		let n = e.getMessageKey(t);
+		u.push({
+			message: t,
+			headers: c.get(n) ?? {},
+			serial: l.get(n) ?? ""
+		});
+	}
+	let d = [...r.values()].toSorted((e, t) => e.firstSeen - t.firstSeen);
+	for (let t of d) {
+		let n = /* @__PURE__ */ new Set(), r = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Map();
+		for (let a of t.accumulator.completedMessages) {
+			let t = e.getMessageKey(a), s = c.get(t);
+			if (s) {
+				r.set(t, s);
+				let e = l.get(t);
+				e && i.set(t, e);
+				let a = s[o];
+				a && n.add(a);
+			}
+		}
+		let a = [...t.msgHeaders.entries()].filter(([e]) => !n.has(e)), s = 0;
+		for (let n of t.accumulator.completedMessages) {
+			let o = e.getMessageKey(n), c = a[s];
+			if (!r.has(o) && c) {
+				let [e, n] = c;
+				r.set(o, n);
+				let a = t.msgSerials.get(e);
+				a && i.set(o, a), s++;
+			}
+		}
+		for (let n of t.accumulator.completedMessages) {
+			let t = e.getMessageKey(n);
+			u.push({
+				message: n,
+				headers: r.get(t) ?? {},
+				serial: i.get(t) ?? ""
+			});
+		}
+	}
+	return u.toReversed();
+}, X = async (e, t, n) => {
+	e.rawMessages.push(...t.items), e.lastAblyPage = t;
+	let r = Y(e).length;
+	for (; r < e.returnedCount + n && t.hasNext();) {
+		e.logger.debug("decodeHistory.fetchUntilLimit(); fetching next page", {
+			collected: e.rawMessages.length,
+			decoded: r
+		});
+		let n = await t.next();
+		if (!n) break;
+		t = n, e.rawMessages.push(...n.items), e.lastAblyPage = n, r = Y(e).length;
+	}
+}, Z = (e, t) => {
+	let n = Y(e), r = n.slice(e.returnedCount, e.returnedCount + t), i = [...r].toReversed();
+	e.returnedCount += r.length;
+	let a = n.length > e.returnedCount, o = e.lastAblyPage?.hasNext() ?? !1, s = e.rawMessages.length - e.returnedRawCount > 0 ? e.rawMessages.slice(e.returnedRawCount).toReversed() : [];
+	return e.returnedRawCount = e.rawMessages.length, {
+		items: i.map((e) => e.message),
+		itemHeaders: i.map((e) => e.headers),
+		itemSerials: i.map((e) => e.serial),
+		rawMessages: s,
+		hasNext: () => a || o,
+		next: async () => {
+			if (a) return Z(e, t);
+			if (!o || !e.lastAblyPage) return;
+			let n = await e.lastAblyPage.next();
+			if (n) return await X(e, n, t), Z(e, t);
+		}
+	};
+}, Be = async (e, t, n, r) => {
+	let i = n?.limit ?? 100, a = {
+		codec: t,
+		rawMessages: [],
+		returnedCount: 0,
+		returnedRawCount: 0,
+		lastAblyPage: void 0,
+		getMessageKey: t.getMessageKey.bind(t),
+		logger: r
+	};
+	r.trace("decodeHistory();", { limit: i });
+	let o = i * 10;
+	return await e.attach(), await X(a, await e.history({
+		untilAttach: !0,
+		limit: o
+	}), i), Z(a, i);
+}, Q = (e) => {
+	let t = {
+		[c]: e.role,
+		[a]: e.turnId,
+		[o]: e.msgId
+	};
+	return e.turnClientId !== void 0 && (t[s] = e.turnClientId), e.parent && (t[p] = e.parent), e.forkOf && (t[m] = e.forkOf), t;
+}, Ve = class {
+	constructor(e, t) {
+		this._turns = /* @__PURE__ */ new Map(), this._isTerminal = e, this._logger = t;
+	}
+	createStream(t) {
+		this._logger.trace("StreamRouter.createStream();", { turnId: t });
+		let n = {}, r = new ReadableStream({ start(e) {
+			n.controller = e;
+		} });
+		if (!n.controller) throw new e.ErrorInfo("unable to create stream; ReadableStream start() was not called synchronously", W.TransportSubscriptionError, 500);
+		return this._turns.set(t, {
+			controller: n.controller,
+			turnId: t
+		}), r;
+	}
+	closeStream(e) {
+		let t = this._turns.get(e);
+		if (!t) return !1;
+		this._logger.debug("StreamRouter.closeStream(); closing stream", { turnId: e });
+		try {
+			t.controller.close();
+		} catch {}
+		return this._turns.delete(e), !0;
+	}
+	route(e, t) {
+		let n = this._turns.get(e);
+		if (!n) return !1;
+		try {
+			n.controller.enqueue(t);
+		} catch {
+			return this._turns.delete(e), !1;
+		}
+		return this._isTerminal(t) && this.closeStream(e), !0;
+	}
+	has(e) {
+		return this._turns.has(e);
+	}
+}, He = (e, t) => new Ve(e, t), Ue = () => {}, We = class {
+	constructor(e) {
+		if (this._ownMsgIds = /* @__PURE__ */ new Set(), this._ownTurnIds = /* @__PURE__ */ new Set(), this._turnClientIds = /* @__PURE__ */ new Map(), this._turnMsgIds = /* @__PURE__ */ new Map(), this._turnObservers = /* @__PURE__ */ new Map(), this._ablyMessages = [], this._withheldKeys = /* @__PURE__ */ new Set(), this._closed = !1, this._channel = e.channel, this._codec = e.codec, this._clientId = e.clientId, this._api = e.api ?? "/api/chat", this._credentials = e.credentials, this._headersFn = typeof e.headers == "function" ? e.headers : e.headers ? () => e.headers : void 0, this._bodyFn = typeof e.body == "function" ? e.body : e.body ? () => e.body : void 0, this._fetchFn = e.fetch ?? globalThis.fetch.bind(globalThis), this._logger = (e.logger ?? Ie({ logLevel: K.Silent })).withContext({ component: "ClientTransport" }), this._emitter = new Pe(this._logger), this._tree = ze(this._codec.getMessageKey.bind(this._codec), this._logger), this._router = He(this._codec.isTerminal.bind(this._codec), this._logger), this._decoder = this._codec.createDecoder(), e.messages) {
+			let t;
+			for (let n of e.messages) {
+				let e = this._codec.getMessageKey(n), r = {};
+				t && (r[p] = t), this._tree.upsert(e, n, r), t = e;
+			}
+			this._emitter.emit("message");
+		}
+		this._onMessage = (e) => {
+			this._handleMessage(e);
+		}, this._attachPromise = this._channel.subscribe(this._onMessage);
+	}
+	_handleMessage(t) {
+		if (!this._closed) {
+			this._ablyMessages.push(t), this._emitter.emit("ably-message");
+			try {
+				if (t.name === "x-ably-turn-start") {
+					let e = b(t), n = e[a], r = e["x-ably-turn-client-id"] ?? "";
+					n && (this._turnClientIds.set(n, r), this._emitter.emit("turn", {
+						type: _,
+						turnId: n,
+						clientId: r
+					}));
+					return;
+				}
+				if (t.name === "x-ably-turn-end") {
+					let e = b(t), n = e[a], r = e["x-ably-turn-client-id"] ?? "", i = e["x-ably-turn-reason"] ?? "complete";
+					if (n) {
+						this._router.closeStream(n), this._turnObservers.delete(n), this._turnClientIds.delete(n);
+						let e = this._turnMsgIds.get(n);
+						if (e) {
+							for (let t of e) this._ownMsgIds.delete(t);
+							this._turnMsgIds.delete(n);
+						}
+						this._ownTurnIds.delete(n), this._emitter.emit("turn", {
+							type: v,
+							turnId: n,
+							clientId: r,
+							reason: i
+						});
+					}
+					return;
+				}
+				let e = this._decoder.decode(t), n = b(t), r = t.serial, i = n[a];
+				i && this._updateTurnObserverHeaders(i, n, r);
+				for (let i of e) i.kind === "message" ? this._handleMessageOutput(i.message, n, r, t.action) : this._handleEventOutput(i, n);
+			} catch (t) {
+				let n = t instanceof e.ErrorInfo ? t : void 0;
+				this._emitter.emit("error", new e.ErrorInfo(`unable to process channel message; ${t instanceof Error ? t.message : String(t)}`, W.TransportSubscriptionError, 500, n));
+			}
+		}
+	}
+	_handleMessageOutput(e, t, n, r) {
+		let i = t[o];
+		if (i && this._ownMsgIds.has(i)) {
+			this._upsertAndNotify(e, t, n);
+			return;
+		}
+		r === "message.create" && this._upsertAndNotify(e, t, n);
+	}
+	_handleEventOutput(e, t) {
+		if (e.kind !== "event") return;
+		let n = e.event, r = t[a];
+		if (r) {
+			if (this._router.route(r, n)) {
+				this._accumulateAndEmit(r, e), this._codec.isTerminal(n) && this._turnObservers.delete(r);
+				return;
+			}
+			this._ownTurnIds.has(r) && !this._turnObservers.has(r) || (this._accumulateAndEmit(r, e), this._codec.isTerminal(n) && this._turnObservers.delete(r));
+		}
+	}
+	_upsertAndNotify(e, t, n) {
+		let r = this._codec.getMessageKey(e), i = t["x-ably-msg-id"] ?? r;
+		this._tree.upsert(i, e, t, n), this._emitter.emit("message");
+	}
+	_updateTurnObserverHeaders(e, t, n) {
+		let r = this._turnObservers.get(e);
+		r ? (Object.keys(t).length > 0 && Object.assign(r.headers, t), n !== void 0 && (r.serial = n)) : this._turnObservers.set(e, {
+			headers: { ...t },
+			serial: n,
+			accumulator: this._codec.createAccumulator()
+		});
+	}
+	_accumulateAndEmit(e, t) {
+		let n = this._turnObservers.get(e);
+		if (!n) return;
+		n.accumulator.processOutputs([t]);
+		let r = n.accumulator.messages;
+		if (r.length === 0) return;
+		let i;
+		try {
+			i = structuredClone(r.at(-1));
+		} catch {
+			i = r.at(-1);
+		}
+		i && (this._tree.upsert(n.headers["x-ably-msg-id"] ?? this._codec.getMessageKey(i), i, { ...n.headers }, n.serial), this._emitter.emit("message"));
+	}
+	async _publishCancel(e) {
+		this._logger.trace("ClientTransport._publishCancel();", { filter: e });
+		let t = {};
+		e.turnId ? t[l] = e.turnId : e.own ? t[u] = "true" : e.clientId ? t[f] = e.clientId : e.all && (t[d] = "true"), await this._channel.publish({
+			name: g,
+			extras: { headers: t }
+		});
+	}
+	_closeMatchingTurnStreams(e) {
+		if (e.all) for (let e of this._ownTurnIds) this._router.closeStream(e);
+		else if (e.own) for (let e of this._ownTurnIds) this._router.closeStream(e);
+		else if (e.clientId) for (let [t, n] of this._turnClientIds) n === e.clientId && this._router.closeStream(t);
+		else e.turnId && this._router.closeStream(e.turnId);
+	}
+	_getMatchingTurnIds(e) {
+		let t = /* @__PURE__ */ new Set();
+		if (e.all) for (let e of this._turnClientIds.keys()) t.add(e);
+		else if (e.own) for (let [e, n] of this._turnClientIds) n === this._clientId && t.add(e);
+		else if (e.clientId) for (let [n, r] of this._turnClientIds) r === e.clientId && t.add(n);
+		else e.turnId && this._turnClientIds.has(e.turnId) && t.add(e.turnId);
+		return t;
+	}
+	_getMessagesWithHeaders() {
+		return this._tree.flatten().map((e) => ({
+			message: e,
+			headers: this.getMessageHeaders(e)
+		}));
+	}
+	_getHistoryBefore(e) {
+		let t = this._getMessagesWithHeaders(), n = t.findIndex((t) => t.headers?.[o] === e);
+		return n === -1 ? t : t.slice(0, n);
+	}
+	_processHistoryPage(e) {
+		for (let [t, n] of e.items.entries()) {
+			let r = e.itemHeaders?.[t] ?? {}, i = e.itemSerials?.[t], a = this._codec.getMessageKey(n), o = r["x-ably-msg-id"] ?? a;
+			this._tree.upsert(o, n, r, i);
+		}
+		this._emitter.emit("message"), e.rawMessages && e.rawMessages.length > 0 && (this._ablyMessages.unshift(...e.rawMessages), this._emitter.emit("ably-message"));
+	}
+	async _loadUntilVisible(e, t, n) {
+		this._processHistoryPage(e);
+		let r = e, i = () => {
+			let e = 0;
+			for (let t of this._tree.flatten()) n.has(this._codec.getMessageKey(t)) || e++;
+			return e;
+		};
+		for (; i() < t && r.hasNext();) {
+			let e = await r.next();
+			if (!e) break;
+			this._processHistoryPage(e), r = e;
+		}
+		return {
+			newVisible: this._tree.flatten().filter((e) => !n.has(this._codec.getMessageKey(e))),
+			lastPage: r
+		};
+	}
+	_releaseWithheld(e) {
+		for (let t of e) this._withheldKeys.delete(this._codec.getMessageKey(t));
+		e.length > 0 && this._emitter.emit("message");
+	}
+	async send(t, n) {
+		if (this._closed || (await this._attachPromise, this._closed)) throw new e.ErrorInfo("unable to send; transport is closed", W.TransportClosed, 400);
+		this._logger.trace("ClientTransport.send();");
+		let r = Array.isArray(t) ? t : [t], i = crypto.randomUUID();
+		this._ownTurnIds.add(i);
+		let a = /* @__PURE__ */ new Set(), s = [], l = this._getMessagesWithHeaders(), u;
+		if (n?.parent === void 0 && !n?.forkOf) {
+			let e = this._tree.flatten();
+			if (e.length > 0) {
+				let t = e.at(-1);
+				if (t) {
+					let e = this._codec.getMessageKey(t);
+					u = this._tree.getNodeByKey(e)?.msgId ?? e;
+				}
+			}
+		}
+		let d = n?.parent === void 0 ? u : n.parent;
+		for (let e of r) {
+			let t = crypto.randomUUID();
+			this._ownMsgIds.add(t), a.add(t);
+			let r = n?.parent === void 0 ? u : n.parent ?? void 0, l = Q({
+				role: "user",
+				turnId: i,
+				msgId: t,
+				turnClientId: this._clientId,
+				parent: r,
+				forkOf: n?.forkOf
+			});
+			this._upsertAndNotify(e, l);
+			let d = {
+				[o]: t,
+				[c]: "user"
+			};
+			r && (d[p] = r), s.push({
+				message: e,
+				headers: d
+			}), n?.parent === void 0 && !n?.forkOf && (u = t);
+		}
+		this._turnMsgIds.set(i, a);
+		let f = this._router.createStream(i), m = this._headersFn?.() ?? {}, h = {
+			...this._bodyFn?.() ?? {},
+			history: l,
+			...n?.body,
+			turnId: i,
+			clientId: this._clientId,
+			messages: s,
+			...n?.forkOf !== void 0 && { forkOf: n.forkOf },
+			...d !== void 0 && { parent: d }
+		}, g = {
+			...m,
+			...n?.headers
+		};
+		return this._fetchFn(this._api, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				...g
+			},
+			body: JSON.stringify(h),
+			...this._credentials ? { credentials: this._credentials } : {}
+		}).then((t) => {
+			t.ok || (this._emitter.emit("error", new e.ErrorInfo(`unable to send; HTTP POST to ${this._api} returned ${String(t.status)} ${t.statusText}`, W.TransportSendFailed, t.status)), this._router.closeStream(i));
+		}).catch((t) => {
+			let n = t instanceof e.ErrorInfo ? t : void 0;
+			this._emitter.emit("error", new e.ErrorInfo(`unable to send; HTTP POST to ${this._api} failed: ${t instanceof Error ? t.message : String(t)}`, W.TransportSendFailed, 500, n)), this._router.closeStream(i);
+		}), {
+			stream: f,
+			turnId: i,
+			cancel: async () => this.cancel({ turnId: i })
+		};
+	}
+	async regenerate(e, t) {
+		this._logger.trace("ClientTransport.regenerate();", { messageId: e });
+		let n = this._tree.getNode(e)?.parentId;
+		return this.send([], {
+			...t,
+			body: {
+				history: this._getHistoryBefore(e),
+				...t?.body
+			},
+			forkOf: e,
+			parent: n
+		});
+	}
+	async edit(e, t, n) {
+		this._logger.trace("ClientTransport.edit();", { messageId: e });
+		let r = this._tree.getNode(e)?.parentId;
+		return this.send(t, {
+			...n,
+			body: {
+				history: this._getHistoryBefore(e),
+				...n?.body
+			},
+			forkOf: e,
+			parent: r
+		});
+	}
+	async cancel(e) {
+		if (this._closed) return;
+		let t = e ?? { own: !0 };
+		this._logger.debug("ClientTransport.cancel();", { filter: t }), await this._publishCancel(t), this._closeMatchingTurnStreams(t);
+	}
+	async waitForTurn(e) {
+		if (this._closed) return;
+		let t = e ?? { own: !0 }, n = this._getMatchingTurnIds(t);
+		if (n.size !== 0) return this._logger.debug("ClientTransport.waitForTurn();", { turnIds: [...n] }), new Promise((e) => {
+			let t = (r) => {
+				r.type === "x-ably-turn-end" && (n.delete(r.turnId), n.size === 0 && (this._emitter.off("turn", t), e()));
+			};
+			this._emitter.on("turn", t);
+		});
+	}
+	on(e, t) {
+		if (this._closed) return Ue;
+		let n = t;
+		return this._emitter.on(e, n), () => {
+			this._emitter.off(e, n);
+		};
+	}
+	getTree() {
+		return this._tree;
+	}
+	getActiveTurnIds() {
+		let e = /* @__PURE__ */ new Map();
+		for (let [t, n] of this._turnClientIds) {
+			let r = e.get(n);
+			r || (r = /* @__PURE__ */ new Set(), e.set(n, r)), r.add(t);
+		}
+		return e;
+	}
+	getMessageHeaders(e) {
+		let t = this._codec.getMessageKey(e);
+		return this._tree.getNodeByKey(t)?.headers;
+	}
+	getMessages() {
+		return this._withheldKeys.size === 0 ? this._tree.flatten() : this._tree.flatten().filter((e) => !this._withheldKeys.has(this._codec.getMessageKey(e)));
+	}
+	getMessagesWithHeaders() {
+		return this._getMessagesWithHeaders();
+	}
+	getAblyMessages() {
+		return [...this._ablyMessages];
+	}
+	async history(t) {
+		if (this._closed) throw new e.ErrorInfo("unable to load history; transport is closed", W.TransportClosed, 400);
+		this._logger.trace("ClientTransport.history();", { limit: t?.limit });
+		let n = t?.limit ?? 100, r = new Set(this._tree.flatten().map((e) => this._codec.getMessageKey(e))), i = await Be(this._channel, this._codec, t, this._logger), a = await this._loadUntilVisible(i, n, r);
+		i = a.lastPage;
+		let o = a.newVisible;
+		for (let e of o) this._withheldKeys.add(this._codec.getMessageKey(e));
+		let s = o.slice(-n), c = o.slice(0, -n);
+		this._releaseWithheld(s);
+		let l = (e) => ({
+			items: e,
+			hasNext: () => c.length > 0 || i.hasNext(),
+			next: async () => {
+				if (c.length > 0) {
+					let e = c.splice(-n, n);
+					return this._releaseWithheld(e), l(e);
+				}
+				if (!i.hasNext()) return;
+				let e = await i.next();
+				if (!e) return;
+				let t = new Set(r);
+				for (let e of this._tree.flatten()) t.add(this._codec.getMessageKey(e));
+				let a = await this._loadUntilVisible(e, n, t);
+				i = a.lastPage;
+				let o = a.newVisible;
+				for (let e of o) this._withheldKeys.add(this._codec.getMessageKey(e));
+				let s = o.splice(-n, n);
+				if (c.push(...o), this._releaseWithheld(s), s.length !== 0) return l(s);
+			}
+		});
+		return l(s);
+	}
+	async close(e) {
+		if (!this._closed) {
+			if (this._closed = !0, this._logger.info("ClientTransport.close();"), e?.cancel) {
+				try {
+					await this._publishCancel(e.cancel);
+				} catch {}
+				this._closeMatchingTurnStreams(e.cancel);
+			}
+			this._channel.unsubscribe(this._onMessage);
+			for (let e of this._ownTurnIds) this._router.closeStream(e);
+			this._turnObservers.clear(), this._emitter.off(), this._ownTurnIds.clear(), this._ownMsgIds.clear(), this._turnMsgIds.clear(), this._turnClientIds.clear(), this._withheldKeys.clear(), this._ablyMessages.length = 0;
+		}
+	}
+}, $ = (e) => new We(e), Ge = async (e, t, n, r, i) => {
+	i?.trace("pipeStream();");
+	let a = e.getReader(), o, s = n ? new Promise((e) => {
+		if (n.aborted) {
+			e();
+			return;
+		}
+		o = () => {
+			e();
+		}, n.addEventListener("abort", o, { once: !0 });
+	}) : new Promise(() => {}), c = "complete";
+	try {
+		for (;;) {
+			let e = await Promise.race([a.read(), s.then(() => "aborted")]);
+			if (e === "aborted") {
+				c = "cancelled", i?.debug("pipeStream(); stream cancelled by abort signal"), r && await r(async (e) => t.appendEvent(e)), await t.abort("cancelled");
+				break;
+			}
+			let { done: n, value: o } = e;
+			if (n) {
+				await t.close(), i?.debug("pipeStream(); stream completed");
+				break;
+			}
+			await t.appendEvent(o);
+		}
+	} catch (e) {
+		c = "error";
+		let n = e instanceof Error ? e.message : String(e);
+		i?.error("pipeStream(); stream error", { error: n });
+		try {
+			await t.close();
+		} catch {}
+	} finally {
+		o && n?.removeEventListener("abort", o), a.releaseLock();
+	}
+	return { reason: c };
+}, Ke = class {
+	constructor(e, t) {
+		this._activeTurns = /* @__PURE__ */ new Map(), this._channel = e, this._logger = t?.withContext({ component: "TurnManager" });
+	}
+	async startTurn(e, t, n) {
+		this._logger?.trace("DefaultTurnManager.startTurn();", {
+			turnId: e,
+			clientId: t
+		});
+		let r = n ?? new AbortController(), i = t ?? "";
+		return this._activeTurns.set(e, {
+			controller: r,
+			clientId: i
+		}), await this._channel.publish({
+			name: _,
+			extras: { headers: {
+				[a]: e,
+				[s]: i
+			} }
+		}), this._logger?.debug("DefaultTurnManager.startTurn(); turn started", { turnId: e }), r.signal;
+	}
+	async endTurn(e, t) {
+		this._logger?.trace("DefaultTurnManager.endTurn();", {
+			turnId: e,
+			reason: t
+		});
+		let n = this._activeTurns.get(e)?.clientId ?? "";
+		await this._channel.publish({
+			name: v,
+			extras: { headers: {
+				[a]: e,
+				[s]: n,
+				[h]: t
+			} }
+		}), this._activeTurns.delete(e), this._logger?.debug("DefaultTurnManager.endTurn(); turn ended", {
+			turnId: e,
+			reason: t
+		});
+	}
+	getSignal(e) {
+		return this._activeTurns.get(e)?.controller.signal;
+	}
+	getClientId(e) {
+		return this._activeTurns.get(e)?.clientId;
+	}
+	abort(e) {
+		this._logger?.debug("DefaultTurnManager.abort();", { turnId: e }), this._activeTurns.get(e)?.controller.abort();
+	}
+	getActiveTurnIds() {
+		return [...this._activeTurns.keys()];
+	}
+	close() {
+		this._logger?.trace("DefaultTurnManager.close();", { activeTurns: this._activeTurns.size });
+		for (let e of this._activeTurns.values()) e.controller.abort();
+		this._activeTurns.clear();
+	}
+}, qe = (e, t) => new Ke(e, t), Je = class {
+	constructor(t) {
+		this._registeredTurns = /* @__PURE__ */ new Map(), this._channel = t.channel, this._codec = t.codec, this._logger = t.logger?.withContext({ component: "ServerTransport" }), this._onError = t.onError, this._turnManager = qe(this._channel, this._logger), this._channelListener = (e) => {
+			this._handleChannelMessage(e);
+		}, this._attachPromise = this._channel.subscribe(g, this._channelListener).then(() => {}, (t) => {
+			let n = new e.ErrorInfo(`unable to subscribe to cancel messages; ${t instanceof Error ? t.message : String(t)}`, W.TransportSubscriptionError, 500, t instanceof e.ErrorInfo ? t : void 0);
+			this._logger?.error("DefaultServerTransport(); subscribe failed"), this._onError?.(n);
+		}), this._logger?.debug("DefaultServerTransport(); transport created");
+	}
+	newTurn(e) {
+		return this._logger?.trace("DefaultServerTransport.newTurn();", { turnId: e.turnId }), this._createTurn(e);
+	}
+	close() {
+		this._logger?.trace("DefaultServerTransport.close();"), this._channel.unsubscribe(g, this._channelListener);
+		for (let e of this._registeredTurns.values()) e.controller.abort();
+		this._registeredTurns.clear(), this._turnManager.close(), this._logger?.debug("DefaultServerTransport.close(); transport closed");
+	}
+	_resolveFilter(e, t) {
+		let n = [...this._registeredTurns.keys()];
+		return e.all ? n : e.own && t ? n.filter((e) => this._registeredTurns.get(e)?.clientId === t) : e.clientId ? n.filter((t) => this._registeredTurns.get(t)?.clientId === e.clientId) : e.turnId && this._registeredTurns.has(e.turnId) ? [e.turnId] : [];
+	}
+	async _handleCancelMessage(t) {
+		let n = b(t), r = {};
+		n["x-ably-cancel-turn-id"] ? r.turnId = n[l] : n["x-ably-cancel-own"] === "true" ? r.own = !0 : n["x-ably-cancel-client-id"] ? r.clientId = n[f] : n["x-ably-cancel-all"] === "true" && (r.all = !0);
+		let i = this._resolveFilter(r, t.clientId);
+		if (i.length === 0) return;
+		this._logger?.debug("DefaultServerTransport._handleCancelMessage(); matched turns", {
+			matchedTurnIds: i,
+			filter: r
+		});
+		let a = /* @__PURE__ */ new Map();
+		for (let e of i) {
+			let t = this._registeredTurns.get(e);
+			a.set(e, t?.clientId ?? "");
+		}
+		let o = {
+			message: t,
+			filter: r,
+			matchedTurnIds: i,
+			turnOwners: a
+		};
+		for (let t of i) {
+			let n = this._registeredTurns.get(t);
+			if (n) try {
+				if (n.onCancel && !await n.onCancel(o)) {
+					this._logger?.debug("DefaultServerTransport._handleCancelMessage(); cancel rejected by onCancel", { turnId: t });
+					continue;
+				}
+				n.controller.abort(), this._logger?.debug("DefaultServerTransport._handleCancelMessage(); turn aborted", { turnId: t });
+			} catch (r) {
+				let i = new e.ErrorInfo(`unable to process cancel for turn ${t}; onCancel handler threw: ${r instanceof Error ? r.message : String(r)}`, W.CancelListenerError, 500, r instanceof e.ErrorInfo ? r : void 0);
+				this._logger?.error("DefaultServerTransport._handleCancelMessage(); onCancel threw", { turnId: t }), (n.onError ?? this._onError)?.(i);
+			}
+		}
+	}
+	_handleChannelMessage(t) {
+		try {
+			t.name === "x-ably-cancel" && this._handleCancelMessage(t).catch((t) => {
+				let n = new e.ErrorInfo(`unable to route cancel message; ${t instanceof Error ? t.message : String(t)}`, W.CancelListenerError, 500, t instanceof e.ErrorInfo ? t : void 0);
+				this._logger?.error("DefaultServerTransport._handleChannelMessage(); cancel routing error"), this._onError?.(n);
+			});
+		} catch (t) {
+			let n = new e.ErrorInfo(`unable to process channel message; ${t instanceof Error ? t.message : String(t)}`, W.TransportSubscriptionError, 500, t instanceof e.ErrorInfo ? t : void 0);
+			this._logger?.error("DefaultServerTransport._handleChannelMessage(); subscription error"), this._onError?.(n);
+		}
+	}
+	_createTurn(t) {
+		let { turnId: n, clientId: r, onMessage: i, onAbort: a, onCancel: o, onError: s, parent: c, forkOf: l } = t, u = new AbortController(), d = !1, f = !1, p = {
+			turnId: n,
+			clientId: r ?? "",
+			controller: u,
+			onCancel: o,
+			onError: s
+		};
+		this._registeredTurns.set(n, p);
+		let m = this._logger, h = this._turnManager, g = this._attachPromise, _ = this._codec, v = this._channel, y = this._registeredTurns;
+		return {
+			get turnId() {
+				return n;
+			},
+			get abortSignal() {
+				return u.signal;
+			},
+			start: async () => {
+				if (m?.trace("Turn.start();", { turnId: n }), u.signal.aborted) throw new e.ErrorInfo(`unable to start turn; turn ${n} was cancelled before start()`, W.InvalidArgument, 400);
+				if (!d) {
+					d = !0;
+					try {
+						await h.startTurn(n, r, u);
+					} catch (t) {
+						let r = new e.ErrorInfo(`unable to publish turn-start for turn ${n}; ${t instanceof Error ? t.message : String(t)}`, W.TurnLifecycleError, 500, t instanceof e.ErrorInfo ? t : void 0);
+						throw m?.error("Turn.start(); failed to publish turn-start", { turnId: n }), s?.(r), r;
+					}
+					m?.debug("Turn.start(); turn started", { turnId: n });
+				}
+			},
+			addMessages: async (t, r) => {
+				if (m?.trace("Turn.addMessages();", {
+					turnId: n,
+					count: t.length
+				}), !d) throw new e.ErrorInfo(`unable to add messages; start() must be called before addMessages() (turn ${n})`, W.InvalidArgument, 400);
+				await g;
+				let a = [];
+				for (let e of t) {
+					let t = crypto.randomUUID(), o = x(Q({
+						role: "user",
+						turnId: n,
+						msgId: t,
+						turnClientId: r?.clientId,
+						parent: r?.parent === void 0 ? c ?? void 0 : r.parent ?? void 0,
+						forkOf: r?.forkOf ?? l
+					}), e.headers);
+					await _.createEncoder(v, {
+						extras: { headers: o },
+						onMessage: i
+					}).writeMessages([e.message], r?.clientId ? { clientId: r.clientId } : void 0), a.push(o["x-ably-msg-id"] ?? t);
+				}
+				return m?.debug("Turn.addMessages(); messages published", {
+					turnId: n,
+					count: t.length
+				}), { msgIds: a };
+			},
+			streamResponse: async (t, r) => {
+				if (m?.trace("Turn.streamResponse();", { turnId: n }), !d) throw new e.ErrorInfo(`unable to stream response; start() must be called before streamResponse() (turn ${n})`, W.InvalidArgument, 400);
+				await g;
+				let o = h.getSignal(n), s = h.getClientId(n), u = r?.parent === void 0 ? c ?? void 0 : r.parent ?? void 0, f = Q({
+					role: "assistant",
+					turnId: n,
+					msgId: crypto.randomUUID(),
+					turnClientId: s,
+					parent: u,
+					forkOf: r?.forkOf ?? l
+				}), p = await Ge(t, _.createEncoder(v, {
+					extras: { headers: f },
+					onMessage: i
+				}), o, a, m);
+				return m?.debug("Turn.streamResponse(); stream finished", {
+					turnId: n,
+					reason: p.reason
+				}), p;
+			},
+			end: async (t) => {
+				if (m?.trace("Turn.end();", {
+					turnId: n,
+					reason: t
+				}), !d) throw new e.ErrorInfo(`unable to end turn; start() must be called before end() (turn ${n})`, W.InvalidArgument, 400);
+				if (!f) {
+					f = !0;
+					try {
+						await h.endTurn(n, t);
+					} catch (t) {
+						let r = new e.ErrorInfo(`unable to publish turn-end for turn ${n}; ${t instanceof Error ? t.message : String(t)}`, W.TurnLifecycleError, 500, t instanceof e.ErrorInfo ? t : void 0);
+						throw m?.error("Turn.end(); failed to publish turn-end", { turnId: n }), s?.(r), r;
+					} finally {
+						y.delete(n);
+					}
+					m?.debug("Turn.end(); turn ended", {
+						turnId: n,
+						reason: t
+					});
+				}
+			}
+		};
+	}
+}, Ye = (e) => new Je(e), Xe = (e) => $({
+	...e,
+	codec: G
+}), Ze = (e) => Ye({
+	...e,
+	codec: G
+});
+//#endregion
+export { G as UIMessageCodec, je as createChatTransport, Xe as createClientTransport, Ze as createServerTransport };
+
+//# sourceMappingURL=ably-ai-transport-vercel.js.map