@assistant-ui/react-a2a 0.2.15 → 0.2.16

package/dist/A2AThreadRuntimeCore.js

@@ -1,483 +1,404 @@
 "use client";
-import { generateId, fromThreadMessageLike } from "@assistant-ui/core/internal";
-import { a2aMessageToContent, isTerminalTaskState, taskStateToMessageStatus, } from "./conversions.js";
+import { a2aMessageToContent, isTerminalTaskState, taskStateToMessageStatus } from "./conversions.js";
+import { fromThreadMessageLike, generateId } from "@assistant-ui/core/internal";
+//#region src/A2AThreadRuntimeCore.ts
 const FALLBACK_USER_STATUS = {
-    type: "complete",
-    reason: "unknown",
+	type: "complete",
+	reason: "unknown"
 };
-export class A2AThreadRuntimeCore {
-    client;
-    contextId;
-    configuration;
-    onError;
-    onCancel;
-    onArtifactComplete;
-    history;
-    notifyUpdate;
-    runtime;
-    messages = [];
-    isRunningFlag = false;
-    abortController = null;
-    pendingError = null;
-    // A2A-specific state
-    currentTask;
-    currentArtifacts = [];
-    agentCardValue;
-    // History tracking
-    assistantHistoryParents = new Map();
-    recordedHistoryIds = new Set();
-    _isLoading = false;
-    _loadPromise;
-    constructor(options) {
-        this.client = options.client;
-        this.contextId = options.contextId;
-        this.configuration = options.configuration;
-        this.onError = options.onError;
-        this.onCancel = options.onCancel;
-        this.onArtifactComplete = options.onArtifactComplete;
-        this.history = options.history;
-        this.notifyUpdate = options.notifyUpdate;
-    }
-    updateOptions(options) {
-        this.client = options.client;
-        this.contextId = options.contextId;
-        this.configuration = options.configuration;
-        this.onError = options.onError;
-        this.onCancel = options.onCancel;
-        this.onArtifactComplete = options.onArtifactComplete;
-        this.history = options.history;
-    }
-    attachRuntime(runtime) {
-        this.runtime = runtime;
-    }
-    detachRuntime() {
-        this.runtime = undefined;
-        // Abort in-flight requests on unmount
-        if (this.abortController) {
-            this.abortController.abort();
-            this.abortController = null;
-        }
-    }
-    getRuntime() {
-        return this.runtime;
-    }
-    getMessages() {
-        return this.messages;
-    }
-    getTask() {
-        return this.currentTask;
-    }
-    getArtifacts() {
-        return this.currentArtifacts;
-    }
-    getAgentCard() {
-        return this.agentCardValue;
-    }
-    isRunning() {
-        return this.isRunningFlag;
-    }
-    get isLoading() {
-        return this._isLoading;
-    }
-    __internal_load() {
-        if (this._loadPromise)
-            return this._loadPromise;
-        this._isLoading = true;
-        const historyPromise = this.history?.load() ?? Promise.resolve(null);
-        const agentCardPromise = this.client.getAgentCard().catch(() => undefined);
-        this._loadPromise = Promise.all([historyPromise, agentCardPromise])
-            .then(([repo, agentCard]) => {
-            if (agentCard) {
-                this.agentCardValue = agentCard;
-            }
-            if (repo) {
-                const messages = repo.messages.map((item) => item.message);
-                this.applyExternalMessages(messages);
-            }
-        })
-            .catch((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 (message.sourceId) {
-            this.messages = this.messages.filter((entry) => entry.id !== message.sourceId);
-        }
-        this.resetHead(message.parentId);
-        const threadMessage = fromThreadMessageLike(message, generateId(), FALLBACK_USER_STATUS);
-        this.messages = [...this.messages, threadMessage];
-        this.notifyUpdate();
-        this.recordHistoryEntry(message.parentId ?? null, threadMessage);
-        if (!startRun)
-            return;
-        await this.startRun(threadMessage);
-    }
-    async edit(message) {
-        await this.append(message);
-    }
-    async reload(parentId, _config = {}) {
-        this.resetHead(parentId);
-        this.notifyUpdate();
-        // Find the last user message to re-run
-        for (let i = this.messages.length - 1; i >= 0; i--) {
-            if (this.messages[i].role === "user") {
-                await this.startRun(this.messages[i]);
-                return;
-            }
-        }
-    }
-    async cancel() {
-        if (!this.abortController)
-            return;
-        // Abort locally first so the stream stops immediately
-        this.abortController.abort();
-        // Then try to cancel the task on the server
-        if (this.currentTask?.id) {
-            try {
-                const updated = await this.client.cancelTask(this.currentTask.id);
-                this.currentTask = updated;
-            }
-            catch {
-                // Server cancel failed; local abort already handled
-            }
-        }
-    }
-    applyExternalMessages(messages) {
-        this.assistantHistoryParents.clear();
-        this.messages = [...messages];
-        this.recordedHistoryIds.clear();
-        for (const message of this.messages) {
-            this.recordedHistoryIds.add(message.id);
-        }
-        // Reset task-specific state to prevent leaking into new thread
-        this.currentTask = undefined;
-        this.currentArtifacts = [];
-        this.notifyUpdate();
-    }
-    // --- Run logic ---
-    async startRun(userThreadMessage) {
-        // Cancel any in-progress run before starting a new one
-        if (this.abortController) {
-            this.abortController.abort();
-            this.abortController = null;
-        }
-        const a2aMessage = this.threadMessageToA2AMessage(userThreadMessage);
-        // Clear task if previous task reached terminal state
-        if (this.currentTask &&
-            isTerminalTaskState(this.currentTask.status.state)) {
-            this.currentTask = undefined;
-        }
-        this.currentArtifacts = [];
-        const assistantParentId = userThreadMessage.id;
-        const assistantId = this.insertAssistantPlaceholder();
-        this.markPendingAssistantHistory(assistantId, assistantParentId);
-        const abortController = new AbortController();
-        this.abortController = abortController;
-        abortController.signal.addEventListener("abort", () => {
-            this.updateAssistantStatus(assistantId, {
-                type: "incomplete",
-                reason: "cancelled",
-            });
-            this.finishRun(abortController);
-            this.onCancel?.();
-        }, { once: true });
-        this.setRunning(true);
-        // Check if agent supports streaming; fall back to sync sendMessage if not
-        const supportsStreaming = this.agentCardValue?.capabilities?.streaming !== false;
-        try {
-            if (supportsStreaming) {
-                await this.runStreaming(a2aMessage, assistantId, abortController);
-            }
-            else {
-                await this.runSync(a2aMessage, assistantId, abortController);
-            }
-        }
-        catch (error) {
-            if (!abortController.signal.aborted) {
-                const err = error instanceof Error ? error : new Error(String(error));
-                this.updateAssistantStatus(assistantId, {
-                    type: "incomplete",
-                    reason: "error",
-                });
-                this.onError?.(err);
-                this.pendingError = this.pendingError ?? err;
-            }
-        }
-        finally {
-            this.finishRun(abortController);
-        }
-        if (this.pendingError) {
-            const err = this.pendingError;
-            this.pendingError = null;
-            throw err;
-        }
-    }
-    async runStreaming(a2aMessage, assistantId, abortController) {
-        const stream = this.client.streamMessage(a2aMessage, this.configuration, undefined, // metadata
-        abortController.signal);
-        for await (const event of stream) {
-            if (abortController.signal.aborted)
-                break;
-            this.handleStreamEvent(assistantId, event);
-        }
-        if (!abortController.signal.aborted) {
-            const lastStatus = this.getAssistantStatus(assistantId);
-            if (lastStatus?.type === "running") {
-                this.updateAssistantStatus(assistantId, {
-                    type: "complete",
-                    reason: "stop",
-                });
-            }
-        }
-    }
-    async runSync(a2aMessage, assistantId, abortController) {
-        const result = await this.client.sendMessage(a2aMessage, this.configuration, undefined, // metadata
-        abortController.signal);
-        if (abortController.signal.aborted)
-            return;
-        // Result is either A2ATask or A2AMessage
-        if ("id" in result && "status" in result) {
-            // It's a Task
-            this.handleTaskSnapshot(assistantId, result);
-        }
-        else if ("messageId" in result && "parts" in result) {
-            // It's a Message
-            this.handleMessage(assistantId, result);
-            this.updateAssistantStatus(assistantId, {
-                type: "complete",
-                reason: "stop",
-            });
-        }
-    }
-    handleStreamEvent(assistantId, event) {
-        switch (event.type) {
-            case "statusUpdate":
-                this.handleStatusUpdate(assistantId, event.event);
-                break;
-            case "artifactUpdate":
-                this.handleArtifactUpdate(event.event);
-                break;
-            case "message":
-                this.handleMessage(assistantId, event.message);
-                break;
-            case "task":
-                this.handleTaskSnapshot(assistantId, event.task);
-                break;
-        }
-    }
-    handleStatusUpdate(assistantId, event) {
-        if (!this.currentTask) {
-            this.currentTask = {
-                id: event.taskId,
-                contextId: event.contextId,
-                status: event.status,
-            };
-        }
-        else {
-            this.currentTask = { ...this.currentTask, status: event.status };
-        }
-        if (event.contextId) {
-            this.contextId = event.contextId;
-        }
-        if (event.status.message) {
-            const content = a2aMessageToContent(event.status.message);
-            this.updateAssistantContent(assistantId, content);
-        }
-        const status = taskStateToMessageStatus(event.status.state);
-        this.updateAssistantStatus(assistantId, status);
-        this.notifyUpdate();
-    }
-    handleArtifactUpdate(event) {
-        const { artifact, append, lastChunk } = event;
-        const existingIdx = this.currentArtifacts.findIndex((a) => a.artifactId === artifact.artifactId);
-        let updated;
-        if (existingIdx >= 0 && append) {
-            const existing = this.currentArtifacts[existingIdx];
-            updated = {
-                ...existing,
-                parts: [...existing.parts, ...artifact.parts],
-            };
-            this.currentArtifacts = [
-                ...this.currentArtifacts.slice(0, existingIdx),
-                updated,
-                ...this.currentArtifacts.slice(existingIdx + 1),
-            ];
-        }
-        else if (existingIdx >= 0) {
-            updated = artifact;
-            this.currentArtifacts = [
-                ...this.currentArtifacts.slice(0, existingIdx),
-                updated,
-                ...this.currentArtifacts.slice(existingIdx + 1),
-            ];
-        }
-        else {
-            updated = artifact;
-            this.currentArtifacts = [...this.currentArtifacts, updated];
-        }
-        if (lastChunk) {
-            this.onArtifactComplete?.(updated);
-        }
-        this.notifyUpdate();
-    }
-    handleMessage(assistantId, message) {
-        if (message.role !== "agent")
-            return;
-        const content = a2aMessageToContent(message);
-        this.updateAssistantContent(assistantId, content);
-        this.notifyUpdate();
-    }
-    handleTaskSnapshot(assistantId, task) {
-        this.currentTask = task;
-        if (task.contextId) {
-            this.contextId = task.contextId;
-        }
-        if (task.artifacts) {
-            this.currentArtifacts = task.artifacts;
-        }
-        if (task.status.message) {
-            const content = a2aMessageToContent(task.status.message);
-            this.updateAssistantContent(assistantId, content);
-        }
-        const status = taskStateToMessageStatus(task.status.state);
-        this.updateAssistantStatus(assistantId, status);
-        this.notifyUpdate();
-    }
-    // --- Message helpers ---
-    threadMessageToA2AMessage(message) {
-        const parts = [];
-        if (message.role === "user") {
-            for (const part of message.content) {
-                if (part.type === "text") {
-                    parts.push({ text: part.text });
-                }
-                else if (part.type === "image") {
-                    parts.push({ url: part.image, mediaType: "image/*" });
-                }
-            }
-        }
-        const a2aMsg = {
-            messageId: message.id,
-            role: "user",
-            parts,
-        };
-        if (this.contextId) {
-            a2aMsg.contextId = this.contextId;
-        }
-        // Only attach taskId if current task is NOT in terminal state
-        if (this.currentTask?.id &&
-            !isTerminalTaskState(this.currentTask.status.state)) {
-            a2aMsg.taskId = this.currentTask.id;
-        }
-        return a2aMsg;
-    }
-    insertAssistantPlaceholder() {
-        const id = generateId();
-        const assistant = {
-            id,
-            role: "assistant",
-            createdAt: new Date(),
-            status: { type: "running" },
-            content: [],
-            metadata: {
-                unstable_state: null,
-                unstable_annotations: [],
-                unstable_data: [],
-                steps: [],
-                custom: {},
-            },
-        };
-        this.messages = [...this.messages, assistant];
-        this.notifyUpdate();
-        return id;
-    }
-    updateAssistantContent(messageId, content) {
-        this.messages = this.messages.map((message) => {
-            if (message.id !== messageId || message.role !== "assistant")
-                return message;
-            return { ...message, content };
-        });
-    }
-    updateAssistantStatus(messageId, status) {
-        let touched = false;
-        this.messages = this.messages.map((message) => {
-            if (message.id !== messageId || message.role !== "assistant")
-                return message;
-            touched = true;
-            return { ...message, status };
-        });
-        if (touched) {
-            this.notifyUpdate();
-            if (status.type === "complete" || status.type === "incomplete") {
-                this.persistAssistantHistory(messageId);
-            }
-        }
-    }
-    getAssistantStatus(messageId) {
-        const msg = this.messages.find((m) => m.id === messageId && m.role === "assistant");
-        return msg?.status;
-    }
-    // --- Lifecycle helpers ---
-    setRunning(running) {
-        this.isRunningFlag = running;
-        this.notifyUpdate();
-    }
-    finishRun(controller) {
-        if (this.abortController === controller) {
-            this.abortController = null;
-        }
-        this.setRunning(false);
-    }
-    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);
-    }
-    // --- History persistence ---
-    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 (message.status?.type !== "complete" &&
-            message.status?.type !== "incomplete")
-            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(() => {
-            this.recordedHistoryIds.delete(message.id);
-        });
-    }
-}
+var A2AThreadRuntimeCore = class {
+	client;
+	contextId;
+	configuration;
+	onError;
+	onCancel;
+	onArtifactComplete;
+	history;
+	notifyUpdate;
+	runtime;
+	messages = [];
+	isRunningFlag = false;
+	abortController = null;
+	pendingError = null;
+	currentTask;
+	currentArtifacts = [];
+	agentCardValue;
+	assistantHistoryParents = /* @__PURE__ */ new Map();
+	recordedHistoryIds = /* @__PURE__ */ new Set();
+	_isLoading = false;
+	_loadPromise;
+	constructor(options) {
+		this.client = options.client;
+		this.contextId = options.contextId;
+		this.configuration = options.configuration;
+		this.onError = options.onError;
+		this.onCancel = options.onCancel;
+		this.onArtifactComplete = options.onArtifactComplete;
+		this.history = options.history;
+		this.notifyUpdate = options.notifyUpdate;
+	}
+	updateOptions(options) {
+		this.client = options.client;
+		this.contextId = options.contextId;
+		this.configuration = options.configuration;
+		this.onError = options.onError;
+		this.onCancel = options.onCancel;
+		this.onArtifactComplete = options.onArtifactComplete;
+		this.history = options.history;
+	}
+	attachRuntime(runtime) {
+		this.runtime = runtime;
+	}
+	detachRuntime() {
+		this.runtime = void 0;
+		if (this.abortController) {
+			this.abortController.abort();
+			this.abortController = null;
+		}
+	}
+	getRuntime() {
+		return this.runtime;
+	}
+	getMessages() {
+		return this.messages;
+	}
+	getTask() {
+		return this.currentTask;
+	}
+	getArtifacts() {
+		return this.currentArtifacts;
+	}
+	getAgentCard() {
+		return this.agentCardValue;
+	}
+	isRunning() {
+		return this.isRunningFlag;
+	}
+	get isLoading() {
+		return this._isLoading;
+	}
+	__internal_load() {
+		if (this._loadPromise) return this._loadPromise;
+		this._isLoading = true;
+		const historyPromise = this.history?.load() ?? Promise.resolve(null);
+		const agentCardPromise = this.client.getAgentCard().catch(() => void 0);
+		this._loadPromise = Promise.all([historyPromise, agentCardPromise]).then(([repo, agentCard]) => {
+			if (agentCard) this.agentCardValue = agentCard;
+			if (repo) {
+				const messages = repo.messages.map((item) => item.message);
+				this.applyExternalMessages(messages);
+			}
+		}).catch((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 (message.sourceId) this.messages = this.messages.filter((entry) => entry.id !== message.sourceId);
+		this.resetHead(message.parentId);
+		const threadMessage = fromThreadMessageLike(message, generateId(), FALLBACK_USER_STATUS);
+		this.messages = [...this.messages, threadMessage];
+		this.notifyUpdate();
+		this.recordHistoryEntry(message.parentId ?? null, threadMessage);
+		if (!startRun) return;
+		await this.startRun(threadMessage);
+	}
+	async edit(message) {
+		await this.append(message);
+	}
+	async reload(parentId, _config = {}) {
+		this.resetHead(parentId);
+		this.notifyUpdate();
+		for (let i = this.messages.length - 1; i >= 0; i--) if (this.messages[i].role === "user") {
+			await this.startRun(this.messages[i]);
+			return;
+		}
+	}
+	async cancel() {
+		if (!this.abortController) return;
+		this.abortController.abort();
+		if (this.currentTask?.id) try {
+			const updated = await this.client.cancelTask(this.currentTask.id);
+			this.currentTask = updated;
+		} catch {}
+	}
+	applyExternalMessages(messages) {
+		this.assistantHistoryParents.clear();
+		this.messages = [...messages];
+		this.recordedHistoryIds.clear();
+		for (const message of this.messages) this.recordedHistoryIds.add(message.id);
+		this.currentTask = void 0;
+		this.currentArtifacts = [];
+		this.notifyUpdate();
+	}
+	async startRun(userThreadMessage) {
+		if (this.abortController) {
+			this.abortController.abort();
+			this.abortController = null;
+		}
+		const a2aMessage = this.threadMessageToA2AMessage(userThreadMessage);
+		if (this.currentTask && isTerminalTaskState(this.currentTask.status.state)) this.currentTask = void 0;
+		this.currentArtifacts = [];
+		const assistantParentId = userThreadMessage.id;
+		const assistantId = this.insertAssistantPlaceholder();
+		this.markPendingAssistantHistory(assistantId, assistantParentId);
+		const abortController = new AbortController();
+		this.abortController = abortController;
+		abortController.signal.addEventListener("abort", () => {
+			this.updateAssistantStatus(assistantId, {
+				type: "incomplete",
+				reason: "cancelled"
+			});
+			this.finishRun(abortController);
+			this.onCancel?.();
+		}, { once: true });
+		this.setRunning(true);
+		const supportsStreaming = this.agentCardValue?.capabilities?.streaming !== false;
+		try {
+			if (supportsStreaming) await this.runStreaming(a2aMessage, assistantId, abortController);
+			else await this.runSync(a2aMessage, assistantId, abortController);
+		} catch (error) {
+			if (!abortController.signal.aborted) {
+				const err = error instanceof Error ? error : new Error(String(error));
+				this.updateAssistantStatus(assistantId, {
+					type: "incomplete",
+					reason: "error"
+				});
+				this.onError?.(err);
+				this.pendingError = this.pendingError ?? err;
+			}
+		} finally {
+			this.finishRun(abortController);
+		}
+		if (this.pendingError) {
+			const err = this.pendingError;
+			this.pendingError = null;
+			throw err;
+		}
+	}
+	async runStreaming(a2aMessage, assistantId, abortController) {
+		const stream = this.client.streamMessage(a2aMessage, this.configuration, void 0, abortController.signal);
+		for await (const event of stream) {
+			if (abortController.signal.aborted) break;
+			this.handleStreamEvent(assistantId, event);
+		}
+		if (!abortController.signal.aborted) {
+			if (this.getAssistantStatus(assistantId)?.type === "running") this.updateAssistantStatus(assistantId, {
+				type: "complete",
+				reason: "stop"
+			});
+		}
+	}
+	async runSync(a2aMessage, assistantId, abortController) {
+		const result = await this.client.sendMessage(a2aMessage, this.configuration, void 0, abortController.signal);
+		if (abortController.signal.aborted) return;
+		if ("id" in result && "status" in result) this.handleTaskSnapshot(assistantId, result);
+		else if ("messageId" in result && "parts" in result) {
+			this.handleMessage(assistantId, result);
+			this.updateAssistantStatus(assistantId, {
+				type: "complete",
+				reason: "stop"
+			});
+		}
+	}
+	handleStreamEvent(assistantId, event) {
+		switch (event.type) {
+			case "statusUpdate":
+				this.handleStatusUpdate(assistantId, event.event);
+				break;
+			case "artifactUpdate":
+				this.handleArtifactUpdate(event.event);
+				break;
+			case "message":
+				this.handleMessage(assistantId, event.message);
+				break;
+			case "task":
+				this.handleTaskSnapshot(assistantId, event.task);
+				break;
+		}
+	}
+	handleStatusUpdate(assistantId, event) {
+		if (!this.currentTask) this.currentTask = {
+			id: event.taskId,
+			contextId: event.contextId,
+			status: event.status
+		};
+		else this.currentTask = {
+			...this.currentTask,
+			status: event.status
+		};
+		if (event.contextId) this.contextId = event.contextId;
+		if (event.status.message) {
+			const content = a2aMessageToContent(event.status.message);
+			this.updateAssistantContent(assistantId, content);
+		}
+		const status = taskStateToMessageStatus(event.status.state);
+		this.updateAssistantStatus(assistantId, status);
+		this.notifyUpdate();
+	}
+	handleArtifactUpdate(event) {
+		const { artifact, append, lastChunk } = event;
+		const existingIdx = this.currentArtifacts.findIndex((a) => a.artifactId === artifact.artifactId);
+		let updated;
+		if (existingIdx >= 0 && append) {
+			const existing = this.currentArtifacts[existingIdx];
+			updated = {
+				...existing,
+				parts: [...existing.parts, ...artifact.parts]
+			};
+			this.currentArtifacts = [
+				...this.currentArtifacts.slice(0, existingIdx),
+				updated,
+				...this.currentArtifacts.slice(existingIdx + 1)
+			];
+		} else if (existingIdx >= 0) {
+			updated = artifact;
+			this.currentArtifacts = [
+				...this.currentArtifacts.slice(0, existingIdx),
+				updated,
+				...this.currentArtifacts.slice(existingIdx + 1)
+			];
+		} else {
+			updated = artifact;
+			this.currentArtifacts = [...this.currentArtifacts, updated];
+		}
+		if (lastChunk) this.onArtifactComplete?.(updated);
+		this.notifyUpdate();
+	}
+	handleMessage(assistantId, message) {
+		if (message.role !== "agent") return;
+		const content = a2aMessageToContent(message);
+		this.updateAssistantContent(assistantId, content);
+		this.notifyUpdate();
+	}
+	handleTaskSnapshot(assistantId, task) {
+		this.currentTask = task;
+		if (task.contextId) this.contextId = task.contextId;
+		if (task.artifacts) this.currentArtifacts = task.artifacts;
+		if (task.status.message) {
+			const content = a2aMessageToContent(task.status.message);
+			this.updateAssistantContent(assistantId, content);
+		}
+		const status = taskStateToMessageStatus(task.status.state);
+		this.updateAssistantStatus(assistantId, status);
+		this.notifyUpdate();
+	}
+	threadMessageToA2AMessage(message) {
+		const parts = [];
+		if (message.role === "user") {
+			for (const part of message.content) if (part.type === "text") parts.push({ text: part.text });
+			else if (part.type === "image") parts.push({
+				url: part.image,
+				mediaType: "image/*"
+			});
+		}
+		const a2aMsg = {
+			messageId: message.id,
+			role: "user",
+			parts
+		};
+		if (this.contextId) a2aMsg.contextId = this.contextId;
+		if (this.currentTask?.id && !isTerminalTaskState(this.currentTask.status.state)) a2aMsg.taskId = this.currentTask.id;
+		return a2aMsg;
+	}
+	insertAssistantPlaceholder() {
+		const id = generateId();
+		const assistant = {
+			id,
+			role: "assistant",
+			createdAt: /* @__PURE__ */ new Date(),
+			status: { type: "running" },
+			content: [],
+			metadata: {
+				unstable_state: null,
+				unstable_annotations: [],
+				unstable_data: [],
+				steps: [],
+				custom: {}
+			}
+		};
+		this.messages = [...this.messages, assistant];
+		this.notifyUpdate();
+		return id;
+	}
+	updateAssistantContent(messageId, content) {
+		this.messages = this.messages.map((message) => {
+			if (message.id !== messageId || message.role !== "assistant") return message;
+			return {
+				...message,
+				content
+			};
+		});
+	}
+	updateAssistantStatus(messageId, status) {
+		let touched = false;
+		this.messages = this.messages.map((message) => {
+			if (message.id !== messageId || message.role !== "assistant") return message;
+			touched = true;
+			return {
+				...message,
+				status
+			};
+		});
+		if (touched) {
+			this.notifyUpdate();
+			if (status.type === "complete" || status.type === "incomplete") this.persistAssistantHistory(messageId);
+		}
+	}
+	getAssistantStatus(messageId) {
+		return this.messages.find((m) => m.id === messageId && m.role === "assistant")?.status;
+	}
+	setRunning(running) {
+		this.isRunningFlag = running;
+		this.notifyUpdate();
+	}
+	finishRun(controller) {
+		if (this.abortController === controller) this.abortController = null;
+		this.setRunning(false);
+	}
+	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);
+	}
+	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 (message.status?.type !== "complete" && message.status?.type !== "incomplete") 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(() => {
+			this.recordedHistoryIds.delete(message.id);
+		});
+	}
+};
+//#endregion
+export { A2AThreadRuntimeCore };
+
 //# sourceMappingURL=A2AThreadRuntimeCore.js.map