@assistant-ui/core 0.3.19 → 0.3.21

package/dist/runtimes/local/local-thread-runtime-core.js

@@ -1,13 +1,14 @@
 import { generateId } from "../../utils/id.js";
 import { consumeSuggestionResult } from "../../adapters/suggestion.js";
 import { MessageNotSentError, toAssistantError } from "../../types/error.js";
+import { appendToolInteraction } from "../../runtime/utils/tool-interactions.js";
 import { fromThreadMessageLike } from "../../runtime/utils/thread-message-like.js";
 import { getAutoStatus } from "../../runtime/utils/auto-status.js";
 import { EMPTY_QUEUE_ITEMS } from "../../runtime/queue/queue-item.js";
 import { createMessageQueue } from "../../runtime/queue/message-queue.js";
+import { captureThreadRuntimeGeneration, invalidateThreadRuntime } from "../../runtime/utils/thread-runtime-lifecycle.js";
 import { BaseThreadRuntimeCore } from "../../runtime/base/base-thread-runtime-core.js";
 import { shouldContinue } from "./should-continue.js";
-import { captureThreadRuntimeGeneration, invalidateThreadRuntime, isThreadRuntimeGenerationCurrent } from "../../runtime/utils/thread-runtime-lifecycle.js";
 //#region src/runtimes/local/local-thread-runtime-core.ts
 var AbortError = class extends Error {
 	name = "AbortError";
@@ -31,6 +32,26 @@ const withLocalPauseReasons = (data) => ({
 		message: withLocalPauseReason(item.message)
 	}))
 });
