@assistant-ui/core 0.3.11 → 0.3.13

package/dist/store/clients/external-thread.js

@@ -0,0 +1,1445 @@
+import { fileMatchesAccept } from "../../adapters/attachment.js";
+import { getThreadMessageText } from "../../utils/text.js";
+import { toMessagePartStatus } from "../../utils/normalizePartStatus.js";
+import { resolveToolApprovalResponse } from "../../runtime/utils/resolveToolApprovalResponse.js";
+import { isCreateAttachment } from "../../types/attachment.js";
+import { ThreadSuggestions } from "./suggestions.js";
+import { ModelContext } from "./model-context-client.js";
+import { DataRenderers } from "../../react/client/DataRenderers.js";
+import { Tools } from "../../react/client/Tools.js";
+import { SingleThreadList } from "./single-thread-list.js";
+import { ToolResponse } from "assistant-stream";
+import { c } from "@assistant-ui/tap/react-shim/compiler-runtime";
+import { useEffect, useRef, useState } from "@assistant-ui/tap/react-shim";
+import { resource, withKey } from "@assistant-ui/tap";
+import { Derived, attachTransformScopes, useClientLookup, useClientResource } from "@assistant-ui/store/client";
+//#region src/store/clients/external-thread.ts
+const EMPTY_QUEUE_ITEMS = [];
+const EMPTY_BRANCH_IDS = [];
+const EMPTY_SUGGESTIONS = [];
+const COMPLETE_STATUS = Object.freeze({ type: "complete" });
+const derivePartStatus = (message, partIndex, part) => {
+	if (!message.status) return COMPLETE_STATUS;
+	return toMessagePartStatus(message, partIndex, part);
+};
+const useMessageClient = (t0) => {
+	const $ = c(71);
+	const { message, index, parentId, onEdit, onReload, queue, branches, onRespondToToolApproval, onAddToolResult, onResumeToolCall, attachmentAdapter, submittedFeedback, onSubmitFeedback, speech, onSpeak, onStopSpeaking } = t0;
+	const [isCopied, setIsCopied] = useState(false);
+	const [isHovering, setIsHovering] = useState(false);
+	let t1;
+	if ($[0] !== message || $[1] !== onAddToolResult || $[2] !== onRespondToToolApproval || $[3] !== onResumeToolCall) {
+		t1 = message.content.map((part, idx) => withKey(idx, PartResource({
+			part,
+			status: derivePartStatus(message, idx, part),
+			messageId: message.id,
+			onRespondToToolApproval,
+			onAddToolResult,
+			onResumeToolCall
+		})));
+		$[0] = message;
+		$[1] = onAddToolResult;
+		$[2] = onRespondToToolApproval;
+		$[3] = onResumeToolCall;
+		$[4] = t1;
+	} else t1 = $[4];
+	const partClients = useClientLookup(t1);
+	let t2;
+	if ($[5] !== message.attachments) {
+		t2 = message.attachments ?? [];
+		$[5] = message.attachments;
+		$[6] = t2;
+	} else t2 = $[6];
+	let t3;
+	if ($[7] !== t2) {
+		t3 = t2.map(_temp2);
+		$[7] = t2;
+		$[8] = t3;
+	} else t3 = $[8];
+	const attachmentClients = useClientLookup(t3);
+	let t4;
+	if ($[9] !== onEdit) {
+		t4 = () => {
+			if (!onEdit) throw new Error("Runtime does not support editing.");
+		};
+		$[9] = onEdit;
+		$[10] = t4;
+	} else t4 = $[10];
+	const handleBeginEdit = t4;
+	let t5;
+	if ($[11] !== message.id || $[12] !== onEdit || $[13] !== parentId) {
+		t5 = (msg) => {
+			if (!onEdit) throw new Error("Runtime does not support editing.");
+			onEdit({
+				...msg,
+				parentId,
+				sourceId: message.id
+			});
+		};
+		$[11] = message.id;
+		$[12] = onEdit;
+		$[13] = parentId;
+		$[14] = t5;
+	} else t5 = $[14];
+	const handleSendEdit = t5;
+	let t6;
+	if ($[15] !== attachmentAdapter || $[16] !== handleBeginEdit || $[17] !== handleSendEdit || $[18] !== message || $[19] !== queue) {
+		t6 = ComposerClientResource({
+			type: "edit",
+			canCancel: true,
+			onBeginEdit: handleBeginEdit,
+			onSend: handleSendEdit,
+			message,
+			queue,
+			attachmentAdapter
+		});
+		$[15] = attachmentAdapter;
+		$[16] = handleBeginEdit;
+		$[17] = handleSendEdit;
+		$[18] = message;
+		$[19] = queue;
+		$[20] = t6;
+	} else t6 = $[20];
+	const composerClient = useClientResource(t6);
+	let branchIds;
+	let t7;
+	if ($[21] !== branches || $[22] !== message.id) {
+		branchIds = branches?.getBranches(message.id) ?? EMPTY_BRANCH_IDS;
+		t7 = branchIds.indexOf(message.id);
+		$[21] = branches;
+		$[22] = message.id;
+		$[23] = branchIds;
+		$[24] = t7;
+	} else {
+		branchIds = $[23];
+		t7 = $[24];
+	}
+	const branchIndex = t7;
+	const branchNumber = branchIndex === -1 ? 1 : branchIndex + 1;
+	const branchCount = branchIndex === -1 ? 1 : branchIds.length;
+	let t8;
+	if ($[25] !== message || $[26] !== submittedFeedback) {
+		t8 = submittedFeedback && message.role === "assistant" ? {
+			...message,
+			metadata: {
+				...message.metadata,
+				submittedFeedback: { type: submittedFeedback }
+			}
+		} : message;
+		$[25] = message;
+		$[26] = submittedFeedback;
+		$[27] = t8;
+	} else t8 = $[27];
+	const messageWithFeedback = t8;
+	let t9;
+	if ($[28] !== message.attachments) {
+		t9 = message.attachments ?? [];
+		$[28] = message.attachments;
+		$[29] = t9;
+	} else t9 = $[29];
+	let t10;
+	if ($[30] !== branchCount || $[31] !== branchNumber || $[32] !== composerClient.state || $[33] !== index || $[34] !== isCopied || $[35] !== isHovering || $[36] !== messageWithFeedback || $[37] !== parentId || $[38] !== partClients.state || $[39] !== speech || $[40] !== t9) {
+		t10 = {
+			...messageWithFeedback,
+			attachments: t9,
+			parentId,
+			isLast: false,
+			branchNumber,
+			branchCount,
+			speech,
+			parts: partClients.state,
+			isCopied,
+			isHovering,
+			index,
+			composer: composerClient.state
+		};
+		$[30] = branchCount;
+		$[31] = branchNumber;
+		$[32] = composerClient.state;
+		$[33] = index;
+		$[34] = isCopied;
+		$[35] = isHovering;
+		$[36] = messageWithFeedback;
+		$[37] = parentId;
+		$[38] = partClients.state;
+		$[39] = speech;
+		$[40] = t9;
+		$[41] = t10;
+	} else t10 = $[41];
+	const state = t10;
+	let t11;
+	if ($[42] !== state) {
+		t11 = () => state;
+		$[42] = state;
+		$[43] = t11;
+	} else t11 = $[43];
+	let t12;
+	if ($[44] !== composerClient.methods) {
+		t12 = () => composerClient.methods;
+		$[44] = composerClient.methods;
+		$[45] = t12;
+	} else t12 = $[45];
+	let t13;
+	if ($[46] !== onReload) {
+		t13 = () => {
+			onReload?.();
+		};
+		$[46] = onReload;
+		$[47] = t13;
+	} else t13 = $[47];
+	let t14;
+	if ($[48] !== branchIds || $[49] !== branchIndex || $[50] !== branches || $[51] !== message.id) {
+		t14 = (t15) => {
+			const { position, branchId } = t15;
+			if (!branches) return;
+			const target = branchId ?? (branchIndex === -1 ? void 0 : position === "previous" ? branchIds[branchIndex - 1] : position === "next" ? branchIds[branchIndex + 1] : void 0);
+			if (target !== void 0 && target !== message.id) branches.switchToBranch(target);
+		};
+		$[48] = branchIds;
+		$[49] = branchIndex;
+		$[50] = branches;
+		$[51] = message.id;
+		$[52] = t14;
+	} else t14 = $[52];
+	let t15;
+	if ($[53] !== message) {
+		t15 = () => getThreadMessageText(message);
+		$[53] = message;
+		$[54] = t15;
+	} else t15 = $[54];
+	let t16;
+	if ($[55] !== partClients || $[56] !== state) {
+		t16 = (selector) => {
+			if ("index" in selector) return partClients.get(selector);
+			const partIndex = state.parts.findIndex((p) => p.type === "tool-call" && p.toolCallId === selector.toolCallId);
+			return partClients.get({ index: partIndex });
+		};
+		$[55] = partClients;
+		$[56] = state;
+		$[57] = t16;
+	} else t16 = $[57];
+	let t17;
+	if ($[58] !== attachmentClients) {
+		t17 = (selector_0) => {
+			if ("id" in selector_0) return attachmentClients.get({ key: selector_0.id });
+			return attachmentClients.get(selector_0);
+		};
+		$[58] = attachmentClients;
+		$[59] = t17;
+	} else t17 = $[59];
+	let t18;
+	if ($[60] !== onSpeak || $[61] !== onStopSpeaking || $[62] !== onSubmitFeedback || $[63] !== t11 || $[64] !== t12 || $[65] !== t13 || $[66] !== t14 || $[67] !== t15 || $[68] !== t16 || $[69] !== t17) {
+		t18 = {
+			getState: t11,
+			composer: t12,
+			delete: _temp3,
+			reload: t13,
+			speak: onSpeak,
+			stopSpeaking: onStopSpeaking,
+			submitFeedback: onSubmitFeedback,
+			switchToBranch: t14,
+			getCopyText: t15,
+			part: t16,
+			attachment: t17,
+			setIsCopied,
+			setIsHovering
+		};
+		$[60] = onSpeak;
+		$[61] = onStopSpeaking;
+		$[62] = onSubmitFeedback;
+		$[63] = t11;
+		$[64] = t12;
+		$[65] = t13;
+		$[66] = t14;
+		$[67] = t15;
+		$[68] = t16;
+		$[69] = t17;
+		$[70] = t18;
+	} else t18 = $[70];
+	return t18;
+};
+const MessageClient = resource(useMessageClient);
+const usePartResource = (t0) => {
+	const $ = c(20);
+	const { part, status, messageId, onRespondToToolApproval, onAddToolResult, onResumeToolCall } = t0;
+	const t1 = status;
+	let t2;
+	if ($[0] !== part || $[1] !== t1) {
+		t2 = {
+			...part,
+			status: t1
+		};
+		$[0] = part;
+		$[1] = t1;
+		$[2] = t2;
+	} else t2 = $[2];
+	const state = t2;
+	let t3;
+	if ($[3] !== state) {
+		t3 = () => state;
+		$[3] = state;
+		$[4] = t3;
+	} else t3 = $[4];
+	let t4;
+	if ($[5] !== messageId || $[6] !== onAddToolResult || $[7] !== part) {
+		t4 = (result) => {
+			if (!onAddToolResult) throw new Error("Runtime does not support tool results (onAddToolResult is not set).");
+			if (part.type !== "tool-call") throw new Error("Tried to add tool result on non-tool message part");
+			const response = ToolResponse.toResponse(result);
+			onAddToolResult({
+				messageId,
+				toolName: part.toolName,
+				toolCallId: part.toolCallId,
+				result: response.result,
+				isError: response.isError,
+				...response.artifact !== void 0 && { artifact: response.artifact },
+				...response.modelContent !== void 0 && { modelContent: response.modelContent }
+			});
+		};
+		$[5] = messageId;
+		$[6] = onAddToolResult;
+		$[7] = part;
+		$[8] = t4;
+	} else t4 = $[8];
+	let t5;
+	if ($[9] !== onResumeToolCall || $[10] !== part) {
+		t5 = (payload) => {
+			if (!onResumeToolCall) throw new Error("Runtime does not support resuming tool calls (onResumeToolCall is not set).");
+			if (part.type !== "tool-call") throw new Error("Tried to resume tool call on non-tool message part");
+			onResumeToolCall({
+				toolCallId: part.toolCallId,
+				payload
+			});
+		};
+		$[9] = onResumeToolCall;
+		$[10] = part;
+		$[11] = t5;
+	} else t5 = $[11];
+	let t6;
+	if ($[12] !== onRespondToToolApproval || $[13] !== part) {
+		t6 = (response_0) => {
+			if (!onRespondToToolApproval) throw new Error("Runtime does not support tool approvals.");
+			if (part.type !== "tool-call") throw new Error("Tried to respond to tool approval on non-tool message part");
+			if (!part.approval || part.approval.approved !== void 0 || part.approval.resolution !== void 0) throw new Error("Tool call has no pending approval");
+			onRespondToToolApproval(resolveToolApprovalResponse(part.approval, response_0));
+		};
+		$[12] = onRespondToToolApproval;
+		$[13] = part;
+		$[14] = t6;
+	} else t6 = $[14];
+	let t7;
+	if ($[15] !== t3 || $[16] !== t4 || $[17] !== t5 || $[18] !== t6) {
+		t7 = {
+			getState: t3,
+			addToolResult: t4,
+			resumeToolCall: t5,
+			respondToToolApproval: t6
+		};
+		$[15] = t3;
+		$[16] = t4;
+		$[17] = t5;
+		$[18] = t6;
+		$[19] = t7;
+	} else t7 = $[19];
+	return t7;
+};
+const PartResource = resource(usePartResource);
+const useAttachmentResource = ({ attachment, onRemove }) => {
+	return {
+		getState: () => attachment,
+		remove: async () => {
+			await onRemove?.();
+		}
+	};
+};
+const AttachmentResource = resource(useAttachmentResource);
+var AttachmentAddOperations = class {
+	operations = /* @__PURE__ */ new Set();
+	start() {
+		const operation = {
+			cancelled: false,
+			attachmentIds: /* @__PURE__ */ new Set()
+		};
+		this.operations.add(operation);
+		return operation;
+	}
+	accept(operation, attachmentId) {
+		if (operation.cancelled) return false;
+		operation.attachmentIds.add(attachmentId);
+		return true;
+	}
+	finish(operation) {
+		this.operations.delete(operation);
+	}
+	isCancelled(operation) {
+		return operation.cancelled;
+	}
+	cancel(attachmentId) {
+		for (const operation of [...this.operations]) {
+			if (!operation.attachmentIds.has(attachmentId)) continue;
+			operation.cancelled = true;
+			this.operations.delete(operation);
+		}
+	}
+	cancelAll() {
+		for (const operation of this.operations) operation.cancelled = true;
+		this.operations.clear();
+	}
+};
+const useQueueItemClient = ({ item, onMove, onRemove }) => {
+	return {
+		getState: () => item,
+		steer: () => onMove({
+			lane: "steer",
+			insertAfter: null
+		}),
+		move: onMove,
+		remove: onRemove
+	};
+};
+const QueueItemClient = resource(useQueueItemClient);
+const drainAdapterAdd = async (result, upsert) => {
+	if (Symbol.asyncIterator in result) {
+		for await (const attachment of result) if (!upsert(attachment)) break;
+	} else upsert(await result);
+};
+const useLiveState = (initial) => {
+	const $ = c(3);
+	const [state, setState] = useState(initial);
+	const ref = useRef(state);
+	let t0;
+	if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+		t0 = (next) => {
+			ref.current = typeof next === "function" ? next(ref.current) : next;
+			setState(ref.current);
+		};
+		$[0] = t0;
+	} else t0 = $[0];
+	const set = t0;
+	let t1;
+	if ($[1] !== state) {
+		t1 = [
+			state,
+			set,
+			ref
+		];
+		$[1] = state;
+		$[2] = t1;
+	} else t1 = $[2];
+	return t1;
+};
+const useComposerClientResource = (t0) => {
+	const $ = c(105);
+	const { type, canCancel, isRunning: t1, isSendDisabled: t2, onCancel, onBeginEdit, onSend, message, queue, attachmentAdapter } = t0;
+	const isRunning = t1 === void 0 ? false : t1;
+	const isSendDisabled = t2 === void 0 ? false : t2;
+	const [isEditing, setIsEditing, isEditingRef] = useLiveState(type === "thread");
+	const [text, setText, textRef] = useLiveState("");
+	const [role, setRole, roleRef] = useLiveState("user");
+	let t3;
+	if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+		t3 = {};
+		$[0] = t3;
+	} else t3 = $[0];
+	const [runConfig, setRunConfig, runConfigRef] = useLiveState(t3);
+	let t4;
+	if ($[1] === Symbol.for("react.memo_cache_sentinel")) {
+		t4 = [];
+		$[1] = t4;
+	} else t4 = $[1];
+	const [attachments, setAttachments, attachmentsRef] = useLiveState(t4);
+	const [quote, setQuote, quoteRef] = useLiveState(void 0);
+	let t5;
+	if ($[2] === Symbol.for("react.memo_cache_sentinel")) {
+		t5 = new AttachmentAddOperations();
+		$[2] = t5;
+	} else t5 = $[2];
+	const attachmentAddOperations = t5;
+	let t6;
+	if ($[3] !== message || $[4] !== setAttachments || $[5] !== setRole || $[6] !== setText) {
+		t6 = () => {
+			if (!message) return;
+			const messageText = message.content.filter(_temp4).map(_temp5).join("\n\n");
+			setText(messageText);
+			setRole(message.role);
+			setAttachments(message.attachments ?? []);
+		};
+		$[3] = message;
+		$[4] = setAttachments;
+		$[5] = setRole;
+		$[6] = setText;
+		$[7] = t6;
+	} else t6 = $[7];
+	const updateFromMessage = t6;
+	let t7;
+	if ($[8] !== attachmentAdapter || $[9] !== attachments || $[10] !== setAttachments) {
+		let t8;
+		if ($[12] !== attachmentAdapter || $[13] !== setAttachments) {
+			t8 = (attachment) => withKey(attachment.id, AttachmentResource({
+				attachment,
+				onRemove: async () => {
+					attachmentAddOperations.cancel(attachment.id);
+					await attachmentAdapter?.remove(attachment);
+					setAttachments((prev) => prev.filter((a) => a.id !== attachment.id));
+				}
+			}));
+			$[12] = attachmentAdapter;
+			$[13] = setAttachments;
+			$[14] = t8;
+		} else t8 = $[14];
+		t7 = attachments.map(t8);
+		$[8] = attachmentAdapter;
+		$[9] = attachments;
+		$[10] = setAttachments;
+		$[11] = t7;
+	} else t7 = $[11];
+	const attachmentClients = useClientLookup(t7);
+	let t8;
+	if ($[15] !== attachmentAdapter) {
+		t8 = async (removed) => {
+			if (!attachmentAdapter) return;
+			await Promise.all(removed.filter(_temp6).map((a_1) => attachmentAdapter.remove(a_1)));
+		};
+		$[15] = attachmentAdapter;
+		$[16] = t8;
+	} else t8 = $[16];
+	const removePendingAttachments = t8;
+	let t9;
+	if ($[17] !== setAttachments) {
+		t9 = (attachment_0) => {
+			setAttachments((prev_0) => {
+				const idx = prev_0.findIndex((a_2) => a_2.id === attachment_0.id);
+				if (idx === -1) return [...prev_0, attachment_0];
+				const next = [...prev_0];
+				next[idx] = attachment_0;
+				return next;
+			});
+		};
+		$[17] = setAttachments;
+		$[18] = t9;
+	} else t9 = $[18];
+	const upsertAttachment = t9;
+	const steerItems = queue?.steerItems ?? EMPTY_QUEUE_ITEMS;
+	const laneItems = queue?.items ?? EMPTY_QUEUE_ITEMS;
+	let t10;
+	if ($[19] !== laneItems || $[20] !== steerItems) {
+		t10 = steerItems.length === 0 ? laneItems : laneItems.length === 0 ? steerItems : [...steerItems, ...laneItems];
+		$[19] = laneItems;
+		$[20] = steerItems;
+		$[21] = t10;
+	} else t10 = $[21];
+	const queueItems = t10;
+	let t11;
+	if ($[22] !== queue || $[23] !== queueItems) {
+		let t12;
+		if ($[25] !== queue) {
+			t12 = (item) => withKey(item.id, QueueItemClient({
+				item,
+				onMove: (placement) => queue?.move(item.id, placement),
+				onRemove: () => queue?.remove(item.id)
+			}));
+			$[25] = queue;
+			$[26] = t12;
+		} else t12 = $[26];
+		t11 = queueItems.map(t12);
+		$[22] = queue;
+		$[23] = queueItems;
+		$[24] = t11;
+	} else t11 = $[24];
+	const queueItemClients = useClientLookup(t11);
+	let t12;
+	if ($[27] !== attachmentAdapter?.accept || $[28] !== attachmentClients.state || $[29] !== attachments.length || $[30] !== canCancel || $[31] !== isEditing || $[32] !== isSendDisabled || $[33] !== queueItems || $[34] !== quote || $[35] !== role || $[36] !== runConfig || $[37] !== text || $[38] !== type) {
+		t12 = () => {
+			const isEmpty = !text.trim() && !attachments.length;
+			return {
+				text,
+				role,
+				attachments: attachmentClients.state,
+				runConfig,
+				isEditing,
+				canCancel,
+				canSend: isEditing && !isEmpty && !isSendDisabled,
+				attachmentAccept: attachmentAdapter?.accept ?? "*",
+				isEmpty,
+				type,
+				dictation: void 0,
+				quote,
+				queue: queueItems
+			};
+		};
+		$[27] = attachmentAdapter?.accept;
+		$[28] = attachmentClients.state;
+		$[29] = attachments.length;
+		$[30] = canCancel;
+		$[31] = isEditing;
+		$[32] = isSendDisabled;
+		$[33] = queueItems;
+		$[34] = quote;
+		$[35] = role;
+		$[36] = runConfig;
+		$[37] = text;
+		$[38] = type;
+		$[39] = t12;
+	} else t12 = $[39];
+	attachmentAdapter?.accept;
+	let t13;
+	if ($[40] !== t12) {
+		t13 = t12();
+		$[40] = t12;
+		$[41] = t13;
+	} else t13 = $[41];
+	const state = t13;
+	let t14;
+	if ($[42] !== state) {
+		t14 = () => state;
+		$[42] = state;
+		$[43] = t14;
+	} else t14 = $[43];
+	let t15;
+	if ($[44] !== attachmentAdapter || $[45] !== setAttachments || $[46] !== upsertAttachment) {
+		t15 = async (fileOrAttachment) => {
+			if (attachmentAdapter) {
+				const file = isCreateAttachment(fileOrAttachment) ? {
+					name: fileOrAttachment.name,
+					type: fileOrAttachment.contentType ?? ""
+				} : {
+					name: fileOrAttachment.name,
+					type: fileOrAttachment.type
+				};
+				if (!fileMatchesAccept(file, attachmentAdapter.accept)) throw new Error(`File type ${file.type || "unknown"} is not accepted. Accepted types: ${attachmentAdapter.accept}`);
+			}
+			if (!isCreateAttachment(fileOrAttachment) && attachmentAdapter) {
+				const operation = attachmentAddOperations.start();
+				try {
+					await drainAdapterAdd(attachmentAdapter.add({ file: fileOrAttachment }), (attachment_1) => {
+						if (!attachmentAddOperations.accept(operation, attachment_1.id)) return false;
+						upsertAttachment(attachment_1);
+						return true;
+					});
+					attachmentAddOperations.finish(operation);
+				} catch (t16) {
+					const error = t16;
+					attachmentAddOperations.finish(operation);
+					if (!attachmentAddOperations.isCancelled(operation)) throw error;
+				}
+			} else if (!isCreateAttachment(fileOrAttachment)) {
+				const newAttachment = {
+					id: Math.random().toString(36).substring(7),
+					type: "file",
+					name: fileOrAttachment.name,
+					contentType: fileOrAttachment.type,
+					file: fileOrAttachment,
+					status: { type: "complete" },
+					content: []
+				};
+				setAttachments((prev_1) => [...prev_1, newAttachment]);
+			} else {
+				const newAttachment_0 = {
+					id: fileOrAttachment.id ?? Math.random().toString(36).substring(7),
+					type: fileOrAttachment.type ?? "document",
+					name: fileOrAttachment.name,
+					contentType: fileOrAttachment.contentType,
+					content: fileOrAttachment.content,
+					status: { type: "complete" }
+				};
+				setAttachments((prev_2) => [...prev_2, newAttachment_0]);
+			}
+		};
+		$[44] = attachmentAdapter;
+		$[45] = setAttachments;
+		$[46] = upsertAttachment;
+		$[47] = t15;
+	} else t15 = $[47];
+	let t16;
+	if ($[48] !== attachmentsRef || $[49] !== removePendingAttachments || $[50] !== setAttachments) {
+		t16 = async () => {
+			attachmentAddOperations.cancelAll();
+			const removed_0 = attachmentsRef.current;
+			setAttachments([]);
+			await removePendingAttachments(removed_0);
+		};
+		$[48] = attachmentsRef;
+		$[49] = removePendingAttachments;
+		$[50] = setAttachments;
+		$[51] = t16;
+	} else t16 = $[51];
+	let t17;
+	if ($[52] !== attachmentClients) {
+		t17 = (selector) => {
+			if ("id" in selector) return attachmentClients.get({ key: selector.id });
+			return attachmentClients.get(selector);
+		};
+		$[52] = attachmentClients;
+		$[53] = t17;
+	} else t17 = $[53];
+	let t18;
+	if ($[54] !== attachmentsRef || $[55] !== removePendingAttachments || $[56] !== setAttachments || $[57] !== setQuote || $[58] !== setRole || $[59] !== setRunConfig || $[60] !== setText) {
+		t18 = async () => {
+			attachmentAddOperations.cancelAll();
+			const removed_1 = attachmentsRef.current;
+			setText("");
+			setRole("user");
+			setRunConfig({});
+			setAttachments([]);
+			setQuote(void 0);
+			await removePendingAttachments(removed_1);
+		};
+		$[54] = attachmentsRef;
+		$[55] = removePendingAttachments;
+		$[56] = setAttachments;
+		$[57] = setQuote;
+		$[58] = setRole;
+		$[59] = setRunConfig;
+		$[60] = setText;
+		$[61] = t18;
+	} else t18 = $[61];
+	let t19;
+	if ($[62] !== attachmentAdapter || $[63] !== attachmentsRef || $[64] !== isEditingRef || $[65] !== isRunning || $[66] !== isSendDisabled || $[67] !== onSend || $[68] !== queue || $[69] !== quoteRef || $[70] !== roleRef || $[71] !== runConfigRef || $[72] !== setAttachments || $[73] !== setIsEditing || $[74] !== setQuote || $[75] !== setText || $[76] !== textRef || $[77] !== type) {
+		t19 = (opts) => {
+			const currentQuote = quoteRef.current;
+			const currentText = textRef.current;
+			const currentRole = roleRef.current;
+			const currentRunConfig = runConfigRef.current;
+			const currentAttachments = attachmentsRef.current;
+			const isEmpty_0 = !currentText.trim() && !currentAttachments.length;
+			if (!isEditingRef.current) throw new Error("Composer is not available");
+			if (isEmpty_0 || isSendDisabled) return;
+			attachmentAddOperations.cancelAll();
+			setText("");
+			setAttachments([]);
+			setQuote(void 0);
+			const dispatch = (sendAttachments) => {
+				const composedMessage = {
+					role: currentRole,
+					content: currentText ? [{
+						type: "text",
+						text: currentText
+					}] : [],
+					attachments: sendAttachments,
+					createdAt: /* @__PURE__ */ new Date(),
+					parentId: null,
+					sourceId: null,
+					runConfig: currentRunConfig,
+					startRun: opts?.startRun,
+					metadata: { custom: { ...currentQuote ? { quote: currentQuote } : {} } }
+				};
+				if (queue && type === "thread") {
+					if (opts?.steer ?? isRunning) queue.steer(composedMessage);
+					else queue.enqueue(composedMessage);
+				} else onSend?.(composedMessage);
+				if (type === "edit") setIsEditing(false);
+			};
+			if (attachmentAdapter && currentAttachments.length > 0) Promise.all(currentAttachments.map((attachment_2) => attachment_2.status.type === "complete" ? attachment_2 : attachmentAdapter.send(attachment_2))).then(dispatch, (error_0) => {
+				setText((prev_3) => currentText && prev_3 ? currentText + "\n" + prev_3 : currentText || prev_3);
+				setQuote((prev_4) => prev_4 ?? currentQuote);
+				setAttachments((prev_5) => [...currentAttachments, ...prev_5]);
+				console.error("Failed to send attachments", error_0);
+			});
+			else dispatch(currentAttachments);
+		};
+		$[62] = attachmentAdapter;
+		$[63] = attachmentsRef;
+		$[64] = isEditingRef;
+		$[65] = isRunning;
+		$[66] = isSendDisabled;
+		$[67] = onSend;
+		$[68] = queue;
+		$[69] = quoteRef;
+		$[70] = roleRef;
+		$[71] = runConfigRef;
+		$[72] = setAttachments;
+		$[73] = setIsEditing;
+		$[74] = setQuote;
+		$[75] = setText;
+		$[76] = textRef;
+		$[77] = type;
+		$[78] = t19;
+	} else t19 = $[78];
+	let t20;
+	if ($[79] !== onCancel || $[80] !== setIsEditing || $[81] !== type) {
+		t20 = () => {
+			onCancel?.();
+			if (type === "edit") setIsEditing(false);
+		};
+		$[79] = onCancel;
+		$[80] = setIsEditing;
+		$[81] = type;
+		$[82] = t20;
+	} else t20 = $[82];
+	let t21;
+	if ($[83] !== isEditingRef || $[84] !== onBeginEdit || $[85] !== setIsEditing || $[86] !== type || $[87] !== updateFromMessage) {
+		t21 = () => {
+			onBeginEdit?.();
+			if (type === "thread") return;
+			if (isEditingRef.current) throw new Error("Edit already in progress");
+			setIsEditing(true);
+			updateFromMessage();
+		};
+		$[83] = isEditingRef;
+		$[84] = onBeginEdit;
+		$[85] = setIsEditing;
+		$[86] = type;
+		$[87] = updateFromMessage;
+		$[88] = t21;
+	} else t21 = $[88];
+	let t22;
+	if ($[89] !== queueItemClients) {
+		t22 = (selector_0) => {
+			if ("id" in selector_0) return queueItemClients.get({ key: selector_0.id });
+			return queueItemClients.get(selector_0);
+		};
+		$[89] = queueItemClients;
+		$[90] = t22;
+	} else t22 = $[90];
+	let t23;
+	if ($[91] !== setQuote || $[92] !== setRole || $[93] !== setRunConfig || $[94] !== setText || $[95] !== t14 || $[96] !== t15 || $[97] !== t16 || $[98] !== t17 || $[99] !== t18 || $[100] !== t19 || $[101] !== t20 || $[102] !== t21 || $[103] !== t22) {
+		t23 = {
+			getState: t14,
+			setText,
+			setRole,
+			setRunConfig,
+			addAttachment: t15,
+			clearAttachments: t16,
+			attachment: t17,
+			reset: t18,
+			send: t19,
+			cancel: t20,
+			beginEdit: t21,
+			startDictation: _temp7,
+			stopDictation: _temp8,
+			setQuote,
+			queueItem: t22
+		};
+		$[91] = setQuote;
+		$[92] = setRole;
+		$[93] = setRunConfig;
+		$[94] = setText;
+		$[95] = t14;
+		$[96] = t15;
+		$[97] = t16;
+		$[98] = t17;
+		$[99] = t18;
+		$[100] = t19;
+		$[101] = t20;
+		$[102] = t21;
+		$[103] = t22;
+		$[104] = t23;
+	} else t23 = $[104];
+	return t23;
+};
+const ComposerClientResource = resource(useComposerClientResource);
+const createSpeechController = (notify) => {
+	let session;
+	const clear = () => {
+		if (!session) return;
+		session.cancel();
+		session = void 0;
+		notify(void 0);
+	};
+	return {
+		speak: (adapter, message) => {
+			clear();
+			const utterance = adapter.speak(getThreadMessageText(message));
+			let unsub;
+			unsub = utterance.subscribe(() => {
+				if (utterance.status.type === "ended") {
+					unsub?.();
+					session = void 0;
+					notify(void 0);
+				} else notify({
+					messageId: message.id,
+					status: utterance.status
+				});
+			});
+			if (utterance.status.type === "ended") {
+				unsub();
+				notify(void 0);
+				return;
+			}
+			session = {
+				messageId: message.id,
+				cancel: () => {
+					unsub();
+					utterance.cancel();
+				}
+			};
+			notify({
+				messageId: message.id,
+				status: utterance.status
+			});
+		},
+		stop: () => {
+			if (!session) throw new Error("No message is being spoken");
+			clear();
+		},
+		stopMessage: (messageId) => {
+			if (session?.messageId !== messageId) throw new Error("Message is not being spoken");
+			clear();
+		},
+		dispose: clear
+	};
+};
+const dedupeMessagesById = (messages) => {
+	const seenIds = /* @__PURE__ */ new Set();
+	const deduped = [];
+	for (let i = messages.length - 1; i >= 0; i--) {
+		const message = messages[i];
+		if (seenIds.has(message.id)) {
+			console.warn(`ExternalThread: duplicate message id "${message.id}" in the provided messages array; keeping the last occurrence.`);
+			continue;
+		}
+		seenIds.add(message.id);
+		deduped.push(message);
+	}
+	return deduped.length === messages.length ? messages : deduped.reverse();
+};
+const useExternalThread = (t0) => {
+	const $ = c(115);
+	const { messages: messagesProp, isRunning: t1, isLoading: t2, state: threadState, extras, isSendDisabled: t3, onNew, onEdit, onReload, onStartRun, onCancel, onResume, onRefetchThread, onAddToolResult, onResumeToolCall, onLoadExternalState, attachmentAdapter, feedbackAdapter, speechAdapter, queue, branches, onRespondToToolApproval } = t0;
+	const isRunning = t1 === void 0 ? false : t1;
+	const isLoading = t2 === void 0 ? false : t2;
+	const isSendDisabled = t3 === void 0 ? false : t3;
+	let t4;
+	if ($[0] !== messagesProp) {
+		t4 = dedupeMessagesById(messagesProp);
+		$[0] = messagesProp;
+		$[1] = t4;
+	} else t4 = $[1];
+	const messages = t4;
+	let t5;
+	if ($[2] === Symbol.for("react.memo_cache_sentinel")) {
+		t5 = {};
+		$[2] = t5;
+	} else t5 = $[2];
+	const [submittedFeedback, setSubmittedFeedback] = useState(t5);
+	let t6;
+	if ($[3] !== submittedFeedback) {
+		t6 = (msg) => {
+			const entry = submittedFeedback[msg.id];
+			return entry && msg.metadata.submittedFeedback?.type === entry.external ? entry.type : void 0;
+		};
+		$[3] = submittedFeedback;
+		$[4] = t6;
+	} else t6 = $[4];
+	const feedbackFor = t6;
+	let t7;
+	let t8;
+	if ($[5] !== messages) {
+		t7 = () => {
+			setSubmittedFeedback((prev) => {
+				const live = Object.entries(prev).filter((t9) => {
+					const [id, entry_0] = t9;
+					const msg_0 = messages.find((m) => m.id === id);
+					return !!msg_0 && msg_0.metadata.submittedFeedback?.type === entry_0.external;
+				});
+				return live.length === Object.keys(prev).length ? prev : Object.fromEntries(live);
+			});
+		};
+		t8 = [messages];
+		$[5] = messages;
+		$[6] = t7;
+		$[7] = t8;
+	} else {
+		t7 = $[6];
+		t8 = $[7];
+	}
+	useEffect(t7, t8);
+	let t9;
+	if ($[8] !== feedbackAdapter) {
+		t9 = (message, t10) => {
+			const { type } = t10;
+			if (!feedbackAdapter) throw new Error("Feedback adapter not configured");
+			feedbackAdapter.submit({
+				message,
+				type
+			});
+			if (message.role === "assistant") setSubmittedFeedback((prev_0) => ({
+				...prev_0,
+				[message.id]: {
+					type,
+					external: message.metadata.submittedFeedback?.type
+				}
+			}));
+		};
+		$[8] = feedbackAdapter;
+		$[9] = t9;
+	} else t9 = $[9];
+	const handleSubmitFeedback = t9;
+	const [speechState, setSpeech] = useState(void 0);
+	let t10;
+	if ($[10] === Symbol.for("react.memo_cache_sentinel")) {
+		t10 = () => createSpeechController(setSpeech);
+		$[10] = t10;
+	} else t10 = $[10];
+	const [speechController] = useState(t10);
+	const hasSpeechAdapter = !!speechAdapter;
+	const speech = hasSpeechAdapter ? speechState : void 0;
+	let t11;
+	let t12;
+	if ($[11] !== hasSpeechAdapter || $[12] !== speechController) {
+		t11 = () => {
+			if (!hasSpeechAdapter) speechController.dispose();
+		};
+		t12 = [hasSpeechAdapter, speechController];
+		$[11] = hasSpeechAdapter;
+		$[12] = speechController;
+		$[13] = t11;
+		$[14] = t12;
+	} else {
+		t11 = $[13];
+		t12 = $[14];
+	}
+	useEffect(t11, t12);
+	let t13;
+	let t14;
+	if ($[15] !== speechController) {
+		t13 = () => () => speechController.dispose();
+		t14 = [speechController];
+		$[15] = speechController;
+		$[16] = t13;
+		$[17] = t14;
+	} else {
+		t13 = $[16];
+		t14 = $[17];
+	}
+	useEffect(t13, t14);
+	let t15;
+	if ($[18] !== speechAdapter || $[19] !== speechController) {
+		t15 = (message_0) => {
+			if (!speechAdapter) throw new Error("Speech adapter not configured");
+			speechController.speak(speechAdapter, message_0);
+		};
+		$[18] = speechAdapter;
+		$[19] = speechController;
+		$[20] = t15;
+	} else t15 = $[20];
+	const handleSpeak = t15;
+	let t16;
+	if ($[21] !== messages || $[22] !== onReload) {
+		t16 = (messageId) => {
+			const messageIndex = messages.findIndex((m_0) => m_0.id === messageId);
+			if (messageIndex === -1) return;
+			const parentId = messageIndex > 0 ? messages[messageIndex - 1].id : null;
+			onReload?.(parentId);
+		};
+		$[21] = messages;
+		$[22] = onReload;
+		$[23] = t16;
+	} else t16 = $[23];
+	const handleReload = t16;
+	let t17;
+	if ($[24] !== attachmentAdapter || $[25] !== branches || $[26] !== feedbackFor || $[27] !== handleReload || $[28] !== handleSpeak || $[29] !== handleSubmitFeedback || $[30] !== messages || $[31] !== onAddToolResult || $[32] !== onEdit || $[33] !== onRespondToToolApproval || $[34] !== onResumeToolCall || $[35] !== queue || $[36] !== speech || $[37] !== speechController) {
+		t17 = messages.map((msg_1, index) => {
+			const props = {
+				message: msg_1,
+				index,
+				parentId: index > 0 ? messages[index - 1].id : null,
+				onReload: () => handleReload(msg_1.id),
+				queue,
+				branches,
+				onRespondToToolApproval,
+				onAddToolResult,
+				onResumeToolCall,
+				attachmentAdapter,
+				submittedFeedback: feedbackFor(msg_1),
+				onSubmitFeedback: (feedback) => handleSubmitFeedback(msg_1, feedback),
+				speech: speech?.messageId === msg_1.id ? speech : void 0,
+				onSpeak: () => handleSpeak(msg_1),
+				onStopSpeaking: () => speechController.stopMessage(msg_1.id)
+			};
+			if (onEdit) props.onEdit = onEdit;
+			return withKey(msg_1.id, MessageClient(props));
+		});
+		$[24] = attachmentAdapter;
+		$[25] = branches;
+		$[26] = feedbackFor;
+		$[27] = handleReload;
+		$[28] = handleSpeak;
+		$[29] = handleSubmitFeedback;
+		$[30] = messages;
+		$[31] = onAddToolResult;
+		$[32] = onEdit;
+		$[33] = onRespondToToolApproval;
+		$[34] = onResumeToolCall;
+		$[35] = queue;
+		$[36] = speech;
+		$[37] = speechController;
+		$[38] = t17;
+	} else t17 = $[38];
+	const messageClients = useClientLookup(t17);
+	let t18;
+	if ($[39] !== onCancel || $[40] !== queue) {
+		t18 = () => {
+			if (!onCancel) return;
+			queue?.__internal_notifyCancelled?.();
+			onCancel();
+		};
+		$[39] = onCancel;
+		$[40] = queue;
+		$[41] = t18;
+	} else t18 = $[41];
+	const handleCancelRun = t18;
+	let t19;
+	if ($[42] !== messages || $[43] !== onNew) {
+		t19 = (message_1) => {
+			onNew?.({
+				...message_1,
+				parentId: messages.at(-1)?.id ?? null
+			});
+		};
+		$[42] = messages;
+		$[43] = onNew;
+		$[44] = t19;
+	} else t19 = $[44];
+	const handleSendNew = t19;
+	let t20;
+	if ($[45] !== messages) {
+		t20 = messages.at(-1)?.id ?? null;
+		$[45] = messages;
+		$[46] = t20;
+	} else t20 = $[46];
+	const headId = t20;
+	const hasCancel = !!onCancel;
+	const hasRefetchThread = !!onRefetchThread;
+	let t21;
+	if ($[47] !== headId || $[48] !== queue) {
+		t21 = queue && {
+			...queue,
+			enqueue: (message_2) => queue.enqueue({
+				...message_2,
+				parentId: message_2.parentId ?? headId
+			}),
+			steer: (message_3) => queue.steer({
+				...message_3,
+				parentId: message_3.parentId ?? headId
+			})
+		};
+		$[47] = headId;
+		$[48] = queue;
+		$[49] = t21;
+	} else t21 = $[49];
+	const composerQueue = t21;
+	const t22 = isRunning && hasCancel;
+	let t23;
+	if ($[50] !== attachmentAdapter || $[51] !== composerQueue || $[52] !== handleCancelRun || $[53] !== handleSendNew || $[54] !== isRunning || $[55] !== isSendDisabled || $[56] !== t22) {
+		t23 = ComposerClientResource({
+			type: "thread",
+			canCancel: t22,
+			isRunning,
+			isSendDisabled,
+			onCancel: handleCancelRun,
+			onSend: handleSendNew,
+			queue: composerQueue,
+			attachmentAdapter
+		});
+		$[50] = attachmentAdapter;
+		$[51] = composerQueue;
+		$[52] = handleCancelRun;
+		$[53] = handleSendNew;
+		$[54] = isRunning;
+		$[55] = isSendDisabled;
+		$[56] = t22;
+		$[57] = t23;
+	} else t23 = $[57];
+	const composerClient = useClientResource(t23);
+	let t24;
+	if ($[58] === Symbol.for("react.memo_cache_sentinel")) {
+		t24 = ThreadSuggestions(EMPTY_SUGGESTIONS);
+		$[58] = t24;
+	} else t24 = $[58];
+	const suggestionsClient = useClientResource(t24);
+	const hasQueue = !!queue;
+	const hasBranches = !!branches;
+	const hasEdit = !!onEdit;
+	const hasReload = !!onReload;
+	const hasAttachments = !!attachmentAdapter;
+	const hasFeedback = !!feedbackAdapter;
+	const hasSpeech = !!speechAdapter;
+	let t25;
+	if ($[59] !== messageClients.state) {
+		t25 = messageClients.state.map(_temp9);
+		$[59] = messageClients.state;
+		$[60] = t25;
+	} else t25 = $[60];
+	const messageStates = t25;
+	const t26 = messages.length === 0;
+	let t27;
+	if ($[61] !== hasAttachments || $[62] !== hasBranches || $[63] !== hasCancel || $[64] !== hasEdit || $[65] !== hasFeedback || $[66] !== hasQueue || $[67] !== hasRefetchThread || $[68] !== hasReload || $[69] !== hasSpeech) {
+		t27 = {
+			edit: hasEdit,
+			delete: false,
+			reload: hasReload,
+			refetchThread: hasRefetchThread,
+			cancel: hasCancel,
+			speech: hasSpeech,
+			attachments: hasAttachments,
+			feedback: hasFeedback,
+			voice: false,
+			switchToBranch: hasBranches,
+			switchBranchDuringRun: false,
+			unstable_copy: false,
+			dictation: false,
+			queue: hasQueue
+		};
+		$[61] = hasAttachments;
+		$[62] = hasBranches;
+		$[63] = hasCancel;
+		$[64] = hasEdit;
+		$[65] = hasFeedback;
+		$[66] = hasQueue;
+		$[67] = hasRefetchThread;
+		$[68] = hasReload;
+		$[69] = hasSpeech;
+		$[70] = t27;
+	} else t27 = $[70];
+	let t28;
+	if ($[71] !== threadState) {
+		t28 = threadState ?? {};
+		$[71] = threadState;
+		$[72] = t28;
+	} else t28 = $[72];
+	let t29;
+	if ($[73] !== composerClient.state || $[74] !== extras || $[75] !== isLoading || $[76] !== isRunning || $[77] !== messageStates || $[78] !== speech || $[79] !== t26 || $[80] !== t27 || $[81] !== t28) {
+		t29 = {
+			isEmpty: t26,
+			isDisabled: false,
+			isLoading,
+			isRunning,
+			capabilities: t27,
+			messages: messageStates,
+			state: t28,
+			suggestions: EMPTY_SUGGESTIONS,
+			extras,
+			speech,
+			voice: void 0,
+			composer: composerClient.state
+		};
+		$[73] = composerClient.state;
+		$[74] = extras;
+		$[75] = isLoading;
+		$[76] = isRunning;
+		$[77] = messageStates;
+		$[78] = speech;
+		$[79] = t26;
+		$[80] = t27;
+		$[81] = t28;
+		$[82] = t29;
+	} else t29 = $[82];
+	const state = t29;
+	let t30;
+	if ($[83] !== state) {
+		t30 = () => state;
+		$[83] = state;
+		$[84] = t30;
+	} else t30 = $[84];
+	let t31;
+	if ($[85] !== composerClient.methods) {
+		t31 = () => composerClient.methods;
+		$[85] = composerClient.methods;
+		$[86] = t31;
+	} else t31 = $[86];
+	let t32;
+	if ($[87] !== suggestionsClient) {
+		t32 = () => suggestionsClient.methods;
+		$[87] = suggestionsClient;
+		$[88] = t32;
+	} else t32 = $[88];
+	let t33;
+	if ($[89] !== messages || $[90] !== onNew || $[91] !== queue) {
+		t33 = (message_4) => {
+			const appendMessage = typeof message_4 === "string" ? {
+				createdAt: /* @__PURE__ */ new Date(),
+				parentId: messages.at(-1)?.id ?? null,
+				sourceId: null,
+				runConfig: {},
+				role: "user",
+				content: [{
+					type: "text",
+					text: message_4
+				}],
+				attachments: [],
+				metadata: { custom: {} }
+			} : {
+				createdAt: message_4.createdAt ?? /* @__PURE__ */ new Date(),
+				parentId: message_4.parentId ?? messages.at(-1)?.id ?? null,
+				sourceId: message_4.sourceId ?? null,
+				role: message_4.role ?? "user",
+				content: message_4.content,
+				attachments: message_4.attachments ?? [],
+				metadata: message_4.metadata ?? { custom: {} },
+				runConfig: message_4.runConfig ?? {},
+				startRun: message_4.startRun
+			};
+			if (queue) queue.enqueue(appendMessage);
+			else onNew?.(appendMessage);
+		};
+		$[89] = messages;
+		$[90] = onNew;
+		$[91] = queue;
+		$[92] = t33;
+	} else t33 = $[92];
+	let t34;
+	if ($[93] !== onStartRun) {
+		t34 = () => {
+			onStartRun?.();
+		};
+		$[93] = onStartRun;
+		$[94] = t34;
+	} else t34 = $[94];
+	let t35;
+	if ($[95] !== onResume) {
+		t35 = () => {
+			if (!onResume) throw new Error("Runtime does not support resuming runs (onResume is not set).");
+			onResume();
+		};
+		$[95] = onResume;
+		$[96] = t35;
+	} else t35 = $[96];
+	let t36;
+	if ($[97] !== onRefetchThread) {
+		t36 = onRefetchThread && { unstable_refetchThread: onRefetchThread };
+		$[97] = onRefetchThread;
+		$[98] = t36;
+	} else t36 = $[98];
+	let t37;
+	if ($[99] !== onLoadExternalState) {
+		t37 = (state_0) => {
+			if (!onLoadExternalState) throw new Error("Runtime does not support importing external states (onLoadExternalState is not set).");
+			onLoadExternalState(state_0);
+		};
+		$[99] = onLoadExternalState;
+		$[100] = t37;
+	} else t37 = $[100];
+	let t38;
+	if ($[101] !== messageClients) {
+		t38 = (selector) => {
+			if ("id" in selector) return messageClients.get({ key: selector.id });
+			return messageClients.get(selector);
+		};
+		$[101] = messageClients;
+		$[102] = t38;
+	} else t38 = $[102];
+	let t39;
+	if ($[103] !== handleCancelRun || $[104] !== speechController.stop || $[105] !== t30 || $[106] !== t31 || $[107] !== t32 || $[108] !== t33 || $[109] !== t34 || $[110] !== t35 || $[111] !== t36 || $[112] !== t37 || $[113] !== t38) {
+		t39 = {
+			getState: t30,
+			composer: t31,
+			suggestions: t32,
+			append: t33,
+			deleteMessage: _temp0,
+			startRun: t34,
+			resumeRun: t35,
+			cancelRun: handleCancelRun,
+			...t36,
+			importExternalState: t37,
+			getModelContext: _temp1,
+			export: _temp10,
+			import: _temp11,
+			reset: _temp12,
+			message: t38,
+			stopSpeaking: speechController.stop,
+			connectVoice: _temp13,
+			disconnectVoice: _temp14,
+			getVoiceVolume: _temp15,
+			subscribeVoiceVolume: _temp17,
+			muteVoice: _temp18,
+			unmuteVoice: _temp19
+		};
+		$[103] = handleCancelRun;
+		$[104] = speechController.stop;
+		$[105] = t30;
+		$[106] = t31;
+		$[107] = t32;
+		$[108] = t33;
+		$[109] = t34;
+		$[110] = t35;
+		$[111] = t36;
+		$[112] = t37;
+		$[113] = t38;
+		$[114] = t39;
+	} else t39 = $[114];
+	return t39;
+};
+const ExternalThread = resource(useExternalThread);
+attachTransformScopes(useExternalThread, (scopes, parent) => {
+	if (!scopes.threads && parent.threads.source === null) {
+		const threadElement = scopes.thread;
+		scopes.threads = SingleThreadList({ thread: threadElement });
+		delete scopes.thread;
+		scopes.thread = Derived({
+			source: "threads",
+			query: { type: "main" },
+			get: (aui) => aui.threads.thread("main")
+		});
+	}
+	if (!scopes.threadListItem && parent.threadListItem.source === null) scopes.threadListItem = Derived({
+		source: "threads",
+		query: { type: "main" },
+		get: (aui) => aui.threads.item("main")
+	});
+	scopes.composer ??= Derived({
+		source: "thread",
+		query: {},
+		get: (aui) => aui.thread.composer()
+	});
+	if (!scopes.modelContext && parent.modelContext.source === null) scopes.modelContext = ModelContext();
+	if (!scopes.tools && parent.tools.source === null) scopes.tools = Tools({});
+	if (!scopes.dataRenderers && parent.dataRenderers.source === null) scopes.dataRenderers = DataRenderers();
+	if (!scopes.suggestions && parent.suggestions.source === null) scopes.suggestions = Derived({
+		source: "thread",
+		query: {},
+		get: (aui) => aui.thread.suggestions()
+	});
+});
+function _temp() {}
+function _temp2(attachment) {
+	return withKey(attachment.id, AttachmentResource({
+		attachment,
+		onRemove: _temp
+	}));
+}
+function _temp3() {}
+function _temp4(part) {
+	return part.type === "text";
+}
+function _temp5(part_0) {
+	return part_0.text;
+}
+function _temp6(a_0) {
+	return a_0.status.type !== "complete";
+}
+function _temp7() {}
+function _temp8() {}
+function _temp9(s, idx, arr) {
+	return {
+		...s,
+		isLast: idx === arr.length - 1
+	};
+}
+function _temp0() {}
+function _temp1() {
+	return {
+		tools: {},
+		config: {}
+	};
+}
+function _temp10() {
+	return { messages: [] };
+}
+function _temp11() {}
+function _temp12() {}
+function _temp13() {}
+function _temp14() {}
+function _temp15() {
+	return 0;
+}
+function _temp16() {}
+function _temp17() {
+	return _temp16;
+}
+function _temp18() {}
+function _temp19() {}
+//#endregion
+export { ExternalThread };
+
+//# sourceMappingURL=external-thread.js.map