@ably/ai-transport 0.0.1

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

@@ -0,0 +1,823 @@
+import { useCallback as e, useEffect as t, useRef as n, useState as r } from "react";
+import * as i from "ably";
+//#region src/react/use-ably-messages.ts
+var a = (e) => {
+	let [n, i] = r(() => e.getAblyMessages());
+	return t(() => (i(e.getAblyMessages()), e.on("ably-message", () => {
+		i(e.getAblyMessages());
+	})), [e]), n;
+}, o = "x-ably-turn-id", s = "x-ably-msg-id", c = "x-ably-turn-client-id", l = "x-ably-role", u = "x-ably-cancel-turn-id", d = "x-ably-cancel-own", f = "x-ably-cancel-all", p = "x-ably-cancel-client-id", m = "x-ably-parent", h = "x-ably-fork-of", g = "x-ably-cancel", _ = "x-ably-turn-start", v = "x-ably-turn-end", y = (e) => {
+	let [n, i] = r(() => /* @__PURE__ */ new Map());
+	return t(() => {
+		if (e) return i(e.getActiveTurnIds()), e.on("turn", (e) => {
+			i((t) => {
+				let n = new Map(t);
+				if (e.type === "x-ably-turn-start") {
+					let t = new Set(n.get(e.clientId) ?? []);
+					t.add(e.turnId), n.set(e.clientId, t);
+				} else {
+					let t = n.get(e.clientId);
+					t && (t.delete(e.turnId), t.size === 0 ? n.delete(e.clientId) : n.set(e.clientId, new Set(t)));
+				}
+				return n;
+			});
+		});
+	}, [e]), n;
+}, b = /* @__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;
+}({}), x = (e) => ({
+	logAction: (t, n, r) => {
+		e.error(n, { detail: r });
+	},
+	shouldLog: () => !0
+}), S = i.Realtime.EventEmitter, C = class extends S {
+	constructor(e) {
+		super(x(e));
+	}
+}, w = /* @__PURE__ */ function(e) {
+	return e.Trace = "trace", e.Debug = "debug", e.Info = "info", e.Warn = "warn", e.Error = "error", e.Silent = "silent", e;
+}({}), T = (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 w.Trace:
+		case w.Debug:
+			console.log(i);
+			break;
+		case w.Info:
+			console.info(i);
+			break;
+		case w.Warn:
+			console.warn(i);
+			break;
+		case w.Error:
+			console.error(i);
+			break;
+		case w.Silent: break;
+	}
+}, E = (e) => new k(e.logHandler ?? T, e.logLevel), D = /* @__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;
+}(D || {}), O = new Map([
+	[w.Trace, D.Trace],
+	[w.Debug, D.Debug],
+	[w.Info, D.Info],
+	[w.Warn, D.Warn],
+	[w.Error, D.Error],
+	[w.Silent, D.Silent]
+]), k = class e {
+	constructor(e, t, n) {
+		this._handler = e, this._context = n;
+		let r = O.get(t);
+		if (r === void 0) throw new i.ErrorInfo(`unable to create logger; invalid log level: ${t}`, b.InvalidArgument, 400);
+		this._levelNumber = r;
+	}
+	trace(e, t) {
+		this._write(e, w.Trace, D.Trace, t);
+	}
+	debug(e, t) {
+		this._write(e, w.Debug, D.Debug, t);
+	}
+	info(e, t) {
+		this._write(e, w.Info, D.Info, t);
+	}
+	warn(e, t) {
+		this._write(e, w.Warn, D.Warn, t);
+	}
+	error(e, t) {
+		this._write(e, w.Error, D.Error, t);
+	}
+	withContext(t) {
+		let n = [...O.entries()].find(([, e]) => e === this._levelNumber)?.[0] ?? w.Error;
+		return new e(this._handler, n, this._mergeContext(t));
+	}
+	_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;
+	}
+}, A = (e) => {
+	let t = e.extras;
+	if (!t || typeof t != "object") return {};
+	let n = t.headers;
+	return !n || typeof n != "object" ? {} : n;
+}, j = 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);
+	}
+}, M = (e, t) => new j(e, t), N = (e) => {
+	let t = [...e.rawMessages].toReversed(), n = e.codec.createDecoder(), r = /* @__PURE__ */ new Map(), i = e.codec.createAccumulator(), a = 0, c = /* @__PURE__ */ new Map(), l = /* @__PURE__ */ new Map();
+	for (let u of t) {
+		let t = n.decode(u), d = A(u), f = d[o], p = d[s], m = u.serial;
+		if (f) {
+			let n = r.get(f);
+			if (n || (n = {
+				accumulator: e.codec.createAccumulator(),
+				firstSeen: a++,
+				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), o = c.get(t);
+			if (o) {
+				r.set(t, o);
+				let e = l.get(t);
+				e && i.set(t, e);
+				let a = o[s];
+				a && n.add(a);
+			}
+		}
+		let a = [...t.msgHeaders.entries()].filter(([e]) => !n.has(e)), o = 0;
+		for (let n of t.accumulator.completedMessages) {
+			let s = e.getMessageKey(n), c = a[o];
+			if (!r.has(s) && c) {
+				let [e, n] = c;
+				r.set(s, n);
+				let a = t.msgSerials.get(e);
+				a && i.set(s, a), o++;
+			}
+		}
+		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();
+}, P = async (e, t, n) => {
+	e.rawMessages.push(...t.items), e.lastAblyPage = t;
+	let r = N(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 = N(e).length;
+	}
+}, F = (e, t) => {
+	let n = N(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 F(e, t);
+			if (!o || !e.lastAblyPage) return;
+			let n = await e.lastAblyPage.next();
+			if (n) return await P(e, n, t), F(e, t);
+		}
+	};
+}, I = 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 P(a, await e.history({
+		untilAttach: !0,
+		limit: o
+	}), i), F(a, i);
+}, L = (e) => {
+	let t = {
+		[l]: e.role,
+		[o]: e.turnId,
+		[s]: e.msgId
+	};
+	return e.turnClientId !== void 0 && (t[c] = e.turnClientId), e.parent && (t[m] = e.parent), e.forkOf && (t[h] = e.forkOf), t;
+}, R = class {
+	constructor(e, t) {
+		this._turns = /* @__PURE__ */ new Map(), this._isTerminal = e, this._logger = t;
+	}
+	createStream(e) {
+		this._logger.trace("StreamRouter.createStream();", { turnId: e });
+		let t = {}, n = new ReadableStream({ start(e) {
+			t.controller = e;
+		} });
+		if (!t.controller) throw new i.ErrorInfo("unable to create stream; ReadableStream start() was not called synchronously", b.TransportSubscriptionError, 500);
+		return this._turns.set(e, {
+			controller: t.controller,
+			turnId: e
+		}), n;
+	}
+	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);
+	}
+}, z = (e, t) => new R(e, t), B = () => {}, V = 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 ?? E({ logLevel: w.Silent })).withContext({ component: "ClientTransport" }), this._emitter = new C(this._logger), this._tree = M(this._codec.getMessageKey.bind(this._codec), this._logger), this._router = z(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[m] = 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(e) {
+		if (!this._closed) {
+			this._ablyMessages.push(e), this._emitter.emit("ably-message");
+			try {
+				if (e.name === "x-ably-turn-start") {
+					let t = A(e), n = t[o], r = t["x-ably-turn-client-id"] ?? "";
+					n && (this._turnClientIds.set(n, r), this._emitter.emit("turn", {
+						type: _,
+						turnId: n,
+						clientId: r
+					}));
+					return;
+				}
+				if (e.name === "x-ably-turn-end") {
+					let t = A(e), n = t[o], r = t["x-ably-turn-client-id"] ?? "", i = t["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 t = this._decoder.decode(e), n = A(e), r = e.serial, i = n[o];
+				i && this._updateTurnObserverHeaders(i, n, r);
+				for (let i of t) i.kind === "message" ? this._handleMessageOutput(i.message, n, r, e.action) : this._handleEventOutput(i, n);
+			} catch (e) {
+				let t = e instanceof i.ErrorInfo ? e : void 0;
+				this._emitter.emit("error", new i.ErrorInfo(`unable to process channel message; ${e instanceof Error ? e.message : String(e)}`, b.TransportSubscriptionError, 500, t));
+			}
+		}
+	}
+	_handleMessageOutput(e, t, n, r) {
+		let i = t[s];
+		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[o];
+		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[u] = e.turnId : e.own ? t[d] = "true" : e.clientId ? t[p] = e.clientId : e.all && (t[f] = "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?.[s] === 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(e, t) {
+		if (this._closed || (await this._attachPromise, this._closed)) throw new i.ErrorInfo("unable to send; transport is closed", b.TransportClosed, 400);
+		this._logger.trace("ClientTransport.send();");
+		let n = Array.isArray(e) ? e : [e], r = crypto.randomUUID();
+		this._ownTurnIds.add(r);
+		let a = /* @__PURE__ */ new Set(), o = [], c = this._getMessagesWithHeaders(), u;
+		if (t?.parent === void 0 && !t?.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 = t?.parent === void 0 ? u : t.parent;
+		for (let e of n) {
+			let n = crypto.randomUUID();
+			this._ownMsgIds.add(n), a.add(n);
+			let i = t?.parent === void 0 ? u : t.parent ?? void 0, c = L({
+				role: "user",
+				turnId: r,
+				msgId: n,
+				turnClientId: this._clientId,
+				parent: i,
+				forkOf: t?.forkOf
+			});
+			this._upsertAndNotify(e, c);
+			let d = {
+				[s]: n,
+				[l]: "user"
+			};
+			i && (d[m] = i), o.push({
+				message: e,
+				headers: d
+			}), t?.parent === void 0 && !t?.forkOf && (u = n);
+		}
+		this._turnMsgIds.set(r, a);
+		let f = this._router.createStream(r), p = this._headersFn?.() ?? {}, h = {
+			...this._bodyFn?.() ?? {},
+			history: c,
+			...t?.body,
+			turnId: r,
+			clientId: this._clientId,
+			messages: o,
+			...t?.forkOf !== void 0 && { forkOf: t.forkOf },
+			...d !== void 0 && { parent: d }
+		}, g = {
+			...p,
+			...t?.headers
+		};
+		return this._fetchFn(this._api, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				...g
+			},
+			body: JSON.stringify(h),
+			...this._credentials ? { credentials: this._credentials } : {}
+		}).then((e) => {
+			e.ok || (this._emitter.emit("error", new i.ErrorInfo(`unable to send; HTTP POST to ${this._api} returned ${String(e.status)} ${e.statusText}`, b.TransportSendFailed, e.status)), this._router.closeStream(r));
+		}).catch((e) => {
+			let t = e instanceof i.ErrorInfo ? e : void 0;
+			this._emitter.emit("error", new i.ErrorInfo(`unable to send; HTTP POST to ${this._api} failed: ${e instanceof Error ? e.message : String(e)}`, b.TransportSendFailed, 500, t)), this._router.closeStream(r);
+		}), {
+			stream: f,
+			turnId: r,
+			cancel: async () => this.cancel({ turnId: r })
+		};
+	}
+	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 B;
+		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(e) {
+		if (this._closed) throw new i.ErrorInfo("unable to load history; transport is closed", b.TransportClosed, 400);
+		this._logger.trace("ClientTransport.history();", { limit: e?.limit });
+		let t = e?.limit ?? 100, n = new Set(this._tree.flatten().map((e) => this._codec.getMessageKey(e))), r = await I(this._channel, this._codec, e, this._logger), a = await this._loadUntilVisible(r, t, n);
+		r = a.lastPage;
+		let o = a.newVisible;
+		for (let e of o) this._withheldKeys.add(this._codec.getMessageKey(e));
+		let s = o.slice(-t), c = o.slice(0, -t);
+		this._releaseWithheld(s);
+		let l = (e) => ({
+			items: e,
+			hasNext: () => c.length > 0 || r.hasNext(),
+			next: async () => {
+				if (c.length > 0) {
+					let e = c.splice(-t, t);
+					return this._releaseWithheld(e), l(e);
+				}
+				if (!r.hasNext()) return;
+				let e = await r.next();
+				if (!e) return;
+				let i = new Set(n);
+				for (let e of this._tree.flatten()) i.add(this._codec.getMessageKey(e));
+				let a = await this._loadUntilVisible(e, t, i);
+				r = a.lastPage;
+				let o = a.newVisible;
+				for (let e of o) this._withheldKeys.add(this._codec.getMessageKey(e));
+				let s = o.splice(-t, t);
+				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;
+		}
+	}
+}, H = (e) => new V(e), U = (e) => {
+	let t = n(null);
+	return t.current === null && (t.current = H(e)), t.current;
+}, W = (n) => {
+	let [i, a] = r(() => n.getMessages());
+	return t(() => (a(n.getMessages()), n.on("message", () => {
+		a(n.getMessages());
+	})), [n]), {
+		messages: i,
+		getSiblings: e((e) => n.getTree().getSiblings(e), [n]),
+		hasSiblings: e((e) => n.getTree().hasSiblings(e), [n]),
+		getSelectedIndex: e((e) => n.getTree().getSelectedIndex(e), [n]),
+		selectSibling: e((e, t) => {
+			n.getTree().select(e, t), a(n.getMessages());
+		}, [n])
+	};
+}, G = (t) => e(async (e, n, r) => t.edit(e, n, r), [t]), K = (i, a) => {
+	let [o, s] = r(!1), [c, l] = r(!1), u = n(!1), d = n(null), f = n(i);
+	f.current = i;
+	let p = e(async (e) => {
+		if (!(!f.current || u.current)) {
+			u.current = !0, l(!0);
+			try {
+				let t = await f.current.history(e);
+				d.current = t, s(t.hasNext());
+			} finally {
+				u.current = !1, l(!1);
+			}
+		}
+	}, []), m = e(async () => {
+		let e = d.current;
+		if (!(!e || !e.hasNext() || u.current || !f.current)) {
+			u.current = !0, l(!0);
+			try {
+				let t = await e.next();
+				t ? (d.current = t, s(t.hasNext())) : s(!1);
+			} finally {
+				u.current = !1, l(!1);
+			}
+		}
+	}, []), h = a != null, g = n(!1), _ = n(a);
+	return _.current = a, t(() => {
+		!h || g.current || !f.current || (g.current = !0, p(_.current ?? void 0));
+	}, [h, p]), {
+		hasNext: o,
+		loading: c,
+		load: p,
+		next: m
+	};
+}, q = (e) => {
+	let [n, i] = r(() => e.getMessages());
+	return t(() => (i(e.getMessages()), e.on("message", () => {
+		i(e.getMessages());
+	})), [e]), n;
+}, J = (t) => e(async (e, n) => t.regenerate(e, n), [t]), Y = (t) => e(async (e, n) => t.send(e, n), [t]);
+//#endregion
+export { a as useAblyMessages, y as useActiveTurns, U as useClientTransport, W as useConversationTree, G as useEdit, K as useHistory, q as useMessages, J as useRegenerate, Y as useSend };
+
+//# sourceMappingURL=ably-ai-transport-react.js.map