+const withoutToolInteractions = (message) => {
+	if (message.role !== "assistant") return message;
+	let hasInteractions = false;
+	const content = message.content.map((part) => {
+		if (part.type !== "tool-call") return part;
+		const nestedMessages = part.messages?.map(withoutToolInteractions);
+		const hasNestedInteractions = nestedMessages?.some((nestedMessage, index) => nestedMessage !== part.messages?.[index]);
+		if (part.unstable_interactions === void 0 && hasNestedInteractions !== true) return part;
+		hasInteractions = true;
+		const { unstable_interactions: _, ...withoutInteractions } = part;
+		return hasNestedInteractions ? {
+			...withoutInteractions,
+			messages: nestedMessages
+		} : withoutInteractions;
+	});
+	return hasInteractions ? {
+		...message,
+		content
+	} : message;
+};
 var LocalThreadRuntimeCore = class extends BaseThreadRuntimeCore {
 	capabilities = {
 		switchToBranch: true,
@@ -50,9 +71,10 @@ var LocalThreadRuntimeCore = class extends BaseThreadRuntimeCore {
 	};
 	abortController = null;
 	_queue = null;
-	_queueRunInFlight = false;
+	_queueRunInFlight = null;
 	_activeRun = null;
 	_runGeneration = 0;
+	_messageReplacements = /* @__PURE__ */ new WeakMap();
 	_historyWrites = /* @__PURE__ */ new Map();
 	_chainHistoryWrite(id, write) {
 		const next = (this._historyWrites.get(id) ?? Promise.resolve()).then(write, write);
@@ -63,10 +85,17 @@ var LocalThreadRuntimeCore = class extends BaseThreadRuntimeCore {
 		});
 		return next;
 	}
-	_persistPausedMessage(parentId, message) {
-		if (message.status?.type !== "requires-action") return;
+	_persistMessageUpdate(messageId) {
 		const history = this._options.adapters.history;
 		if (!history?.update) return;
+		let entry;
+		try {
+			entry = this.repository.getMessage(messageId);
+		} catch {
+			return;
+		}
+		const { parentId, message } = entry;
+		if (message.role !== "assistant" || message.status.type === "running") return;
 		const update = history.update.bind(history);
 		const item = {
 			parentId,
@@ -142,16 +171,20 @@ var LocalThreadRuntimeCore = class extends BaseThreadRuntimeCore {
 		const canQueue = options.unstable_enableMessageQueue === true;
 		if (canQueue && !this._queue) {
 			this._queue = createMessageQueue({ run: (message) => {
-				this._queueRunInFlight = true;
+				const dispatch = {};
+				this._queueRunInFlight = dispatch;
 				const generation = this._runGeneration;
 				this._runAppend({
 					...message,
-					parentId: this.messages.at(-1)?.id ?? null
+					parentId: this._resolveAppendParent(this.messages.at(-1)?.id ?? null)
 				}).finally(() => {
-					this._queueRunInFlight = false;
-					if (this._runGeneration === generation) this._queue?.notifyIdle();
+					if (this._queueRunInFlight === dispatch) {
+						this._queueRunInFlight = null;
+						if (this._runGeneration === generation) this._queue?.notifyIdle();
+					}
 				}).catch(() => {});
 			} });
+			if (this.voice) this._queue.hold();
 			this._queue.subscribe(() => this._notifySubscribers());
 		} else if (!canQueue && this._queue) this._queue = null;
 		if (this.capabilities.queue !== canQueue) {
@@ -171,7 +204,6 @@ var LocalThreadRuntimeCore = class extends BaseThreadRuntimeCore {
 		if (!this.adapters.history) return Promise.resolve();
 		const promise = this.adapters.history.load();
 		this._isLoading = true;
-		this._notifySubscribers();
 		this._loadPromise = promise.then((repo) => {
 			if (!repo) return;
 			this.repository.import(withLocalPauseReasons(repo));
@@ -187,20 +219,58 @@ var LocalThreadRuntimeCore = class extends BaseThreadRuntimeCore {
 			this._isLoading = false;
 			this._notifySubscribers();
 		});
+		this._notifySubscribers();
 		return this._loadPromise;
 	}
+	_getHistoryLoadBarrier() {
+		if (!this._isLoading || !this._loadPromise) return void 0;
+		return this._loadPromise.catch(() => {});
+	}
 	async append(message) {
+		message = {
+			...message,
+			parentId: this._resolveAppendParent(message.parentId)
+		};
+		if (this.voice) return this._appendToVoiceSession(message);
 		if (this._isVoiceMessage(message.sourceId)) throw new Error("Voice transcript messages cannot be edited");
 		const isTail = message.parentId === (this.messages.at(-1)?.id ?? null);
 		const willRun = message.startRun ?? message.role === "user";
 		if (this._queue && willRun && isTail) {
-			if (message.steer ?? this._queueRunInFlight) this._queue.adapter.steer(message);
+			if (message.steer ?? this._queueRunInFlight !== null) this._queue.adapter.steer(message);
 			else this._queue.adapter.enqueue(message);
 			return;
 		}
 		if (this._queue && !isTail && (this._options.unstable_queueClearOnRewind ?? true)) this._queue.clear();
 		return this._runAppend(message);
 	}
+	_commitVoiceMessage(message) {
+		const generation = captureThreadRuntimeGeneration(this);
+		const commit = (notify) => {
+			if (generation.aborted) {
+				this._dropVoiceMessage(message.id, notify);
+				return;
+			}
+			const parentId = this.repository.headId;
+			this.repository.addOrUpdateMessage(parentId, message);
+			this.repository.resetHead(message.id);
+			const historyWrite = this._options.adapters.history?.append({
+				parentId,
+				message
+			});
+			historyWrite?.catch(() => {});
+			this._dropVoiceMessage(message.id, false);
+			if (notify) this._notifySubscribers();
+			return historyWrite;
+		};
+		const barrier = this._getVoiceCommitBarrier();
+		return barrier ? barrier.then(() => commit(true)) : commit(false);
+	}
+	_onVoiceConnected() {
+		this._queue?.hold();
+	}
+	_onVoiceDisconnected() {
+		this._queue?.release();
+	}
 	getQueueItems() {
 		return this._queue?.adapter.items ?? EMPTY_QUEUE_ITEMS;
 	}
@@ -221,8 +291,30 @@ var LocalThreadRuntimeCore = class extends BaseThreadRuntimeCore {
 		}
 		this._notifySubscribers();
 	}
+	_pendingAppends = 0;
+	_isRunActive() {
+		return this._pendingAppends > 0 || super._isRunActive();
+	}
 	async _runAppend(rawMessage) {
+		this._pendingAppends += 1;
+		try {
+			await this._runAppendInner(rawMessage);
+		} finally {
+			this._pendingAppends -= 1;
+		}
+	}
+	async _runAppendInner(rawMessage) {
 		const generation = captureThreadRuntimeGeneration(this);
+		const loadBarrier = this._getHistoryLoadBarrier();
+		if (loadBarrier) {
+			const wasAtTail = rawMessage.parentId === (this.messages.at(-1)?.id ?? null);
+			await loadBarrier;
+			if (generation.aborted) return;
+			if (wasAtTail) rawMessage = {
+				...rawMessage,
+				parentId: this._resolveAppendParent(this.messages.at(-1)?.id ?? null)
+			};
+		}
 		const message = this.enrichAppendMetadata(rawMessage);
 		this.ensureInitialized();
 		const newMessage = fromThreadMessageLike(message, generateId(), {
@@ -236,12 +328,12 @@ var LocalThreadRuntimeCore = class extends BaseThreadRuntimeCore {
 			if (initPromise) await initPromise;
 		} catch (error) {
 			this._rollbackAppend(newMessage.id);
-			if (!isThreadRuntimeGenerationCurrent(this, generation)) return;
+			if (generation.aborted) return;
 			const notSent = new MessageNotSentError();
 			notSent.cause = error;
 			throw notSent;
 		}
-		if (!isThreadRuntimeGenerationCurrent(this, generation)) {
+		if (generation.aborted) {
 			this._rollbackAppend(newMessage.id);
 			return;
 		}
@@ -298,6 +390,7 @@ var LocalThreadRuntimeCore = class extends BaseThreadRuntimeCore {
 	}
 	async startRun({ parentId, sourceId, runConfig }, runCallback) {
 		this.ensureInitialized();
+		if (this.voice) throw new Error("Cannot start a run while a voice session is connected");
 		if (this._isVoiceMessage(sourceId)) throw new Error("Voice transcript messages cannot be reloaded");
 		const message = {
 			id: generateId(),
@@ -316,6 +409,7 @@ var LocalThreadRuntimeCore = class extends BaseThreadRuntimeCore {
 		return this._runLoop(parentId, message, runConfig, runCallback);
 	}
 	async _runLoop(parentId, message, runConfig, runCallback) {
+		if (this.voice) throw new Error("Cannot start a run while a voice session is connected");
 		this._notifyEventSubscribers("runStart", {});
 		const alreadyPersisted = message.status?.type === "requires-action" && this._options.adapters.history?.update !== void 0;
 		const run = { cancelled: false };
@@ -332,6 +426,12 @@ var LocalThreadRuntimeCore = class extends BaseThreadRuntimeCore {
 				message = await this.performRoundtrip(parentId, message, runConfig, alreadyPersisted, run, runCallback);
 				runCallback = void 0;
 				if (this._activeRun !== run) break;
+				let replacement = this._messageReplacements.get(message);
+				while (replacement) {
+					message = replacement.message;
+					replacement = this._messageReplacements.get(message);
+				}
+				if (this.getMessageById(message.id)?.message !== message) break;
 			} while (shouldContinue(message, this._options.unstable_humanToolNames));
 		} finally {
 			this._notifyEventSubscribers("runEnd", {});
@@ -361,7 +461,7 @@ var LocalThreadRuntimeCore = class extends BaseThreadRuntimeCore {
 		}
 	}
 	async performRoundtrip(parentId, message, runConfig, alreadyPersisted, run, runCallback) {
-		const messages = parentId ? this.repository.getMessages(parentId) : [];
+		const modelMessages = (parentId ? this.repository.getMessages(parentId) : []).map(withoutToolInteractions);
 		this.abortController?.abort();
 		const abortController = new AbortController();
 		this.abortController = abortController;
@@ -370,31 +470,79 @@ var LocalThreadRuntimeCore = class extends BaseThreadRuntimeCore {
 		const initialData = message.metadata?.unstable_data;
 		const initialSteps = message.metadata?.steps;
 		const initialCustom = message.metadata?.custom;
+		const externalToolCallIds = /* @__PURE__ */ new Set();
 		let hasStoredMessage = true;
 		try {
 			this.repository.getMessage(message.id);
 		} catch {
 			hasStoredMessage = false;
 		}
-		const ownsMessage = () => {
+		const syncOwnedMessage = () => {
 			if (!hasStoredMessage) return this._activeRun === run;
 			try {
-				return this.repository.getMessage(message.id).message === message;
+				let ownedMessage = message;
+				let replacement = this._messageReplacements.get(ownedMessage);
+				while (replacement) {
+					if (replacement.toolCallId !== void 0) externalToolCallIds.add(replacement.toolCallId);
+					ownedMessage = replacement.message;
+					replacement = this._messageReplacements.get(ownedMessage);
+				}
+				if (this.repository.getMessage(message.id).message !== ownedMessage) return false;
+				message = ownedMessage;
+				return true;
 			} catch {
 				return false;
 			}
 		};
+		const withExternalResults = (parts) => {
+			const interactions = /* @__PURE__ */ new Map();
+			for (const part of message.content) if (part.type === "tool-call" && part.unstable_interactions !== void 0) interactions.set(part.toolCallId, part.unstable_interactions);
+			const withInteractions = parts.map((part) => {
+				if (part.type !== "tool-call" || part.unstable_interactions !== void 0) return part;
+				const unstable_interactions = interactions.get(part.toolCallId);
+				return unstable_interactions === void 0 ? part : {
+					...part,
+					unstable_interactions
+				};
+			});
+			if (externalToolCallIds.size === 0) return withInteractions;
+			const previousToolCalls = /* @__PURE__ */ new Map();
+			for (const part of message.content) {
+				if (part.type !== "tool-call" || !externalToolCallIds.has(part.toolCallId)) continue;
+				const occurrences = previousToolCalls.get(part.toolCallId) ?? [];
+				occurrences.push(part);
+				previousToolCalls.set(part.toolCallId, occurrences);
+			}
+			const incomingOccurrences = /* @__PURE__ */ new Map();
+			return withInteractions.map((part) => {
+				if (part.type !== "tool-call") return part;
+				const occurrence = incomingOccurrences.get(part.toolCallId) ?? 0;
+				incomingOccurrences.set(part.toolCallId, occurrence + 1);
+				if (part.result !== void 0 && part.isPreliminary !== true) return part;
+				const completed = previousToolCalls.get(part.toolCallId)?.[occurrence];
+				if (!completed || completed.result === void 0 || completed.isPreliminary === true) return part;
+				const { isPreliminary: _, artifact: _artifact, modelContent: _modelContent, ...settledPart } = part;
+				return {
+					...settledPart,
+					result: completed.result,
+					isError: completed.isError,
+					...completed.artifact !== void 0 && { artifact: completed.artifact },
+					...completed.modelContent !== void 0 && { modelContent: completed.modelContent }
+				};
+			});
+		};
 		const updateMessage = (m) => {
-			if (!ownsMessage()) return;
+			if (!syncOwnedMessage()) return;
 			const newSteps = m.metadata?.steps;
 			const steps = newSteps ? [...initialSteps ?? [], ...newSteps] : void 0;
 			const newAnnotations = m.metadata?.unstable_annotations;
 			const newData = m.metadata?.unstable_data;
 			const annotations = newAnnotations ? [...initialAnnotations ?? [], ...newAnnotations] : void 0;
 			const data = newData ? [...initialData ?? [], ...newData] : void 0;
+			const content = m.content ? withExternalResults([...initialContent, ...m.content]) : void 0;
 			message = {
 				...message,
-				...m.content ? { content: [...initialContent, ...m.content ?? []] } : void 0,
+				...content ? { content } : void 0,
 				status: m.status ?? message.status,
 				...m.metadata ? { metadata: {
 					...message.metadata,
@@ -432,7 +580,7 @@ var LocalThreadRuntimeCore = class extends BaseThreadRuntimeCore {
 			const shouldCancelMessage = () => abortSignal.aborted && (message.status.type === "running" || message.status.type === "requires-action" && (this._activeRun !== run || shouldContinue(message, this._options.unstable_humanToolNames)));
 			const threadId = this._getThreadId?.();
 			const promiseOrGenerator = runCallback({
-				messages,
+				messages: modelMessages,
 				runConfig: this._lastRunConfig,
 				abortSignal,
 				context,
@@ -440,7 +588,8 @@ var LocalThreadRuntimeCore = class extends BaseThreadRuntimeCore {
 				unstable_threadId: threadId,
 				unstable_parentId: parentId,
 				unstable_getMessage() {
-					return message;
+					syncOwnedMessage();
+					return withoutToolInteractions(message);
 				}
 			});
 			if (Symbol.asyncIterator in promiseOrGenerator) for await (const r of promiseOrGenerator) {
@@ -482,6 +631,7 @@ var LocalThreadRuntimeCore = class extends BaseThreadRuntimeCore {
 		} finally {
 			if (this.abortController === abortController) this.abortController = null;
 			const history = this._options.adapters.history;
+			const ownsCurrentMessage = syncOwnedMessage();
 			const item = {
 				parentId,
 				message,
@@ -489,7 +639,7 @@ var LocalThreadRuntimeCore = class extends BaseThreadRuntimeCore {
 			};
 			const isTerminal = message.status.type === "complete" || message.status.type === "incomplete";
 			const isPausing = message.status.type === "requires-action" && !shouldContinue(message, this._options.unstable_humanToolNames);
-			if (ownsMessage() && (isTerminal || isPausing && history?.update)) {
+			if (ownsCurrentMessage && (isTerminal || isPausing && history?.update)) {
 				const write = alreadyPersisted && history?.update ? history.update.bind(history) : history?.append.bind(history);
 				if (write) await this._chainHistoryWrite(message.id, () => write(item));
 			}
@@ -519,7 +669,12 @@ var LocalThreadRuntimeCore = class extends BaseThreadRuntimeCore {
 		this._suggestionsController?.abort();
 		this._suggestionsController = null;
 	}
-	addToolResult({ messageId, toolCallId, result, isError, artifact }) {
+	_onMessageMetadataChanged(previousMessage, message) {
+		this._messageReplacements.set(previousMessage, { message });
+		this._persistMessageUpdate(message.id);
+	}
+	addToolResult({ messageId, toolCallId, result, isError, artifact, modelContent }) {
+		if (this.voice) throw new Error("Cannot add a tool result while a voice session is connected");
 		const messageData = this.repository.getMessage(messageId);
 		const { parentId } = messageData;
 		let { message } = messageData;
@@ -530,28 +685,63 @@ var LocalThreadRuntimeCore = class extends BaseThreadRuntimeCore {
 			if (c.type !== "tool-call") return c;
 			if (c.toolCallId !== toolCallId) return c;
 			found = true;
-			if (c.result === void 0) added = true;
+			if (c.result === void 0 || c.isPreliminary === true) added = true;
+			const { isPreliminary: _isPreliminary, ...part } = c;
 			return {
-				...c,
+				...part,
 				result,
-				artifact,
-				isError
+				isError,
+				...artifact !== void 0 && { artifact },
+				...modelContent !== void 0 && { modelContent }
 			};
 		});
 		if (!found) throw new Error("Tried to add tool result to non-existing tool call");
+		const previousMessage = message;
 		message = {
 			...message,
 			content: newContent
 		};
+		if (previousMessage.status.type === "running") this._messageReplacements.set(previousMessage, {
+			message,
+			toolCallId
+		});
 		this.repository.addOrUpdateMessage(parentId, message);
 		this._notifySubscribers();
-		if (added && shouldContinue(message, this._options.unstable_humanToolNames)) this._runLoop(parentId, message, this._lastRunConfig).catch(() => {});
-		else if (added) this._persistPausedMessage(parentId, message);
+		if (!added) return;
+		const stored = this.getMessageById(messageId);
+		if (stored?.message.role === "assistant" && shouldContinue(stored.message, this._options.unstable_humanToolNames)) this._runLoop(stored.parentId, stored.message, this._lastRunConfig).catch(() => {});
+		else this._persistMessageUpdate(messageId);
 	}
 	resumeToolCall(_options) {
 		throw new Error("Local runtime does not support resuming tool calls. For human-in-the-loop tools, list the tool in unstable_humanToolNames and complete the call with addToolResult.");
 	}
+	async unstable_recordToolInteraction({ messageId, toolCallId, interaction }) {
+		let messageData;
+		try {
+			messageData = this.repository.getMessage(messageId);
+		} catch {
+			throw new Error("Tried to record a tool interaction on a non-existing message");
+		}
+		const { parentId, message: previousMessage } = messageData;
+		if (previousMessage.role !== "assistant") throw new Error("Tried to record a tool interaction on a non-assistant message");
+		const toolCallIndex = previousMessage.content.findIndex((part) => part.type === "tool-call" && part.toolCallId === toolCallId);
+		if (toolCallIndex === -1) throw new Error("Tried to record a tool interaction on a non-existing tool call");
+		const target = previousMessage.content[toolCallIndex];
+		if (target.type !== "tool-call") throw new Error("Tried to record a tool interaction on a non-existing tool call");
+		const message = {
+			...previousMessage,
+			content: previousMessage.content.map((part, index) => index === toolCallIndex ? {
+				...part,
+				unstable_interactions: appendToolInteraction(target.unstable_interactions, interaction)
+			} : part)
+		};
+		if (previousMessage.status.type === "running") this._messageReplacements.set(previousMessage, { message });
+		this.repository.addOrUpdateMessage(parentId, message);
+		this._notifySubscribers();
+		this._persistMessageUpdate(message.id);
+	}
 	respondToToolApproval({ approvalId, approved, optionId, text, reason }) {
+		if (this.voice) throw new Error("Cannot respond to a tool approval while a voice session is connected");
 		let message = this.repository.getMessages().findLast((m) => m.role === "assistant" && m.content.some((c) => c.type === "tool-call" && c.approval?.id === approvalId));
 		if (!message) throw new Error("Tried to respond to a non-existing tool approval");
 		if (this.abortController !== null) throw new Error("Tried to respond to a tool approval while a run is in progress");
@@ -589,8 +779,9 @@ var LocalThreadRuntimeCore = class extends BaseThreadRuntimeCore {
 		this.repository.addOrUpdateMessage(parentId, message);
 		this._notifySubscribers();
 		this._notifyToolApprovalAnswered(message.id, target.toolCallId, target.toolName, approved);
-		if (this.repository.headId === message.id && shouldContinue(message, this._options.unstable_humanToolNames)) this._runLoop(parentId, message, this._lastRunConfig).catch(() => {});
-		else this._persistPausedMessage(parentId, message);
+		const stored = this.getMessageById(message.id);
+		if (this.repository.headId === message.id && stored?.message.role === "assistant" && shouldContinue(stored.message, this._options.unstable_humanToolNames)) this._runLoop(stored.parentId, stored.message, this._lastRunConfig).catch(() => {});
+		else this._persistMessageUpdate(message.id);
 		return Promise.resolve();
 	}
 };