@ably/ai-transport 0.0.1 → 0.2.0

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

@@ -1,407 +1,68 @@
 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) => {
+var n = "stream", r = "status", i = "stream-id", a = "discrete", o = "run-id", s = "invocation-id", c = "event-id", l = "codec-message-id", u = "run-client-id", d = "input-client-id", f = "role", p = "parent", m = "fork-of", h = "msg-regenerate", g = "run-reason", _ = "input-codec-message-id", v = "error-code", y = "ai-cancel", b = "ai-run-start", x = "ai-run-suspend", S = "ai-run-resume", C = "ai-run-end", w = "ai-output", T = "ai-input", E = (e, t) => {
+	let n = e.extras;
+	if (!n || typeof n != "object") return {};
+	let r = n.ai;
+	if (!r || typeof r != "object") return {};
+	let i = r[t];
+	return !i || typeof i != "object" ? {} : i;
+}, D = (e) => E(e, "transport"), O = (e) => E(e, "codec"), ee = (e) => {
 	if (e !== void 0) try {
 		return JSON.parse(e);
 	} catch {
 		return;
 	}
-}, x = (e, t) => ({
+}, te = (e, t) => ({
 	...e,
 	...t
-}), te = (e) => {
+}), k = (e) => {
 	if (e !== void 0) return e === "true";
-}, S = (e, t) => e[y + t], C = (e) => {
+}, A = (e, t) => e.serial === void 0 && t.serial === void 0 ? 0 : e.serial === void 0 ? 1 : t.serial === void 0 || e.serial < t.serial ? -1 : +(e.serial > t.serial), j = (e, t) => e[t], M = (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 = () => {
+}, N = (e) => ({
+	str: (t) => j(e, t),
+	strOr: (t, n) => j(e, t) ?? n,
+	bool: (t) => k(j(e, t)),
+	json: (t) => ee(j(e, t))
+}), P = () => {
 	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),
+		str: (n, r) => (r !== void 0 && (e[n] = r), t),
+		bool: (n, r) => (r !== void 0 && (e[n] = String(r)), t),
+		json: (n, r) => (r != null && (e[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 {
+}, F = 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();", {
+		switch (this._logger?.trace("DefaultDecoderCore.decode();", {
 			action: t,
 			serial: e.serial,
 			name: e.name
-		});
-		let n;
-		switch (t) {
+		}), 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;
+				return t.transportHeaders?.stream === "true" ? this._decodeStreamedCreate(t, e.serial) : this._hooks.decodeDiscrete(t);
 			}
-			case "message.append":
-				n = this._decodeAppend(e);
-				break;
-			case "message.update":
-				n = this._decodeUpdate(e);
-				break;
-			case "message.delete":
-				n = this._decodeDelete(e);
-				break;
+			case "message.append": return this._decodeAppend(e);
+			case "message.update": return this._decodeUpdate(e);
+			case "message.delete": return this._decodeDelete(e);
 			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)
+			transportHeaders: D(e),
+			codecHeaders: O(e)
 		};
 	}
 	_stringData(e) {
@@ -423,42 +84,43 @@ var n = "x-ably-stream", r = "x-ably-status", i = "x-ably-stream-id", a = "x-abl
 	}
 	_decodeStreamedCreate(e, t) {
 		if (!t) return [];
-		let n = e.headers?.["x-ably-stream-id"] ?? "", r = e.headers ?? {}, i = {
+		let n = e.transportHeaders?.["stream-id"] ?? "", r = {
 			name: e.name,
 			streamId: n,
 			accumulated: "",
-			headers: { ...r },
+			codecHeaders: { ...e.codecHeaders },
+			transportHeaders: { ...e.transportHeaders },
 			closed: !1
 		};
-		return this._serialState.set(t, i), this._logger?.debug("DefaultDecoderCore._decodeStreamedCreate(); new stream", {
+		return this._serialState.set(t, r), this._logger?.debug("DefaultDecoderCore._decodeStreamedCreate(); new stream", {
 			name: e.name,
 			streamId: n,
 			serial: t
-		}), this._hooks.buildStartEvents(i);
+		}), this._hooks.buildStartEvents(r);
 	}
 	_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;
+		let i = D(e), a = O(e), o = typeof e.data == "string" ? e.data : "", s = i[r], c = [];
+		return o.length > 0 && (n.accumulated += o, c.push(...this._hooks.buildDeltaEvents(n, o))), s === "complete" && !n.closed ? (n.closed = !0, c.push(...this._hooks.buildEndEvents(n, a)), this._logger?.debug("DefaultDecoderCore._decodeAppend(); stream complete", { streamId: n.streamId })) : s === "cancelled" && !n.closed && (n.closed = !0, this._logger?.debug("DefaultDecoderCore._decodeAppend(); stream cancelled", { streamId: n.streamId })), c;
 	}
 	_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;
+		let i = this._toPayload(e), a = i.transportHeaders ?? {}, o = i.codecHeaders ?? {}, s = a[n] === "true", c = a[r], l = this._serialState.get(t);
+		if (!l) return this._decodeFirstContact(i, s, c, t);
+		let u = this._stringData(e);
+		if (u.startsWith(l.accumulated)) {
+			let e = u.slice(l.accumulated.length), t = [];
+			return e.length > 0 && (l.accumulated = u, t.push(...this._hooks.buildDeltaEvents(l, e))), c === "complete" && !l.closed ? (l.closed = !0, t.push(...this._hooks.buildEndEvents(l, o))) : c === "cancelled" && !l.closed && (l.closed = !0), t;
 		}
-		return c.accumulated = l, c.headers = { ...a }, this._invokeOnStreamUpdate(c), [];
+		return l.accumulated = u, l.codecHeaders = { ...o }, l.transportHeaders = { ...a }, this._invokeOnStreamUpdate(l), [];
 	}
 	_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 : "";
