@assistant-ui/core 0.3.19 → 0.3.21

package/dist/runtime/base/base-composer-runtime-core.js

@@ -1,11 +1,12 @@
-import { notifyEventListeners } from "../../utils/notify-event-listeners.js";
-import { BaseSubscribable } from "../../subscribable/subscribable.js";
 import { generateId } from "../../utils/id.js";
 import { fileMatchesAccept } from "../../adapters/attachment.js";
+import { notifyEventListeners } from "../../utils/notify-event-listeners.js";
+import { BaseSubscribable } from "../../subscribable/subscribable.js";
 import { isMessageNotSentError } from "../../types/error.js";
 import { EMPTY_QUEUE_ITEMS } from "../queue/queue-item.js";
 import { isAttachmentComplete, isCreateAttachment } from "../../types/attachment.js";
 import { AttachmentAddOperations, drainAttachmentAdd } from "../utils/attachment-add-operations.js";
+import { AttachmentSendOperations } from "../utils/attachment-send-operations.js";
 //#region src/runtime/base/base-composer-runtime-core.ts
 var BaseComposerRuntimeCore = class extends BaseSubscribable {
 	isEditing = true;
@@ -83,10 +84,65 @@ var BaseComposerRuntimeCore = class extends BaseSubscribable {
 		this._runConfig = runConfig;
 		this._notifySubscribers();
 	}
-	_isSending = false;
-	_removedDuringSend = /* @__PURE__ */ new Set();
+	_submission;
+	_submissionSend;
+	_inTransit = [];
+	_inTransitSubmissions = [];
 	_sendGeneration = 0;
 	_attachmentAddOperations = new AttachmentAddOperations();
+	_attachmentSends = new AttachmentSendOperations();
+	get submission() {
+		return this._submission;
+	}
+	get inTransit() {
+		return this._inTransitSubmissions;
+	}
+	/** Whether a send is still being prepared, which holds the composer. */
+	get isSubmitting() {
+		return this._submission !== void 0;
+	}
+	/** Whether a send takes the draft with it, leaving the composer free. */
+	get detachesDraftOnSend() {
+		return true;
+	}
+	/**
+	* The ids of the thread's messages of a role, or undefined when this
+	* composer's sends do not render in the thread. A dispatched submission
+	* stays in transit until a message of its role that was not there at
+	* dispatch shows up.
+	*/
+	threadMessageIds(_role) {}
+	/**
+	* Releases the messages in transit that the thread now shows. Each new
+	* message stands in for the oldest send still waiting for one, and only
+	* once, so sends made in quick succession hand over in order.
+	*/
+	settleInTransit() {
+		if (this._inTransit.length === 0) return;
+		const claimed = /* @__PURE__ */ new Set();
+		const pending = this._inTransit.filter(({ submission, known }) => {
+			const shown = this.threadMessageIds(submission.role)?.find((id) => !known.has(id) && !claimed.has(id));
+			if (shown === void 0) return true;
+			claimed.add(shown);
+			return false;
+		});
+		if (pending.length === this._inTransit.length) return;
+		this._setInTransit(pending.map((entry) => ({
+			...entry,
+			known: /* @__PURE__ */ new Set([...entry.known, ...claimed])
+		})));
+		this._notifySubscribers();
+	}
+	_setInTransit(entries) {
+		this._inTransit = entries;
+		this._inTransitSubmissions = entries.map((entry) => entry.submission);
+	}
+	_leaveTransit(submission) {
+		const remaining = this._inTransit.filter((entry) => entry.submission !== submission);
+		if (remaining.length === this._inTransit.length) return false;
+		this._setInTransit(remaining);
+		return true;
+	}
 	_cancelAttachmentAdd(attachmentId) {
 		this._attachmentAddOperations.cancel(attachmentId);
 	}
@@ -109,105 +165,236 @@ var BaseComposerRuntimeCore = class extends BaseSubscribable {
 	async reset() {
 		this._cancelAllAttachmentAdds();
 		this._sendGeneration++;
-		this._isSending = false;
-		this._removedDuringSend.clear();
-		if (this._attachments.length === 0 && this._text === "" && this._role === "user" && Object.keys(this._runConfig).length === 0 && this._quote === void 0) return;
+		const discarded = this._discardSubmission();
+		if (this._attachments.length === 0 && this._text === "" && this._role === "user" && Object.keys(this._runConfig).length === 0 && this._quote === void 0) {
+			await discarded;
+			return;
+		}
 		this._role = "user";
 		this._runConfig = {};
 		this._quote = void 0;
 		const task = this._onClearAttachments();
 		this._emptyTextAndAttachments();
-		await task;
+		await Promise.all([task, discarded]);
 	}
 	async clearAttachments() {
 		this._cancelAllAttachmentAdds();
-		if (this._isSending) for (const attachment of this._attachments) this._removedDuringSend.add(attachment.id);
+		if (this.isSubmitting) for (const attachment of this._attachments) this._attachmentSends.markRemoved(attachment);
 		const task = this._onClearAttachments();
 		this.setAttachments([]);
 		await task;
 	}
 	async send(options) {
-		if (!this.canSend || this._isSending) return;
-		if (this._dictationSession) try {
-			this._dictationSession.cancel();
-		} catch (error) {
-			console.error("[assistant-ui] Dictation session cancel threw", error);
-		} finally {
-			this._cleanupDictation();
+		if (!this.canSend || this.isSubmitting) return;
+		if (this._dictationSession) {
+			const sessionId = this._activeDictationSessionId;
+			try {
+				this._dictationSession.cancel();
+			} catch (error) {
+				console.error("[assistant-ui] Dictation session cancel threw", error);
+			} finally {
+				this._cleanupDictation({ sessionId });
+			}
+		}
+		const attachments = this.attachments.filter((attachment) => !this._attachmentSends.isRemoved(attachment));
+		if (!this.text.trim() && attachments.length === 0) return;
+		const draft = {
+			id: generateId(),
+			role: this.role,
+			text: this.text,
+			quote: this._quote,
+			attachments
+		};
+		const context = {
+			options,
+			runConfig: this.runConfig
+		};
+		const complete = attachments.filter(isAttachmentComplete);
+		const ready = complete.length === attachments.length;
+		if (!ready) {
+			this._submission = draft;
+			this._submissionSend = {
+				...context,
+				controller: new AbortController()
+			};
+		}
+		if (this.detachesDraftOnSend) {
+			const detached = new Set(attachments);
+			this._attachments = this._attachments.filter((a) => !detached.has(a));
+			this._text = "";
+			this._rebaseDictation("");
+			this._quote = void 0;
 		}
-		const adapter = this.getAttachmentAdapter();
-		const attachmentTasks = this.attachments.map(async (a) => {
-			if (isAttachmentComplete(a)) return a;
-			if (!adapter) throw new Error("Attachments are not supported");
-			return await adapter.send(a);
-		});
-		const originalAttachments = this.attachments;
-		const text = this.text;
-		const quote = this._quote;
-		const role = this.role;
-		const runConfig = this.runConfig;
-		this._quote = void 0;
-		this._text = "";
-		this._isSending = true;
 		const generation = ++this._sendGeneration;
 		this._notifySubscribers();
-		let resolvedAttachments;
-		try {
-			resolvedAttachments = await Promise.all(attachmentTasks);
-		} catch (e) {
-			if (generation === this._sendGeneration) {
-				if (!this.text.trim() && this._quote === void 0) {
-					this._text = text;
-					this._rebaseDictation(text);
-					this._quote = quote;
-					this._notifySubscribers();
-				}
-				Promise.allSettled(attachmentTasks).then(() => {
-					if (generation !== this._sendGeneration) return;
-					this._removedDuringSend.clear();
-					this._isSending = false;
-					this._notifySubscribers();
-				});
-			}
-			throw e;
+		if (ready) {
+			this._dispatch(generation, draft, complete, context, false);
+			return;
+		}
+		await this._prepareSubmission(generation);
+	}
+	async _prepareSubmission(generation) {
+		const adapter = this.getAttachmentAdapter();
+		const uploads = (this._submission?.attachments ?? []).flatMap((attachment) => {
+			const upload = this._attachmentAddOperations.whenSendable(attachment.id);
+			return upload ? [upload] : [];
+		});
+		if (uploads.length > 0) {
+			await Promise.all(uploads);
+			if (generation !== this._sendGeneration) return;
+			this._refreshSubmissionAttachments();
 		}
+		const submission = this._submission;
+		const context = this._submissionSend;
+		if (!submission || !context) return;
+		const sent = submission.attachments.filter((attachment) => !this._attachmentSends.isRemoved(attachment));
+		for (const attachment of sent) this._cancelAttachmentAdd(attachment.id);
+		const settled = await Promise.allSettled(sent.map((attachment) => this._attachmentSends.send(attachment, adapter, context.controller.signal)));
 		if (generation !== this._sendGeneration) return;
-		const sentIds = new Set(originalAttachments.map((a) => a.id));
-		this._attachments = this._attachments.filter((a) => !sentIds.has(a.id));
-		this._isSending = false;
-		this._notifySubscribers();
-		const finalAttachments = resolvedAttachments.filter((a) => !this._removedDuringSend.has(a.id));
-		this._removedDuringSend.clear();
+		const rejection = settled.find((result) => result.status === "rejected");
+		if (rejection) {
+			this._returnSubmissionToDraft(sent, settled, rejection.reason);
+			return;
+		}
+		const finalAttachments = settled.flatMap((result, index) => this._attachmentSends.isRemoved(sent[index]) || result.status === "rejected" ? [] : [result.value]);
+		this._dispatch(generation, submission, finalAttachments, context, true);
+	}
+	_dispatch(generation, draft, attachments, context, isSubmission) {
 		const message = {
 			createdAt: /* @__PURE__ */ new Date(),
-			role,
-			content: text ? [{
+			role: draft.role,
+			content: draft.text ? [{
 				type: "text",
-				text
+				text: draft.text
 			}] : [],
-			attachments: finalAttachments,
-			runConfig,
-			metadata: { custom: { ...quote ? { quote } : {} } }
+			attachments,
+			runConfig: context.runConfig,
+			metadata: { custom: { ...draft.quote ? { quote: draft.quote } : {} } }
 		};
-		const draft = {
-			text,
-			quote,
-			attachments: finalAttachments
+		const sent = {
+			...draft,
+			attachments
 		};
+		const queued = this.queue.length;
+		if (isSubmission) {
+			this._submission = void 0;
+			this._submissionSend = void 0;
+			if (!this.detachesDraftOnSend) {
+				const delivered = new Map(attachments.map((attachment) => [attachment.id, attachment]));
+				this._attachments = this._attachments.map((attachment) => delivered.get(attachment.id) ?? attachment);
+			}
+			const known = this.threadMessageIds(draft.role);
+			if (known) this._setInTransit([...this._inTransit, {
+				submission: sent,
+				known: new Set(known)
+			}]);
+		}
 		let sendTask;
 		try {
-			sendTask = this.handleSend(message, options);
+			sendTask = this.handleSend(message, context.options);
 		} catch (error) {
-			this._restoreUnsentDraft(error, generation, draft);
-			throw error;
+			console.error("[assistant-ui] Failed to send the message", error);
+			this._leaveTransit(sent);
+			if (generation === this._sendGeneration) this._returnToDraft(sent);
+			else this._notifySubscribers();
+			return;
 		}
 		if (sendTask) sendTask.catch((error) => {
-			this._restoreUnsentDraft(error, generation, draft);
+			const wasInTransit = this._leaveTransit(sent);
+			if (generation === this._sendGeneration && isMessageNotSentError(error)) this._returnToDraft(sent);
+			else if (wasInTransit) this._notifySubscribers();
 		});
 		this._notifyEventSubscribers("send", {
-			chars: text.length,
-			attachments: finalAttachments.length
+			chars: draft.text.length,
+			attachments: attachments.length
+		});
+		if (!isSubmission) return;
+		if (this.queue.length > queued) this._leaveTransit(sent);
+		this._notifySubscribers();
+		this.settleInTransit();
+	}
+	_refreshSubmissionAttachments() {
+		const submission = this._submission;
+		if (!submission) return;
+		const attachments = submission.attachments.filter((attachment) => !this._attachmentSends.isRemoved(attachment));
+		if (attachments.length === submission.attachments.length) return;
+		this._submission = {
+			...submission,
+			attachments
+		};
+	}
+	_returnSubmissionToDraft(sent, settled, reason) {
+		const submission = this._submission;
+		if (!submission) return;
+		const failures = /* @__PURE__ */ new Map();
+		settled.forEach((result, index) => {
+			if (result.status === "rejected") failures.set(sent[index].id, result.reason);
+		});
+		const attachments = submission.attachments.map((attachment) => {
+			if (!failures.has(attachment.id) || isAttachmentComplete(attachment)) return attachment;
+			const failure = failures.get(attachment.id);
+			return this._attachmentSends.transfer(attachment, {
+				...attachment,
+				status: {
+					type: "incomplete",
+					reason: "error",
+					message: failure instanceof Error ? failure.message : String(failure)
+				}
+			});
 		});
+		this._endSubmission();
+		this._returnToDraft({
+			...submission,
+			attachments
+		});
+		console.error("[assistant-ui] Failed to send attachments", reason);
+	}
+	/** Ends the send being prepared, so nothing it started can dispatch it. */
+	_endSubmission() {
+		this._sendGeneration++;
+		this._submission = void 0;
+		this._submissionSend = void 0;
+	}
+	/**
+	* Stops the submission and takes its content back into the draft, merging it
+	* ahead of anything written since, so a send is never dropped.
+	*/
+	cancelSubmission() {
+		const submission = this._submission;
+		if (!submission) return;
+		this._submissionSend?.controller.abort();
+		this._endSubmission();
+		this._returnToDraft(submission);
+	}
+	/**
+	* Takes a send's content back into the draft, ahead of anything written
+	* since. A composer that kept its draft only takes back the state the
+	* attachments came back in, such as the reason one failed.
+	*/
+	_returnToDraft(submission) {
+		if (this.detachesDraftOnSend) {
+			const kept = submission.attachments.filter((attachment) => !this._attachmentSends.isRemoved(attachment));
+			this._attachments = [...kept, ...this._attachments];
+			const text = [submission.text, this._text].filter(Boolean).join("\n");
+			this._text = text;
+			this._rebaseDictation(text);
+			this._quote = this._quote ?? submission.quote;
+		} else {
+			const returned = new Map(submission.attachments.map((attachment) => [attachment.id, attachment]));
+			this._attachments = this._attachments.map((attachment) => returned.get(attachment.id) ?? attachment);
+		}
+		this._notifySubscribers();
+	}
+	async _discardSubmission() {
+		const submission = this._submission;
+		if (!submission) return;
+		this._submissionSend?.controller.abort();
+		this._endSubmission();
+		this._notifySubscribers();
+		const adapter = this.getAttachmentAdapter();
+		if (!adapter) return;
+		const drafted = new Set(this._attachments.map((attachment) => attachment.id));
+		await Promise.all(submission.attachments.filter((attachment) => !isAttachmentComplete(attachment) && !drafted.has(attachment.id)).map(async (attachment) => adapter.remove(attachment)));
 	}
 	/**
 	* Take a message back into the composer when it has nowhere else to live:
@@ -240,12 +427,12 @@ var BaseComposerRuntimeCore = class extends BaseSubscribable {
 		this._attachments = [];
 		this._notifySubscribers();
 	}
-	_restoreUnsentDraft(error, generation, draft) {
-		if (!isMessageNotSentError(error)) return;
-		if (generation !== this._sendGeneration) return;
-		this.restoreDraft(draft);
-	}
 	cancel() {
+		if (this.isSubmitting && !this.detachesDraftOnSend) {
+			this._submissionSend?.controller.abort();
+			this._endSubmission();
+			this._notifySubscribers();
+		}
 		this.handleCancel();
 	}
 	get queue() {
@@ -296,14 +483,20 @@ var BaseComposerRuntimeCore = class extends BaseSubscribable {
 		}
 		const operation = this._attachmentAddOperations.start();
 		const upsertAttachment = (a) => {
-			if (!this._attachmentAddOperations.accept(operation, a.id)) return false;
+			if (!this._attachmentAddOperations.accept(operation, a)) return false;
+			const submission = this._submission;
+			const submitted = submission?.attachments.some((attachment) => attachment.id === a.id) ?? false;
+			if (submission && submitted) this._submission = {
+				...submission,
+				attachments: submission.attachments.map((attachment) => attachment.id === a.id ? this._attachmentSends.transfer(attachment, a) : attachment)
+			};
 			const idx = this._attachments.findIndex((attachment) => attachment.id === a.id);
 			if (idx !== -1) this._attachments = [
 				...this._attachments.slice(0, idx),
 				a,
 				...this._attachments.slice(idx + 1)
 			];
-			else this._attachments = [...this._attachments, a];
+			else if (!submitted) this._attachments = [...this._attachments, a];
 			this._notifySubscribers();
 			return true;
 		};
@@ -347,10 +540,13 @@ var BaseComposerRuntimeCore = class extends BaseSubscribable {
 	}
 	async removeAttachment(attachmentId) {
 		const index = this._attachments.findIndex((a) => a.id === attachmentId);
-		if (index === -1) throw new Error("Attachment not found");
+		if (index === -1) {
+			await this._removeSubmittedAttachment(attachmentId);
+			return;
+		}
 		const attachment = this._attachments[index];
 		this._cancelAttachmentAdd(attachmentId);
-		if (this._isSending) this._removedDuringSend.add(attachmentId);
+		this._attachmentSends.markRemoved(attachment);
 		if (!isAttachmentComplete(attachment)) {
 			const adapter = this.getAttachmentAdapter();
 			if (!adapter) throw new Error("Attachments are not supported");
@@ -358,14 +554,14 @@ var BaseComposerRuntimeCore = class extends BaseSubscribable {
 				await adapter.remove(attachment);
 			} catch (error) {
 				const message = error instanceof Error ? error.message : String(error);
-				this._attachments = this._attachments.map((candidate) => candidate.id === attachmentId && !isAttachmentComplete(candidate) ? {
+				this._attachments = this._attachments.map((candidate) => candidate.id === attachmentId && !isAttachmentComplete(candidate) ? this._attachmentSends.transfer(candidate, {
 					...candidate,
 					status: {
 						type: "incomplete",
 						reason: "error",
 						message
 					}
-				} : candidate);
+				}) : candidate);
 				this._notifySubscribers();
 				throw error;
 			}
@@ -373,6 +569,59 @@ var BaseComposerRuntimeCore = class extends BaseSubscribable {
 		this._attachments = this._attachments.filter((a) => a.id !== attachmentId);
 		this._notifySubscribers();
 	}
+	/**
+	* A submission is not delivered yet, so an attachment can still be taken out
+	* of it, which the draft no longer holds once the send detached it.
+	*/
+	async _removeSubmittedAttachment(attachmentId) {
+		const submitted = this._submission?.attachments.find((a) => a.id === attachmentId);
+		if (!submitted) throw new Error("Attachment not found");
+		this._cancelAttachmentAdd(attachmentId);
+		this._attachmentSends.markRemoved(submitted);
+		if (!isAttachmentComplete(submitted)) {
+			const adapter = this.getAttachmentAdapter();
+			if (!adapter) throw new Error("Attachments are not supported");
+			try {
+				await adapter.remove(submitted);
+			} catch (error) {
+				this._failSubmittedRemoval(attachmentId, error);
+				throw error;
+			}
+		}
+		const submission = this._submission;
+		if (!submission) return;
+		this._submission = {
+			...submission,
+			attachments: submission.attachments.filter((a) => a.id !== attachmentId)
+		};
+		this._notifySubscribers();
+	}
+	/**
+	* An attachment whose removal failed stays out of the message it was taken
+	* from and shows why, so the removal can be tried again.
+	*/
+	_failSubmittedRemoval(attachmentId, error) {
+		const submission = this._submission;
+		if (!submission) return;
+		const message = error instanceof Error ? error.message : String(error);
+		this._submission = {
+			...submission,
+			attachments: submission.attachments.map((attachment) => {
+				if (attachment.id !== attachmentId || isAttachmentComplete(attachment)) return attachment;
+				const failed = this._attachmentSends.transfer(attachment, {
+					...attachment,
+					status: {
+						type: "incomplete",
+						reason: "error",
+						message
+					}
+				});
+				this._attachmentSends.markRemoved(failed);
+				return failed;
+			})
+		};
+		this._notifySubscribers();
+	}
 	_dictation;
 	_dictationSession;
 	_dictationUnsubscribes = [];
@@ -417,50 +666,79 @@ var BaseComposerRuntimeCore = class extends BaseSubscribable {
 			status: session.status,
 			inputDisabled
 		};
-		this._notifySubscribers();
-		const unsubSpeech = session.onSpeech((result) => {
-			if (!this._isActiveSession(sessionId, session)) return;
-			const isFinal = result.isFinal !== false;
-			const separator = this._dictationBaseText && !this._dictationBaseText.endsWith(" ") && result.transcript ? " " : "";
-			if (isFinal) {
-				this._dictationBaseText = this._dictationBaseText + separator + result.transcript;
-				this._currentInterimText = "";
-				this._text = this._dictationBaseText;
-				if (this._dictation) {
-					const { transcript: _, ...rest } = this._dictation;
-					this._dictation = rest;
+		try {
+			this._notifySubscribers();
+		} catch (notifyError) {
+			console.error("[assistant-ui] Dictation start notification threw", notifyError);
+		}
+		if (!this._isActiveSession(sessionId, session)) return;
+		const setupUnsubscribes = [];
+		const releaseSetup = () => {
+			for (const unsubscribe of setupUnsubscribes.splice(0)) try {
+				unsubscribe();
+			} catch (cleanupError) {
+				console.error("[assistant-ui] Dictation cleanup threw", cleanupError);
+			}
+		};
+		const keepUnsubscribe = (unsubscribe) => {
+			setupUnsubscribes.push(unsubscribe);
+			if (this._isActiveSession(sessionId, session)) return true;
+			releaseSetup();
+			return false;
+		};
+		try {
+			if (!keepUnsubscribe(session.onSpeech((result) => {
+				if (!this._isActiveSession(sessionId, session)) return;
+				const isFinal = result.isFinal !== false;
+				const separator = this._dictationBaseText && !this._dictationBaseText.endsWith(" ") && result.transcript ? " " : "";
+				if (isFinal) {
+					this._dictationBaseText = this._dictationBaseText + separator + result.transcript;
+					this._currentInterimText = "";
+					this._text = this._dictationBaseText;
+					if (this._dictation) {
+						const { transcript: _, ...rest } = this._dictation;
+						this._dictation = rest;
+					}
+					this._notifySubscribers();
+				} else {
+					this._currentInterimText = separator + result.transcript;
+					this._text = this._dictationBaseText + this._currentInterimText;
+					if (this._dictation) this._dictation = {
+						...this._dictation,
+						transcript: result.transcript
+					};
+					this._notifySubscribers();
 				}
-				this._notifySubscribers();
-			} else {
-				this._currentInterimText = separator + result.transcript;
-				this._text = this._dictationBaseText + this._currentInterimText;
-				if (this._dictation) this._dictation = {
-					...this._dictation,
-					transcript: result.transcript
+			}))) return;
+			if (!keepUnsubscribe(session.onSpeechStart(() => {
+				if (!this._isActiveSession(sessionId, session)) return;
+				this._dictation = {
+					status: { type: "running" },
+					inputDisabled,
+					...this._dictation?.transcript && { transcript: this._dictation.transcript }
 				};
 				this._notifySubscribers();
+			}))) return;
+			if (!keepUnsubscribe(session.onSpeechEnd(() => {
+				this._cleanupDictation({ sessionId });
+			}))) return;
+			const statusInterval = setInterval(() => {
+				if (!this._isActiveSession(sessionId, session)) return;
+				if (session.status.type === "ended") this._cleanupDictation({ sessionId });
+			}, 100);
+			if (!keepUnsubscribe(() => clearInterval(statusInterval))) return;
+			this._dictationUnsubscribes.push(...setupUnsubscribes.splice(0));
+		} catch (error) {
+			releaseSetup();
+			if (this._isActiveSession(sessionId, session)) try {
+				session.cancel();
+			} catch (cancelError) {
+				console.error("[assistant-ui] Dictation session cancel threw", cancelError);
+			} finally {
+				this._cleanupDictation({ sessionId });
 			}
-		});
-		this._dictationUnsubscribes.push(unsubSpeech);
-		const unsubStart = session.onSpeechStart(() => {
-			if (!this._isActiveSession(sessionId, session)) return;
-			this._dictation = {
-				status: { type: "running" },
-				inputDisabled,
-				...this._dictation?.transcript && { transcript: this._dictation.transcript }
-			};
-			this._notifySubscribers();
-		});
-		this._dictationUnsubscribes.push(unsubStart);
-		const unsubEnd = session.onSpeechEnd(() => {
-			this._cleanupDictation({ sessionId });
-		});
-		this._dictationUnsubscribes.push(unsubEnd);
-		const statusInterval = setInterval(() => {
-			if (!this._isActiveSession(sessionId, session)) return;
-			if (session.status.type === "ended") this._cleanupDictation({ sessionId });
-		}, 100);
-		this._dictationUnsubscribes.push(() => clearInterval(statusInterval));
+			throw error;
+		}
 	}
 	stopDictation() {
 		if (!this._dictationSession) return;