@astralbeam/sdk 0.19.1 → 0.20.0

package/dist/{core-CLWlvgYl.js → core-D53b-MKt.js}

@@ -10990,6 +10990,7 @@ function selectedThread(key, id) {
 }
 //#endregion
 //#region src/core/session.ts
+const HISTORY_FAILED = "Reopen this conversation or start a new one before sending.";
 const CORE_OPTION_KEYS = Object.keys({
 	agentId: true,
 	threadId: true,
@@ -11027,21 +11028,58 @@ function createAstralBeamChat(options, deferStart = false) {
 			commands: []
 		},
 		thread: void 0,
-		threadLoading: false,
-		threadLoadFailed: false,
+		history: "idle",
 		messagesCursor: void 0,
 		olderMessagesLoading: false,
-		unsentMessage: void 0,
+		submission: void 0,
 		activeToolCallIds: [],
 		pendingInteractions: []
 	};
+	let submission;
+	const submissions = /* @__PURE__ */ new Map();
+	let clientStatus = "ready";
 	const update = (next) => {
+		const status = submission?.phase === "submitting" && clientStatus !== "streaming" ? "submitted" : clientStatus;
 		state = {
 			...state,
-			...next
+			...next,
+			status
 		};
 		for (const listener of listeners) listener();
 	};
+	const project = ({ id, content, phase, error }) => ({
+		id,
+		content,
+		phase,
+		...error ? { error } : {}
+	});
+	const nextPhases = {
+		submitting: [
+			"accepted",
+			"failed",
+			"refused"
+		],
+		failed: ["submitting"],
+		accepted: [],
+		refused: []
+	};
+	const settle = (sent, phase, error) => {
+		if (!nextPhases[sent.phase].includes(phase)) return false;
+		sent.phase = phase;
+		sent.error = error;
+		if (sent === submission) update({ submission: project(sent) });
+		if (phase === "refused") sent.onRefused?.();
+		return true;
+	};
+	const current = (sent, attempt) => sent === submission && sent.attempt === attempt;
+	const owns = (sent, attempt) => current(sent, attempt) && sent.phase === "submitting";
+	const endUnaccepted = (sent, error) => settle(sent, sent.tools ? "failed" : "refused", error ?? (sent.tools ? /* @__PURE__ */ new Error("This message may not have been sent. Retry to send it.") : void 0));
+	const releaseSubmission = (reason) => {
+		const released = submission;
+		if (released?.phase === "submitting") endUnaccepted(released, released.tools ? void 0 : new Error(reason));
+		submission = void 0;
+		return released;
+	};
 	const authentication = createChatAuthentication({
 		apiUrl: live.apiUrl,
 		scope: "tenant",
@@ -11052,7 +11090,6 @@ function createAstralBeamChat(options, deferStart = false) {
 	let identity;
 	let started = false;
 	let selectionGeneration = 0;
-	let navigationGeneration = 0;
 	let historyGeneration = 0;
 	let hydration = Promise.resolve();
 	let requestController = new AbortController();
@@ -11060,17 +11097,13 @@ function createAstralBeamChat(options, deferStart = false) {
 	let startWithNewThread = false;
 	let threadRecords = [];
 	const clientId = newUuid();
-	let pendingSend;
-	let sending = false;
-	const pendingSends = /* @__PURE__ */ new Map();
-	const acceptPendingSend = () => {
-		if (!pendingSend || pendingSend.accepted) return;
-		pendingSend.accepted = true;
+	const acceptSubmission = () => {
+		if (!submission || !settle(submission, "accepted")) return;
 		if (state.thread) update({ thread: {
 			...state.thread,
 			hasMessages: true
 		} });
-		pendingSend.callbacks?.onAccepted?.();
+		submission.callbacks?.onAccepted?.();
 	};
 	const replaceAcceptedMessage = (record) => {
 		const messages = [...client.getMessages()];
@@ -11102,14 +11135,14 @@ function createAstralBeamChat(options, deferStart = false) {
 		toolResults.clear();
 		for (const [id, result] of retained) toolResults.set(id, result);
 	};
+	const notifyError = (error) => {
+		if (state.auth.status !== "error" || state.auth.error !== error) live.streamCallbacks?.onError?.(error);
+	};
 	const reportError = (error) => {
 		if (error instanceof Error && error.name === "AbortError") return;
 		const failure = error instanceof Error ? error : new Error(String(error));
-		update({
-			error: failure,
-			status: "error"
-		});
-		if (state.auth.status !== "error" || state.auth.error !== failure) live.streamCallbacks?.onError?.(failure);
+		update({ error: failure });
+		notifyError(failure);
 	};
 	const clearUnavailableMcpConnection = (id) => {
 		update({ unavailableMcpConnections: state.unavailableMcpConnections?.filter((entry) => entry !== id) ?? [] });
@@ -11278,15 +11311,15 @@ function createAstralBeamChat(options, deferStart = false) {
 		const body = JSON.parse(init.body);
 		let path = getRunChatUrl();
 		let payload;
-		const submission = body.messages.at(-1)?.role === "user" ? pendingSend : void 0;
-		const previouslyAttempted = submission?.tools !== void 0;
-		if (submission) payload = {
+		const sent = body.messages.at(-1)?.role === "user" && submission?.phase === "submitting" ? submission : void 0;
+		const previouslyAttempted = sent?.tools !== void 0;
+		if (sent) payload = {
 			...body,
 			threadId: thread.id,
 			resume: void 0,
 			parentRunId: void 0,
 			messages: [body.messages.at(-1)],
-			tools: submission.tools ??= body.tools,
+			tools: sent.tools ??= body.tools,
 			forwardedProps: {
 				...body.forwardedProps,
 				clientId
@@ -11321,7 +11354,7 @@ function createAstralBeamChat(options, deferStart = false) {
 		liveToolCalls.clear();
 		update({ activeToolCallIds: [] });
 		const headers = new Headers(init.headers);
-		if (submission) headers.set("Idempotency-Key", submission.key);
+		if (sent) headers.set("Idempotency-Key", sent.key);
 		const response = await astralBeamChatFetch(path, {
 			...auth,
 			...init,
@@ -11333,7 +11366,7 @@ function createAstralBeamChat(options, deferStart = false) {
 				name: limit.name,
 				resetsAt: limit.resets_at
 			} });
-			if (submission && !previouslyAttempted && isAstralBeamApiError(error) && (error.status === 400 || error.status === 413 || error.status === 429)) delete submission.tools;
+			if (sent && !previouslyAttempted && isAstralBeamApiError(error) && (error.status === 400 || error.status === 413 || error.status === 429)) delete sent.tools;
 			throw error;
 		});
 		if (generation !== selectionGeneration) throw new DOMException("Conversation changed", "AbortError");
@@ -11350,12 +11383,12 @@ function createAstralBeamChat(options, deferStart = false) {
 					resetsAt: receipt.usage_limit.resets_at
 				} } : {}
 			});
-			if (submission) {
+			if (sent) {
 				const history = await loadThreadMessages(thread.id, auth, void 0, liveToolMessageIds);
 				if (generation !== selectionGeneration) throw new DOMException("Conversation changed", "AbortError");
 				const accepted = history.messages.find((message) => message.id === receipt.accepted_message_id);
 				if (accepted) replaceAcceptedMessage(accepted);
-				acceptPendingSend();
+				acceptSubmission();
 			}
 			return new Response("", { headers: { "Content-Type": "text/event-stream" } });
 		}
@@ -11416,70 +11449,76 @@ function createAstralBeamChat(options, deferStart = false) {
 			throw error instanceof Error && isAstralBeamApiError(error.cause) ? error.cause : error;
 		}
 	};
-	const createClient = (threadId = state.thread?.id) => {
-		const generation = selectionGeneration;
-		const adapter = { ...connection };
-		delete adapter.hydrate;
-		if (threadId) adapter.hydrate = (_id, options) => {
-			const readGeneration = ++historyGeneration;
-			if (!options?.before) update({ threadLoading: true });
-			const read = (async () => {
-				let history = await loadThreadMessages(threadId, await requestOptions(), options?.before, liveToolMessageIds);
-				while (options?.before && history.messages.every((message) => message.role === "tool") && history.page_after) {
-					const earlier = await loadThreadMessages(threadId, await requestOptions(), history.page_after, liveToolMessageIds);
-					history = {
-						...earlier,
-						messages: [...earlier.messages, ...history.messages]
-					};
-				}
-				if (generation !== selectionGeneration || readGeneration !== historyGeneration) throw new DOMException("Conversation changed", "AbortError");
-				retainToolResults(history);
-				threadRecords = options?.before ? [...history.messages, ...threadRecords] : history.messages;
-				const pageIds = new Set(history.messages.map((message) => message.id));
-				const messages = projectThreadMessages(threadRecords, history.pendingInteractions, liveToolMessageIds).filter((message) => pageIds.has(message.id));
-				if (history.thread.role === "viewer") disposeRenders();
-				const agentChanged = state.thread?.agentId !== history.thread.agent_id;
-				update({
-					thread: threadFromRecord(history.thread, history.messages.length > 0),
-					messagesCursor: history.page_after ?? void 0,
-					pendingInteractions: history.pendingInteractions,
-					threadLoadFailed: false
-				});
-				restoreCompletedWidgets(messages);
-				if (!options?.before && agentChanged) resolveCapabilities();
-				if (!options?.before && messages.length === 0) next.setMessagesManually([]);
-				return {
-					messages,
-					activeRun: null,
-					interrupts: null,
-					page: history.page_after ? {
-						truncated: true,
-						cursor: history.page_after
-					} : { truncated: false }
-				};
-			})();
-			if (!options?.before) {
-				hydration = read;
-				const settled = (failed) => queueMicrotask(() => {
-					if (generation === selectionGeneration && readGeneration === historyGeneration) update({
-						threadLoading: false,
-						threadLoadFailed: failed
-					});
-				});
-				read.then(() => settled(false), () => settled(true));
-			}
-			return read;
-		};
+	const createClient = () => {
 		const next = new ChatClient({
-			connection: adapter,
-			threadId: threadId ?? clientId,
+			connection: {
+				...connection,
+				hydrate: (_id, options) => {
+					const threadId = selectedId;
+					if (!threadId) return Promise.resolve({
+						messages: [],
+						activeRun: null,
+						interrupts: null,
+						page: { truncated: false }
+					});
+					const older = options?.before !== void 0;
+					const readGeneration = older ? historyGeneration : ++historyGeneration;
+					if (!options?.before) update({ history: state.messages.length > 0 || state.thread?.hasMessages === false ? "refreshing" : "loading" });
+					const read = (async () => {
+						let history = await loadThreadMessages(threadId, await requestOptions(), options?.before, liveToolMessageIds);
+						while (options?.before && history.messages.every((message) => message.role === "tool") && history.page_after) {
+							const earlier = await loadThreadMessages(threadId, await requestOptions(), history.page_after, liveToolMessageIds);
+							history = {
+								...earlier,
+								messages: [...earlier.messages, ...history.messages]
+							};
+						}
+						if (client !== next || readGeneration !== historyGeneration) throw new DOMException("Conversation changed", "AbortError");
+						if (!older) retainToolResults(history);
+						threadRecords = older ? [...history.messages, ...threadRecords] : history.messages;
+						const pageIds = new Set(history.messages.map((message) => message.id));
+						const messages = projectThreadMessages(threadRecords, older ? state.pendingInteractions : history.pendingInteractions, liveToolMessageIds).filter((message) => pageIds.has(message.id));
+						if (older) update({ messagesCursor: history.page_after ?? void 0 });
+						else {
+							if (history.thread.role === "viewer") disposeRenders();
+							const agentChanged = state.thread?.agentId !== history.thread.agent_id;
+							update({
+								thread: threadFromRecord(history.thread, history.messages.length > 0),
+								messagesCursor: history.page_after ?? void 0,
+								pendingInteractions: history.pendingInteractions
+							});
+							if (agentChanged) resolveCapabilities();
+							if (messages.length === 0) next.setMessagesManually([]);
+						}
+						restoreCompletedWidgets(messages);
+						return {
+							messages,
+							activeRun: null,
+							interrupts: null,
+							page: history.page_after ? {
+								truncated: true,
+								cursor: history.page_after
+							} : { truncated: false }
+						};
+					})();
+					if (!older) {
+						hydration = read.then(() => "idle", () => "failed").then((history) => new Promise((resolve) => queueMicrotask(() => {
+							if (client === next && readGeneration === historyGeneration) update({ history });
+							resolve();
+						}))).then(() => read);
+						hydration.catch(() => void 0);
+					}
+					return read;
+				}
+			},
+			threadId: selectedId ?? clientId,
 			persistence: true,
 			history: { pageSize: 100 },
 			queue: "drop",
 			tools: declareTools(),
 			forwardedProps: forwardedProps(),
 			onMessagesChange: (messages) => {
-				if (client !== next || generation !== selectionGeneration) return;
+				if (client !== next) return;
 				restoreCompletedWidgets(messages);
 				for (const message of messages) {
 					if (message.role !== "user") continue;
@@ -11488,16 +11527,13 @@ function createAstralBeamChat(options, deferStart = false) {
 				}
 				update({
 					messages,
-					sandbox: collectSandboxActivity(messages),
-					error: next.getError()
+					sandbox: collectSandboxActivity(messages)
 				});
 			},
 			onStatusChange: (status) => {
-				if (client === next && generation === selectionGeneration) update({
-					status,
-					error: next.getError(),
-					...status === "submitted" ? { usageLimitReached: void 0 } : {}
-				});
+				if (client !== next) return;
+				clientStatus = status;
+				update(status === "submitted" ? { usageLimitReached: void 0 } : {});
 			},
 			onInterruptStateChange: (interrupts) => {
 				if (client === next) debug?.("tool", "interrupt state changed", interrupts);
@@ -11507,8 +11543,8 @@ function createAstralBeamChat(options, deferStart = false) {
 				if (eventType === "astralbeam_thread") {
 					const event = data;
 					if (state.thread?.id === event.threadId) {
-						if (event.acceptedMessage && pendingSend && !pendingSend.accepted) replaceAcceptedMessage(event.acceptedMessage);
-						if (event.acceptedMessageId) acceptPendingSend();
+						if (event.acceptedMessage && submission?.phase === "submitting") replaceAcceptedMessage(event.acceptedMessage);
+						if (event.acceptedMessageId) acceptSubmission();
 						if (event.saved) for (const id of event.executableToolCallIds ?? []) {
 							if (!liveToolCalls.has(id)) toolResults.delete(toolResultKey(id));
 							liveToolCalls.add(id);
@@ -11518,8 +11554,7 @@ function createAstralBeamChat(options, deferStart = false) {
 								...state.thread,
 								version: event.version
 							},
-							activeToolCallIds: [...liveToolCalls],
-							...event.acceptedMessageId ? { unsentMessage: void 0 } : {}
+							activeToolCallIds: [...liveToolCalls]
 						});
 					}
 					return;
@@ -11565,20 +11600,24 @@ function createAstralBeamChat(options, deferStart = false) {
 				if (client === next) live.streamCallbacks?.onFinish?.(message);
 			},
 			onError: (error) => {
-				if (client === next && (state.auth.status !== "error" || state.auth.error !== error)) live.streamCallbacks?.onError?.(error);
+				if (client !== next) return;
+				if (submission?.phase !== "submitting" && error.name !== "AbortError") update({ error });
+				notifyError(error);
 			}
 		});
 		return next;
 	};
+	let selectedId;
 	let client = createClient();
-	const replaceClient = (threadId = state.thread?.id) => {
-		client.stop();
+	const replaceClient = () => {
 		const previous = client;
+		client = createClient();
+		clientStatus = "ready";
+		previous.stop();
 		previous.detach();
 		liveToolCalls.clear();
 		liveToolMessageIds.clear();
 		update({ activeToolCallIds: [] });
-		client = createClient(threadId);
 		if (started) client.attach();
 		previous.dispose();
 	};
@@ -11609,17 +11648,16 @@ function createAstralBeamChat(options, deferStart = false) {
 	};
 	const changeSelection = (threadId) => {
 		const previousId = state.thread?.id;
+		const released = releaseSubmission("The conversation changed before this was sent.");
 		if (previousId) {
-			if (pendingSend && !pendingSend.accepted) pendingSends.set(previousId, pendingSend);
-			else pendingSends.delete(previousId);
+			if (released?.phase === "failed") submissions.set(previousId, released);
+			else submissions.delete(previousId);
 			threadToolResults.set(previousId, toolResults);
 		}
 		selectionGeneration++;
-		historyGeneration++;
-		sending = false;
+		selectedId = threadId;
 		requestController.abort();
 		requestController = new AbortController();
-		pendingSend = void 0;
 		toolResults = threadToolResults.get(threadId ?? "") ?? /* @__PURE__ */ new Map();
 		historicalToolIds.clear();
 		threadRecords = [];
@@ -11627,9 +11665,8 @@ function createAstralBeamChat(options, deferStart = false) {
 		update({
 			thread: void 0,
 			messages: [],
-			unsentMessage: void 0,
+			submission: void 0,
 			error: void 0,
-			status: "ready",
 			sandbox: {
 				files: [],
 				commands: []
@@ -11639,41 +11676,30 @@ function createAstralBeamChat(options, deferStart = false) {
 			pendingInteractions: [],
 			serverToolTitles: {},
 			unavailableMcpConnections: [],
-			threadLoadFailed: false,
+			history: "idle",
 			messagesCursor: void 0,
 			olderMessagesLoading: false
 		});
-		replaceClient(threadId);
+		replaceClient();
 	};
 	const openThread = async (id, restoring = false) => {
-		if (!restoring) navigationGeneration++;
 		changeSelection(id);
 		const generation = selectionGeneration;
-		update({ threadLoading: true });
+		submission = submissions.get(id);
+		if (submission) update({ submission: project(submission) });
 		try {
-			pendingSend = pendingSends.get(id);
-			update({ unsentMessage: pendingSend?.content });
 			if (!started) client.attach();
 			await hydration;
 			if (generation !== selectionGeneration) return;
 			if (threadKey) selectedThread(threadKey, id);
 		} catch (error) {
-			if (generation === selectionGeneration) {
-				if (restoring && (live.threadId === void 0 || live.threadId === "auto") && isAstralBeamApiError(error) && error.status === 404) {
-					newThread();
-					return;
-				}
-				update({ threadLoadFailed: true });
-				reportError(error);
-			}
-		} finally {
-			if (generation === selectionGeneration) update({ threadLoading: false });
+			if (generation !== selectionGeneration) return;
+			if (restoring && (live.threadId === void 0 || live.threadId === "auto") && isAstralBeamApiError(error) && error.status === 404) newThread();
+			else reportError(error);
 		}
 	};
 	const newThread = () => {
-		navigationGeneration++;
 		changeSelection();
-		update({ threadLoading: false });
 		if (started) resolveCapabilities();
 		if (threadKey) selectedThread(threadKey, null);
 		else startWithNewThread = true;
@@ -11687,53 +11713,33 @@ function createAstralBeamChat(options, deferStart = false) {
 		if (selected && selected !== "new") openThread(selected, restoring);
 		else if (!restoring) newThread();
 	};
-	const ensureThread = async () => {
+	const ensureThread = async (sent, attempt) => {
 		if (state.thread) return;
-		const generation = selectionGeneration;
 		const options = await requestOptions();
 		const record = await createChatThread(live.agentId ? { agent_id: live.agentId } : {}, options);
-		if (generation !== selectionGeneration) throw new DOMException("Conversation changed", "AbortError");
-		const thread = threadFromRecord(record, false);
-		update({ thread });
-		replaceClient();
-		await hydration;
+		if (!owns(sent, attempt)) throw new DOMException("Send cancelled", "AbortError");
+		selectedId = record.id;
+		update({ thread: threadFromRecord(record, false) });
 		resolveCapabilities();
-		if (threadKey) selectedThread(threadKey, thread.id);
+		if (threadKey) selectedThread(threadKey, record.id);
 	};
-	const refreshThread = async (preserveError = false, resetClient = true) => {
-		if (!state.thread?.id) return;
+	const refreshThread = async (explicit = true) => {
+		if (!state.thread) return;
 		const generation = selectionGeneration;
-		const previousError = state.error;
-		update({
-			threadLoading: true,
-			olderMessagesLoading: false
-		});
+		update({ olderMessagesLoading: false });
 		try {
-			if (resetClient) replaceClient();
-			else {
-				client.detach();
-				client.attach();
-			}
+			client.detach();
+			client.attach();
 			await hydration;
-			if (generation !== selectionGeneration) return;
-			if (preserveError && previousError) update({
-				error: previousError,
-				status: "error"
-			});
+			if (explicit && generation === selectionGeneration) update({ error: void 0 });
 		} catch (error) {
-			if (generation === selectionGeneration) {
-				if (isAstralBeamApiError(error) && error.status === 404) {
-					newThread();
-					return;
-				}
-				reportError(error);
-			}
-		} finally {
-			if (generation === selectionGeneration) update({ threadLoading: false });
+			if (generation !== selectionGeneration) return;
+			if (isAstralBeamApiError(error) && error.status === 404) newThread();
+			else reportError(error);
 		}
 	};
 	const loadOlderMessages = async () => {
-		if (!client.getHasOlderMessages() || state.olderMessagesLoading || state.threadLoading || sending) return;
+		if (!client.getHasOlderMessages() || state.olderMessagesLoading || state.history !== "idle" || submission?.phase === "submitting") return;
 		const generation = selectionGeneration;
 		update({ olderMessagesLoading: true });
 		try {
@@ -11755,11 +11761,7 @@ function createAstralBeamChat(options, deferStart = false) {
 			}, await requestOptions());
 			if (generation !== selectionGeneration) return false;
 			const renamed = threadFromRecord(record, thread.hasMessages);
-			update({
-				thread: renamed,
-				error: client.getError(),
-				status: client.getStatus()
-			});
+			update({ thread: renamed });
 			return true;
 		} catch (error) {
 			if (generation === selectionGeneration) reportError(error);
@@ -11780,7 +11782,7 @@ function createAstralBeamChat(options, deferStart = false) {
 	};
 	const addToolResult = async (result) => {
 		const generation = selectionGeneration;
-		if (sending || client.getIsLoading()) {
+		if (submission?.phase === "submitting" || client.getIsLoading()) {
 			reportError(/* @__PURE__ */ new Error("Wait for this client's current request to finish before responding."));
 			return;
 		}
@@ -11805,96 +11807,76 @@ function createAstralBeamChat(options, deferStart = false) {
 		}
 		scopeCompletedToolCalls();
 		if (pending) {
-			replaceClient();
-			await hydration;
+			client.stop();
+			await refreshThread(false);
 			if (generation !== selectionGeneration) return;
-			update({ threadLoading: false });
 			await client.append({
 				role: "tool",
 				toolCallId: result.toolCallId,
 				content: JSON.stringify(toolResults.get(toolResultKey(result.toolCallId)))
 			});
 		} else if ("tool" in result) await client.addToolResult(result);
-		if (generation === selectionGeneration) await refreshThread(client.getError() !== void 0, false);
+		if (generation === selectionGeneration) await refreshThread(false);
 	};
 	const abandonToolCall = (toolCallId) => addToolResult({ toolCallId });
-	const sendMessage = async (content, callbacks) => {
-		const navigation = navigationGeneration;
+	const deliver = async (sent) => {
+		const attempt = ++sent.attempt;
 		try {
 			await getValidChatAuthToken(authentication);
-		} catch (error) {
-			if (navigation !== navigationGeneration) return;
-			update({ unsentMessage: content });
-			reportError(error);
-			return;
-		}
-		if (navigation !== navigationGeneration) return;
-		if (sending || state.threadLoading || state.status === "streaming") {
-			reportError(/* @__PURE__ */ new Error("Wait for this client's current request to finish before sending."));
-			return;
-		}
-		if (state.threadLoadFailed) {
-			reportError(/* @__PURE__ */ new Error("Reopen this conversation or start a new one before sending."));
-			return;
-		}
-		const samePendingContent = pendingSend !== void 0 && JSON.stringify(pendingSend.content) === JSON.stringify(content);
-		const uncertainSend = pendingSend?.tools !== void 0 && !pendingSend.accepted ? pendingSend : void 0;
-		const retrying = uncertainSend !== void 0 && samePendingContent;
-		if (state.thread?.agentId === null && !retrying) {
-			reportError(/* @__PURE__ */ new Error("This conversation’s agent is unavailable. Start a new conversation to continue."));
-			return;
-		}
-		if (state.thread?.role === "viewer" && !retrying) {
-			reportError(/* @__PURE__ */ new Error("You have read-only access to this conversation."));
-			return;
-		}
-		if (uncertainSend && !samePendingContent) {
-			update({ unsentMessage: uncertainSend.content });
-			reportError(/* @__PURE__ */ new Error("The previous message’s acceptance is unconfirmed. Retry that message before sending different text, or start a new conversation."));
-			return;
-		}
-		const generation = selectionGeneration;
-		historyGeneration++;
-		update({ olderMessagesLoading: false });
-		sending = true;
-		if (!pendingSend || pendingSend.accepted || !samePendingContent) {
-			pendingSend = {
-				content,
-				accepted: false,
-				key: newUuid(),
-				callbacks
-			};
-			client.stop();
-			liveToolCalls.clear();
+			await hydration.catch(() => void 0);
+			if (!owns(sent, attempt)) return project(sent);
+			if (state.history === "failed") throw new Error(HISTORY_FAILED);
+			await ensureThread(sent, attempt);
+			if (!owns(sent, attempt)) return project(sent);
+			sent.callbacks?.onThreadReady?.(state.thread.id);
+			if (!owns(sent, attempt)) return project(sent);
 			scopeCompletedToolCalls();
-			liveToolMessageIds.clear();
-			update({ activeToolCallIds: [] });
+			await client.sendMessage(sent.content);
+			if (!current(sent, attempt)) return project(sent);
+			endUnaccepted(sent, client.getError());
+			await refreshThread(false);
+		} catch (error) {
+			if (!current(sent, attempt)) return project(sent);
+			const failure = error instanceof Error ? error : new Error(String(error));
+			if (failure.name === "AbortError") endUnaccepted(sent);
+			else if (endUnaccepted(sent, failure)) notifyError(failure);
 		}
-		pendingSend.callbacks ??= callbacks;
+		return project(sent);
+	};
+	const sendMessage = async (content, callbacks) => {
+		const rejection = submission?.phase === "submitting" || state.status === "streaming" || client.getIsLoading() ? "Wait for this client's current request to finish before sending." : state.history === "loading" ? "Wait for this conversation to load before sending." : state.history === "failed" ? HISTORY_FAILED : state.thread?.agentId === null ? "This conversation’s agent is unavailable. Start a new conversation to continue." : state.thread?.role === "viewer" ? "You have read-only access to this conversation." : submission?.phase === "failed" ? "The previous message’s acceptance is unconfirmed. Retry that message before sending different text, or start a new conversation." : void 0;
+		if (rejection) return {
+			id: newUuid(),
+			content,
+			phase: "refused",
+			error: new Error(rejection)
+		};
+		const sent = {
+			id: newUuid(),
+			content,
+			phase: "submitting",
+			key: newUuid(),
+			callbacks,
+			attempt: 0
+		};
+		submission = sent;
 		update({
-			unsentMessage: content,
+			submission: project(sent),
 			error: void 0,
-			status: "submitted"
+			olderMessagesLoading: false
 		});
-		try {
-			await ensureThread();
-			if (generation !== selectionGeneration) return;
-			pendingSend.callbacks?.onThreadReady?.(state.thread.id);
-			if (generation !== selectionGeneration) return;
-			scopeCompletedToolCalls();
-			await client.sendMessage(content);
-			if (generation !== selectionGeneration) return;
-			const failed = client.getError() !== void 0;
-			if (pendingSend?.accepted) {
-				pendingSend = void 0;
-				update({ unsentMessage: void 0 });
-			}
-			await refreshThread(failed, false);
-		} catch (error) {
-			if (generation === selectionGeneration) reportError(error);
-		} finally {
-			if (generation === selectionGeneration) sending = false;
-		}
+		client.stop();
+		liveToolCalls.clear();
+		scopeCompletedToolCalls();
+		liveToolMessageIds.clear();
+		update({ activeToolCallIds: [] });
+		const refused = new Promise((resolve) => sent.onRefused = resolve);
+		return Promise.race([deliver(sent), refused.then(() => project(sent))]);
+	};
+	const retry = async () => {
+		if (!submission || !settle(submission, "submitting")) return void 0;
+		update({ error: void 0 });
+		return deliver(submission);
 	};
 	const observeAuthentication = () => {
 		const auth = authenticationState(authentication);
@@ -11902,16 +11884,15 @@ function createAstralBeamChat(options, deferStart = false) {
 		if (auth.status === "ready") {
 			const nextIdentity = authenticationIdentity(auth.currentUser);
 			if (identity !== void 0 && identity !== nextIdentity) {
-				navigationGeneration++;
-				pendingSends.clear();
+				releaseSubmission("The account changed before this was sent.");
+				submissions.clear();
 				threadToolResults.clear();
 				toolResults.clear();
-				pendingSend = void 0;
 			}
 			identity = nextIdentity;
 			const nextThreadKey = `astralbeam:thread:${live.apiUrl ?? "https://astralbeam.ai/api"}:${nextIdentity}`;
 			if (threadKey !== nextThreadKey) {
-				changeSelection();
+				if (threadKey !== void 0) changeSelection();
 				threadKey = nextThreadKey;
 				if (startWithNewThread) {
 					selectedThread(nextThreadKey, null);
@@ -11963,22 +11944,24 @@ function createAstralBeamChat(options, deferStart = false) {
 				forwardedProps: forwardedProps()
 			});
 			if (live.apiUrl !== apiUrl) {
-				navigationGeneration++;
-				pendingSends.clear();
+				releaseSubmission("The chat service changed before this was sent.");
+				submissions.clear();
 				threadToolResults.clear();
 				toolResults.clear();
-				pendingSend = void 0;
 				changeSelection();
 				threadKey = void 0;
-				update({ threadLoading: false });
 				observeAuthentication();
 			} else if (live.threadId !== selectedId) selectConfiguredThread();
 			if (widgets !== live.widgets || onRenderWidget !== live.onRenderWidget) restoreCompletedWidgets(state.messages);
 			if (started && (live.agentId !== agent || live.apiUrl !== apiUrl)) resolveCapabilities();
 		},
 		sendMessage,
+		retry,
 		addToolResult,
-		stop: () => client.stop(),
+		stop: () => {
+			if (submission?.phase === "submitting") endUnaccepted(submission);
+			client.stop();
+		},
 		retryAuthentication: () => {
 			getValidChatAuthToken({
 				...authentication,
@@ -12016,7 +11999,7 @@ function createAstralBeamChat(options, deferStart = false) {
 		openThread,
 		renameThread,
 		deleteThread,
-		refreshThread,
+		refreshThread: () => refreshThread(),
 		loadOlderMessages,
 		uploadAttachment: async ({ data, filename, mimeType }) => {
 			const agentId = state.thread ? state.thread.agentId : live.agentId;
@@ -12062,6 +12045,7 @@ function createAstralBeamChat(options, deferStart = false) {
 			newThread();
 		},
 		dispose: () => {
+			releaseSubmission("The chat closed before this was sent.");
 			client.detach();
 			disposeRenders();
 			client.stop();