+		let i = e.transportHeaders?.["stream-id"] ?? "", a = e.codecHeaders ?? {}, o = typeof e.data == "string" ? e.data : "";
 		this._logger?.debug("DefaultDecoderCore._decodeFirstContact(); first-contact stream", {
 			name: e.name,
 			streamId: i,
@@ -468,12 +130,13 @@ var n = "x-ably-stream", r = "x-ably-status", i = "x-ably-stream-id", a = "x-abl
 			name: e.name,
 			streamId: i,
 			accumulated: o,
-			headers: { ...a },
-			closed: n === "finished" || n === "aborted"
+			codecHeaders: { ...a },
+			transportHeaders: { ...e.transportHeaders },
+			closed: n === "complete" || n === "cancelled"
 		};
 		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;
+		return o.length > 0 && c.push(...this._hooks.buildDeltaEvents(s, o)), n === "complete" && c.push(...this._hooks.buildEndEvents(s, a)), c;
 	}
 	_decodeDelete(e) {
 		let t = e.serial;
@@ -481,7 +144,7 @@ var n = "x-ably-stream", r = "x-ably-status", i = "x-ably-stream-id", a = "x-abl
 		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 {
+}, I = (e, t = {}) => new F(e, t), L = class {
 	constructor(e) {
 		this._emitted = /* @__PURE__ */ new Map(), this._phases = e;
 	}
@@ -503,32 +166,32 @@ var n = "x-ably-stream", r = "x-ably-status", i = "x-ably-stream-id", a = "x-abl
 		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);
+}, ne = (e) => new L(e), R = (e) => {
+	let t = N(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) => {
+}, z = (e, t) => e === "stop" || e === "length" || e === "content-filter" || e === "tool-calls" || e === "error" || e === "other" ? e : t, B = (e) => e.startsWith("data-"), V = (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({
+}, H = (e) => R(e.codecHeaders).strOr("type", ""), U = (e) => {
+	let t = R(e.codecHeaders);
+	switch (H(e)) {
+		case "text": return M({
 			type: "text-start",
 			id: e.streamId,
 			providerMetadata: t.providerMetadata()
 		});
-		case "reasoning": return C({
+		case "reasoning": return M({
 			type: "reasoning-start",
 			id: e.streamId,
 			providerMetadata: t.providerMetadata()
 		});
-		case "tool-input": return C({
+		case "tool-input": return M({
 			type: "tool-input-start",
 			toolCallId: e.streamId,
 			toolName: t.strOr("toolName", ""),
@@ -542,8 +205,8 @@ var n = "x-ably-stream", r = "x-ably-status", i = "x-ably-stream-id", a = "x-abl
 			id: e.streamId
 		};
 	}
-}, M = (e, t) => {
-	switch (e.name) {
+}, re = (e, t) => {
+	switch (H(e)) {
 		case "text": return {
 			type: "text-delta",
 			id: e.streamId,
@@ -565,24 +228,24 @@ var n = "x-ably-stream", r = "x-ably-status", i = "x-ably-stream-id", a = "x-abl
 			delta: t
 		};
 	}
-}, N = (e, t) => {
-	let n = O(t);
-	switch (e.name) {
-		case "text": return C({
+}, ie = (e, t) => {
+	let n = R(t);
+	switch (H(e)) {
+		case "text": return M({
 			type: "text-end",
 			id: e.streamId,
 			providerMetadata: n.providerMetadata()
 		});
-		case "reasoning": return C({
+		case "reasoning": return M({
 			type: "reasoning-end",
 			id: e.streamId,
 			providerMetadata: n.providerMetadata()
 		});
-		case "tool-input": return C({
+		case "tool-input": return M({
 			type: "tool-input-available",
 			toolCallId: e.streamId,
-			toolName: n.strOr("toolName", O(e.headers).strOr("toolName", "")),
-			input: ue(e.accumulated),
+			toolName: n.strOr("toolName", R(e.codecHeaders).strOr("toolName", "")),
+			input: V(e.accumulated),
 			providerMetadata: n.providerMetadata()
 		});
 		default: return {
@@ -590,56 +253,53 @@ var n = "x-ably-stream", r = "x-ably-status", i = "x-ably-stream-id", a = "x-abl
 			id: e.streamId
 		};
 	}
-}, P = () => ce([{
+}, ae = () => ne([{
 	key: "start",
-	build: (e) => [C({
+	build: (e) => [M({
 		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({
+}]), oe = (e, t, n) => (n.markEmitted(t, "start"), [M({
 	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({
+})]), se = (e, t) => (t.markEmitted(e, "start-step"), [{ type: "start-step" }]), ce = (e, t) => (t.resetPhase(e, "start-step"), [{ type: "finish-step" }]), le = (e, t, n) => (n.clearScope(t), [M({
 	type: "finish",
-	finishReason: le(e.str("finishReason"), "stop"),
+	finishReason: z(e.str("finishReason"), "stop"),
 	messageMetadata: e.json("messageMetadata")
-}))), B = (e) => k({
+})]), ue = (e, t, n) => (n.clearScope(t), [{
 	type: "error",
 	errorText: typeof e == "string" ? e : ""
-}), V = (e, t, n) => (n.clearScope(t), k(C({
+}]), de = (e, t, n) => (n.clearScope(t), [M({
 	type: "abort",
 	reason: typeof e == "string" && e ? e : void 0
-}))), H = (e) => k({
+})]), fe = (e) => [{
 	type: "message-metadata",
 	messageMetadata: e.json("messageMetadata")
-}), U = (e, t) => k(C({
+}], pe = (e, t) => [M({
 	type: "file",
 	url: typeof t == "string" ? t : "",
 	mediaType: e.strOr("mediaType", ""),
 	providerMetadata: e.providerMetadata()
-})), de = (e, t) => k(C({
+})], me = (e, t) => [M({
 	type: "source-url",
 	sourceId: e.strOr("sourceId", ""),
 	url: typeof t == "string" ? t : "",
 	title: e.str("title"),
 	providerMetadata: e.providerMetadata()
-})), fe = (e) => k(C({
+})], he = (e) => [M({
 	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) => {
+})], ge = (e, t) => {
 	let n = t;
-	return k(C({
+	return [M({
 		type: "tool-input-error",
 		toolCallId: e.strOr("toolCallId", ""),
 		toolName: e.strOr("toolName", ""),
@@ -649,64 +309,59 @@ var n = "x-ably-stream", r = "x-ably-status", i = "x-ably-stream-id", a = "x-abl
 		title: e.str("title"),
 		providerExecuted: e.bool("providerExecuted"),
 		providerMetadata: e.providerMetadata()
-	}));
-}, me = (e, t) => {
+	})];
+}, _e = (e, t) => {
 	let n = t;
-	return k(C({
+	return [M({
 		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) => {
+	})];
+}, ve = (e, t) => {
 	let n = t;
-	return k(C({
+	return [M({
 		type: "tool-output-error",
 		toolCallId: e.strOr("toolCallId", ""),
 		errorText: n?.errorText ?? "",
 		dynamic: e.bool("dynamic"),
 		providerExecuted: e.bool("providerExecuted")
-	}));
-}, ge = (e) => k({
+	})];
+}, ye = (e) => [{
 	type: "tool-approval-request",
 	toolCallId: e.strOr("toolCallId", ""),
 	approvalId: e.strOr("approvalId", "")
-}), _e = (e) => k({
+}], be = (e) => [{
 	type: "tool-output-denied",
 	toolCallId: e.strOr("toolCallId", "")
-}), ve = (e, t, n) => k(C({
+}], xe = (e, t, n) => [M({
 	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) {
+})], Se = (e, t, n, r) => [
+	...r.ensurePhases(n, { messageId: e.str("messageId") }),
+	M({
+		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()
+	}),
+	M({
+		type: "tool-input-available",
+		toolCallId: e.strOr("toolCallId", ""),
+		toolName: e.strOr("toolName", ""),
+		input: t,
+		providerMetadata: e.providerMetadata()
+	})
+], Ce = (e) => {
+	let t = R(e.codecHeaders ?? {}), n = e.transportHeaders?.role ?? "user", r = t.str("messageId") ?? "", i = t.strOr("type", ""), a;
+	switch (i) {
 		case "text":
 			a = {
 				type: "text",
@@ -716,69 +371,110 @@ var n = "x-ably-stream", r = "x-ably-status", i = "x-ably-stream-id", a = "x-abl
 		case "file":
 			a = {
 				type: "file",
-				mediaType: n.strOr("mediaType", ""),
+				mediaType: t.strOr("mediaType", ""),
 				url: typeof e.data == "string" ? e.data : ""
 			};
 			break;
 		default:
-			A(e.name) && (a = C({
-				type: e.name,
-				id: n.str("id"),
+			B(i) && (a = M({
+				type: i,
+				id: t.str("id"),
 				data: e.data
 			}));
 			break;
 	}
 	return a ? [{
-		kind: "message",
+		kind: "user-message",
 		message: {
-			id: i,
-			role: r,
+			id: r,
+			role: n,
 			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) => ({
+}, we = (e, t) => (e === "text" || e === "file" || B(e)) && "discrete" in t, Te = (e, t, n) => {
+	let r = n;
+	return [{
+		kind: "tool-result",
+		codecMessageId: e,
+		payload: {
+			toolCallId: t.strOr("toolCallId", ""),
+			output: r?.output
+		}
+	}];
+}, Ee = (e, t, n) => {
+	let r = n;
+	return [{
+		kind: "tool-result-error",
+		codecMessageId: e,
+		payload: {
+			toolCallId: t.strOr("toolCallId", ""),
+			message: r?.message ?? ""
+		}
+	}];
+}, De = (e, t) => [{
+	kind: "tool-approval-response",
+	codecMessageId: e,
+	payload: M({
+		toolCallId: t.strOr("toolCallId", ""),
+		approved: t.bool("approved") ?? !1,
+		reason: t.str("reason")
+	})
+}], Oe = (e, t, n, r, i) => {
+	switch (e) {
+		case "start": return oe(t, r, i);
+		case "start-step": return se(r, i);
+		case "finish-step": return ce(r, i);
+		case "finish": return le(t, r, i);
+		case "error": return ue(n, r, i);
+		case "abort": return de(n, r, i);
+		case "message-metadata": return fe(t);
+		case "file": return pe(t, n);
+		case "source-url": return me(t, n);
+		case "source-document": return he(t);
+		case "tool-input": return Se(t, n, r, i);
+		case "tool-input-error": return ge(t, n);
+		case "tool-output-available": return _e(t, n);
+		case "tool-output-error": return ve(t, n);
+		case "tool-approval-request": return ye(t);
+		case "tool-output-denied": return be(t);
+		default: return B(e) ? xe(e, t, n) : [];
+	}
+}, ke = (e, t, n) => {
+	if (we(e, t.transportHeaders ?? {})) return Ce(t);
+	let r = t.transportHeaders?.["codec-message-id"] ?? "";
+	switch (e) {
+		case "tool-result": return Te(r, n, t.data);
+		case "tool-result-error": return Ee(r, n, t.data);
+		case "tool-approval-response": return De(r, n);
+		case "regenerate": return [];
+		default: return [];
+	}
+}, Ae = (e, t) => {
+	let n = R(e.codecHeaders ?? {}), r = e.transportHeaders?.["run-id"] ?? "", i = n.strOr("type", "");
+	return e.name === "ai-input" ? ke(i, e, n) : e.name === "ai-output" ? Oe(i, n, e.data, r, t) : [];
+}, je = (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;
+		let n = t.transportHeaders["run-id"] ?? "", r = R(t.codecHeaders).str("messageId");
+		return [...e.ensurePhases(n, { messageId: r }), U(t)];
 	},
-	buildDeltaEvents: (e, t) => k(M(e, t)),
-	buildEndEvents: (e, t) => k(N(e, t)),
-	decodeDiscrete: (t) => Se(t, e)
-}), we = class {
+	buildDeltaEvents: (e, t) => [re(e, t)],
+	buildEndEvents: (e, t) => [ie(e, t)],
+	decodeDiscrete: (t) => Ae(t, e)
+}), Me = (e) => "kind" in e, Ne = class {
 	constructor(e = {}) {
-		this._core = oe(Ce(P()), e);
+		this._core = I(je(ae()), e);
 	}
 	decode(e) {
-		return this._core.decode(e);
+		let t = this._core.decode(e), n = [], r = [];
+		for (let e of t) Me(e) ? n.push(e) : r.push(e);
+		return {
+			inputs: n,
+			outputs: r
+		};
 	}
-}, 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 {
+}, Pe = (e = {}) => new Ne(e), W = /* @__PURE__ */ function(e) {
+	return e[e.BadRequest = 4e4] = "BadRequest", e[e.InvalidArgument = 40003] = "InvalidArgument", e[e.InsufficientCapability = 40160] = "InsufficientCapability", e[e.EncoderRecoveryFailed = 104e3] = "EncoderRecoveryFailed", e[e.SessionSubscriptionError = 104001] = "SessionSubscriptionError", e[e.CancelListenerError = 104002] = "CancelListenerError", e[e.RunLifecycleError = 104003] = "RunLifecycleError", e[e.SessionClosed = 104004] = "SessionClosed", e[e.SessionSendFailed = 104005] = "SessionSendFailed", e[e.ChannelContinuityLost = 104006] = "ChannelContinuityLost", e[e.ChannelNotReady = 104007] = "ChannelNotReady", e[e.StreamError = 104008] = "StreamError", e[e.InputEventNotFound = 104010] = "InputEventNotFound", e;
+}({}), Fe = (e, t) => e.code === t, Ie = 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" });
 	}
@@ -789,7 +485,7 @@ var n = "x-ably-stream", r = "x-ably-status", i = "x-ably-stream-id", a = "x-abl
 	}
 	async publishDiscreteBatch(e, t) {
 		this._assertNotClosed(), this._logger?.trace("DefaultEncoderCore.publishDiscreteBatch();", { count: e.length });
-		let n = e.map((e) => this._buildDiscreteMessage(e, t));
+		let n = e.map((e) => this._buildDiscreteMessage(e, t, !0));
 		return this._writer.publish(n);
 	}
 	async startStream(t, a, o) {
@@ -797,28 +493,29 @@ var n = "x-ably-stream", r = "x-ably-status", i = "x-ably-stream-id", a = "x-abl
 			name: a.name,
 			streamId: t
 		});
-		let s = this._buildHeaders(a.headers ?? {}, o);
+		let s = this._buildTransport(a.transportHeaders, o);
 		s[n] = "true", s[r] = "streaming", s[i] = t;
-		let c = this._resolveClientId(o), l = {
+		let c = a.codecHeaders ?? {}, l = this._resolveClientId(o), u = {
 			name: a.name,
 			data: a.data,
-			extras: { headers: s },
-			...c ? { clientId: c } : {}
+			extras: { ai: this._aiExtras(s, c) },
+			...l ? { clientId: l } : {}
 		};
-		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._invokeOnMessage(u);
+		let d = (await this._writer.publish(u)).serials[0];
+		if (!d) 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,
+			serial: d,
 			name: a.name,
 			streamId: t,
 			accumulated: a.data,
-			persistentHeaders: s,
-			aborted: !1
+			persistentTransport: s,
+			persistentCodec: c,
+			cancelled: !1
 		}), this._logger?.debug("DefaultEncoderCore.startStream(); stream started", {
 			name: a.name,
 			streamId: t,
-			serial: u
+			serial: d
 		});
 	}
 	appendStream(t, n) {
@@ -829,7 +526,7 @@ var n = "x-ably-stream", r = "x-ably-status", i = "x-ably-stream-id", a = "x-abl
 		let i = {
 			serial: r.serial,
 			data: n,
-			extras: { headers: { ...r.persistentHeaders } }
+			extras: { ai: this._aiExtras({ ...r.persistentTransport }, { ...r.persistentCodec }) }
 		};
 		this._invokeOnMessage(i);
 		let a = this._writer.appendMessage(i);
@@ -843,54 +540,54 @@ var n = "x-ably-stream", r = "x-ably-status", i = "x-ably-stream-id", a = "x-abl
 		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 = {
+		let { transport: a, codec: o } = this._buildClosing(i, n);
+		a[r] = "complete";
+		let s = {
 			serial: i.serial,
 			data: n.data,
-			extras: { headers: a }
+			extras: { ai: this._aiExtras(a, o) }
 		};
-		this._invokeOnMessage(o);
-		let s = this._writer.appendMessage(o);
+		this._invokeOnMessage(s);
+		let c = this._writer.appendMessage(s);
 		this._pending.push({
-			promise: s,
+			promise: c,
 			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 });
+	async cancelStream(t, n) {
+		this._assertNotClosed(), this._logger?.trace("DefaultEncoderCore.cancelStream();", { 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 = {
+		if (!i) throw new e.ErrorInfo(`unable to cancel stream; no active stream for streamId '${t}'`, W.InvalidArgument, 400);
+		i.cancelled = !0;
+		let { transport: a, codec: o } = this._buildClosing(i, void 0, n);
+		a[r] = "cancelled";
+		let s = {
 			serial: i.serial,
 			data: "",
-			extras: { headers: a }
+			extras: { ai: this._aiExtras(a, o) }
 		};
-		this._invokeOnMessage(o);
-		let s = this._writer.appendMessage(o);
+		this._invokeOnMessage(s);
+		let c = this._writer.appendMessage(s);
 		this._pending.push({
-			promise: s,
+			promise: c,
 			streamId: t
-		}), await this._flushPending(), this._logger?.debug("DefaultEncoderCore.abortStream(); stream aborted", { streamId: t });
+		}), await this._flushPending(), this._logger?.debug("DefaultEncoderCore.cancelStream(); stream cancelled", { streamId: t });
 	}
-	async abortAllStreams(e) {
-		this._assertNotClosed(), this._logger?.trace("DefaultEncoderCore.abortAllStreams();", { streamCount: this._trackers.size });
+	async cancelAllStreams(e) {
+		this._assertNotClosed(), this._logger?.trace("DefaultEncoderCore.cancelAllStreams();", { 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 = {
+			t.cancelled = !0;
+			let { transport: n, codec: i } = this._buildClosing(t, void 0, e);
+			n[r] = "cancelled";
+			let a = {
 				serial: t.serial,
 				data: "",
-				extras: { headers: n }
+				extras: { ai: this._aiExtras(n, i) }
 			};
-			this._invokeOnMessage(i);
-			let a = this._writer.appendMessage(i);
+			this._invokeOnMessage(a);
+			let o = this._writer.appendMessage(a);
 			this._pending.push({
-				promise: a,
+				promise: o,
 				streamId: t.streamId
 			});
 		}
@@ -923,13 +620,13 @@ var n = "x-ably-stream", r = "x-ably-status", i = "x-ably-stream-id", a = "x-abl
 		for (let e of i) {
 			let t = this._trackers.get(e);
 			if (!t) continue;
-			let n = t.aborted ? "aborted" : "finished", i = {
+			let n = t.cancelled ? "cancelled" : "complete", i = {
 				serial: t.serial,
 				data: t.accumulated,
-				extras: { headers: {
-					...t.persistentHeaders,
+				extras: { ai: this._aiExtras({
+					...t.persistentTransport,
 					[r]: n
-				} }
+				}, { ...t.persistentCodec }) }
 			};
 			try {
 				await this._writer.updateMessage(i);
@@ -969,429 +666,878 @@ var n = "x-ably-stream", r = "x-ably-status", i = "x-ably-stream-id", a = "x-abl
 	_resolveClientId(e) {
 		return e?.clientId ?? this._defaultClientId;
 	}
-	_buildHeaders(e, t) {
+	_buildTransport(e, t) {
 		let n = {
-			...x(this._defaultExtras?.headers, t?.extras?.headers),
+			...te(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 = {
+		return t?.messageId !== void 0 && (n[l] = t.messageId), n;
+	}
+	_aiExtras(e, t) {
+		return Object.keys(t).length > 0 ? {
+			transport: e,
+			codec: t
+		} : { transport: e };
+	}
+	_buildDiscreteMessage(e, t, r = !1) {
+		let i = this._buildTransport(e.transportHeaders, t);
+		i[n] = "false", r && (i[a] = "true");
+		let o = this._resolveClientId(t), s = {
 			name: e.name,
 			data: e.data,
 			extras: {
-				headers: r,
+				ai: this._aiExtras(i, e.codecHeaders ?? {}),
 				...e.ephemeral ? { ephemeral: !0 } : {}
 			},
-			...i ? { clientId: i } : {}
+			...o ? { clientId: o } : {}
 		};
-		return this._invokeOnMessage(a), a;
+		return this._invokeOnMessage(s), s;
 	}
-	_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;
+	_buildClosing(e, t, n) {
+		let r = te(this._defaultExtras?.headers, n?.extras?.headers);
+		return {
+			transport: {
+				...e.persistentTransport,
+				...r,
+				...t?.transportHeaders
+			},
+			codec: {
+				...e.persistentCodec,
+				...t?.codecHeaders
+			}
+		};
 	}
-}, Oe = (e, t = {}) => new De(e, t), ke = class {
+}, Le = (e, t = {}) => new Ie(e, t), Re = class {
 	constructor(e, t = {}) {
-		this._aborted = !1, this._core = Oe(e, t);
+		this._cancelled = !1, this._core = Le(e, t), this._messageId = t.messageId;
+	}
+	async publishInput(e, t) {
+		switch (e.kind) {
+			case "user-message":
+				await this._publishUserMessage(e, t);
+				return;
+			case "regenerate":
+				await this._publishRegenerate(t);
+				return;
+			case "tool-result":
+				await this._publishToolResult(e, t);
+				return;
+			case "tool-result-error":
+				await this._publishToolResultError(e, t);
+				return;
+			case "tool-approval-response":
+				await this._publishToolApprovalResponse(e, t);
+				return;
+		}
+	}
+	async publishOutput(e, t) {
+		await this._publishChunk(e, t);
+	}
+	async cancel(e) {
+		this._cancelled || (this._cancelled = !0, await this._core.cancelAllStreams(), await this._core.publishDiscrete({
+			name: w,
+			data: e ?? "",
+			codecHeaders: P().str("type", "abort").build(),
+			transportHeaders: { [r]: "cancelled" }
+		}));
+	}
+	async close() {
+		await this._core.close();
 	}
-	async appendEvent(t, n) {
+	async _publishChunk(t, n) {
 		switch (t.type) {
 			case "text-start": {
-				let e = w().str("id", t.id).json("providerMetadata", t.providerMetadata).build();
+				let e = P().str("type", "text").str("id", t.id).json("providerMetadata", t.providerMetadata).build();
 				await this._core.startStream(t.id, {
-					name: "text",
+					name: w,
 					data: "",
-					headers: e
+					codecHeaders: e
 				}, n);
-				break;
+				return;
 			}
 			case "reasoning-start": {
-				let e = w().str("id", t.id).json("providerMetadata", t.providerMetadata).build();
+				let e = P().str("type", "reasoning").str("id", t.id).json("providerMetadata", t.providerMetadata).build();
 				await this._core.startStream(t.id, {
-					name: "reasoning",
+					name: w,
 					data: "",
-					headers: e
+					codecHeaders: e
 				}, n);
-				break;
+				return;
 			}
 			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();
+				let e = P().str("type", "tool-input").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",
+					name: w,
 					data: "",
-					headers: e
+					codecHeaders: e
 				}, n);
-				break;
+				return;
 			}
 			case "text-delta":
 				this._core.appendStream(t.id, t.delta);
-				break;
+				return;
 			case "reasoning-delta":
 				this._core.appendStream(t.id, t.delta);
-				break;
+				return;
 			case "tool-input-delta":
 				this._core.appendStream(t.toolCallId, t.inputTextDelta);
-				break;
+				return;
 			case "text-end": {
-				let e = w().str("id", t.id).json("providerMetadata", t.providerMetadata).build();
+				let e = P().str("type", "text").str("id", t.id).json("providerMetadata", t.providerMetadata).build();
 				await this._core.closeStream(t.id, {
-					name: "text",
+					name: w,
 					data: "",
-					headers: e
+					codecHeaders: e
 				});
-				break;
+				return;
 			}
 			case "reasoning-end": {
-				let e = w().str("id", t.id).json("providerMetadata", t.providerMetadata).build();
+				let e = P().str("type", "reasoning").str("id", t.id).json("providerMetadata", t.providerMetadata).build();
 				await this._core.closeStream(t.id, {
-					name: "reasoning",
+					name: w,
 					data: "",
-					headers: e
+					codecHeaders: e
 				});
-				break;
+				return;
 			}
 			case "tool-input-available":
 				try {
-					let e = w().str("toolCallId", t.toolCallId).str("toolName", t.toolName).json("providerMetadata", t.providerMetadata).build();
+					let e = P().str("type", "tool-input").str("toolCallId", t.toolCallId).str("toolName", t.toolName).json("providerMetadata", t.providerMetadata).build();
 					await this._core.closeStream(t.toolCallId, {
-						name: "tool-input",
+						name: w,
 						data: "",
-						headers: e
+						codecHeaders: 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();
+					if (!(n instanceof e.ErrorInfo && Fe(n, W.InvalidArgument))) throw n;
+					let r = P().str("type", "tool-input").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",
+						name: w,
 						data: t.input,
-						headers: r
+						codecHeaders: r
 					});
 				}
-				break;
+				return;
 			case "start": {
-				let e = w().str("messageId", t.messageId).json("messageMetadata", t.messageMetadata).build();
+				let e = P().str("type", "start").str("messageId", t.messageId ?? this._messageId).json("messageMetadata", t.messageMetadata).build();
 				await this._core.publishDiscrete({
-					name: "start",
+					name: w,
 					data: "",
-					headers: e
+					codecHeaders: e
 				}, n);
-				break;
+				return;
 			}
-			case "start-step":
+			case "start-step": {
+				let e = P().str("type", "start-step").build();
 				await this._core.publishDiscrete({
-					name: "start-step",
-					data: ""
+					name: w,
+					data: "",
+					codecHeaders: e
 				}, n);
-				break;
-			case "finish-step":
+				return;
+			}
+			case "finish-step": {
+				let e = P().str("type", "finish-step").build();
 				await this._core.publishDiscrete({
-					name: "finish-step",
-					data: ""
+					name: w,
+					data: "",
+					codecHeaders: e
 				}, n);
-				break;
+				return;
+			}
 			case "finish": {
-				let e = w().str("finishReason", t.finishReason).json("messageMetadata", t.messageMetadata).build();
+				let e = P().str("type", "finish").str("finishReason", t.finishReason).json("messageMetadata", t.messageMetadata).build();
 				await this._core.publishDiscrete({
-					name: "finish",
+					name: w,
 					data: "",
-					headers: e
+					codecHeaders: e
 				}, n);
-				break;
+				return;
 			}
-			case "error":
+			case "error": {
+				let e = P().str("type", "error").build();
 				await this._core.publishDiscrete({
-					name: "error",
-					data: t.errorText
+					name: w,
+					data: t.errorText,
+					codecHeaders: e
 				}, n);
-				break;
+				return;
+			}
 			case "abort":
-				this._aborted = !0, await this._core.abortAllStreams(n), await this._core.publishDiscrete({
-					name: "abort",
+				this._cancelled = !0, await this._core.cancelAllStreams(n), await this._core.publishDiscrete({
+					name: w,
 					data: t.reason ?? "",
-					headers: { [r]: "aborted" }
+					codecHeaders: P().str("type", "abort").build(),
+					transportHeaders: { [r]: "cancelled" }
 				}, n);
-				break;
+				return;
+			case "message-metadata": {
+				let e = P().str("type", "message-metadata").json("messageMetadata", t.messageMetadata).build();
+				await this._core.publishDiscrete({
+					name: w,
+					data: "",
+					codecHeaders: e
+				}, n);
+				return;
+			}
 			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();
+				let e = P().str("type", "tool-input-error").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",
+					name: w,
 					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
+					codecHeaders: e
 				}, n);
-				break;
+				return;
 			}
+			case "tool-output-available":
+			case "tool-output-error":
+			case "tool-approval-request":
+			case "tool-output-denied":
+				await this._core.publishDiscrete(ze(t), n);
+				return;
 			case "file": {
-				let e = w().str("mediaType", t.mediaType).json("providerMetadata", t.providerMetadata).build();
+				let e = P().str("type", "file").str("mediaType", t.mediaType).json("providerMetadata", t.providerMetadata).build();
 				await this._core.publishDiscrete({
-					name: "file",
+					name: w,
 					data: t.url,
-					headers: e
+					codecHeaders: e
 				}, n);
-				break;
+				return;
 			}
 			case "source-url": {
-				let e = w().str("sourceId", t.sourceId).str("title", t.title).json("providerMetadata", t.providerMetadata).build();
+				let e = P().str("type", "source-url").str("sourceId", t.sourceId).str("title", t.title).json("providerMetadata", t.providerMetadata).build();
 				await this._core.publishDiscrete({
-					name: "source-url",
+					name: w,
 					data: t.url,
-					headers: e
+					codecHeaders: e
 				}, n);
-				break;
+				return;
 			}
 			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();
+				let e = P().str("type", "source-document").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: "message-metadata",
+					name: w,
 					data: "",
-					headers: e
+					codecHeaders: e
 				}, n);
-				break;
+				return;
 			}
 			default:
 				if (t.type.startsWith("data-")) {
-					let e = w().str("id", t.id).bool("transient", t.transient).build(), r = t.transient === !0;
+					let e = t, r = P().str("type", e.type).str("id", e.id).bool("transient", e.transient).build(), i = e.transient === !0;
 					await this._core.publishDiscrete({
-						name: t.type,
-						data: t.data,
-						headers: e,
-						ephemeral: r
+						name: w,
+						data: e.data,
+						codecHeaders: r,
+						ephemeral: i
 					}, n);
+					return;
 				}
-				break;
+				throw new e.ErrorInfo(`unable to publish output; unsupported chunk type '${t.type}'`, W.InvalidArgument, 400);
 		}
 	}
-	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 _publishUserMessage(e, t) {
+		let n = Be(e.message);
+		for (let e of n) e.transportHeaders = {
+			...e.transportHeaders,
+			[f]: "user"
+		};
+		await 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();
+	async _publishRegenerate(e) {
+		let t = P().str("type", "regenerate").build();
+		await this._core.publishDiscrete({
+			name: T,
+			data: "",
+			codecHeaders: t
+		}, e);
+	}
+	async _publishToolResult(e, t) {
+		let n = P().str("type", "tool-result").str("toolCallId", e.payload.toolCallId).build();
+		await this._core.publishDiscrete({
+			name: T,
+			data: { output: e.payload.output },
+			codecHeaders: n
+		}, t);
+	}
+	async _publishToolResultError(e, t) {
+		let n = P().str("type", "tool-result-error").str("toolCallId", e.payload.toolCallId).build();
+		await this._core.publishDiscrete({
+			name: T,
+			data: { message: e.payload.message },
+			codecHeaders: n
+		}, t);
+	}
+	async _publishToolApprovalResponse(e, t) {
+		let n = P().str("type", "tool-approval-response").str("toolCallId", e.payload.toolCallId).bool("approved", e.payload.approved).str("reason", e.payload.reason).build();
+		await this._core.publishDiscrete({
+			name: T,
+			data: "",
+			codecHeaders: n
+		}, t);
+	}
+}, ze = (e) => {
+	switch (e.type) {
+		case "tool-output-available": {
+			let t = P().str("type", "tool-output-available").str("toolCallId", e.toolCallId).bool("dynamic", e.dynamic).bool("providerExecuted", e.providerExecuted).bool("preliminary", e.preliminary).build();
+			return {
+				name: w,
+				data: { output: e.output },
+				codecHeaders: t
+			};
+		}
+		case "tool-output-error": {
+			let t = P().str("type", "tool-output-error").str("toolCallId", e.toolCallId).bool("dynamic", e.dynamic).bool("providerExecuted", e.providerExecuted).build();
+			return {
+				name: w,
+				data: { errorText: e.errorText },
+				codecHeaders: t
+			};
+		}
+		case "tool-approval-request": return {
+			name: w,
+			data: "",
+			codecHeaders: P().str("type", "tool-approval-request").str("toolCallId", e.toolCallId).str("approvalId", e.approvalId).build()
+		};
+		case "tool-output-denied": return {
+			name: w,
+			data: "",
+			codecHeaders: P().str("type", "tool-output-denied").str("toolCallId", e.toolCallId).build()
+		};
 	}
-}, Ae = (e) => {
+}, Be = (e) => {
 	let n = e.id, r = [];
 	for (let i of e.parts) switch (i.type) {
 		case "text":
 			r.push({
-				name: "text",
+				name: T,
 				data: i.text,
-				headers: w().str("messageId", n).build()
+				codecHeaders: P().str("type", "text").str("messageId", n).build()
 			});
 			break;
 		case "file":
 			r.push({
-				name: "file",
+				name: T,
 				data: i.url,
-				headers: w().str("messageId", n).str("mediaType", i.mediaType).build()
+				codecHeaders: P().str("type", "file").str("messageId", n).str("mediaType", i.mediaType).build()
 			});
 			break;
 		default:
 			t(i) && r.push({
-				name: i.type,
+				name: T,
 				data: i.data,
-				headers: w().str("messageId", n).str("id", i.id).build()
+				codecHeaders: P().str("type", i.type).str("messageId", n).str("id", i.id).build()
 			});
 			break;
 	}
 	return r.length === 0 && r.push({
-		name: "text",
+		name: T,
 		data: "",
-		headers: w().str("messageId", n).build()
+		codecHeaders: P().str("type", "text").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
+}, Ve = (e, t = {}) => new Re(e, t), G = (e) => M({
+	type: "dynamic-tool",
+	toolCallId: e.toolCallId,
+	toolName: e.toolName,
+	title: e.title,
+	providerExecuted: e.providerExecuted
+}), K = (e, t) => {
+	let n = G(e);
+	switch (t.type) {
+		case "tool-output-available": return M({
+			...n,
+			state: "output-available",
+			input: e.input,
+			output: t.output,
+			preliminary: t.preliminary
+		});
+		case "tool-output-error": return {
+			...n,
+			state: "output-error",
+			input: e.input,
+			errorText: t.errorText
 		};
-		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(() => {});
+		case "tool-output-denied": return {
+			...n,
+			state: "output-denied",
+			input: e.input,
+			approval: {
+				id: "",
+				approved: !1
 			}
-		})).catch(() => {
-			v.close().catch(() => {});
-		}), g;
-	},
-	reconnectToStream: () => Promise.resolve(null),
-	close: async (e) => t.close(e)
-}), Me = (e) => ({
+		};
+		case "tool-approval-request": return {
+			...n,
+			state: "approval-requested",
+			input: e.input,
+			approval: { id: t.approvalId }
+		};
+	}
+}, He = () => ({
+	messages: [],
+	conflictSerials: /* @__PURE__ */ new Map(),
+	trackers: /* @__PURE__ */ new Map(),
+	pendingToolResolutions: []
+}), Ue = (e, t, n) => {
+	if (n.serial) {
+		let r = Ge(t, n);
+		if (r !== void 0) {
+			let t = e.conflictSerials.get(r);
+			if (t !== void 0 && n.serial <= t) return e;
+			e.conflictSerials.set(r, n.serial);
+		}
+	}
+	if (We(t)) switch (t.kind) {
+		case "user-message":
+			Ke(e, t.message, n);
+			break;
+		case "regenerate": break;
+		case "tool-result":
+			qe(e, t, n);
+			break;
+		case "tool-result-error":
+			Je(e, t, n);
+			break;
+		case "tool-approval-response":
+			Ye(e, t, n);
+			break;
+	}
+	else $e(e, t, n);
+	return e.pendingToolResolutions.length > 0 && Qe(e), e;
+}, We = (e) => "kind" in e, Ge = (e, t) => {
+	if (We(e)) switch (e.kind) {
+		case "user-message": return t.messageId === void 0 ? void 0 : `user-msg:${t.messageId}`;
+		case "tool-approval-response": return `tool-approval:${e.payload.toolCallId}`;
+		case "tool-result":
+		case "tool-result-error": return `tool-output:${e.payload.toolCallId}`;
+		case "regenerate": return;
+	}
+	switch (e.type) {
+		case "tool-input-start":
+		case "tool-input-available":
+		case "tool-input-error": return `${e.type}:${e.toolCallId}`;
+		case "tool-output-available":
+		case "tool-output-error":
+		case "tool-output-denied":
+		case "tool-approval-request": return `tool-output:${e.toolCallId}`;
+		case "text-start":
+		case "text-end":
+		case "reasoning-start":
+		case "reasoning-end": return `${e.type}:${t.messageId ?? ""}:${e.id}`;
+		case "finish":
+		case "message-metadata": return `${e.type}:${t.messageId ?? ""}`;
+		default: return;
+	}
+}, Ke = (e, t, n) => {
+	let r = n.messageId;
+	if (r === void 0) return e.messages.push({
+		codecMessageId: t.id,
+		message: t
+	}), e;
+	let i = e.messages.findIndex((e) => e.codecMessageId === r);
+	return i === -1 ? e.messages.push({
+		codecMessageId: r,
+		message: t
+	}) : e.messages[i] = {
+		codecMessageId: r,
+		message: t
+	}, e;
+}, qe = (e, t, n) => {
+	let { toolCallId: r, output: i } = t.payload, a = q(e, t.codecMessageId, r);
+	return a ? (a.message.parts[a.tracker.partIndex] = K(a.part, {
+		type: "tool-output-available",
+		toolCallId: r,
+		output: i
+	}), e) : (e.pendingToolResolutions.push({
+		targetCodecMessageId: t.codecMessageId,
+		toolCallId: r,
+		serial: n.serial,
+		resolution: {
+			kind: "tool-result",
+			output: i
+		}
+	}), e);
+}, Je = (e, t, n) => {
+	let { toolCallId: r, message: i } = t.payload, a = q(e, t.codecMessageId, r);
+	return a ? (a.message.parts[a.tracker.partIndex] = K(a.part, {
+		type: "tool-output-error",
+		toolCallId: r,
+		errorText: i
+	}), e) : (e.pendingToolResolutions.push({
+		targetCodecMessageId: t.codecMessageId,
+		toolCallId: r,
+		serial: n.serial,
+		resolution: {
+			kind: "tool-result-error",
+			message: i
+		}
+	}), e);
+}, Ye = (e, t, n) => {
+	let { toolCallId: r, approved: i, reason: a } = t.payload, o = q(e, t.codecMessageId, r);
+	return o ? (o.message.parts[o.tracker.partIndex] = Ze(o.part, i, a), e) : (e.pendingToolResolutions.push({
+		targetCodecMessageId: t.codecMessageId,
+		toolCallId: r,
+		serial: n.serial,
+		resolution: {
+			kind: "tool-approval-response",
+			approved: i,
+			...a === void 0 ? {} : { reason: a }
+		}
+	}), e);
+}, q = (e, t, n) => {
+	let r = e.messages.find((e) => e.codecMessageId === t);
+	if (!r) return;
+	let i = Y(e, t), a = X(r.message, i, n);
+	if (a) return {
+		message: r.message,
+		tracker: a.tracker,
+		part: a.part
+	};
+}, Xe = (e, t) => {
+	for (let n of e.messages) {
+		let r = e.trackers.get(n.codecMessageId);
+		if (!r) continue;
+		let i = X(n.message, r, t);
+		if (i) return {
+			message: n.message,
+			tracker: i.tracker,
+			part: i.part
+		};
+	}
+}, Ze = (e, t, n) => t ? {
+	...G(e),
+	state: "approval-responded",
+	input: "input" in e ? e.input : void 0,
+	approval: {
+		id: "approval" in e && e.approval ? e.approval.id : "",
+		approved: !0,
+		...n === void 0 ? {} : { reason: n }
+	}
+} : K(e, {
+	type: "tool-output-denied",
+	toolCallId: e.toolCallId,
+	...n === void 0 ? {} : { reason: n }
+}), Qe = (e) => {
+	let t = [];
+	for (let n of e.pendingToolResolutions) {
+		let r = q(e, n.targetCodecMessageId, n.toolCallId);
+		if (!r) {
+			t.push(n);
+			continue;
+		}
+		switch (n.resolution.kind) {
+			case "tool-result":
+				r.message.parts[r.tracker.partIndex] = K(r.part, {
+					type: "tool-output-available",
+					toolCallId: n.toolCallId,
+					output: n.resolution.output
+				});
+				break;
+			case "tool-result-error":
+				r.message.parts[r.tracker.partIndex] = K(r.part, {
+					type: "tool-output-error",
+					toolCallId: n.toolCallId,
+					errorText: n.resolution.message
+				});
+				break;
+			case "tool-approval-response":
+				r.message.parts[r.tracker.partIndex] = Ze(r.part, n.resolution.approved, n.resolution.reason);
+				break;
+		}
+	}
+	e.pendingToolResolutions = t;
+}, $e = (e, t, n) => {
+	let r = n.messageId;
+	if (r === void 0) return e;
+	switch (t.type) {
+		case "start":
+		case "start-step":
+		case "finish-step":
+		case "finish":
+		case "abort":
+		case "error":
+		case "message-metadata": return et(e, t, r);
+		case "text-start":
+		case "text-delta":
+		case "text-end":
+		case "reasoning-start":
+		case "reasoning-delta":
+		case "reasoning-end": return tt(e, t, r);
+		case "tool-input-start":
+		case "tool-input-delta":
+		case "tool-input-available":
+		case "tool-input-error": return nt(e, t, r);
+		case "tool-output-available":
+		case "tool-output-error":
+		case "tool-output-denied":
+		case "tool-approval-request": return rt(e, t, r);
+		case "file":
+		case "source-url":
+		case "source-document": return it(e, t, r);
+		default: return t.type.startsWith("data-") ? at(e, t, r) : e;
+	}
+}, J = (e, t) => {
+	let n = e.messages.find((e) => e.codecMessageId === t);
+	return n || (n = {
+		codecMessageId: t,
+		message: {
+			id: t,
+			role: "assistant",
+			parts: []
+		}
+	}, e.messages.push(n)), n.message;
+}, Y = (e, t) => {
+	let n = e.trackers.get(t);
+	return n || (n = {
+		text: /* @__PURE__ */ new Map(),
+		reasoning: /* @__PURE__ */ new Map(),
+		tools: /* @__PURE__ */ new Map()
+	}, e.trackers.set(t, n)), n;
+}, X = (e, t, n) => {
+	let r = t.tools.get(n);
+	if (!r) return;
+	let i = e.parts[r.partIndex];
+	if (i?.type === "dynamic-tool") return {
+		tracker: r,
+		part: i
+	};
+}, et = (e, t, n) => {
+	switch (t.type) {
+		case "start": {
+			let r = J(e, n);
+			return t.messageId !== void 0 && (r.id = t.messageId), t.messageMetadata !== void 0 && (r.metadata = t.messageMetadata), e;
+		}
+		case "start-step": return J(e, n).parts.push({ type: "step-start" }), e;
+		case "finish-step": {
+			let t = e.trackers.get(n);
+			return t && (t.text.clear(), t.reasoning.clear()), e;
+		}
+		case "finish": {
+			let r = e.messages.find((e) => e.codecMessageId === n)?.message;
+			return r && t.messageMetadata !== void 0 && (r.metadata = t.messageMetadata), e;
+		}
+		case "abort":
+		case "error": return e;
+		case "message-metadata": {
+			let r = e.messages.find((e) => e.codecMessageId === n)?.message;
+			return r && t.messageMetadata !== void 0 && (r.metadata = t.messageMetadata), e;
+		}
+	}
+}, tt = (e, t, n) => {
+	let r = J(e, n), i = Y(e, n), a = t.type.startsWith("text-"), o = a ? "text" : "reasoning", s = a ? i.text : i.reasoning;
+	switch (t.type) {
+		case "text-start":
+		case "reasoning-start": return s.set(t.id, r.parts.length), r.parts.push({
+			type: o,
+			text: ""
+		}), e;
+		case "text-delta":
+		case "reasoning-delta": {
+			let n = s.get(t.id);
+			if (n === void 0) return e;
+			let i = r.parts[n];
+			return i?.type === o && (i.text += t.delta), e;
+		}
+		case "text-end":
+		case "reasoning-end": return s.delete(t.id), e;
+	}
+}, nt = (e, t, n) => {
+	let r = J(e, n), i = Y(e, n);
+	switch (t.type) {
+		case "tool-input-start": {
+			let n = r.parts.length;
+			return r.parts.push({
+				...G(t),
+				state: "input-streaming",
+				input: void 0
+			}), i.tools.set(t.toolCallId, {
+				partIndex: n,
+				inputText: ""
+			}), e;
+		}
+		case "tool-input-delta": {
+			let n = i.tools.get(t.toolCallId);
+			if (!n) return e;
+			n.inputText += t.inputTextDelta;
+			let a;
+			try {
+				a = JSON.parse(n.inputText);
+			} catch {
+				a = void 0;
+			}
+			let o = X(r, i, t.toolCallId);
+			return o && (r.parts[o.tracker.partIndex] = {
+				...G(o.part),
+				state: "input-streaming",
+				input: a
+			}), e;
+		}
+		case "tool-input-available": {
+			let n = X(r, i, t.toolCallId);
+			return n && (r.parts[n.tracker.partIndex] = {
+				...G(n.part),
+				state: "input-available",
+				input: t.input
+			}), e;
+		}
+		case "tool-input-error": {
+			let n = X(r, i, t.toolCallId);
+			if (n) r.parts[n.tracker.partIndex] = {
+				...G(n.part),
+				state: "output-error",
+				input: t.input,
+				errorText: t.errorText
+			};
+			else {
+				let e = r.parts.length;
+				r.parts.push({
+					...G(t),
+					state: "output-error",
+					input: t.input,
+					errorText: t.errorText
+				}), i.tools.set(t.toolCallId, {
+					partIndex: e,
+					inputText: ""
+				});
+			}
+			return e;
+		}
+	}
+}, rt = (e, t, n) => {
+	if (t.type === "tool-output-available" || t.type === "tool-output-error") {
+		let n = Xe(e, t.toolCallId);
+		return n && (n.message.parts[n.tracker.partIndex] = K(n.part, t)), e;
+	}
+	let r = J(e, n), i = X(r, Y(e, n), t.toolCallId);
+	return i && (r.parts[i.tracker.partIndex] = K(i.part, t)), e;
+}, it = (e, t, n) => {
+	let r = J(e, n);
+	switch (t.type) {
+		case "file": return r.parts.push({
+			type: "file",
+			mediaType: t.mediaType,
+			url: t.url
+		}), e;
+		case "source-url": return r.parts.push(M({
+			type: "source-url",
+			sourceId: t.sourceId,
+			url: t.url,
+			title: t.title
+		})), e;
+		case "source-document": return r.parts.push(M({
+			type: "source-document",
+			sourceId: t.sourceId,
+			mediaType: t.mediaType,
+			title: t.title,
+			filename: t.filename
+		})), e;
+	}
+}, at = (e, t, n) => {
+	if (t.transient) return e;
+	let r = J(e, n), i = M({
+		type: t.type,
+		id: t.id,
+		data: t.data
+	});
+	if (t.id !== void 0) {
+		let n = r.parts.findIndex((e) => e.type === t.type && "id" in e && e.id === t.id);
+		if (n !== -1) return r.parts[n] = i, e;
+	}
+	return r.parts.push(i), e;
+}, Z = {
+	adapterTag: "vercel-ai-sdk-ui-message",
+	init: He,
+	fold: Ue,
+	createEncoder: Ve,
+	createDecoder: Pe,
+	getMessages: (e) => e.messages,
+	createUserMessage: (e) => ({
+		kind: "user-message",
+		message: e
+	}),
+	createRegenerate: (e, t) => ({
+		kind: "regenerate",
+		target: e,
+		parent: t
+	}),
+	createToolResult: (e, t) => ({
+		kind: "tool-result",
+		codecMessageId: e,
+		payload: t
+	}),
+	createToolResultError: (e, t) => ({
+		kind: "tool-result-error",
+		codecMessageId: e,
+		payload: t
+	}),
+	createToolApprovalResponse: (e, t) => ({
+		kind: "tool-approval-response",
+		codecMessageId: e,
+		payload: t
+	})
+}, ot = (e) => ({
 	logAction: (t, n, r) => {
 		e.error(n, { detail: r });
 	},
 	shouldLog: () => !0
-}), Ne = e.Realtime.EventEmitter, Pe = class extends Ne {
+}), st = e.Realtime.EventEmitter, Q = class extends st {
 	constructor(e) {
-		super(Me(e));
+		super(ot(e));
 	}
-}, K = /* @__PURE__ */ function(e) {
+}, ct = /* @__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) => {
+}({}), lt = (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:
+		case "trace":
+		case "debug":
 			console.log(i);
 			break;
-		case K.Info:
+		case "info":
 			console.info(i);
 			break;
-		case K.Warn:
+		case "warn":
 			console.warn(i);
 			break;
-		case K.Error:
+		case "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 {
+		case "silent": break;
+	}
+}, ut = (e) => new ft(e.logHandler ?? lt, e.logLevel), dt = new Map([
+	["trace", 0],
+	["debug", 1],
+	["info", 2],
+	["warn", 3],
+	["error", 4],
+	["silent", 5]
+]), ft = class t {
 	constructor(t, n, r) {
 		this._handler = t, this._context = r;
-		let i = J.get(n);
+		let i = dt.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);
+		this._write(e, "trace", 0, t);
 	}
 	debug(e, t) {
-		this._write(e, K.Debug, q.Debug, t);
+		this._write(e, "debug", 1, t);
 	}
 	info(e, t) {
-		this._write(e, K.Info, q.Info, t);
+		this._write(e, "info", 2, t);
 	}
 	warn(e, t) {
-		this._write(e, K.Warn, q.Warn, t);
+		this._write(e, "warn", 3, t);
 	}
 	error(e, t) {
-		this._write(e, K.Error, q.Error, t);
+		this._write(e, "error", 4, t);
 	}
 	withContext(e) {
-		let n = [...J.entries()].find(([, e]) => e === this._levelNumber)?.[0] ?? K.Error;
+		let n = [...dt.entries()].find(([, e]) => e === this._levelNumber)?.[0] ?? "error";
 		return new t(this._handler, n, this._mergeContext(e));
 	}
 	_write(e, t, n, r) {
@@ -1403,929 +1549,1906 @@ var n = "x-ably-stream", r = "x-ably-status", i = "x-ably-stream-id", a = "x-abl
 			...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;
+}, pt = (e) => e.type === "finish" || e.type === "error" || e.type === "abort", mt = (t, n, r) => {
+	let i = {}, a = [], o = new ReadableStream({
+		start: (e) => {
+			i.controller = e;
+		},
+		cancel: () => {
+			u();
 		}
-		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;
+	}), { controller: s } = i;
+	if (!s) throw new e.ErrorInfo("unable to create run stream; ReadableStream start() was not called synchronously", W.SessionSubscriptionError, 500);
+	let c;
+	n.then((e) => {
+		c = e;
+	}, () => {});
+	let l = !1, u = () => {
+		for (let e of a) e();
+		a.length = 0;
+	}, d = (e) => {
+		if (!l) {
+			l = !0;
+			try {
+				e();
+			} catch {}
+			u();
 		}
-		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);
+	}, f = () => {
+		d(() => {
+			s.close();
+		});
+	}, p = (e) => {
+		d(() => {
+			s.error(e);
+		});
+	};
+	return a.push(t.tree.on("output", (e) => {
+		if (e.inputCodecMessageId === r) for (let t of e.events) {
+			try {
+				s.enqueue(t);
+			} catch {
+				f();
+				return;
+			}
+			if (pt(t)) {
+				f();
+				return;
+			}
 		}
-		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);
+	}), t.tree.on("run", (e) => {
+		e.type === "end" && c !== void 0 && e.runId === c && f();
+	}), t.on("error", (e) => {
+		p(e);
+	})), {
+		stream: o,
+		close: f,
+		error: p
+	};
+}, ht = (e) => {
+	let t, n = new Promise((e) => {
+		t = e;
+	}), r = new TransformStream({ flush: () => {
+		t();
+	} }), i = new AbortController();
+	return e.pipeTo(r.writable, {
+		signal: i.signal,
+		preventCancel: !0
+	}).catch(() => {
+		t();
+	}), {
+		stream: r.readable,
+		done: n,
+		fail: (e) => {
+			i.abort(e);
 		}
-		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;
+	};
+}, gt = (e) => (e.type === "dynamic-tool" || e.type.startsWith("tool-")) && "toolCallId" in e && "state" in e, _t = (e) => e.role === "assistant" && e.parts.some((e) => gt(e) && (e.state === "input-streaming" || e.state === "input-available" || e.state === "approval-requested")), vt = new Set([
+	"input-streaming",
+	"input-available",
+	"approval-requested"
+]), yt = (e, t) => {
+	let n = [];
+	for (let r of t) {
+		if (r.role !== "assistant") continue;
+		let t = e.find((e) => e.message.id === r.id);
+		if (!t) continue;
+		let { codecMessageId: i, message: a } = t;
+		for (let e of r.parts) {
+			if (!gt(e)) continue;
+			let t = a.parts.find((t) => gt(t) && t.toolCallId === e.toolCallId);
+			if (e.state === "approval-responded" && (!t || t.state === "approval-requested")) {
+				n.push(Z.createToolApprovalResponse(i, {
+					toolCallId: e.toolCallId,
+					approved: e.approval.approved,
+					...e.approval.reason === void 0 ? {} : { reason: e.approval.reason }
+				}));
+				continue;
 			}
-			t.add(a), e.push(i.message);
+			e.state !== "output-available" && e.state !== "output-error" || t && !vt.has(t.state) || (e.state === "output-available" ? n.push(Z.createToolResult(i, {
+				toolCallId: e.toolCallId,
+				output: e.output
+			})) : n.push(Z.createToolResultError(i, {
+				toolCallId: e.toolCallId,
+				message: e.errorText
+			})));
 		}
-		return e;
 	}
-	getSiblings(e) {
-		return this._getSiblingGroup(e).map((e) => e.message);
+	return n;
+}, bt = (e, t) => {
+	let n = e.findIndex((e) => e.message.id === t);
+	if (!(n <= 0)) return e[n - 1]?.codecMessageId;
+}, xt = (t, n) => {
+	let r = n?.api ?? "/api/chat", i = n?.fetch ?? globalThis.fetch.bind(globalThis), a = n?.credentials, o = !1, s = new Q(ut({ logLevel: ct.Silent })), c = (e) => {
+		o = e, s.emit("streaming", e);
+	};
+	return {
+		sendMessages: async (o) => {
+			let { messages: s, abortSignal: l, trigger: u, messageId: d } = o, f = t.view.getMessages(), p = new Map(f.map((e) => [e.message.id, e.codecMessageId])), m = (e) => p.get(e), h = s.at(-1), g = !!h && p.has(h.id), _ = u === "submit-message" && h?.role === "assistant" && g, v = u === "submit-message" && !d && h?.role === "user" ? s.at(-2) : void 0, y = v && _t(v) && p.has(v.id) ? v.id : void 0, b, x;
+			if (u === "regenerate-message" || _) b = [], x = s;
+			else {
+				if (s.length === 0) throw new e.ErrorInfo("unable to send messages; messages array is empty for submit-message trigger", W.InvalidArgument, 400);
+				b = [s.at(-1)], x = y ? s.slice(0, -2) : s.slice(0, -1);
+			}
+			let S, C;
+			u === "submit-message" && d && !_ ? (S = m(d), C = bt(f, d)) : y && (S = m(y), C = bt(f, y));
+			let w, T;
+			if (n?.prepareSendMessagesRequest) {
+				let e = n.prepareSendMessagesRequest({
+					chatId: o.chatId,
+					trigger: u,
+					messageId: d,
+					history: x,
+					messages: b,
+					forkOf: S,
+					parent: C
+				});
+				w = e.body ?? {}, T = e.headers;
+			} else w = {}, T = void 0;
+			let E = {};
+			if (S !== void 0 && (E.forkOf = S), C !== void 0 && (E.parent = C), _) {
+				let e = m(h.id), n = e === void 0 ? void 0 : t.view.runOf(e);
+				n && (E.runId = n.runId);
+			}
+			let D;
+			if (_) {
+				let e = yt(f, s);
+				D = await t.view.send(e, E);
+			} else if (u === "regenerate-message") {
+				if (d === void 0) throw new e.ErrorInfo("unable to regenerate; regenerate-message trigger fired without messageId", W.InvalidArgument, 400);
+				let n = m(d);
+				if (n === void 0) throw new e.ErrorInfo(`unable to regenerate; message not visible: ${d}`, W.InvalidArgument, 400);
+				D = await t.view.regenerate(n, E);
+			} else {
+				let e = b.map((e) => Z.createUserMessage(e));
+				D = await t.view.send(e, E);
+			}
+			let O = mt(t, D.runId, D.inputCodecMessageId);
+			if (l) {
+				let e = () => {
+					D.cancel(), O.close();
+				};
+				l.aborted ? e() : l.addEventListener("abort", e, { once: !0 });
+			}
+			let { stream: ee, done: te, fail: k } = ht(O.stream);
+			c(!0), te.then(() => {
+				c(!1);
+			});
+			let A = {
+				...w,
+				...D.toInvocation().toJSON()
+			};
+			return i(r, {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+					...T
+				},
+				body: JSON.stringify(A),
+				...a ? { credentials: a } : {}
+			}).then((t) => {
+				t.ok || k(new e.ErrorInfo(`unable to send; HTTP POST to ${r} returned ${String(t.status)} ${t.statusText}`, W.SessionSendFailed, t.status));
+			}).catch((t) => {
+				let n = t instanceof e.ErrorInfo ? t : void 0;
+				k(new e.ErrorInfo(`unable to send; HTTP POST to ${r} failed: ${t instanceof Error ? t.message : String(t)}`, W.SessionSendFailed, 500, n));
+			}), ee;
+		},
+		reconnectToStream: () => Promise.resolve(null),
+		close: async () => t.close(),
+		get streaming() {
+			return o;
+		},
+		onStreamingChange: (e) => (s.on("streaming", e), () => {
+			s.off("streaming", e);
+		})
+	};
+}, St = "0.2.0", Ct = "ai-transport-js", wt = (e, t) => {
+	let n = e;
+	return n.options.agents = {
+		...n.options.agents,
+		...t
+	}, { params: { agent: Object.entries(t).map(([e, t]) => `${e}/${t}`).join(" ") } };
+}, Tt = (e, t) => {
+	let n = t?.adapterTag, r = { [Ct]: St };
+	return n && (r[n] = St), wt(e, r);
+}, Et = (e) => {
+	let t = {
+		[f]: e.role,
+		[l]: e.codecMessageId
+	};
+	return e.runId !== void 0 && (t[o] = e.runId), e.runClientId !== void 0 && (t[u] = e.runClientId), e.parent && (t[p] = e.parent), e.forkOf && (t[m] = e.forkOf), e.regenerates && (t[h] = e.regenerates), e.invocationId && (t[s] = e.invocationId), e.inputClientId !== void 0 && (t[d] = e.inputClientId), e.inputCodecMessageId !== void 0 && (t[_] = e.inputCodecMessageId), e.inputEventId && (t[c] = e.inputEventId), t;
+}, Dt = (e) => {
+	let t = {
+		[o]: e.runId,
+		[u]: e.runClientId
+	};
+	return e.reason !== void 0 && (t[g] = e.reason), e.parent !== void 0 && (t[p] = e.parent), e.forkOf !== void 0 && (t[m] = e.forkOf), e.regenerates !== void 0 && (t[h] = e.regenerates), e.invocationId !== void 0 && (t[s] = e.invocationId), e.inputClientId !== void 0 && (t[d] = e.inputClientId), e.inputCodecMessageId !== void 0 && (t[_] = e.inputCodecMessageId), t;
+}, Ot = (e) => e === "ai-run-start" || e === "ai-run-suspend" || e === "ai-run-resume" || e === "ai-run-end", kt = (e, t, n) => {
+	let r = t[o];
+	if (!r) return;
+	let i = t["run-client-id"] ?? "";
+	if (e === "ai-run-start") {
+		let e = t[p], a = t[m], o = t[h];
+		return {
+			type: "start",
+			runId: r,
+			clientId: i,
+			serial: n,
+			invocationId: t["invocation-id"] ?? "",
+			...e !== void 0 && { parent: e },
+			...a !== void 0 && { forkOf: a },
+			...o !== void 0 && { regenerates: o }
+		};
 	}
-	hasSiblings(e) {
-		return this._getSiblingGroup(e).length > 1;
+	if (e === "ai-run-suspend") return {
+		type: "suspend",
+		runId: r,
+		clientId: i,
+		serial: n,
+		invocationId: t["invocation-id"] ?? ""
+	};
+	if (e === "ai-run-resume") return {
+		type: "resume",
+		runId: r,
+		clientId: i,
+		serial: n,
+		invocationId: t["invocation-id"] ?? ""
+	};
+	if (e === "ai-run-end") {
+		let e = t["run-reason"] ?? "complete";
+		return {
+			type: "end",
+			runId: r,
+			clientId: i,
+			serial: n,
+			invocationId: t["invocation-id"] ?? "",
+			reason: e
+		};
 	}
-	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));
+}, At = (e, t, n) => {
+	if (e.has(t) || e.size < n) return;
+	let r = e.keys().next().value;
+	if (r !== void 0) return e.delete(r), r;
+}, jt = (e, t) => {
+	let n = [], r = /* @__PURE__ */ new Set(), i = t;
+	for (; i !== void 0 && !r.has(i);) r.add(i), n.push(i), i = e.get(i)?.parentCodecMessageId;
+	return n.toReversed();
+}, Mt = (e, t, n) => {
+	let r = D(n), i = n.serial;
+	if (Ot(n.name)) {
+		let t = kt(n.name, r, i);
+		return t && e.applyRunLifecycle(t), t;
+	}
+	let { inputs: a, outputs: o } = t.decode(n);
+	(a.length > 0 || o.length > 0 || r["run-id"]) && e.applyMessage({
+		inputs: a,
+		outputs: o
+	}, r, i);
+}, Nt = (e, t, n, r, i) => {
+	let { inputs: a, outputs: o } = t.decode(r), s = n;
+	for (let t of [...a, ...o]) s = e.fold(s, t, {
+		serial: r.serial ?? "",
+		messageId: i
+	});
+	return s;
+}, Pt = (e, t) => {
+	let n = /* @__PURE__ */ new Set(), r = [];
+	for (let t of e) t.serial !== void 0 && !n.has(t.serial) && (n.add(t.serial), r.push(t));
+	if (t !== void 0) for (let e of t) e.serial !== void 0 && !n.has(e.serial) && (n.add(e.serial), r.push(e));
+	return r.toSorted(A);
+}, Ft = async (e, t, n) => {
+	let r = [], i = await e.history({ limit: t });
+	for (r.push(...i.items); i.hasNext() && r.length < n;) {
+		let e = await i.next();
+		if (!e) break;
+		r.push(...e.items), i = e;
+	}
+	return r;
+}, It = (e, t, n, r) => {
+	let i = e.createDecoder(), a = e.init(), o = 0;
+	for (let s of t) {
+		let t = D(s);
+		if (t["run-id"] !== n || Ot(s.name)) continue;
+		let c = t[l];
+		if (r !== void 0 && c === r) break;
+		a = Nt(e, i, a, s, c ?? ""), o++;
 	}
-	select(e, t) {
-		this._logger.debug("ConversationTree.select();", {
-			msgId: e,
-			index: t
+	return {
+		projection: a,
+		folded: o
+	};
+}, Lt = (e, t, n) => {
+	let r = e.createDecoder(), i = e.init();
+	for (let a of t) {
+		let t = D(a);
+		t["run-id"] === void 0 && t["codec-message-id"] === n && (i = Nt(e, r, i, a, n));
+	}
+	return i;
+}, Rt = async (t) => {
+	let { channel: n, codec: r, runId: i, signal: a, logger: o, liveMessages: s } = t;
+	if (a.aborted) throw new e.ErrorInfo(`unable to load run projection; run ${i} was cancelled`, W.InvalidArgument, 400);
+	await n.attach();
+	let { projection: c, folded: l } = It(r, Pt(await Ft(n, 200, 2e3), s), i);
+	return o?.debug("loadRunProjection(); folded run events", {
+		runId: i,
+		folded: l
+	}), c;
+}, zt = async (t) => {
+	let { channel: n, codec: r, runId: i, signal: a, logger: s, liveMessages: c, assistantParentFallback: u, pageLimit: d, maxMessages: f } = t;
+	if (a.aborted) throw new e.ErrorInfo(`unable to load conversation; run ${i} was cancelled`, W.InvalidArgument, 400);
+	let m = Pt(await Ft(n, d, f), c), h = /* @__PURE__ */ new Map(), g = /* @__PURE__ */ new Map();
+	for (let e of m) {
+		if (Ot(e.name)) continue;
+		let t = D(e), n = t[l];
+		if (n === void 0) continue;
+		let r = t[o];
+		r !== void 0 && g.set(r, n), h.has(n) || h.set(n, {
+			runId: r,
+			parentCodecMessageId: t[p]
 		});
-		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;
+	for (let e of m) {
+		if (e.name !== "ai-run-start") continue;
+		let t = D(e), n = t[o];
+		if (n === void 0) continue;
+		let r = g.get(n);
+		if (r === void 0) continue;
+		let i = h.get(r);
+		i && i.parentCodecMessageId === void 0 && (i.parentCodecMessageId = t[p]);
+	}
+	let _ = [], v = 0;
+	if (u !== void 0) {
+		let e = jt(h, u);
+		v = e.length;
+		for (let t of e) {
+			let e = h.get(t);
+			if (e?.runId === i) continue;
+			let n = e?.runId === void 0 ? Lt(r, m, t) : It(r, m, e.runId).projection;
+			_.push(...r.getMessages(n).map((e) => e.message));
 		}
-		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 { projection: y, folded: b } = It(r, m, i);
+	return _.push(...r.getMessages(y).map((e) => e.message)), s?.debug("loadConversation(); built", {
+		runId: i,
+		chainLength: v,
+		totalMessages: _.length,
+		folded: b
+	}), {
+		messages: _,
+		projection: y
+	};
+}, Bt = (e) => {
+	let t;
+	return {
+		promise: e === void 0 ? new Promise(() => {}) : e.aborted ? Promise.resolve() : new Promise((n) => {
+			t = () => {
+				n();
+			}, e.addEventListener("abort", t, { once: !0 });
+		}),
+		cleanup: () => {
+			t && e && e.removeEventListener("abort", t);
 		}
-	}
-	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);
+	};
+}, Vt = async (e, t, n, r, i, a) => {
+	a?.trace("pipeStream();");
+	let o = e.getReader(), s = Bt(n), c = "complete", l;
+	try {
+		for (;;) {
+			let e = await Promise.race([o.read(), s.promise.then(() => "cancelled")]);
+			if (e === "cancelled") {
+				c = "cancelled", a?.debug("pipeStream(); stream cancelled by AbortSignal"), r && await r(async (e) => t.publishOutput(e)), await t.cancel("cancelled");
+				break;
 			}
-		}
-		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++;
+			let { done: n, value: l } = e;
+			if (n) {
+				await t.close(), a?.debug("pipeStream(); stream completed");
+				break;
 			}
+			await t.publishOutput(l, i?.(l));
 		}
-		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;
+	} catch (e) {
+		c = "error", l = e instanceof Error ? e : Error(String(e)), a?.error("pipeStream(); stream error", { error: l.message });
+		try {
+			await t.close();
+		} catch {}
+	} finally {
+		s.cleanup(), o.releaseLock();
 	}
-}, 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 {
+		reason: c,
+		error: l
 	};
-	return e.turnClientId !== void 0 && (t[s] = e.turnClientId), e.parent && (t[p] = e.parent), e.forkOf && (t[m] = e.forkOf), t;
-}, Ve = class {
+}, Ht = 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;
+		this._activeRuns = /* @__PURE__ */ new Map(), this._channel = e, this._logger = t?.withContext({ component: "RunManager" });
 	}
-	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;
+	async startRun(e, t, n, r) {
+		this._logger?.trace("DefaultRunManager.startRun();", {
+			runId: e,
+			clientId: t
+		});
+		let i = n ?? new AbortController(), a = t ?? "";
+		this._activeRuns.set(e, {
+			controller: i,
+			clientId: a
+		});
+		let o = r?.continuation === !0, s = Dt({
+			runId: e,
+			runClientId: a,
+			parent: o ? void 0 : r?.parent,
+			forkOf: o ? void 0 : r?.forkOf,
+			regenerates: o ? void 0 : r?.regenerates,
+			invocationId: r?.invocationId,
+			inputClientId: r?.inputClientId,
+			inputCodecMessageId: r?.inputCodecMessageId
+		});
+		return await this._channel.publish({
+			name: o ? S : b,
+			extras: { ai: { transport: s } }
+		}), this._logger?.debug("DefaultRunManager.startRun(); run started", { runId: e }), i.signal;
+	}
+	async suspendRun(e, t, n, r) {
+		this._logger?.trace("DefaultRunManager.suspendRun();", { runId: e }), await this._publishTerminal(x, e, {
+			invocationId: t,
+			inputClientId: n,
+			inputCodecMessageId: r
+		}), this._logger?.debug("DefaultRunManager.suspendRun(); run suspended", { runId: e });
+	}
+	async endRun(e, t, n, r, i) {
+		this._logger?.trace("DefaultRunManager.endRun();", {
+			runId: e,
+			reason: t
+		}), await this._publishTerminal(C, e, {
+			reason: t,
+			invocationId: n,
+			inputClientId: r,
+			inputCodecMessageId: i
+		}), this._logger?.debug("DefaultRunManager.endRun(); run ended", {
+			runId: e,
+			reason: t
+		});
+	}
+	async _publishTerminal(e, t, n) {
+		let r = Dt({
+			runId: t,
+			runClientId: this._activeRuns.get(t)?.clientId ?? "",
+			...n
+		});
+		await this._channel.publish({
+			name: e,
+			extras: { ai: { transport: r } }
+		}), this._activeRuns.delete(t);
+	}
+	getSignal(e) {
+		return this._activeRuns.get(e)?.controller.signal;
+	}
+	getClientId(e) {
+		return this._activeRuns.get(e)?.clientId;
 	}
-	has(e) {
-		return this._turns.has(e);
+	cancel(e) {
+		this._logger?.debug("DefaultRunManager.cancel();", { runId: e }), this._activeRuns.get(e)?.controller.abort();
 	}
-}, He = (e, t) => new Ve(e, t), Ue = () => {}, We = class {
+	getActiveRunIds() {
+		return [...this._activeRuns.keys()];
+	}
+	close() {
+		this._logger?.trace("DefaultRunManager.close();", { activeRuns: this._activeRuns.size });
+		for (let e of this._activeRuns.values()) e.controller.abort();
+		this._activeRuns.clear();
+	}
+}, Ut = (e, t) => new Ht(e, t), Wt = async (t) => {
+	let { register: n, codec: r, invocationId: i, runId: a, expectedInputEventIds: o, timeoutMs: s, signal: l, logger: u } = t, d = new Set(o), f = d.size, h = [], g = [], _ = /* @__PURE__ */ new Set(), v, y, b = (e) => {
+		let t = r.createDecoder(), n = D(e), i = n["codec-message-id"] ?? "", { inputs: a, outputs: o } = t.decode(e), s = [...a, ...o], c = r.init();
+		for (let t of s) c = r.fold(c, t, {
+			serial: e.serial ?? "",
+			messageId: i
+		});
+		return r.getMessages(c).map(({ message: t }) => ({
+			kind: "message",
+			message: t,
+			codecMessageId: i,
+			parentId: n[p],
+			forkOf: n[m],
+			headers: n,
+			serial: e.serial
+		}));
+	};
+	return new Promise((t, r) => {
+		let o = !1, p = /* @__PURE__ */ new Set(), m = () => {}, x, S = () => {
+			m(), x !== void 0 && clearTimeout(x), l.removeEventListener("abort", C);
+		}, C = () => {
+			o || (o = !0, S(), r(new e.ErrorInfo(`unable to look up input event; run ${a} was cancelled`, W.InvalidArgument, 400)));
+		};
+		if (l.addEventListener("abort", C, { once: !0 }), !o) {
+			if (m = n((n) => {
+				if (o || n.serial !== void 0 && p.has(n.serial)) return;
+				n.serial !== void 0 && p.add(n.serial);
+				let s = D(n), l = s[c];
+				if (!l || !d.has(l) || _.has(l)) return;
+				_.add(l), v === void 0 && (v = s, y = n.clientId);
+				let m;
+				try {
+					m = b(n);
+				} catch (t) {
+					o = !0, S();
+					let n = t instanceof e.ErrorInfo ? t : void 0;
+					r(new e.ErrorInfo(`unable to look up input event; decode failed for invocation ${i}: ${t instanceof Error ? t.message : String(t)}`, W.InputEventNotFound, 504, n));
+					return;
+				}
+				for (let e of m) h.push(e);
+				g.push(n), !(_.size < f) && (o = !0, S(), h.sort(A), u?.debug("lookupInputEvents(); collected input events", {
+					runId: a,
+					invocationId: i,
+					count: h.length
+				}), t({
+					nodes: h,
+					firstHeaders: v,
+					firstClientId: y,
+					rawMessages: g
+				}));
+			}), o) {
+				m();
+				return;
+			}
+			x = setTimeout(() => {
+				o || (o = !0, S(), r(new e.ErrorInfo(`unable to look up input event; received ${String(h.length)} of ${String(f)} input events for invocation ${i} within ${String(s)}ms`, W.InputEventNotFound, 504)));
+			}, s);
+		}
+	});
+}, Gt = 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._registeredRuns = /* @__PURE__ */ new Map(), this._runIdByInputCodecMessageId = /* @__PURE__ */ new Map(), this._deferredCancels = /* @__PURE__ */ new Map(), this._pendingInputEventLookups = /* @__PURE__ */ new Map(), this._inputEventBuffer = /* @__PURE__ */ new Map(), this._state = "ready", this._codec = e.codec;
+		let t = { params: {
+			...Tt(e.client, e.codec).params,
+			rewind: e.rewindWindow ?? "2m"
+		} };
+		this._channel = e.client.channels.get(e.channelName, t), this._logger = e.logger?.withContext({ component: "AgentSession" }), this._onError = e.onError, this._runManager = Ut(this._channel, this._logger), this._inputEventLookupTimeoutMs = e.inputEventLookupTimeoutMs ?? 3e4, this._inputEventBufferLimit = e.inputEventBufferLimit ?? 200, this._channelListener = (e) => {
+			this._handleChannelMessage(e);
+		}, this._hasAttachedOnce = this._channel.state === "attached", this._onChannelStateChange = (e) => {
+			this._handleChannelStateChange(e);
+		}, this._channel.on(this._onChannelStateChange), this._logger?.debug("DefaultAgentSession(); session created");
+	}
+	connect() {
+		return this._state === "closed" ? Promise.reject(new e.ErrorInfo("unable to connect; session is closed", W.SessionClosed, 400)) : this._connectPromise ? this._connectPromise : (this._logger?.trace("DefaultAgentSession.connect();"), this._connectPromise = this._channel.subscribe(this._channelListener).then(() => {
+			this._logger?.debug("DefaultAgentSession.connect(); subscribed and attached");
+		}, (t) => {
+			let n = new e.ErrorInfo(`unable to subscribe to channel; ${t instanceof Error ? t.message : String(t)}`, W.SessionSubscriptionError, 500, t instanceof e.ErrorInfo ? t : void 0);
+			throw this._logger?.error("DefaultAgentSession.connect(); subscribe failed"), this._onError?.(n), n;
+		}), this._connectPromise);
+	}
+	_registerInputEventListener(e, t) {
+		for (let n of e) this._pendingInputEventLookups.set(n, t);
+		for (let n of e) {
+			let e = this._inputEventBuffer.get(n);
+			if (e) {
+				this._inputEventBuffer.delete(n);
+				for (let n of e) t(n);
 			}
-			this._emitter.emit("message");
 		}
-		this._onMessage = (e) => {
-			this._handleMessage(e);
-		}, this._attachPromise = this._channel.subscribe(this._onMessage);
+		return () => {
+			for (let n of e) this._pendingInputEventLookups.get(n) === t && this._pendingInputEventLookups.delete(n);
+		};
 	}
-	_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));
+	createRun(e, t) {
+		return this._logger?.trace("DefaultAgentSession.createRun();", { inputEventId: e.inputEventId }), this._createRun(e, t ?? {});
+	}
+	async close() {
+		if (this._state !== "closed") {
+			this._state = "closed", this._logger?.trace("DefaultAgentSession.close();"), this._connectPromise && this._channel.unsubscribe(this._channelListener), this._channel.off(this._onChannelStateChange);
+			for (let e of this._registeredRuns.values()) e.controller.abort();
+			if (this._registeredRuns.clear(), this._runIdByInputCodecMessageId.clear(), this._deferredCancels.clear(), this._pendingInputEventLookups.clear(), this._inputEventBuffer.clear(), this._runManager.close(), this._connectPromise) try {
+				await this._channel.detach();
+			} catch (e) {
+				this._logger?.debug("DefaultAgentSession.close(); channel detach failed", { error: e });
 			}
+			this._logger?.debug("DefaultAgentSession.close(); session closed");
 		}
 	}
-	_handleMessageOutput(e, t, n, r) {
-		let i = t[o];
-		if (i && this._ownMsgIds.has(i)) {
-			this._upsertAndNotify(e, t, n);
+	async _handleCancelMessage(e) {
+		let t = D(e), n = t[o], r = t[_];
+		if (!n && !r) {
+			this._logger?.warn("DefaultAgentSession._handleCancelMessage(); missing run-id and input-codec-message-id", { serial: e.serial });
+			return;
+		}
+		let i = n ?? (r ? this._runIdByInputCodecMessageId.get(r) : void 0), a = i ? this._registeredRuns.get(i) : void 0;
+		if (!a) {
+			r !== void 0 && this._bufferDeferredCancel(r, e);
 			return;
 		}
-		r === "message.create" && this._upsertAndNotify(e, t, n);
+		await this._cancelRegistration(a, e);
+	}
+	_bufferDeferredCancel(e, t) {
+		let n = At(this._deferredCancels, e, this._inputEventBufferLimit);
+		n !== void 0 && this._logger?.warn("DefaultAgentSession._bufferDeferredCancel(); deferred-cancel buffer full, dropping oldest", {
+			evictedInputCodecMessageId: n,
+			limit: this._inputEventBufferLimit
+		}), this._deferredCancels.set(e, t), this._logger?.debug("DefaultAgentSession._bufferDeferredCancel(); buffered early cancel", {
+			inputCodecMessageId: e,
+			serial: t.serial
+		});
 	}
-	_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);
+	async _pullDeferredCancel(e, t) {
+		let n = this._deferredCancels.get(t);
+		n !== void 0 && (this._deferredCancels.delete(t), this._logger?.debug("DefaultAgentSession._pullDeferredCancel(); honouring buffered cancel", {
+			runId: e.runId,
+			inputCodecMessageId: t
+		}), await this._cancelRegistration(e, n));
+	}
+	async _cancelRegistration(t, n) {
+		let { runId: r } = t;
+		this._logger?.debug("DefaultAgentSession._cancelRegistration(); matched run", { runId: r });
+		let i = {
+			message: n,
+			runId: r
+		};
+		try {
+			if (t.onCancel && !await t.onCancel(i)) {
+				this._logger?.debug("DefaultAgentSession._cancelRegistration(); cancel rejected by onCancel", { runId: r });
 				return;
 			}
-			this._ownTurnIds.has(r) && !this._turnObservers.has(r) || (this._accumulateAndEmit(r, e), this._codec.isTerminal(n) && this._turnObservers.delete(r));
+			t.controller.abort(), this._logger?.debug("DefaultAgentSession._cancelRegistration(); run cancelled", { runId: r });
+		} catch (n) {
+			let i = new e.ErrorInfo(`unable to process cancel for run ${r}; onCancel handler threw: ${n instanceof Error ? n.message : String(n)}`, W.CancelListenerError, 500, n instanceof e.ErrorInfo ? n : void 0);
+			this._logger?.error("DefaultAgentSession._cancelRegistration(); onCancel threw", { runId: r }), (t.onError ?? this._onError)?.(i);
 		}
 	}
-	_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()
+	_handleChannelStateChange(t) {
+		if (this._state === "closed") return;
+		let { current: n, resumed: r } = t;
+		if (n === "attached" && !this._hasAttachedOnce) {
+			this._hasAttachedOnce = !0;
+			return;
+		}
+		if (!(n === "failed" || n === "suspended" || n === "detached" || n === "attached" && !r)) return;
+		this._logger?.error("DefaultAgentSession._handleChannelStateChange(); channel continuity lost", {
+			current: n,
+			resumed: r,
+			previous: t.previous
 		});
+		let i = new e.ErrorInfo(`unable to deliver cancel messages; channel continuity lost (${n}${n === "attached" ? ", resumed: false" : ""})`, W.ChannelContinuityLost, 500, t.reason);
+		this._onError?.(i);
 	}
-	_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;
+	_handleChannelMessage(t) {
 		try {
-			i = structuredClone(r.at(-1));
-		} catch {
-			i = r.at(-1);
+			if (t.name === "ai-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("DefaultAgentSession._handleChannelMessage(); cancel routing error"), this._onError?.(n);
+				});
+				return;
+			}
+			let n = D(t)[c];
+			if (n !== void 0) {
+				let e = this._pendingInputEventLookups.get(n);
+				if (e) e(t);
+				else {
+					let e = this._inputEventBuffer.get(n);
+					if (e) e.push(t);
+					else {
+						let e = At(this._inputEventBuffer, n, this._inputEventBufferLimit);
+						e !== void 0 && this._logger?.warn("DefaultAgentSession._handleChannelMessage(); input-event buffer full, dropping oldest entry", {
+							evictedEventId: e,
+							limit: this._inputEventBufferLimit
+						}), this._inputEventBuffer.set(n, [t]);
+					}
+				}
+			}
+		} catch (t) {
+			let n = new e.ErrorInfo(`unable to process channel message; ${t instanceof Error ? t.message : String(t)}`, W.SessionSubscriptionError, 500, t instanceof e.ErrorInfo ? t : void 0);
+			this._logger?.error("DefaultAgentSession._handleChannelMessage(); subscription error"), this._onError?.(n);
 		}
-		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 }
-		});
+	async _requireConnected(t) {
+		if (!this._connectPromise) throw new e.ErrorInfo(`unable to ${t}; connect() must be called before ${t}()`, W.InvalidArgument, 400);
+		return this._connectPromise;
+	}
+	_createRun(t, n) {
+		let r = n.runId ?? crypto.randomUUID(), i = n.invocationId ?? crypto.randomUUID(), a = this._inputEventLookupTimeoutMs, { onMessage: s, onCancelled: c, onCancel: d, onError: f, signal: g } = n, _ = new AbortController(), v = "initialized", y = g ? AbortSignal.any([_.signal, g]) : _.signal, b = {
+			runId: r,
+			invocationId: i,
+			controller: _,
+			signal: y,
+			onCancel: d,
+			onError: f
+		};
+		this._registeredRuns.set(r, b);
+		let x = this._logger, S = this._runManager, C = this._codec, w = this._channel, T = this._registeredRuns, E = this._runIdByInputCodecMessageId, D = this._deferredCancels, O = this._requireConnected.bind(this), ee = this._registerInputEventListener.bind(this), te = this._pullDeferredCancel.bind(this), k = t.inputEventId, A = [], j = { get messages() {
+			return A;
+		} }, M, N, P, F, I, L, ne = !1, R, z, B, V = () => {
+			T.delete(r), L !== void 0 && (E.delete(L), D.delete(L));
+		}, H, U;
+		return {
+			get runId() {
+				return r;
+			},
+			get invocationId() {
+				return i;
+			},
+			get abortSignal() {
+				return y;
+			},
+			get view() {
+				return j;
+			},
+			get messages() {
+				return U === void 0 ? H === void 0 ? A.map((e) => e.message) : C.getMessages(H).map((e) => e.message) : [...U];
+			},
+			start: async () => {
+				if (x?.trace("Run.start();", {
+					runId: r,
+					inputEventId: k
+				}), await O("start"), y.aborted) throw new e.ErrorInfo(`unable to start run; run ${r} was cancelled before start()`, W.InvalidArgument, 400);
+				if (v !== "initialized") return;
+				if (v = "started", k && a > 0) try {
+					let e = await Wt({
+						register: (e) => ee([k], e),
+						codec: C,
+						invocationId: i,
+						runId: r,
+						expectedInputEventIds: [k],
+						timeoutMs: a,
+						signal: y,
+						logger: x
+					});
+					for (let t of e.nodes) A.push(t);
+					e.firstHeaders !== void 0 && (R = e.firstHeaders), e.firstClientId !== void 0 && (N = e.firstClientId), B = e.rawMessages;
+				} catch (t) {
+					let n = t instanceof e.ErrorInfo ? t : new e.ErrorInfo(`unable to look up input event; ${t instanceof Error ? t.message : String(t)}`, W.InputEventNotFound, 504);
+					throw V(), x?.error("Run.start(); input-event lookup failed", {
+						runId: r,
+						invocationId: i
+					}), n;
+				}
+				let t = R ?? A[0]?.headers;
+				if (t) {
+					M = t[u], P = t[p], F = t[m], I = t[h], L = t[l];
+					let e = t[o];
+					ne = e !== void 0, e !== void 0 && e !== r && (T.delete(r), r = e, b.runId = r, T.set(r, b));
+				}
+				z = A.at(-1)?.codecMessageId ?? P, L !== void 0 && (E.set(L, r), await te(b, L));
+				try {
+					await S.startRun(r, M, _, {
+						parent: z,
+						forkOf: F,
+						regenerates: I,
+						invocationId: i,
+						inputClientId: N,
+						inputCodecMessageId: L,
+						continuation: ne
+					});
+				} catch (t) {
+					let n = new e.ErrorInfo(`unable to publish run-start for run ${r}; ${t instanceof Error ? t.message : String(t)}`, W.RunLifecycleError, 500, t instanceof e.ErrorInfo ? t : void 0);
+					throw x?.error("Run.start(); failed to publish run-start", { runId: r }), n;
+				}
+				x?.debug("Run.start(); run started", {
+					runId: r,
+					inputEventId: k
+				});
+			},
+			addEvents: async (t) => {
+				if (x?.trace("Run.addEvents();", {
+					runId: r,
+					count: t.length
+				}), await O("addEvents"), v === "initialized") throw new e.ErrorInfo(`unable to add events; start() must be called before addEvents() (run ${r})`, W.InvalidArgument, 400);
+				let n = S.getClientId(r);
+				try {
+					for (let e of t) {
+						let t = Et({
+							role: "assistant",
+							runId: r,
+							codecMessageId: e.codecMessageId,
+							runClientId: n,
+							invocationId: i,
+							inputClientId: N,
+							inputCodecMessageId: L
+						}), a = C.createEncoder(w, {
+							extras: { headers: t },
+							onMessage: s
+						});
+						for (let t of e.events) await a.publishOutput(t);
+						await a.close();
+					}
+				} catch (t) {
+					let n = new e.ErrorInfo(`unable to publish events for run ${r}; ${t instanceof Error ? t.message : String(t)}`, W.RunLifecycleError, 500, t instanceof e.ErrorInfo ? t : void 0);
+					throw x?.error("Run.addEvents(); publish failed", { runId: r }), n;
+				}
+				x?.debug("Run.addEvents(); events published", {
+					runId: r,
+					count: t.length
+				});
+			},
+			loadProjection: async () => {
+				x?.trace("Run.loadProjection();", { runId: r }), await O("loadProjection");
+				let e = await Rt({
+					channel: w,
+					codec: C,
+					runId: r,
+					signal: y,
+					logger: x,
+					liveMessages: B
+				});
+				return H = e, e;
+			},
+			loadConversation: async (e) => {
+				x?.trace("Run.loadConversation();", { runId: r }), await O("loadConversation");
+				let { messages: t, projection: n } = await zt({
+					channel: w,
+					codec: C,
+					runId: r,
+					signal: y,
+					logger: x,
+					liveMessages: B,
+					assistantParentFallback: z,
+					pageLimit: e?.pageLimit ?? 200,
+					maxMessages: e?.maxMessages ?? 2e3
+				});
+				return H = n, U = t, t;
+			},
+			pipe: async (t, n) => {
+				if (x?.trace("Run.pipe();", { runId: r }), await O("pipe"), v === "initialized") throw new e.ErrorInfo(`unable to pipe stream; start() must be called before pipe() (run ${r})`, W.InvalidArgument, 400);
+				let a = S.getClientId(r), o = n?.parent ?? z, l = n?.forkOf ?? F, u = I, d = crypto.randomUUID(), p = Et({
+					role: "assistant",
+					runId: r,
+					codecMessageId: d,
+					runClientId: a,
+					parent: o,
+					forkOf: l,
+					invocationId: i,
+					inputClientId: N,
+					inputCodecMessageId: L,
+					regenerates: u
+				}), m = await Vt(t, C.createEncoder(w, {
+					extras: { headers: p },
+					onMessage: s,
+					messageId: d
+				}), y, c, n?.resolveWriteOptions, x);
+				if (m.error) {
+					let t = new e.ErrorInfo(`unable to pipe response for run ${r}; ${m.error.message}`, W.StreamError, 500, m.error instanceof e.ErrorInfo ? m.error : void 0);
+					x?.error("Run.pipe(); stream error", { runId: r }), f?.(t);
+				}
+				return x?.debug("Run.pipe(); stream finished", {
+					runId: r,
+					reason: m.reason
+				}), m;
+			},
+			suspend: async () => {
+				if (x?.trace("Run.suspend();", { runId: r }), await O("suspend"), v === "initialized") throw new e.ErrorInfo(`unable to suspend run; start() must be called before suspend() (run ${r})`, W.InvalidArgument, 400);
+				if (v !== "ended") {
+					v = "ended";
+					try {
+						await S.suspendRun(r, i, N, L);
+					} catch (t) {
+						let n = new e.ErrorInfo(`unable to publish run-suspend for run ${r}; ${t instanceof Error ? t.message : String(t)}`, W.RunLifecycleError, 500, t instanceof e.ErrorInfo ? t : void 0);
+						throw x?.error("Run.suspend(); failed to publish run-suspend", { runId: r }), n;
+					} finally {
+						V();
+					}
+					x?.debug("Run.suspend(); run suspended", { runId: r });
+				}
+			},
+			end: async (t) => {
+				if (x?.trace("Run.end();", {
+					runId: r,
+					reason: t
+				}), await O("end"), v === "initialized") throw new e.ErrorInfo(`unable to end run; start() must be called before end() (run ${r})`, W.InvalidArgument, 400);
+				if (v !== "ended") {
+					v = "ended";
+					try {
+						await S.endRun(r, t, i, N, L);
+					} catch (t) {
+						let n = new e.ErrorInfo(`unable to publish run-end for run ${r}; ${t instanceof Error ? t.message : String(t)}`, W.RunLifecycleError, 500, t instanceof e.ErrorInfo ? t : void 0);
+						throw x?.error("Run.end(); failed to publish run-end", { runId: r }), n;
+					} finally {
+						V();
+					}
+					x?.debug("Run.end(); run ended", {
+						runId: r,
+						reason: 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;
+}, Kt = (e) => new Gt(e), qt = class e {
+	constructor(e) {
+		this.inputEventId = e.inputEventId, this.sessionName = e.sessionName;
 	}
-	_getMessagesWithHeaders() {
-		return this._tree.flatten().map((e) => ({
-			message: e,
-			headers: this.getMessageHeaders(e)
-		}));
+	static fromJSON(t) {
+		return new e(t);
 	}
-	_getHistoryBefore(e) {
-		let t = this._getMessagesWithHeaders(), n = t.findIndex((t) => t.headers?.[o] === e);
-		return n === -1 ? t : t.slice(0, n);
+	toJSON() {
+		return {
+			inputEventId: this.inputEventId,
+			sessionName: this.sessionName
+		};
 	}
-	_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);
+}, $ = (e) => e.kind === "run" ? e.runId : e.codecMessageId, Jt = (e) => e.kind === "run" ? e.startSerial : e.serial, Yt = (e, t, n) => {
+	let r = e.get(t);
+	r || (r = /* @__PURE__ */ new Set(), e.set(t, r)), r.add(n);
+}, Xt = (e, t, n) => {
+	let r = e.get(t);
+	r && (r.delete(n), r.size === 0 && e.delete(t));
+}, Zt = class {
+	constructor(e, t) {
+		this._nodeIndex = /* @__PURE__ */ new Map(), this._codecMessageIdToNodeKey = /* @__PURE__ */ new Map(), this._sortedNodes = [], this._parentIndex = /* @__PURE__ */ new Map(), this._replyRunsByInput = /* @__PURE__ */ new Map(), this._seqCounter = 0, this._structuralVersion = 0, this._siblingCache = /* @__PURE__ */ new Map(), this._siblingCacheVersion = -1, this._codec = e, this._logger = t, this._emitter = new Q(t);
+	}
+	_compareNodes(e, t) {
+		let n = Jt(e.node), r = Jt(t.node);
+		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;
+	}
+	_insertSortedNode(e) {
+		if (Jt(e.node) === void 0) {
+			this._sortedNodes.push(e);
+			return;
+		}
+		let t = 0, n = this._sortedNodes.length;
+		for (; t < n;) {
+			let r = t + n >>> 1, i = this._sortedNodes[r];
+			if (!i) break;
+			this._compareNodes(i, e) <= 0 ? t = r + 1 : n = r;
 		}
-		this._emitter.emit("message"), e.rawMessages && e.rawMessages.length > 0 && (this._ablyMessages.unshift(...e.rawMessages), this._emitter.emit("ably-message"));
+		this._sortedNodes.splice(t, 0, e);
 	}
-	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;
+	_removeSortedNode(e) {
+		let t = this._sortedNodes.indexOf(e);
+		t !== -1 && this._sortedNodes.splice(t, 1);
+	}
+	_insertNode(e, t, n) {
+		this._nodeIndex.set(e, t), this._addToParentIndex(n, e), this._insertSortedNode(t), this._structuralVersion++;
+	}
+	_promoteSerial(e) {
+		this._removeSortedNode(e), this._insertSortedNode(e), this._structuralVersion++;
+	}
+	_foldInto(e, t, n, r) {
+		for (let i of t) try {
+			e.node.projection = this._codec.fold(e.node.projection, i, {
+				serial: n ?? "",
+				messageId: r
+			});
+		} catch (t) {
+			this._logger.error("Tree._foldInto(); fold threw", {
+				key: $(e.node),
+				messageId: r,
+				err: t
+			});
 		}
-		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");
+	_addToParentIndex(e, t) {
+		Yt(this._parentIndex, e, t);
 	}
-	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;
+	_removeFromParentIndex(e, t) {
+		Xt(this._parentIndex, e, t);
+	}
+	_parentKeyOf(e) {
+		let t = e.parentCodecMessageId;
+		return t === void 0 ? void 0 : this._codecMessageIdToNodeKey.get(t);
+	}
+	_inputGroupRoot(e) {
+		let t = e, n = new Set([$(t)]);
+		for (; t.forkOf !== void 0 && !n.has(t.forkOf);) {
+			let e = this._nodeIndex.get(t.forkOf);
+			if (e?.node.kind !== "input" || e.node.parentCodecMessageId !== t.parentCodecMessageId) break;
+			t = e.node, n.add($(t));
+		}
+		return t;
+	}
+	_getSiblingGroup(e) {
+		this._siblingCacheVersion !== this._structuralVersion && (this._siblingCache.clear(), this._siblingCacheVersion = this._structuralVersion);
+		let t = this._siblingCache.get(e);
+		if (t) return t;
+		let n = this._nodeIndex.get(e);
+		if (!n) return [];
+		let r = n.node;
+		r.kind === "input" && (r = this._inputGroupRoot(r));
+		let i = r.parentCodecMessageId, a = [], o = this._parentIndex.get(i);
+		if (o) for (let e of o) {
+			let t = this._nodeIndex.get(e);
+			t && this._isSiblingOf(t.node, r) && a.push(t);
+		}
+		a.sort((e, t) => this._compareNodes(e, t));
+		for (let e of a) this._siblingCache.set($(e.node), a);
+		return this._siblingCache.set(e, a), a;
+	}
+	_isSiblingOf(e, t) {
+		if (e.kind !== t.kind || e.parentCodecMessageId !== t.parentCodecMessageId) return !1;
+		if (e.kind === "run") return !0;
+		let n = $(t);
+		if ($(e) === n) return !0;
+		let r = e, i = new Set([$(r)]);
+		for (; r.kind === "input" && r.forkOf !== void 0;) {
+			if (r.forkOf === n) return !0;
+			if (i.has(r.forkOf)) break;
+			let e = this._nodeIndex.get(r.forkOf);
+			if (!e) break;
+			r = e.node, i.add($(r));
+		}
+		return !1;
+	}
+	getGroupRoot(e) {
+		let t = this._nodeIndex.get(e);
+		if (!t) return e;
+		if (t.node.kind === "input") return $(this._inputGroupRoot(t.node));
+		let n = this._getSiblingGroup(e)[0]?.node;
+		return n ? $(n) : e;
+	}
+	visibleNodes(e = /* @__PURE__ */ new Map()) {
+		this._logger.trace("DefaultTree.visibleNodes();");
+		let t = [], n = /* @__PURE__ */ new Set(), r = /* @__PURE__ */ new Map();
+		for (let i of this._sortedNodes) {
+			let a = i.node, o = $(a), s = this._parentKeyOf(a);
+			if (s !== void 0 && !n.has(s)) continue;
+			let c = this._getSiblingGroup(o);
+			if (c.length > 1) {
+				let t = this.getGroupRoot(o), n = r.get(t);
+				if (n === void 0) {
+					let i = e.get(t);
+					if (i !== void 0 && c.some((e) => $(e.node) === i)) n = i;
+					else {
+						let e = c.at(-1);
+						if (!e) break;
+						n = $(e.node);
+					}
+					r.set(t, n);
 				}
+				if (o !== n) continue;
 			}
+			n.add(o), t.push(a);
 		}
-		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 })
-		};
+		return t;
 	}
-	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
+	getRunNode(e) {
+		this._logger.trace("DefaultTree.getRunNode();", { runId: e });
+		let t = this._nodeIndex.get(e)?.node;
+		return t?.kind === "run" ? t : void 0;
+	}
+	getNode(e) {
+		return this._logger.trace("DefaultTree.getNode();", { key: e }), this._nodeIndex.get(e)?.node;
+	}
+	getNodeByCodecMessageId(e) {
+		this._logger.trace("DefaultTree.getNodeByCodecMessageId();", { codecMessageId: e });
+		let t = this._codecMessageIdToNodeKey.get(e);
+		return t === void 0 ? void 0 : this._nodeIndex.get(t)?.node;
+	}
+	getReplyRuns(e) {
+		let t = this._replyRunsByInput.get(e);
+		if (!t) return [];
+		let n = [];
+		for (let e of t) {
+			let t = this._nodeIndex.get(e)?.node;
+			t?.kind === "run" && n.push(t);
+		}
+		return n;
+	}
+	getSiblingNodes(e) {
+		return this._logger.trace("DefaultTree.getSiblingNodes();", { key: e }), this._getSiblingGroup(e).map((e) => e.node);
+	}
+	applyMessage(e, t, n) {
+		let r = t[o], i = t[l], a = r === void 0 && i !== void 0 && t.role === "user" && e.inputs.length > 0 ? i : void 0;
+		if (r === void 0 && a === void 0) {
+			this._logger.warn("Tree.applyMessage(); message has no run-id and is not a user input; skipping");
+			return;
+		}
+		let s = [...e.inputs, ...e.outputs], c = a ?? r;
+		if (s.length === 0 && c !== void 0 && !this._nodeIndex.has(c)) return;
+		let u = this._structuralVersion;
+		a === void 0 ? r !== void 0 && this._applyRunMessage(r, e, t, n) : this._applyInputMessage(a, t, n, s), this._structuralVersion !== u && this._emitter.emit("update");
+	}
+	_applyInputMessage(e, t, n, r) {
+		let i = this._nodeIndex.get(e);
+		i ? i.node.kind === "input" && n && !i.node.serial && (this._logger.debug("Tree.applyMessage(); promoting input serial", {
+			codecMessageId: e,
+			serial: n
+		}), i.node.serial = n, this._promoteSerial(i)) : (i = this._createInputNodeFromHeaders(e, t, n), this._insertNode(e, i, i.node.parentCodecMessageId), this._codecMessageIdToNodeKey.set(e, e), this._logger.debug("Tree.applyMessage(); created input node", { codecMessageId: e })), this._foldInto(i, r, n, e), this._emitter.emit("output", {
+			runId: void 0,
+			inputCodecMessageId: e,
+			codecMessageId: e,
+			serial: n,
+			events: []
 		});
 	}
-	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
+	_applyRunMessage(e, t, n, r) {
+		let i = n[l], a = n[_], o = [...t.inputs, ...t.outputs], s = t.outputs, c = this._nodeIndex.get(e);
+		if (!c && i !== void 0) {
+			let e = this._codecMessageIdToNodeKey.get(i), t = e === void 0 ? void 0 : this._nodeIndex.get(e);
+			t?.node.kind === "run" && t.node.startSerial === void 0 && (c = t);
+		}
+		c ? r && c.node.kind === "run" && !c.node.startSerial && (this._logger.debug("Tree.applyMessage(); promoting startSerial", {
+			runId: e,
+			serial: r
+		}), c.node.startSerial = r, this._promoteSerial(c)) : (c = this._createRunFromHeaders(e, n, r), this._insertNode(e, c, c.node.parentCodecMessageId), this._indexReplyRun(c.node, e), this._logger.debug("Tree.applyMessage(); created new Run", { runId: e }));
+		let u = $(c.node);
+		i && this._codecMessageIdToNodeKey.set(i, u), this._foldInto(c, o, r, i), this._emitter.emit("output", {
+			runId: u,
+			inputCodecMessageId: a,
+			codecMessageId: i,
+			serial: r,
+			events: s
 		});
 	}
-	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);
+	_indexReplyRun(e, t) {
+		e.parentCodecMessageId !== void 0 && Yt(this._replyRunsByInput, e.parentCodecMessageId, t);
+	}
+	applyRunLifecycle(e) {
+		this._logger.trace("DefaultTree.applyRunLifecycle();", {
+			type: e.type,
+			runId: e.runId
+		});
+		let t = this._structuralVersion;
+		switch (e.type) {
+			case "start":
+				this._applyRunStart(e);
+				break;
+			case "suspend":
+				this._applyRunSuspend(e);
+				break;
+			case "resume":
+				this._applyRunResume(e);
+				break;
+			case "end":
+				this._applyRunEnd(e);
+				break;
+		}
+		this._emitter.emit("run", e), this._structuralVersion !== t && this._emitter.emit("update");
+	}
+	_applyRunStart(e) {
+		let t = this._nodeIndex.get(e.runId);
+		if (t?.node.kind === "run") {
+			let n = t.node;
+			if (n.status !== "active" && (n.status = "active"), e.serial && !n.startSerial && (n.startSerial = e.serial, this._promoteSerial(t)), n.parentCodecMessageId === void 0 && e.parent !== void 0 && (n.parentCodecMessageId = e.parent, this._removeFromParentIndex(void 0, e.runId), this._addToParentIndex(n.parentCodecMessageId, e.runId), this._indexReplyRun(n, e.runId), this._structuralVersion++), n.forkOf === void 0 && e.forkOf !== void 0) {
+				let t = this._codecMessageIdToNodeKey.get(e.forkOf);
+				t !== void 0 && t !== e.runId && (n.forkOf = t, this._structuralVersion++);
+			}
+			n.regeneratesCodecMessageId === void 0 && e.regenerates !== void 0 && (n.regeneratesCodecMessageId = e.regenerates, this._structuralVersion++), n.invocationId === "" && e.invocationId !== "" && (n.invocationId = e.invocationId);
+		} else if (!t) {
+			let t = this._createRunFromLifecycle(e);
+			this._insertNode(e.runId, t, t.node.parentCodecMessageId), this._indexReplyRun(t.node, e.runId);
+		}
+	}
+	_applyRunSuspend(e) {
+		let t = this._nodeIndex.get(e.runId);
+		t?.node.kind === "run" && (t.node.status = "suspended", t.node.endSerial = e.serial);
+	}
+	_applyRunResume(e) {
+		let t = this._nodeIndex.get(e.runId);
+		t?.node.kind === "run" && t.node.status === "suspended" && (t.node.status = "active");
+	}
+	_applyRunEnd(e) {
+		let t = this._nodeIndex.get(e.runId);
+		t?.node.kind === "run" && (t.node.status = e.reason, t.node.endSerial = e.serial);
+	}
+	delete(e) {
+		let t = this._nodeIndex.get(e);
+		t && (this._logger.debug("Tree.delete();", { key: e }), this._removeFromParentIndex(t.node.parentCodecMessageId, e), this._removeSortedNode(t), this._nodeIndex.delete(e), t.node.kind === "run" && t.node.parentCodecMessageId !== void 0 && Xt(this._replyRunsByInput, t.node.parentCodecMessageId, e), this._structuralVersion++, this._emitter.emit("update"));
+	}
+	_createRunFromHeaders(e, t, n) {
+		let r = t[m];
+		return this._buildRunNode({
+			runId: e,
+			parentCodecMessageId: t[p],
+			forkOf: r ? this._codecMessageIdToNodeKey.get(r) : void 0,
+			regeneratesCodecMessageId: t[h],
+			clientId: t["run-client-id"] ?? "",
+			invocationId: t["invocation-id"] ?? "",
+			startSerial: n
+		});
+	}
+	_buildRunNode(e) {
+		return {
+			node: {
+				kind: "run",
+				runId: e.runId,
+				parentCodecMessageId: e.parentCodecMessageId,
+				forkOf: e.forkOf,
+				regeneratesCodecMessageId: e.regeneratesCodecMessageId,
+				clientId: e.clientId,
+				invocationId: e.invocationId,
+				status: "active",
+				projection: this._codec.init(),
+				startSerial: e.startSerial,
+				endSerial: void 0
+			},
+			insertSeq: this._seqCounter++
+		};
+	}
+	_createInputNodeFromHeaders(e, t, n) {
+		let r = t[m];
+		return {
+			node: {
+				kind: "input",
+				codecMessageId: e,
+				parentCodecMessageId: t[p],
+				forkOf: r,
+				projection: this._codec.init(),
+				serial: n
+			},
+			insertSeq: this._seqCounter++
+		};
+	}
+	_createRunFromLifecycle(e) {
+		let t = e.forkOf;
+		return this._buildRunNode({
+			runId: e.runId,
+			parentCodecMessageId: e.parent,
+			forkOf: t ? this._codecMessageIdToNodeKey.get(t) : void 0,
+			regeneratesCodecMessageId: e.regenerates,
+			clientId: e.clientId,
+			invocationId: e.invocationId,
+			startSerial: e.serial
 		});
 	}
 	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;
+	emitAblyMessage(e) {
+		this._logger.trace("DefaultTree.emitAblyMessage();"), this._emitter.emit("ably-message", e);
+	}
+}, Qt = (e, t) => new Zt(e, t), $t = (e, t) => {
+	for (let n of t) {
+		let t = D(n), i = t[l];
+		if (!i) continue;
+		let a = n.action, o = a === "message.create" && "discrete" in t, s = t.stream === "true" && (a === "message.create" || a === "message.update" || a === "message.append"), c = t[r], u = c === "complete" || c === "cancelled";
+		(o || s) && e.startedCodecMessageIds.add(i), (o || u) && e.terminatedCodecMessageIds.add(i), e.startedCodecMessageIds.has(i) && e.terminatedCodecMessageIds.has(i) && e.completedCodecMessageIds.add(i);
+	}
+}, en = async (e, t, n) => {
+	e.rawMessages.push(...t.items), e.lastAblyPage = t, $t(e, t.items);
+	let r = e.returnedCount + n;
+	for (; e.completedCodecMessageIds.size < r && t.hasNext();) {
+		e.logger.debug("loadHistory.fetchUntilLimit(); fetching next page", {
+			collected: e.rawMessages.length,
+			completed: e.completedCodecMessageIds.size
+		});
+		let n = await t.next();
+		if (!n) break;
+		t = n, e.rawMessages.push(...n.items), e.lastAblyPage = n, $t(e, n.items);
 	}
-	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);
+}, tn = (e, t) => {
+	let n = e.completedCodecMessageIds.size, r = Math.min(t, Math.max(0, n - e.returnedCount));
+	e.returnedCount += r;
+	let i = n > e.returnedCount, a = e.lastAblyPage?.hasNext() ?? !1, o = e.rawMessages.length - e.returnedRawCount > 0 ? e.rawMessages.slice(e.returnedRawCount).toReversed() : [];
+	return e.returnedRawCount = e.rawMessages.length, {
+		rawMessages: o,
+		hasNext: () => i || a,
+		next: async () => {
+			if (i) return tn(e, t);
+			if (!a || !e.lastAblyPage) return;
+			let n = await e.lastAblyPage.next();
+			if (n) return await en(e, n, t), tn(e, t);
 		}
-		return e;
+	};
+}, nn = async (e, t, n) => {
+	let r = t?.limit ?? 100, i = {
+		rawMessages: [],
+		returnedCount: 0,
+		returnedRawCount: 0,
+		lastAblyPage: void 0,
+		startedCodecMessageIds: /* @__PURE__ */ new Set(),
+		terminatedCodecMessageIds: /* @__PURE__ */ new Set(),
+		completedCodecMessageIds: /* @__PURE__ */ new Set(),
+		logger: n
+	};
+	n.trace("loadHistory();", { limit: r });
+	let a = r * 10;
+	return await e.attach(), await en(i, await e.history({
+		untilAttach: !0,
+		limit: a
+	}), r), tn(i, r);
+}, rn = (e) => Array.isArray(e) ? e : [e], an = 3, on = (e) => ({
+	runId: e.runId,
+	clientId: e.clientId,
+	status: e.status,
+	invocationId: e.invocationId
+}), sn = class {
+	constructor(e) {
+		this._branchSelections = /* @__PURE__ */ new Map(), this._regenSelections = /* @__PURE__ */ new Map(), this._withheldRunIds = /* @__PURE__ */ new Set(), this._lastVisibleNodeKeys = [], this._lastVisibleProjections = [], this._lastVisibleMessagePairs = [], this._lastVisibleNodeKeySet = /* @__PURE__ */ new Set(), this._hasMoreHistory = !1, this._withheldBuffer = [], this._unsubs = [], this._cachedNodes = [], this._loadingOlder = !1, this._processingHistory = !1, this._closed = !1, this._tree = e.tree, this._channel = e.channel, this._codec = e.codec, this._sendDelegate = e.sendDelegate, this._onClose = e.onClose, this._logger = e.logger.withContext({ component: "View" }), this._logger.trace("DefaultView();"), this._emitter = new Q(this._logger), this._cachedNodes = this._computeFlatNodes(), this._updateVisibleSnapshot(this._cachedNodes), this._unsubs.push(this._tree.on("update", () => {
+			this._onTreeUpdate();
+		}), this._tree.on("ably-message", (e) => {
+			this._onTreeAblyMessage(e);
+		}), this._tree.on("run", (e) => {
+			this._onTreeRun(e);
+		}), this._tree.on("output", (e) => {
+			this._onTreeOutput(e);
+		}));
 	}
-	getMessageHeaders(e) {
-		let t = this._codec.getMessageKey(e);
-		return this._tree.getNodeByKey(t)?.headers;
+	_onTreeOutput(e) {
+		this._processingHistory || (e.runId !== void 0 && this._lastVisibleNodeKeySet.has(e.runId) || e.inputCodecMessageId !== void 0 && this._lastVisibleNodeKeySet.has(e.inputCodecMessageId)) && (this._lastVisibleProjections = this._cachedNodes.map((e) => e.projection), this._lastVisibleMessagePairs = this._extractMessages(this._cachedNodes), this._emitter.emit("update"));
 	}
 	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);
+		return this._lastVisibleMessagePairs;
 	}
-	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);
+	runs() {
+		return this._cachedNodes.filter((e) => e.kind === "run").map((e) => on(e));
+	}
+	_computeFlatNodes() {
+		let e = this._treeVisibleNodes();
+		return this._withheldRunIds.size === 0 ? e : e.filter((e) => !this._withheldRunIds.has($(e)));
+	}
+	_recomputeAndEmit() {
+		this._cachedNodes = this._computeFlatNodes(), this._updateVisibleSnapshot(this._cachedNodes), this._emitter.emit("update");
+	}
+	_recomputeAndEmitIfChanged() {
+		let e = this._computeFlatNodes();
+		this._visibleChanged(e) && (this._cachedNodes = e, this._updateVisibleSnapshot(e), this._emitter.emit("update"));
+	}
+	_runByCodecMessageId(e) {
+		let t = this._tree.getNodeByCodecMessageId(e);
+		return t?.kind === "run" ? t : void 0;
+	}
+	_extractMessages(e) {
+		let t = [];
+		for (let n of e) for (let e of this._codec.getMessages(n.projection)) t.push(e);
+		return t;
+	}
+	hasOlder() {
+		return this._withheldBuffer.length > 0 || this._hasMoreHistory;
+	}
+	async loadOlder(e = 100) {
+		if (!(this._closed || this._loadingOlder)) {
+			this._loadingOlder = !0, this._logger.trace("DefaultView.loadOlder();", { limit: e });
+			try {
+				if (this._withheldBuffer.length > 0) {
+					let t = this._withheldBuffer.splice(-e, e);
+					this._releaseWithheld(t);
+					return;
+				}
+				if (!this._hasMoreHistory && !this._lastHistoryPage) {
+					await this._loadFirstPage(e);
+					return;
+				}
+				if (!this._hasMoreHistory) return;
+				if (!this._lastHistoryPage?.hasNext()) {
+					this._hasMoreHistory = !1;
+					return;
+				}
+				let t = await this._lastHistoryPage.next();
+				if (this._closed || !t) {
+					t || (this._hasMoreHistory = !1);
+					return;
+				}
+				await this._revealFromPage(t, e);
+			} catch (e) {
+				throw this._logger.error("DefaultView.loadOlder(); failed", { error: e }), e;
+			} finally {
+				this._loadingOlder = !1;
 			}
-			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;
+	runOf(e) {
+		this._logger.trace("DefaultView.runOf();", { codecMessageId: e });
+		let t = this._tree.getNodeByCodecMessageId(e);
+		if (!t) return;
+		if (t.kind === "run") return on(t);
+		let n = this._selectedReplyRun(t.codecMessageId);
+		return n ? on(n) : void 0;
+	}
+	_selectedReplyRun(e) {
+		let t = this._tree.getReplyRuns(e);
+		if (t.length === 0) return;
+		if (t.length === 1) return t[0];
+		let n = this._tree.getGroupRoot(t[0]?.runId ?? ""), r = this._regenSelections.get(n), i = r && r.kind !== "pending" ? r.selectedRunId : void 0;
+		if (i !== void 0) {
+			let e = t.find((e) => e.runId === i);
+			if (e) return e;
 		}
-		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;
+		return t.toSorted((e, t) => (e.startSerial ?? "￿").localeCompare(t.startSerial ?? "￿")).at(-1);
+	}
+	run(e) {
+		this._logger.trace("DefaultView.run();", { runId: e });
+		let t = this._tree.getRunNode(e);
+		return t ? on(t) : void 0;
+	}
+	branchSelection(e) {
+		let t = this._resolveMessageBranchPoint(e);
+		if (t) {
+			let e = t.siblings.flatMap((e) => {
+				let t = this._codec.getMessages(e.projection).at(0);
+				return t ? [t.message] : [];
+			});
+			if (e.length > 0) {
+				let n = this._resolveSelectedIndex(t), r = Math.max(0, Math.min(n, e.length - 1)), i = e[r];
+				return {
+					hasSiblings: e.length > 1,
+					siblings: e,
+					index: r,
+					selected: i
+				};
 			}
-			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" });
+		let n = this._tree.getNodeByCodecMessageId(e);
+		if (n) {
+			let t = this._codec.getMessages(n.projection).find((t) => t.codecMessageId === e);
+			if (t !== void 0) return {
+				hasSiblings: !1,
+				siblings: [t.message],
+				index: 0,
+				selected: t.message
+			};
+		}
+		return {
+			hasSiblings: !1,
+			siblings: [],
+			index: 0,
+			selected: void 0
+		};
 	}
-	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
+	selectSibling(e, t) {
+		this._logger.trace("DefaultView.selectSibling();", {
+			codecMessageId: e,
+			index: t
 		});
+		let n = this._resolveMessageBranchPoint(e);
+		if (!n) return;
+		let r = Math.max(0, Math.min(t, n.siblings.length - 1)), i = n.siblings[r];
+		i && (n.kind === "fork-of" ? (this._branchSelections.set(n.groupRoot, {
+			kind: "user",
+			selectedKey: $(i)
+		}), this._logger.debug("DefaultView.selectSibling(); fork-of", {
+			codecMessageId: e,
+			index: r,
+			selectedKey: $(i)
+		})) : (this._regenSelections.set(n.groupRoot, {
+			kind: "user",
+			selectedRunId: $(i)
+		}), this._logger.debug("DefaultView.selectSibling(); regenerate", {
+			codecMessageId: e,
+			index: r,
+			selectedRunId: $(i),
+			groupRoot: n.groupRoot
+		})), this._recomputeAndEmit());
+	}
+	_resolveSelectedIndex(e) {
+		if (e.kind === "fork-of") {
+			let t = this._branchSelections.get(e.groupRoot);
+			if (!t) return e.siblings.length - 1;
+			let n = e.siblings.findIndex((e) => $(e) === t.selectedKey);
+			return n === -1 ? e.siblings.length - 1 : n;
+		}
+		let t = this._regenSelections.get(e.groupRoot);
+		if (!t || t.kind === "pending") return e.siblings.length - 1;
+		let n = e.siblings.findIndex((e) => $(e) === t.selectedRunId);
+		return n === -1 ? e.siblings.length - 1 : n;
 	}
-	getSignal(e) {
-		return this._activeTurns.get(e)?.controller.signal;
+	_resolveMessageBranchPoint(e) {
+		let t = this._tree.getNodeByCodecMessageId(e);
+		if (!t) return;
+		if (t.kind === "input") {
+			let e = this._tree.getSiblingNodes(t.codecMessageId);
+			return e.length > 1 ? {
+				kind: "fork-of",
+				groupRoot: this._tree.getGroupRoot(t.codecMessageId),
+				siblings: e
+			} : void 0;
+		}
+		let n = this._tree.getSiblingNodes(t.runId);
+		if (n.length > 1 && this._codec.getMessages(t.projection).at(0)?.codecMessageId === e) return {
+			kind: "regen",
+			groupRoot: this._tree.getGroupRoot(t.runId),
+			siblings: n
+		};
 	}
-	getClientId(e) {
-		return this._activeTurns.get(e)?.clientId;
+	async send(t, n) {
+		if (this._logger.trace("DefaultView.send();"), this._closed) throw new e.ErrorInfo("unable to send; view is closed", W.InvalidArgument, 400);
+		let r = rn(t), i = this._lastVisibleMessagePairs.at(-1)?.codecMessageId, a = await this._sendDelegate(r, n, i);
+		return this._applyForkAutoSelect(a, n), a;
+	}
+	_applyForkAutoSelect(e, t) {
+		if (!t?.forkOf) return;
+		let n = e.optimisticCodecMessageIds.at(0);
+		if (n === void 0) return;
+		let r = this._tree.getGroupRoot(n);
+		this._branchSelections.set(r, {
+			kind: "auto",
+			selectedKey: n
+		}), this._recomputeAndEmit();
+	}
+	_applyRegenerateAutoSelect(e, t) {
+		let n = this._runByCodecMessageId(t);
+		if (!n) return;
+		let r = this._tree.getGroupRoot(n.runId);
+		this._regenSelections.set(r, {
+			kind: "pending",
+			carrierCodecMessageId: e.inputCodecMessageId
+		}), this._logger.debug("DefaultView._applyRegenerateAutoSelect(); deferring regenerate selection", {
+			anchorCodecMessageId: t,
+			groupRoot: r,
+			carrier: e.inputCodecMessageId
+		}), this._resolvePendingRegenSelections(), this._recomputeAndEmitIfChanged();
+	}
+	async regenerate(t, n) {
+		if (this._logger.trace("DefaultView.regenerate();", { messageId: t }), this._closed) throw new e.ErrorInfo("unable to regenerate; view is closed", W.InvalidArgument, 400);
+		let r = this._runByCodecMessageId(t);
+		if (!r) throw new e.ErrorInfo(`unable to regenerate; message not found in tree: ${t}`, W.InvalidArgument, 400);
+		let i = this._findParentMsgId(r, t);
+		if (!i) throw new e.ErrorInfo(`unable to regenerate; parent user message not found for ${t}`, W.InvalidArgument, 400);
+		let a = t;
+		r.regeneratesCodecMessageId !== void 0 && this._codec.getMessages(r.projection).at(0)?.codecMessageId === t && (a = r.regeneratesCodecMessageId);
+		let o = {
+			...n,
+			parent: i
+		}, s = this._codec.createRegenerate(a, i), c = await this._sendDelegate([s], o, i);
+		return this._applyRegenerateAutoSelect(c, a), c;
+	}
+	async edit(t, n, r) {
+		if (this._logger.trace("DefaultView.edit();", { messageId: t }), this._closed) throw new e.ErrorInfo("unable to edit; view is closed", W.InvalidArgument, 400);
+		let i = this._tree.getNodeByCodecMessageId(t);
+		if (!i) throw new e.ErrorInfo(`unable to edit; message not found in tree: ${t}`, W.InvalidArgument, 400);
+		let a = this._findParentMsgId(i, t);
+		return this.send(n, {
+			...r,
+			forkOf: t,
+			parent: a
+		});
 	}
-	abort(e) {
-		this._logger?.debug("DefaultTurnManager.abort();", { turnId: e }), this._activeTurns.get(e)?.controller.abort();
+	_findParentMsgId(e, t) {
+		let n = this._lastVisibleMessagePairs, r = n.findIndex((e) => e.codecMessageId === t);
+		if (r > 0) return n[r - 1]?.codecMessageId;
+		if (r === 0) return;
+		let i = this._codec.getMessages(e.projection), a = i.findIndex((e) => e.codecMessageId === t);
+		if (a > 0) return i[a - 1]?.codecMessageId;
+		if (a === 0 && e.parentCodecMessageId !== void 0) {
+			let t = this._tree.getNodeByCodecMessageId(e.parentCodecMessageId);
+			if (t) return this._codec.getMessages(t.projection).at(-1)?.codecMessageId;
+		}
 	}
-	getActiveTurnIds() {
-		return [...this._activeTurns.keys()];
+	on(e, t) {
+		let n = t;
+		return this._emitter.on(e, n), () => {
+			this._emitter.off(e, n);
+		};
 	}
 	close() {
-		this._logger?.trace("DefaultTurnManager.close();", { activeTurns: this._activeTurns.size });
-		for (let e of this._activeTurns.values()) e.controller.abort();
-		this._activeTurns.clear();
+		if (!this._closed) {
+			this._logger.info("DefaultView.close();"), this._closed = !0, this._loadingOlder = !1;
+			for (let e of this._unsubs) e();
+			this._unsubs.length = 0, this._emitter.off(), this._branchSelections.clear(), this._regenSelections.clear(), this._withheldRunIds.clear(), this._withheldBuffer.length = 0, this._onClose?.();
+		}
 	}
-}, 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");
+	async _loadFirstPage(e) {
+		let t = e * an, n = await nn(this._channel, { limit: t }, this._logger);
+		this._closed || await this._revealFromPage(n, e);
 	}
-	newTurn(e) {
-		return this._logger?.trace("DefaultServerTransport.newTurn();", { turnId: e.turnId }), this._createTurn(e);
+	async _revealFromPage(e, t) {
+		let n = new Set(this._treeVisibleNodes().map((e) => $(e))), { newVisible: r, lastPage: i } = await this._loadUntilVisible(e, t, n);
+		this._closed || (this._lastHistoryPage = i, this._hasMoreHistory = i.hasNext(), this._splitReveal(r, t));
 	}
-	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);
+	_splitReveal(e, t) {
+		let n = 0, r = e.length;
+		for (let i = e.length - 1; i >= 0; i--) {
+			if (e[i]?.kind === "run") {
+				if (n === t) break;
+				n++;
 			}
+			r = i;
 		}
+		let i = e.slice(r), a = e.slice(0, r);
+		for (let e of a) this._withheldRunIds.add($(e));
+		this._withheldBuffer.push(...a), this._releaseWithheld(i);
 	}
-	_handleChannelMessage(t) {
+	_processHistoryPage(e) {
+		this._processingHistory = !0;
 		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);
+			let t = this._codec.createDecoder();
+			for (let n of e.rawMessages) Mt(this._tree, t, n);
+			for (let t of e.rawMessages) this._tree.emitAblyMessage(t);
+		} finally {
+			this._processingHistory = !1;
 		}
 	}
-	_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
+	async _loadUntilVisible(e, t, n) {
+		this._processHistoryPage(e);
+		let r = e, i = () => {
+			let e = 0;
+			for (let t of this._treeVisibleNodes()) t.kind === "run" && !n.has($(t)) && e++;
+			return e;
 		};
-		this._registeredTurns.set(n, p);
-		let m = this._logger, h = this._turnManager, g = this._attachPromise, _ = this._codec, v = this._channel, y = this._registeredTurns;
+		for (; i() < t && r.hasNext();) {
+			let e = await r.next();
+			if (!e || this._closed) break;
+			this._processHistoryPage(e), r = e;
+		}
 		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);
+			newVisible: this._treeVisibleNodes().filter((e) => !n.has($(e))),
+			lastPage: r
+		};
+	}
+	_releaseWithheld(e) {
+		for (let t of e) this._withheldRunIds.delete($(t));
+		e.length > 0 && this._recomputeAndEmit();
+	}
+	_updateVisibleSnapshot(e) {
+		let t = e ?? this._cachedNodes;
+		this._lastVisibleNodeKeys = t.map((e) => $(e)), this._lastVisibleNodeKeySet = new Set(this._lastVisibleNodeKeys), this._lastVisibleProjections = t.map((e) => e.projection), this._lastVisibleMessagePairs = this._extractMessages(t);
+	}
+	_onTreeUpdate() {
+		this._processingHistory || (this._pinBranchSelections(), this._resolvePendingRegenSelections(), this._recomputeAndEmitIfChanged());
+	}
+	_resolveSelections() {
+		let e = /* @__PURE__ */ new Map();
+		for (let [t, n] of this._branchSelections) e.set(t, n.selectedKey);
+		for (let [t, n] of this._regenSelections) n.kind !== "pending" && e.set(t, n.selectedRunId);
+		return e;
+	}
+	_treeVisibleNodes() {
+		return this._tree.visibleNodes(this._resolveSelections());
+	}
+	_pinBranchSelections() {
+		for (let e of this._lastVisibleNodeKeys) {
+			if (this._tree.getNode(e)?.kind !== "input" || this._tree.getSiblingNodes(e).length <= 1) continue;
+			let t = this._tree.getGroupRoot(e);
+			this._branchSelections.get(t) || this._branchSelections.set(t, {
+				kind: "pinned",
+				selectedKey: e
+			});
+		}
+	}
+	_resolvePendingRegenSelections() {
+		for (let [e, t] of this._regenSelections) {
+			if (t.kind === "user") continue;
+			let n = this._tree.getSiblingNodes(e).filter((e) => e.kind === "run");
+			if (n.length <= 1) continue;
+			let r = n.at(-1);
+			r && this._regenSelections.set(e, {
+				kind: "auto",
+				selectedRunId: r.runId
+			});
+		}
+	}
+	_onTreeAblyMessage(e) {
+		let t = D(e), n = t[l], r = t[o];
+		if (!n && !r) {
+			this._emitter.emit("ably-message", e);
+			return;
+		}
+		r && this._lastVisibleNodeKeySet.has(r) && this._emitter.emit("ably-message", e);
+	}
+	_onTreeRun(e) {
+		if (this._lastVisibleNodeKeySet.has(e.runId)) {
+			this._emitter.emit("run", e);
+			return;
+		}
+		e.type === "start" && this._isRunStartVisible(e) && (this._lastVisibleNodeKeySet.add(e.runId), this._emitter.emit("run", e));
+	}
+	_isRunStartVisible(e) {
+		let { parent: t } = e;
+		if (t === void 0) return !0;
+		let n = this._tree.getNodeByCodecMessageId(t);
+		return n ? this._lastVisibleNodeKeySet.has($(n)) : !0;
+	}
+	_visibleChanged(e) {
+		if (e.length !== this._lastVisibleNodeKeys.length) return !0;
+		for (let [t, n] of e.entries()) if ($(n) !== this._lastVisibleNodeKeys[t] || n.projection !== this._lastVisibleProjections[t]) return !0;
+		return !1;
+	}
+}, cn = (e) => new sn(e), ln = () => {}, un = class {
+	constructor(e) {
+		this._views = /* @__PURE__ */ new Set(), this._state = "ready", this._pendingRunStarts = /* @__PURE__ */ new Map();
+		let t = Tt(e.client, e.codec);
+		if (this._channel = e.client.channels.get(e.channelName, t), this._codec = e.codec, this._clientId = e.clientId, this._logger = (e.logger ?? ut({ logLevel: ct.Silent })).withContext({ component: "ClientSession" }), this._emitter = new Q(this._logger), this._hasAttachedOnce = this._channel.state === "attached", this._tree = Qt(this._codec, this._logger), this._view = cn({
+			tree: this._tree,
+			channel: this._channel,
+			codec: this._codec,
+			sendDelegate: this._internalSend.bind(this),
+			logger: this._logger,
+			onClose: () => this._views.delete(this._view)
+		}), this._decoder = this._codec.createDecoder(), this._encoder = this._codec.createEncoder(this._channel, this._clientId === void 0 ? void 0 : { clientId: this._clientId }), this._views.add(this._view), this.tree = this._tree, this.view = this._view, e.messages) {
+			let t;
+			for (let n of e.messages) {
+				let e = crypto.randomUUID(), r = {
+					[l]: e,
+					[f]: "user"
+				};
+				t && (r[p] = t), this._tree.applyMessage({
+					inputs: [this._codec.createUserMessage(n)],
+					outputs: []
+				}, r), t = e;
+			}
+		}
+		this._onMessage = (e) => {
+			this._handleMessage(e);
+		}, this._onChannelStateChange = (e) => {
+			this._handleChannelStateChange(e);
+		}, this._channel.on(this._onChannelStateChange);
+	}
+	connect() {
+		return this._state === "closed" ? Promise.reject(new e.ErrorInfo("unable to connect; session is closed", W.SessionClosed, 400)) : this._connectPromise ? this._connectPromise : (this._logger.trace("DefaultClientSession.connect();"), this._connectPromise = this._channel.subscribe(this._onMessage).then(() => {
+			this._logger.debug("DefaultClientSession.connect(); subscribed and attached");
+		}, (t) => {
+			let n = new e.ErrorInfo(`unable to subscribe to channel; ${t instanceof Error ? t.message : String(t)}`, W.SessionSubscriptionError, 500, t instanceof e.ErrorInfo ? t : void 0);
+			throw this._logger.error("DefaultClientSession.connect(); subscribe failed"), this._emitter.emit("error", n), n;
+		}), this._connectPromise);
+	}
+	async _requireConnected(t) {
+		if (!this._connectPromise) throw new e.ErrorInfo(`unable to ${t}; connect() must be called before ${t}()`, W.InvalidArgument, 400);
+		return this._connectPromise;
+	}
+	_handleMessage(t) {
+		if (this._state !== "closed") try {
+			if (t.name === "ai-run-end") {
+				let n = D(t);
+				if ((n["run-reason"] ?? "complete") === "error") {
+					let t = n[v], r = t === void 0 ? NaN : Number(t), i = Number.isFinite(r) ? r : W.SessionSubscriptionError, a = n["error-message"] ?? "agent reported an error", c = i >= 1e4 && i < 6e4 ? Math.floor(i / 100) : 500, l = new e.ErrorInfo(a, i, c);
+					this._logger.error("ClientSession._handleMessage(); agent error received", {
+						runId: n[o],
+						invocationId: n[s],
+						code: i
+					}), this._emitter.emit("error", l);
 				}
-				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
-					});
+			}
+			let n = Mt(this._tree, this._decoder, t);
+			if (n && (n.type === "start" || n.type === "resume")) {
+				let e = D(t)[_];
+				if (e !== void 0) {
+					let t = this._pendingRunStarts.get(e);
+					t && (this._pendingRunStarts.delete(e), t.resolve(n.runId));
 				}
 			}
+			this._tree.emitAblyMessage(t);
+		} 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.SessionSubscriptionError, 500, n));
+		}
+	}
+	_handleChannelStateChange(t) {
+		if (this._state === "closed") return;
+		let { current: n, resumed: r } = t;
+		if (n === "attached" && !this._hasAttachedOnce) {
+			this._hasAttachedOnce = !0;
+			return;
+		}
+		if (!(n === "failed" || n === "suspended" || n === "detached" || n === "attached" && !r)) return;
+		this._logger.error("ClientSession._handleChannelStateChange(); channel continuity lost", {
+			current: n,
+			resumed: r,
+			previous: t.previous
+		});
+		let i = new e.ErrorInfo(`unable to deliver events; channel continuity lost (${n}${n === "attached" ? ", resumed: false" : ""})`, W.ChannelContinuityLost, 500, t.reason);
+		this._emitter.emit("error", i);
+	}
+	_cleanupFailedSend(e) {
+		for (let t of e) {
+			let e = this._tree.getNodeByCodecMessageId(t);
+			e?.kind === "input" && e.serial === void 0 && this._tree.delete(e.codecMessageId);
+		}
+	}
+	createView() {
+		if (this._state === "closed") throw new e.ErrorInfo("unable to create view; session is closed", W.SessionClosed, 400);
+		this._logger.trace("DefaultClientSession.createView();");
+		let t = cn({
+			tree: this._tree,
+			channel: this._channel,
+			codec: this._codec,
+			sendDelegate: this._internalSend.bind(this),
+			logger: this._logger,
+			onClose: () => this._views.delete(t)
+		});
+		return this._views.add(t), t;
+	}
+	async _internalSend(t, n, r) {
+		if (this._state === "closed" || (await this._requireConnected("send"), this._state === "closed")) throw new e.ErrorInfo("unable to send; session is closed", W.SessionClosed, 400);
+		let i = this._channel.state;
+		if (i !== "attached" && i !== "attaching") throw new e.ErrorInfo(`unable to send; channel is ${i}`, W.ChannelNotReady, 400);
+		this._logger.trace("ClientSession._internalSend();");
+		let a = n?.runId !== void 0, o = n?.runId, s;
+		n?.parent === void 0 && !n?.forkOf && (s = r);
+		let c = /* @__PURE__ */ new Set(), l = [];
+		for (let e of t) {
+			let t = crypto.randomUUID(), r = e.codecMessageId ?? crypto.randomUUID();
+			c.add(r);
+			let i = e.kind !== "user-message" && (e.kind === "regenerate" || e.codecMessageId !== void 0), a = e.parent ?? (n?.parent === void 0 ? s : n.parent), u = n?.forkOf, d = e.kind === "regenerate" ? e.target : void 0, f = Et({
+				role: "user",
+				runId: o,
+				codecMessageId: r,
+				runClientId: this._clientId,
+				...a !== void 0 && { parent: a },
+				...u !== void 0 && { forkOf: u },
+				...d !== void 0 && { regenerates: d },
+				inputEventId: t
+			});
+			i || this._tree.applyMessage({
+				inputs: [e],
+				outputs: []
+			}, f), l.push({
+				input: e,
+				codecMessageId: r,
+				inputEventId: t,
+				headers: f,
+				isWireOnly: i
+			}), !i && n?.parent === void 0 && !n?.forkOf && e.parent === void 0 && (s = r);
+		}
+		let u = l.at(-1);
+		if (u === void 0) throw new e.ErrorInfo("unable to send; inputs array is empty (include at least one input)", W.InvalidArgument, 400);
+		let d = u.inputEventId, f = u.codecMessageId, p = new Promise((e, t) => {
+			this._pendingRunStarts.set(f, {
+				resolve: e,
+				reject: t
+			});
+		});
+		return p.catch(() => {}), await (async () => {
+			try {
+				for (let e of l) await this._encoder.publishInput(e.input, {
+					extras: { headers: e.headers },
+					messageId: e.codecMessageId,
+					...this._clientId !== void 0 && { clientId: this._clientId }
+				});
+			} catch (t) {
+				let n = t instanceof e.ErrorInfo ? t : void 0, r = n?.statusCode === 401 || n?.statusCode === 403, i = new e.ErrorInfo(r ? "unable to publish events; missing publish capability on the channel" : `unable to publish events; ${t instanceof Error ? t.message : String(t)}`, r ? W.InsufficientCapability : W.SessionSendFailed, r ? 401 : 500, n);
+				throw this._emitter.emit("error", i), this._pendingRunStarts.delete(f), a || this._cleanupFailedSend([...c]), i;
+			}
+		})(), {
+			inputCodecMessageId: f,
+			runId: p,
+			inputEventId: d,
+			cancel: async () => {
+				await this._publishCancel({
+					inputCodecMessageId: f,
+					...o !== void 0 && { runId: o }
+				});
+			},
+			optimisticCodecMessageIds: [...c],
+			toInvocation: () => qt.fromJSON({
+				inputEventId: d,
+				sessionName: this._channel.name
+			})
+		};
+	}
+	async cancel(e) {
+		return this._publishCancel({ runId: e });
+	}
+	async _publishCancel(e) {
+		if (this._state === "closed" || (await this._requireConnected("cancel"), this._state === "closed")) return;
+		this._logger.debug("ClientSession._publishCancel();", {
+			runId: e.runId,
+			inputCodecMessageId: e.inputCodecMessageId
+		});
+		let t = { [c]: crypto.randomUUID() };
+		e.runId !== void 0 && (t[o] = e.runId), e.inputCodecMessageId !== void 0 && (t[_] = e.inputCodecMessageId), await this._channel.publish({
+			name: y,
+			extras: { ai: { transport: t } }
+		});
+	}
+	on(e, t) {
+		if (this._state === "closed") return ln;
+		let n = t;
+		return this._emitter.on(e, n), () => {
+			this._emitter.off(e, n);
 		};
 	}
-}, Ye = (e) => new Je(e), Xe = (e) => $({
+	async close() {
+		if (this._state !== "closed") {
+			this._state = "closed", this._logger.info("ClientSession.close();"), this._connectPromise && this._channel.unsubscribe(this._onMessage), this._channel.off(this._onChannelStateChange), this._emitter.off();
+			for (let e of this._views) e.close();
+			if (this._views.clear(), this._pendingRunStarts.size > 0) {
+				let t = new e.ErrorInfo("unable to await run-start; session closed", W.SessionClosed, 400);
+				for (let e of this._pendingRunStarts.values()) e.reject(t);
+				this._pendingRunStarts.clear();
+			}
+			try {
+				await this._encoder.close();
+			} catch {}
+			if (this._connectPromise) try {
+				await this._channel.detach();
+			} catch (e) {
+				this._logger.debug("ClientSession.close(); channel detach failed", { error: e });
+			}
+		}
+	}
+}, dn = (e) => new un(e), fn = (e) => dn({
 	...e,
-	codec: G
-}), Ze = (e) => Ye({
+	codec: Z
+}), pn = (e) => Kt({
 	...e,
-	codec: G
-});
+	codec: Z
+}), mn = async (e, t) => {
+	if (e.reason !== "complete") return Promise.resolve(t).catch(() => {}), e.reason;
+	try {
+		return await t === "tool-calls" ? "suspend" : "complete";
+	} catch (e) {
+		return hn(e) ? "cancelled" : "error";
+	}
+}, hn = (e) => typeof e != "object" || !e ? !1 : e.name === "AbortError";
 //#endregion
-export { G as UIMessageCodec, je as createChatTransport, Xe as createClientTransport, Ze as createServerTransport };
+export { Z as UIMessageCodec, pn as createAgentSession, xt as createChatTransport, fn as createClientSession, mn as vercelRunOutcome };
 
 //# sourceMappingURL=ably-ai-transport-vercel.js.map