@assistant-ui/react-ag-ui 0.0.30 → 0.0.32

package/dist/runtime/AgUiThreadRuntimeCore.js

@@ -1,631 +1,546 @@
 "use client";
-import { generateId, generateOptimisticId, isOptimisticId, fromThreadMessageLike, } from "@assistant-ui/core/internal";
-import { AG_UI_METADATA_NAMESPACE, RunAggregator, } from "./adapter/run-aggregator.js";
-import { fromAgUiMessages, toAgUiMessages, toAgUiTools, } from "./adapter/conversions.js";
+import { AG_UI_METADATA_NAMESPACE, RunAggregator } from "./adapter/run-aggregator.js";
+import { fromAgUiMessages, toAgUiMessages, toAgUiTools } from "./adapter/conversions.js";
 import { createAgUiSubscriber } from "./adapter/subscriber.js";
+import { fromThreadMessageLike, generateId, generateOptimisticId, isOptimisticId } from "@assistant-ui/core/internal";
+//#region src/runtime/AgUiThreadRuntimeCore.ts
 const symbolResumeShim = Symbol("agui-resume-shim");
-const FALLBACK_USER_STATUS = { type: "complete", reason: "unknown" };
-export class AgUiThreadRuntimeCore {
-    agent;
-    logger;
-    showThinking;
-    onError;
-    onCancel;
-    notifyUpdate;
-    runtime;
-    messages = [];
-    isRunningFlag = false;
-    abortController = null;
-    stateSnapshot;
-    pendingError = null;
-    history;
-    lastRunConfig;
-    assistantHistoryParents = new Map();
-    recordedHistoryIds = new Set();
-    _isLoading = false;
-    _loadPromise;
-    constructor(options) {
-        this.agent = options.agent;
-        this.logger = options.logger;
-        this.showThinking = options.showThinking;
-        this.onError = options.onError;
-        this.onCancel = options.onCancel;
-        this.history = options.history;
-        this.notifyUpdate = options.notifyUpdate;
-        this.installResumeShim();
-    }
-    updateOptions(options) {
-        this.agent = options.agent;
-        this.logger = options.logger;
-        this.showThinking = options.showThinking;
-        this.onError = options.onError;
-        this.onCancel = options.onCancel;
-        this.history = options.history;
-        this.installResumeShim();
-    }
-    attachRuntime(runtime) {
-        this.runtime = runtime;
-    }
-    detachRuntime() {
-        this.runtime = undefined;
-    }
-    getMessages() {
-        return this.messages;
-    }
-    getState() {
-        return this.stateSnapshot;
-    }
-    isRunning() {
-        return this.isRunningFlag;
-    }
-    get isLoading() {
-        return this._isLoading;
-    }
-    __internal_load() {
-        if (this._loadPromise)
-            return this._loadPromise;
-        const promise = this.history?.load() ?? Promise.resolve(null);
-        this._isLoading = true;
-        this._loadPromise = promise
-            .then(async (repo) => {
-            if (!repo)
-                return;
-            const messages = repo.messages.map((item) => item.message);
-            this.applyExternalMessages(messages);
-            if (repo.unstable_resume) {
-                const parentId = repo.headId ?? messages.at(-1)?.id ?? null;
-                await this.startRun(parentId, this.lastRunConfig);
-            }
-        })
-            .catch((error) => {
-            this.logger.error?.("[agui] failed to load history", error);
-            this.onError?.(error instanceof Error ? error : new Error(String(error)));
-        })
-            .finally(() => {
-            this._isLoading = false;
-            this.notifyUpdate();
-        });
-        this.notifyUpdate();
-        return this._loadPromise;
-    }
-    async append(message) {
-        const startRun = message.startRun ?? message.role === "user";
-        if (startRun)
-            this.assertNoPendingInterrupts();
-        if (message.sourceId) {
-            this.messages = this.messages.filter((entry) => entry.id !== message.sourceId);
-        }
-        this.resetHead(message.parentId);
-        const threadMessage = this.toThreadMessage(message);
-        this.messages = [...this.messages, threadMessage];
-        this.notifyUpdate();
-        this.recordHistoryEntry(message.parentId ?? null, threadMessage);
-        if (!startRun)
-            return;
-        await this.startRun(threadMessage.id, message.runConfig);
-    }
-    async edit(message) {
-        await this.append(message);
-    }
-    async reload(parentId, config = {}) {
-        this.assertNoPendingInterrupts();
-        this.resetHead(parentId);
-        this.notifyUpdate();
-        await this.startRun(parentId, config.runConfig);
-    }
-    async cancel() {
-        if (!this.abortController)
-            return;
-        this.abortController.abort();
-    }
-    async resume(config) {
-        this.assertNoPendingInterrupts();
-        if (config.stream) {
-            this.logger.debug?.("[agui] resume stream is not supported, falling back to regular run");
-        }
-        await this.startRun(config.parentId, config.runConfig ?? this.lastRunConfig);
-    }
-    assertNoPendingInterrupts() {
-        if (!this.getPendingInterrupts())
-            return;
-        throw new Error("[agui] cannot start a new run while interrupts are pending; resolve them with submitInterruptResponses()");
-    }
-    getPendingInterrupts() {
-        const assistant = this.messages.findLast((m) => m.role === "assistant");
-        if (!assistant ||
-            assistant.status?.type !== "requires-action" ||
-            assistant.status.reason !== "interrupt") {
-            return null;
-        }
-        const stored = assistant.metadata.custom[AG_UI_METADATA_NAMESPACE]?.interrupts;
-        if (!stored?.length)
-            return null;
-        return { messageId: assistant.id, interrupts: stored };
-    }
-    async submitInterruptResponses(responses) {
-        const pending = this.getPendingInterrupts();
-        if (!pending) {
-            throw new Error("[agui] submitInterruptResponses: no pending interrupts on this thread");
-        }
-        const responsesById = new Map();
-        for (const entry of responses) {
-            if (!entry || typeof entry.interruptId !== "string") {
-                throw new Error("[agui] submitInterruptResponses: every entry must have an interruptId");
-            }
-            if (entry.status !== "resolved" && entry.status !== "cancelled") {
-                throw new Error(`[agui] submitInterruptResponses: invalid status "${entry.status}" for interrupt ${entry.interruptId}`);
-            }
-            if (responsesById.has(entry.interruptId)) {
-                throw new Error(`[agui] submitInterruptResponses: duplicate response for interrupt ${entry.interruptId}`);
-            }
-            responsesById.set(entry.interruptId, entry);
-        }
-        const openIds = pending.interrupts.map((i) => i.id);
-        const missing = openIds.filter((id) => !responsesById.has(id));
-        if (missing.length > 0) {
-            throw new Error(`[agui] submitInterruptResponses: missing responses for open interrupts: ${missing.join(", ")}`);
-        }
-        const known = new Set(openIds);
-        const unknownIds = [...responsesById.keys()].filter((id) => !known.has(id));
-        if (unknownIds.length > 0) {
-            throw new Error(`[agui] submitInterruptResponses: unknown interrupt ids: ${unknownIds.join(", ")}`);
-        }
-        const now = Date.now();
-        for (const interrupt of pending.interrupts) {
-            if (!interrupt.expiresAt)
-                continue;
-            const expiry = new Date(interrupt.expiresAt).getTime();
-            if (Number.isNaN(expiry)) {
-                throw new Error(`[agui] submitInterruptResponses: interrupt ${interrupt.id} has malformed expiresAt "${interrupt.expiresAt}"`);
-            }
-            if (expiry <= now) {
-                throw new Error(`[agui] submitInterruptResponses: interrupt ${interrupt.id} expired at ${interrupt.expiresAt}`);
-            }
-        }
-        const resume = openIds.map((id) => responsesById.get(id));
-        if (this.isRunningFlag) {
-            throw new Error("[agui] submitInterruptResponses: a run is already in progress");
-        }
-        this.clearPendingInterrupts(pending.messageId);
-        await this.startRun(pending.messageId, this.lastRunConfig, resume);
-    }
-    clearPendingInterrupts(messageId) {
-        let touched = false;
-        this.messages = this.messages.map((message) => {
-            if (message.id !== messageId || message.role !== "assistant")
-                return message;
-            const assistant = message;
-            if (assistant.status?.type !== "requires-action" ||
-                assistant.status.reason !== "interrupt") {
-                return assistant;
-            }
-            touched = true;
-            const aguiMeta = assistant.metadata.custom[AG_UI_METADATA_NAMESPACE];
-            const { interrupts: _drop, ...restAgui } = aguiMeta ?? {};
-            const newCustom = { ...assistant.metadata.custom };
-            if (Object.keys(restAgui).length > 0) {
-                newCustom[AG_UI_METADATA_NAMESPACE] = restAgui;
-            }
-            else {
-                delete newCustom[AG_UI_METADATA_NAMESPACE];
-            }
-            return {
-                ...assistant,
-                status: { type: "complete", reason: "unknown" },
-                metadata: { ...assistant.metadata, custom: newCustom },
-            };
-        });
-        if (touched)
-            this.notifyUpdate();
-    }
-    findMessageIdForToolCall(toolCallId) {
-        let fallbackMessageId;
-        for (let index = this.messages.length - 1; index >= 0; index--) {
-            const message = this.messages[index];
-            if (!message || message.role !== "assistant")
-                continue;
-            for (const part of message.content) {
-                if (part.type !== "tool-call" || part.toolCallId !== toolCallId)
-                    continue;
-                if (!("result" in part) || part.result === undefined) {
-                    return message.id;
-                }
-                fallbackMessageId ??= message.id;
-            }
-        }
-        return fallbackMessageId;
-    }
-    addToolResult(options) {
-        let updated = false;
-        let shouldResume = false;
-        this.messages = this.messages.map((message) => {
-            if (message.id !== options.messageId || message.role !== "assistant")
-                return message;
-            const assistant = message;
-            let matchedToolCall = false;
-            const content = assistant.content.map((part) => {
-                if (part.type !== "tool-call" || part.toolCallId !== options.toolCallId)
-                    return part;
-                matchedToolCall = true;
-                return {
-                    ...part,
-                    result: options.result,
-                    artifact: options.artifact,
-                    isError: options.isError,
-                };
-            });
-            if (!matchedToolCall)
-                return message;
-            updated = true;
-            if (assistant.status?.type === "requires-action" &&
-                assistant.status.reason === "tool-calls" &&
-                content.every((part) => part.type !== "tool-call" ||
-                    ("result" in part && part.result !== undefined))) {
-                shouldResume = true;
-                return {
-                    ...assistant,
-                    content,
-                    status: { type: "complete", reason: "unknown" },
-                };
-            }
-            return {
-                ...assistant,
-                content,
-            };
-        });
-        if (updated) {
-            this.notifyUpdate();
-            if (shouldResume) {
-                this.persistAssistantHistory(options.messageId);
-                if (!this.isRunningFlag) {
-                    void this.startRun(options.messageId, this.lastRunConfig).catch((error) => {
-                        this.onError?.(error instanceof Error ? error : new Error(String(error)));
-                    });
-                }
-            }
-        }
-    }
-    applyExternalMessages(messages) {
-        this.assistantHistoryParents.clear();
-        this.messages = [...messages];
-        this.recordedHistoryIds.clear();
-        for (const message of this.messages) {
-            this.recordedHistoryIds.add(message.id);
-        }
-        this.notifyUpdate();
-    }
-    loadExternalState(state) {
-        this.stateSnapshot = state;
-        this.notifyUpdate();
-    }
-    async startRun(parentId, runConfig, resume) {
-        const normalizedRunConfig = runConfig ?? {};
-        this.lastRunConfig = normalizedRunConfig;
-        this.resetHead(parentId);
-        const historicalMessages = [...this.messages];
-        const runId = generateId();
-        this.pendingError = null;
-        const input = this.buildRunInput(runId, normalizedRunConfig, historicalMessages, resume);
-        const assistantParentId = parentId ?? this.messages.at(-1)?.id ?? null;
-        let assistantMessageId;
-        const ensureAssistant = () => {
-            if (assistantMessageId)
-                return assistantMessageId;
-            const created = this.insertAssistantPlaceholder();
-            assistantMessageId = created;
-            this.markPendingAssistantHistory(created, assistantParentId ?? null);
-            return created;
-        };
-        const aggregator = new RunAggregator({
-            showThinking: this.showThinking,
-            logger: this.logger,
-            emit: (update) => {
-                const resolved = this.updateAssistantMessage(ensureAssistant(), update);
-                if (resolved !== assistantMessageId) {
-                    assistantMessageId = resolved;
-                }
-            },
-            onServerMessageId: (serverId) => {
-                const placeholder = ensureAssistant();
-                if (placeholder === serverId)
-                    return;
-                this.reassignAssistantId(placeholder, serverId);
-                assistantMessageId = serverId;
-            },
-        });
-        const dispatch = (event) => this.handleEvent(aggregator, event);
-        const abortController = new AbortController();
-        const abortSignal = abortController.signal;
-        this.abortController = abortController;
-        abortSignal.addEventListener("abort", () => {
-            dispatch({ type: "RUN_CANCELLED" });
-            this.finishRun(abortController);
-            this.onCancel?.();
-        }, { once: true });
-        const subscriber = createAgUiSubscriber({
-            dispatch,
-            runId,
-            logger: this.logger,
-            onRunFailed: (error) => {
-                this.pendingError = error;
-                this.onError?.(error);
-            },
-        });
-        aggregator.handle({ type: "RUN_STARTED", runId });
-        this.setRunning(true);
-        try {
-            try {
-                this.agent.messages = input.messages;
-                this.agent.threadId = input.threadId;
-                this.agent.state = input.state ?? null;
-            }
-            catch {
-                // ignore
-            }
-            await this.agent.runAgent(input, subscriber, {
-                signal: abortSignal,
-            });
-        }
-        catch (error) {
-            if (!abortSignal.aborted) {
-                const err = error instanceof Error ? error : new Error(String(error));
-                dispatch({ type: "RUN_ERROR", message: err.message });
-                this.onError?.(err);
-                this.pendingError = this.pendingError ?? err;
-            }
-        }
-        finally {
-            this.finishRun(abortController);
-        }
-        if (this.pendingError) {
-            const err = this.pendingError;
-            this.pendingError = null;
-            throw err;
-        }
-    }
-    buildRunInput(runId, runConfig, historyMessages, resume) {
-        const threadId = this.agent.threadId || "main";
-        const messages = toAgUiMessages(historyMessages ?? this.messages);
-        const context = this.runtime?.thread.getModelContext();
-        return {
-            threadId,
-            runId,
-            state: this.stateSnapshot ?? null,
-            messages,
-            tools: toAgUiTools(context?.tools),
-            context: context?.system
-                ? [{ description: "system", value: context.system }]
-                : [],
-            forwardedProps: {
-                ...(context?.callSettings ?? {}),
-                ...(context?.config ?? {}),
-                ...(runConfig?.custom ? { runConfig: runConfig.custom } : {}),
-            },
-            ...(resume !== undefined ? { resume } : {}),
-        };
-    }
-    installResumeShim() {
-        const agent = this.agent;
-        if (agent[symbolResumeShim])
-            return;
-        agent[symbolResumeShim] = true;
-        const onInstance = Object.hasOwn(agent, "prepareRunAgentInput");
-        const original = onInstance
-            ? agent.prepareRunAgentInput
-            : Object.getPrototypeOf(agent)?.prepareRunAgentInput;
-        if (typeof original !== "function")
-            return;
-        agent.prepareRunAgentInput = function (params) {
-            const input = original.call(this, params);
-            if (params?.resume !== undefined && input && typeof input === "object") {
-                return { ...input, resume: params.resume };
-            }
-            return input;
-        };
-    }
-    setRunning(running) {
-        this.isRunningFlag = running;
-        this.notifyUpdate();
-    }
-    finishRun(controller) {
-        if (this.abortController === controller) {
-            this.abortController = null;
-        }
-        this.setRunning(false);
-    }
-    insertAssistantPlaceholder() {
-        const id = generateOptimisticId();
-        const assistant = {
-            id,
-            role: "assistant",
-            createdAt: new Date(),
-            status: { type: "running" },
-            content: [],
-            metadata: {
-                unstable_state: this.stateSnapshot ?? null,
-                unstable_annotations: [],
-                unstable_data: [],
-                steps: [],
-                custom: {},
-            },
-        };
-        this.messages = [...this.messages, assistant];
-        this.notifyUpdate();
-        return id;
-    }
-    reassignAssistantId(oldId, newId) {
-        if (oldId === newId)
-            return;
-        const collidesWithExisting = this.messages.some((m) => m.id === newId);
-        if (collidesWithExisting) {
-            this.logger.debug?.("[agui] reassignAssistantId: server id already present in messages, dropping placeholder", { oldId, newId });
-            this.messages = this.messages.filter((m) => m.id !== oldId);
-        }
-        else {
-            this.messages = this.messages.map((m) => m.id === oldId ? { ...m, id: newId } : m);
-        }
-        const pendingParent = this.assistantHistoryParents.get(oldId);
-        if (pendingParent !== undefined) {
-            this.assistantHistoryParents.delete(oldId);
-            if (!this.assistantHistoryParents.has(newId)) {
-                this.assistantHistoryParents.set(newId, pendingParent);
-            }
-        }
-        if (this.recordedHistoryIds.has(oldId)) {
-            this.recordedHistoryIds.delete(oldId);
-            this.recordedHistoryIds.add(newId);
-        }
-        this.notifyUpdate();
-    }
-    updateAssistantMessage(messageId, update) {
-        let touched = false;
-        let latestStatus;
-        this.messages = this.messages.map((message) => {
-            if (message.id !== messageId || message.role !== "assistant")
-                return message;
-            touched = true;
-            const assistant = message;
-            const metadata = update.metadata
-                ? this.mergeAssistantMetadata(assistant.metadata, update.metadata)
-                : assistant.metadata;
-            latestStatus = update.status ?? assistant.status;
-            return {
-                ...assistant,
-                content: (update.content ??
-                    assistant.content),
-                status: latestStatus,
-                metadata,
-            };
-        });
-        if (!touched)
-            return messageId;
-        let resolvedMessageId = messageId;
-        const isSettled = latestStatus !== undefined && latestStatus.type !== "running";
-        if (isSettled && isOptimisticId(messageId)) {
-            const stableId = generateId();
-            this.reassignAssistantId(messageId, stableId);
-            resolvedMessageId = stableId;
-        }
-        else {
-            this.notifyUpdate();
-        }
-        if (this.isPersistableStatus(latestStatus)) {
-            this.persistAssistantHistory(resolvedMessageId);
-        }
-        return resolvedMessageId;
-    }
-    mergeAssistantMetadata(current, incoming) {
-        const annotations = incoming.unstable_annotations
-            ? [...current.unstable_annotations, ...incoming.unstable_annotations]
-            : current.unstable_annotations;
-        const data = incoming.unstable_data
-            ? [...current.unstable_data, ...incoming.unstable_data]
-            : current.unstable_data;
-        const steps = incoming.steps
-            ? [...current.steps, ...incoming.steps]
-            : current.steps;
-        return {
-            unstable_state: incoming.unstable_state !== undefined
-                ? incoming.unstable_state
-                : current.unstable_state,
-            unstable_annotations: annotations,
-            unstable_data: data,
-            steps,
-            custom: incoming.custom
-                ? { ...current.custom, ...incoming.custom }
-                : current.custom,
-        };
-    }
-    handleEvent(aggregator, event) {
-        switch (event.type) {
-            case "STATE_SNAPSHOT": {
-                this.stateSnapshot = event.snapshot;
-                this.notifyUpdate();
-                return;
-            }
-            case "STATE_DELTA": {
-                this.logger.debug?.("[agui] state delta event ignored", event.delta);
-                return;
-            }
-            case "MESSAGES_SNAPSHOT": {
-                this.importMessagesSnapshot(event.messages);
-                return;
-            }
-            default:
-                aggregator.handle(event);
-        }
-    }
-    importMessagesSnapshot(rawMessages) {
-        try {
-            const normalized = fromAgUiMessages(rawMessages);
-            const converted = [];
-            for (const message of normalized) {
-                try {
-                    converted.push(fromThreadMessageLike(message, generateId(), FALLBACK_USER_STATUS));
-                }
-                catch (error) {
-                    this.logger.error?.("[agui] failed to import message from snapshot", error);
-                }
-            }
-            this.applyExternalMessages(converted);
-        }
-        catch (error) {
-            this.logger.error?.("[agui] failed to import messages snapshot", error);
-        }
-    }
-    toThreadMessage(message) {
-        return fromThreadMessageLike(message, generateId(), FALLBACK_USER_STATUS);
-    }
-    resetHead(parentId) {
-        if (!parentId) {
-            if (this.messages.length) {
-                this.messages = [];
-            }
-            return;
-        }
-        const idx = this.messages.findIndex((message) => message.id === parentId);
-        if (idx === -1)
-            return;
-        this.messages = this.messages.slice(0, idx + 1);
-    }
-    isTerminalStatus(status) {
-        return status?.type === "complete" || status?.type === "incomplete";
-    }
-    isPersistableStatus(status) {
-        if (this.isTerminalStatus(status))
-            return true;
-        return status?.type === "requires-action" && status.reason === "interrupt";
-    }
-    recordHistoryEntry(parentId, message) {
-        this.appendHistoryItem(parentId, message);
-    }
-    markPendingAssistantHistory(messageId, parentId) {
-        if (!this.history)
-            return;
-        this.assistantHistoryParents.set(messageId, parentId);
-    }
-    persistAssistantHistory(messageId) {
-        if (!this.history)
-            return;
-        const parentId = this.assistantHistoryParents.get(messageId);
-        if (parentId === undefined)
-            return;
-        const message = this.messages.find((m) => m.id === messageId);
-        if (!message || message.role !== "assistant")
-            return;
-        if (!this.isPersistableStatus(message.status))
-            return;
-        this.assistantHistoryParents.delete(messageId);
-        this.appendHistoryItem(parentId, message);
-    }
-    appendHistoryItem(parentId, message) {
-        if (!this.history || this.recordedHistoryIds.has(message.id))
-            return;
-        this.recordedHistoryIds.add(message.id);
-        void this.history.append({ parentId, message }).catch((error) => {
-            this.recordedHistoryIds.delete(message.id);
-            this.logger.error?.("[agui] failed to append history entry", error);
-        });
-    }
-}
+const FALLBACK_USER_STATUS = {
+	type: "complete",
+	reason: "unknown"
+};
+var AgUiThreadRuntimeCore = class {
+	agent;
+	logger;
+	showThinking;
+	onError;
+	onCancel;
+	notifyUpdate;
+	runtime;
+	messages = [];
+	isRunningFlag = false;
+	abortController = null;
+	stateSnapshot;
+	pendingError = null;
+	history;
+	lastRunConfig;
+	assistantHistoryParents = /* @__PURE__ */ new Map();
+	recordedHistoryIds = /* @__PURE__ */ new Set();
+	_isLoading = false;
+	_loadPromise;
+	constructor(options) {
+		this.agent = options.agent;
+		this.logger = options.logger;
+		this.showThinking = options.showThinking;
+		this.onError = options.onError;
+		this.onCancel = options.onCancel;
+		this.history = options.history;
+		this.notifyUpdate = options.notifyUpdate;
+		this.installResumeShim();
+	}
+	updateOptions(options) {
+		this.agent = options.agent;
+		this.logger = options.logger;
+		this.showThinking = options.showThinking;
+		this.onError = options.onError;
+		this.onCancel = options.onCancel;
+		this.history = options.history;
+		this.installResumeShim();
+	}
+	attachRuntime(runtime) {
+		this.runtime = runtime;
+	}
+	detachRuntime() {
+		this.runtime = void 0;
+	}
+	getMessages() {
+		return this.messages;
+	}
+	getState() {
+		return this.stateSnapshot;
+	}
+	isRunning() {
+		return this.isRunningFlag;
+	}
+	get isLoading() {
+		return this._isLoading;
+	}
+	__internal_load() {
+		if (this._loadPromise) return this._loadPromise;
+		const promise = this.history?.load() ?? Promise.resolve(null);
+		this._isLoading = true;
+		this._loadPromise = promise.then(async (repo) => {
+			if (!repo) return;
+			const messages = repo.messages.map((item) => item.message);
+			this.applyExternalMessages(messages);
+			if (repo.unstable_resume) {
+				const parentId = repo.headId ?? messages.at(-1)?.id ?? null;
+				await this.startRun(parentId, this.lastRunConfig);
+			}
+		}).catch((error) => {
+			this.logger.error?.("[agui] failed to load history", error);
+			this.onError?.(error instanceof Error ? error : new Error(String(error)));
+		}).finally(() => {
+			this._isLoading = false;
+			this.notifyUpdate();
+		});
+		this.notifyUpdate();
+		return this._loadPromise;
+	}
+	async append(message) {
+		const startRun = message.startRun ?? message.role === "user";
+		if (startRun) this.assertNoPendingInterrupts();
+		if (message.sourceId) this.messages = this.messages.filter((entry) => entry.id !== message.sourceId);
+		this.resetHead(message.parentId);
+		const threadMessage = this.toThreadMessage(message);
+		this.messages = [...this.messages, threadMessage];
+		this.notifyUpdate();
+		this.recordHistoryEntry(message.parentId ?? null, threadMessage);
+		if (!startRun) return;
+		await this.startRun(threadMessage.id, message.runConfig);
+	}
+	async edit(message) {
+		await this.append(message);
+	}
+	async reload(parentId, config = {}) {
+		this.assertNoPendingInterrupts();
+		this.resetHead(parentId);
+		this.notifyUpdate();
+		await this.startRun(parentId, config.runConfig);
+	}
+	async cancel() {
+		if (!this.abortController) return;
+		this.abortController.abort();
+	}
+	async resume(config) {
+		this.assertNoPendingInterrupts();
+		if (config.stream) this.logger.debug?.("[agui] resume stream is not supported, falling back to regular run");
+		await this.startRun(config.parentId, config.runConfig ?? this.lastRunConfig);
+	}
+	assertNoPendingInterrupts() {
+		if (!this.getPendingInterrupts()) return;
+		throw new Error("[agui] cannot start a new run while interrupts are pending; resolve them with submitInterruptResponses()");
+	}
+	getPendingInterrupts() {
+		const assistant = this.messages.findLast((m) => m.role === "assistant");
+		if (!assistant || assistant.status?.type !== "requires-action" || assistant.status.reason !== "interrupt") return null;
+		const stored = assistant.metadata.custom[AG_UI_METADATA_NAMESPACE]?.interrupts;
+		if (!stored?.length) return null;
+		return {
+			messageId: assistant.id,
+			interrupts: stored
+		};
+	}
+	async submitInterruptResponses(responses) {
+		const pending = this.getPendingInterrupts();
+		if (!pending) throw new Error("[agui] submitInterruptResponses: no pending interrupts on this thread");
+		const responsesById = /* @__PURE__ */ new Map();
+		for (const entry of responses) {
+			if (!entry || typeof entry.interruptId !== "string") throw new Error("[agui] submitInterruptResponses: every entry must have an interruptId");
+			if (entry.status !== "resolved" && entry.status !== "cancelled") throw new Error(`[agui] submitInterruptResponses: invalid status "${entry.status}" for interrupt ${entry.interruptId}`);
+			if (responsesById.has(entry.interruptId)) throw new Error(`[agui] submitInterruptResponses: duplicate response for interrupt ${entry.interruptId}`);
+			responsesById.set(entry.interruptId, entry);
+		}
+		const openIds = pending.interrupts.map((i) => i.id);
+		const missing = openIds.filter((id) => !responsesById.has(id));
+		if (missing.length > 0) throw new Error(`[agui] submitInterruptResponses: missing responses for open interrupts: ${missing.join(", ")}`);
+		const known = new Set(openIds);
+		const unknownIds = [...responsesById.keys()].filter((id) => !known.has(id));
+		if (unknownIds.length > 0) throw new Error(`[agui] submitInterruptResponses: unknown interrupt ids: ${unknownIds.join(", ")}`);
+		const now = Date.now();
+		for (const interrupt of pending.interrupts) {
+			if (!interrupt.expiresAt) continue;
+			const expiry = new Date(interrupt.expiresAt).getTime();
+			if (Number.isNaN(expiry)) throw new Error(`[agui] submitInterruptResponses: interrupt ${interrupt.id} has malformed expiresAt "${interrupt.expiresAt}"`);
+			if (expiry <= now) throw new Error(`[agui] submitInterruptResponses: interrupt ${interrupt.id} expired at ${interrupt.expiresAt}`);
+		}
+		const resume = openIds.map((id) => responsesById.get(id));
+		if (this.isRunningFlag) throw new Error("[agui] submitInterruptResponses: a run is already in progress");
+		this.clearPendingInterrupts(pending.messageId);
+		await this.startRun(pending.messageId, this.lastRunConfig, resume);
+	}
+	clearPendingInterrupts(messageId) {
+		let touched = false;
+		this.messages = this.messages.map((message) => {
+			if (message.id !== messageId || message.role !== "assistant") return message;
+			const assistant = message;
+			if (assistant.status?.type !== "requires-action" || assistant.status.reason !== "interrupt") return assistant;
+			touched = true;
+			const { interrupts: _drop, ...restAgui } = assistant.metadata.custom["agui"] ?? {};
+			const newCustom = { ...assistant.metadata.custom };
+			if (Object.keys(restAgui).length > 0) newCustom[AG_UI_METADATA_NAMESPACE] = restAgui;
+			else delete newCustom[AG_UI_METADATA_NAMESPACE];
+			return {
+				...assistant,
+				status: {
+					type: "complete",
+					reason: "unknown"
+				},
+				metadata: {
+					...assistant.metadata,
+					custom: newCustom
+				}
+			};
+		});
+		if (touched) this.notifyUpdate();
+	}
+	findMessageIdForToolCall(toolCallId) {
+		let fallbackMessageId;
+		for (let index = this.messages.length - 1; index >= 0; index--) {
+			const message = this.messages[index];
+			if (!message || message.role !== "assistant") continue;
+			for (const part of message.content) {
+				if (part.type !== "tool-call" || part.toolCallId !== toolCallId) continue;
+				if (!("result" in part) || part.result === void 0) return message.id;
+				fallbackMessageId ??= message.id;
+			}
+		}
+		return fallbackMessageId;
+	}
+	addToolResult(options) {
+		let updated = false;
+		let shouldResume = false;
+		this.messages = this.messages.map((message) => {
+			if (message.id !== options.messageId || message.role !== "assistant") return message;
+			const assistant = message;
+			let matchedToolCall = false;
+			const content = assistant.content.map((part) => {
+				if (part.type !== "tool-call" || part.toolCallId !== options.toolCallId) return part;
+				matchedToolCall = true;
+				return {
+					...part,
+					result: options.result,
+					artifact: options.artifact,
+					isError: options.isError
+				};
+			});
+			if (!matchedToolCall) return message;
+			updated = true;
+			if (assistant.status?.type === "requires-action" && assistant.status.reason === "tool-calls" && content.every((part) => part.type !== "tool-call" || "result" in part && part.result !== void 0)) {
+				shouldResume = true;
+				return {
+					...assistant,
+					content,
+					status: {
+						type: "complete",
+						reason: "unknown"
+					}
+				};
+			}
+			return {
+				...assistant,
+				content
+			};
+		});
+		if (updated) {
+			this.notifyUpdate();
+			if (shouldResume) {
+				this.persistAssistantHistory(options.messageId);
+				if (!this.isRunningFlag) this.startRun(options.messageId, this.lastRunConfig).catch((error) => {
+					this.onError?.(error instanceof Error ? error : new Error(String(error)));
+				});
+			}
+		}
+	}
+	applyExternalMessages(messages) {
+		this.assistantHistoryParents.clear();
+		this.messages = [...messages];
+		this.recordedHistoryIds.clear();
+		for (const message of this.messages) this.recordedHistoryIds.add(message.id);
+		this.notifyUpdate();
+	}
+	loadExternalState(state) {
+		this.stateSnapshot = state;
+		this.notifyUpdate();
+	}
+	async startRun(parentId, runConfig, resume) {
+		const normalizedRunConfig = runConfig ?? {};
+		this.lastRunConfig = normalizedRunConfig;
+		this.resetHead(parentId);
+		const historicalMessages = [...this.messages];
+		const runId = generateId();
+		this.pendingError = null;
+		const input = this.buildRunInput(runId, normalizedRunConfig, historicalMessages, resume);
+		const assistantParentId = parentId ?? this.messages.at(-1)?.id ?? null;
+		let assistantMessageId;
+		const ensureAssistant = () => {
+			if (assistantMessageId) return assistantMessageId;
+			const created = this.insertAssistantPlaceholder();
+			assistantMessageId = created;
+			this.markPendingAssistantHistory(created, assistantParentId ?? null);
+			return created;
+		};
+		const aggregator = new RunAggregator({
+			showThinking: this.showThinking,
+			logger: this.logger,
+			emit: (update) => {
+				const resolved = this.updateAssistantMessage(ensureAssistant(), update);
+				if (resolved !== assistantMessageId) assistantMessageId = resolved;
+			},
+			onServerMessageId: (serverId) => {
+				const placeholder = ensureAssistant();
+				if (placeholder === serverId) return;
+				this.reassignAssistantId(placeholder, serverId);
+				assistantMessageId = serverId;
+			}
+		});
+		const dispatch = (event) => this.handleEvent(aggregator, event);
+		const abortController = new AbortController();
+		const abortSignal = abortController.signal;
+		this.abortController = abortController;
+		abortSignal.addEventListener("abort", () => {
+			dispatch({ type: "RUN_CANCELLED" });
+			this.finishRun(abortController);
+			this.onCancel?.();
+		}, { once: true });
+		const subscriber = createAgUiSubscriber({
+			dispatch,
+			runId,
+			logger: this.logger,
+			onRunFailed: (error) => {
+				this.pendingError = error;
+				this.onError?.(error);
+			}
+		});
+		aggregator.handle({
+			type: "RUN_STARTED",
+			runId
+		});
+		this.setRunning(true);
+		try {
+			try {
+				this.agent.messages = input.messages;
+				this.agent.threadId = input.threadId;
+				this.agent.state = input.state ?? null;
+			} catch {}
+			await this.agent.runAgent(input, subscriber, { signal: abortSignal });
+		} catch (error) {
+			if (!abortSignal.aborted) {
+				const err = error instanceof Error ? error : new Error(String(error));
+				dispatch({
+					type: "RUN_ERROR",
+					message: err.message
+				});
+				this.onError?.(err);
+				this.pendingError = this.pendingError ?? err;
+			}
+		} finally {
+			this.finishRun(abortController);
+		}
+		if (this.pendingError) {
+			const err = this.pendingError;
+			this.pendingError = null;
+			throw err;
+		}
+	}
+	buildRunInput(runId, runConfig, historyMessages, resume) {
+		const threadId = this.agent.threadId || "main";
+		const messages = toAgUiMessages(historyMessages ?? this.messages);
+		const context = this.runtime?.thread.getModelContext();
+		return {
+			threadId,
+			runId,
+			state: this.stateSnapshot ?? null,
+			messages,
+			tools: toAgUiTools(context?.tools),
+			context: context?.system ? [{
+				description: "system",
+				value: context.system
+			}] : [],
+			forwardedProps: {
+				...context?.callSettings ?? {},
+				...context?.config ?? {},
+				...runConfig?.custom ? { runConfig: runConfig.custom } : {}
+			},
+			...resume !== void 0 ? { resume } : {}
+		};
+	}
+	installResumeShim() {
+		const agent = this.agent;
+		if (agent[symbolResumeShim]) return;
+		agent[symbolResumeShim] = true;
+		const original = Object.hasOwn(agent, "prepareRunAgentInput") ? agent.prepareRunAgentInput : Object.getPrototypeOf(agent)?.prepareRunAgentInput;
+		if (typeof original !== "function") return;
+		agent.prepareRunAgentInput = function(params) {
+			const input = original.call(this, params);
+			if (params?.resume !== void 0 && input && typeof input === "object") return {
+				...input,
+				resume: params.resume
+			};
+			return input;
+		};
+	}
+	setRunning(running) {
+		this.isRunningFlag = running;
+		this.notifyUpdate();
+	}
+	finishRun(controller) {
+		if (this.abortController === controller) this.abortController = null;
+		this.setRunning(false);
+	}
+	insertAssistantPlaceholder() {
+		const id = generateOptimisticId();
+		const assistant = {
+			id,
+			role: "assistant",
+			createdAt: /* @__PURE__ */ new Date(),
+			status: { type: "running" },
+			content: [],
+			metadata: {
+				unstable_state: this.stateSnapshot ?? null,
+				unstable_annotations: [],
+				unstable_data: [],
+				steps: [],
+				custom: {}
+			}
+		};
+		this.messages = [...this.messages, assistant];
+		this.notifyUpdate();
+		return id;
+	}
+	reassignAssistantId(oldId, newId) {
+		if (oldId === newId) return;
+		if (this.messages.some((m) => m.id === newId)) {
+			this.logger.debug?.("[agui] reassignAssistantId: server id already present in messages, dropping placeholder", {
+				oldId,
+				newId
+			});
+			this.messages = this.messages.filter((m) => m.id !== oldId);
+		} else this.messages = this.messages.map((m) => m.id === oldId ? {
+			...m,
+			id: newId
+		} : m);
+		const pendingParent = this.assistantHistoryParents.get(oldId);
+		if (pendingParent !== void 0) {
+			this.assistantHistoryParents.delete(oldId);
+			if (!this.assistantHistoryParents.has(newId)) this.assistantHistoryParents.set(newId, pendingParent);
+		}
+		if (this.recordedHistoryIds.has(oldId)) {
+			this.recordedHistoryIds.delete(oldId);
+			this.recordedHistoryIds.add(newId);
+		}
+		this.notifyUpdate();
+	}
+	updateAssistantMessage(messageId, update) {
+		let touched = false;
+		let latestStatus;
+		this.messages = this.messages.map((message) => {
+			if (message.id !== messageId || message.role !== "assistant") return message;
+			touched = true;
+			const assistant = message;
+			const metadata = update.metadata ? this.mergeAssistantMetadata(assistant.metadata, update.metadata) : assistant.metadata;
+			latestStatus = update.status ?? assistant.status;
+			return {
+				...assistant,
+				content: update.content ?? assistant.content,
+				status: latestStatus,
+				metadata
+			};
+		});
+		if (!touched) return messageId;
+		let resolvedMessageId = messageId;
+		if (latestStatus !== void 0 && latestStatus.type !== "running" && isOptimisticId(messageId)) {
+			const stableId = generateId();
+			this.reassignAssistantId(messageId, stableId);
+			resolvedMessageId = stableId;
+		} else this.notifyUpdate();
+		if (this.isPersistableStatus(latestStatus)) this.persistAssistantHistory(resolvedMessageId);
+		return resolvedMessageId;
+	}
+	mergeAssistantMetadata(current, incoming) {
+		const annotations = incoming.unstable_annotations ? [...current.unstable_annotations, ...incoming.unstable_annotations] : current.unstable_annotations;
+		const data = incoming.unstable_data ? [...current.unstable_data, ...incoming.unstable_data] : current.unstable_data;
+		const steps = incoming.steps ? [...current.steps, ...incoming.steps] : current.steps;
+		return {
+			unstable_state: incoming.unstable_state !== void 0 ? incoming.unstable_state : current.unstable_state,
+			unstable_annotations: annotations,
+			unstable_data: data,
+			steps,
+			...incoming.timing ? { timing: incoming.timing } : {},
+			custom: incoming.custom ? {
+				...current.custom,
+				...incoming.custom
+			} : current.custom
+		};
+	}
+	handleEvent(aggregator, event) {
+		switch (event.type) {
+			case "STATE_SNAPSHOT":
+				this.stateSnapshot = event.snapshot;
+				this.notifyUpdate();
+				return;
+			case "STATE_DELTA":
+				this.logger.debug?.("[agui] state delta event ignored", event.delta);
+				return;
+			case "MESSAGES_SNAPSHOT":
+				this.importMessagesSnapshot(event.messages);
+				return;
+			default: aggregator.handle(event);
+		}
+	}
+	importMessagesSnapshot(rawMessages) {
+		try {
+			const normalized = fromAgUiMessages(rawMessages);
+			const converted = [];
+			for (const message of normalized) try {
+				converted.push(fromThreadMessageLike(message, generateId(), FALLBACK_USER_STATUS));
+			} catch (error) {
+				this.logger.error?.("[agui] failed to import message from snapshot", error);
+			}
+			this.applyExternalMessages(converted);
+		} catch (error) {
+			this.logger.error?.("[agui] failed to import messages snapshot", error);
+		}
+	}
+	toThreadMessage(message) {
+		return fromThreadMessageLike(message, generateId(), FALLBACK_USER_STATUS);
+	}
+	resetHead(parentId) {
+		if (!parentId) {
+			if (this.messages.length) this.messages = [];
+			return;
+		}
+		const idx = this.messages.findIndex((message) => message.id === parentId);
+		if (idx === -1) return;
+		this.messages = this.messages.slice(0, idx + 1);
+	}
+	isTerminalStatus(status) {
+		return status?.type === "complete" || status?.type === "incomplete";
+	}
+	isPersistableStatus(status) {
+		if (this.isTerminalStatus(status)) return true;
+		return status?.type === "requires-action" && status.reason === "interrupt";
+	}
+	recordHistoryEntry(parentId, message) {
+		this.appendHistoryItem(parentId, message);
+	}
+	markPendingAssistantHistory(messageId, parentId) {
+		if (!this.history) return;
+		this.assistantHistoryParents.set(messageId, parentId);
+	}
+	persistAssistantHistory(messageId) {
+		if (!this.history) return;
+		const parentId = this.assistantHistoryParents.get(messageId);
+		if (parentId === void 0) return;
+		const message = this.messages.find((m) => m.id === messageId);
+		if (!message || message.role !== "assistant") return;
+		if (!this.isPersistableStatus(message.status)) return;
+		this.assistantHistoryParents.delete(messageId);
+		this.appendHistoryItem(parentId, message);
+	}
+	appendHistoryItem(parentId, message) {
+		if (!this.history || this.recordedHistoryIds.has(message.id)) return;
+		this.recordedHistoryIds.add(message.id);
+		this.history.append({
+			parentId,
+			message
+		}).catch((error) => {
+			this.recordedHistoryIds.delete(message.id);
+			this.logger.error?.("[agui] failed to append history entry", error);
+		});
+	}
+};
+//#endregion
+export { AgUiThreadRuntimeCore };
+
 //# sourceMappingURL=AgUiThreadRuntimeCore.js.map