@better-agent/client 0.1.0-canary.6 → 0.2.0-beta.2

package/dist/controller-xMlzSCc7.mjs

@@ -0,0 +1,1342 @@
+import { EventType, RuntimeInterruptReason } from "@better-agent/core";
+import { createRuntimeStateControl } from "@better-agent/core/runtime";
+
+//#region src/core/errors.ts
+var BetterAgentClientError = class extends Error {
+	status;
+	code;
+	details;
+	constructor(message, options = {}) {
+		super(message, { cause: options.cause });
+		this.name = "BetterAgentClientError";
+		this.status = options.status;
+		this.code = options.code;
+		this.details = options.details;
+	}
+};
+const toBetterAgentClientError = (error) => {
+	if (error instanceof BetterAgentClientError) return error;
+	if (error instanceof Error) return new BetterAgentClientError(error.message, { cause: error });
+	return new BetterAgentClientError("An unknown error occurred.", { cause: error });
+};
+
+//#endregion
+//#region src/ui/helpers.ts
+const toMessageRole = (role) => {
+	switch (role) {
+		case "user": return "user";
+		case "system": return "system";
+		case "developer": return "system";
+		default: return "assistant";
+	}
+};
+const sourceToUrl = (source) => {
+	if (source.type === "data") return `data:${source.mimeType ?? "application/octet-stream"};base64,${source.value}`;
+	return source.value;
+};
+const urlToSource = (url, mimeType) => {
+	const match = /^data:([^;,]+)?;base64,(.*)$/.exec(url);
+	if (match) return {
+		type: "data",
+		value: match[2] ?? "",
+		mimeType: mimeType ?? match[1] ?? "application/octet-stream"
+	};
+	return {
+		type: "url",
+		value: url,
+		...mimeType ? { mimeType } : {}
+	};
+};
+const contentToParts = (content) => {
+	if (typeof content === "string") return [{
+		type: "text",
+		text: content
+	}];
+	if (!Array.isArray(content)) return [];
+	return content.flatMap((part) => {
+		if (part.type === "text") return [{
+			type: "text",
+			text: part.text
+		}];
+		if (part.type === "image" || part.type === "audio" || part.type === "video") return [{
+			type: part.type,
+			url: sourceToUrl(part.source),
+			mimeType: part.source.mimeType
+		}];
+		return [];
+	});
+};
+const partsToContent = (parts) => {
+	const content = [];
+	for (const part of parts) {
+		if (part.type === "text") {
+			if (part.text) content.push({
+				type: "text",
+				text: part.text
+			});
+			continue;
+		}
+		if (part.type === "image" || part.type === "audio" || part.type === "video") {
+			content.push({
+				type: part.type,
+				source: urlToSource(part.url, part.mimeType)
+			});
+			continue;
+		}
+		if (part.type === "file") content.push({
+			type: "document",
+			source: urlToSource(part.url, part.mimeType)
+		});
+	}
+	if (content.length === 1 && content[0]?.type === "text") return content[0].text;
+	return content;
+};
+const contentToText = (content) => {
+	if (typeof content === "string") return content;
+	return content.filter((part) => part.type === "text").map((part) => part.text).join("");
+};
+
+//#endregion
+//#region src/ui/convert.ts
+const isAgentMessageContent = (content) => {
+	return content === void 0 || typeof content === "string" || Array.isArray(content);
+};
+const fromAgentMessages = (messages) => {
+	const parseToolInput = (input) => {
+		try {
+			return JSON.parse(input);
+		} catch {
+			return;
+		}
+	};
+	const parseToolContent = (content) => {
+		try {
+			return JSON.parse(content);
+		} catch {
+			return content;
+		}
+	};
+	const toolResults = /* @__PURE__ */ new Map();
+	for (const message of messages) if (message.role === "tool") toolResults.set(message.toolCallId, {
+		content: message.content,
+		error: message.error,
+		status: message.status,
+		approval: message.approval
+	});
+	const uiMessages = [];
+	let pendingReasoning = [];
+	for (const message of messages) {
+		const parts = isAgentMessageContent(message.content) ? contentToParts(message.content) : [];
+		if (message.role === "reasoning") {
+			if (typeof message.content === "string") pendingReasoning = [...pendingReasoning, {
+				id: message.id,
+				part: {
+					type: "reasoning",
+					text: message.content
+				}
+			}];
+			continue;
+		}
+		if (message.role === "assistant") {
+			const assistantParts = [...pendingReasoning.map((reasoning) => reasoning.part), ...parts];
+			pendingReasoning = [];
+			if (Array.isArray(message.toolCalls)) for (const toolCall of message.toolCalls) {
+				const result = toolResults.get(toolCall.id);
+				const toolPart = {
+					inputText: toolCall.function.arguments,
+					input: parseToolInput(toolCall.function.arguments),
+					toolCallId: toolCall.id,
+					toolName: toolCall.function.name,
+					type: "tool-call",
+					...toolCall.providerExecuted ? { providerExecuted: true } : {},
+					state: "input-available",
+					...result?.approval ? {
+						approval: {
+							interruptId: `${toolCall.id}:approval`,
+							needsApproval: true,
+							approved: result.approval.approved,
+							...result.approval.metadata ? { metadata: result.approval.metadata } : {}
+						},
+						state: "approval-responded"
+					} : {}
+				};
+				assistantParts.push(toolPart);
+				if (result) {
+					const deniedResult = result.content.length > 0 ? (() => {
+						const parsed = parseToolContent(result.content);
+						return typeof parsed === "string" ? parsed : void 0;
+					})() : void 0;
+					const resultPart = result.status === "denied" ? {
+						type: "tool-result",
+						toolCallId: toolCall.id,
+						state: "output-denied",
+						result: deniedResult
+					} : result.status === "error" || result.error ? {
+						type: "tool-result",
+						toolCallId: toolCall.id,
+						state: "output-error",
+						error: result.error ?? result.content
+					} : {
+						type: "tool-result",
+						toolCallId: toolCall.id,
+						state: "output-available",
+						result: parseToolContent(result.content)
+					};
+					assistantParts.push(resultPart);
+				}
+			}
+			for (const source of message.sources ?? []) assistantParts.push({
+				type: "source",
+				sourceId: source.id,
+				sourceType: "url",
+				url: source.url,
+				...source.title ? { title: source.title } : {}
+			});
+			uiMessages.push({
+				id: message.id,
+				role: message.role,
+				parts: assistantParts
+			});
+			continue;
+		}
+		if (message.role === "user" || message.role === "system" || message.role === "developer") uiMessages.push({
+			id: message.id,
+			role: toMessageRole(message.role),
+			parts
+		});
+	}
+	if (pendingReasoning.length > 0) for (const reasoning of pendingReasoning) uiMessages.push({
+		id: reasoning.id,
+		role: "assistant",
+		parts: [reasoning.part]
+	});
+	return uiMessages;
+};
+const toAgentMessages = (messages) => {
+	return messages.map((message) => {
+		const content = partsToContent(message.parts);
+		if (message.role === "assistant") {
+			const toolCalls = message.parts.filter((part) => part.type === "tool-call").map((part) => ({
+				id: part.toolCallId,
+				type: "function",
+				function: {
+					name: part.toolName,
+					arguments: part.inputText
+				},
+				...part.providerExecuted ? { providerExecuted: true } : {}
+			}));
+			return {
+				id: message.id,
+				role: "assistant",
+				content,
+				...toolCalls.length > 0 ? { toolCalls } : {}
+			};
+		}
+		if (message.role === "system") return {
+			id: message.id,
+			role: "system",
+			content: contentToText(content)
+		};
+		return {
+			id: message.id,
+			role: "user",
+			content
+		};
+	});
+};
+
+//#endregion
+//#region src/ui/messages.ts
+const createMessageId = () => {
+	const webCrypto = globalThis.crypto;
+	if (typeof webCrypto?.randomUUID === "function") return `msg_${webCrypto.randomUUID()}`;
+	if (typeof webCrypto?.getRandomValues === "function") {
+		const bytes = webCrypto.getRandomValues(new Uint8Array(16));
+		return `msg_${Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("")}`;
+	}
+	return `msg_${Date.now().toString(36)}_${Math.random().toString(36).slice(2)}`;
+};
+const createUserUIMessage = (content) => ({
+	id: createMessageId(),
+	role: "user",
+	parts: [{
+		type: "text",
+		text: content
+	}]
+});
+
+//#endregion
+//#region src/ui/reducer.ts
+const updateMessage = (messages, messageId, update) => {
+	return messages.map((message) => message.id === messageId ? update(message) : message);
+};
+const upsertMessage = (messages, message, update) => {
+	return messages.some((current) => current.id === message.id) ? updateMessage(messages, message.id, update) : [...messages, update(message)];
+};
+const updateToolPart = (messages, toolCallId, update) => {
+	return messages.map((message) => ({
+		...message,
+		parts: message.parts.map((part) => part.type === "tool-call" && part.toolCallId === toolCallId ? update(part) : part)
+	}));
+};
+const upsertToolResultPartByToolCallId = (messages, toolCallId, update) => {
+	return messages.map((message) => {
+		const existingResultIndex = message.parts.findIndex((part) => part.type === "tool-result" && part.toolCallId === toolCallId);
+		if (existingResultIndex !== -1) return {
+			...message,
+			parts: message.parts.map((part, index) => index === existingResultIndex && part.type === "tool-result" ? update(part) : part)
+		};
+		const toolCallIndex = message.parts.findIndex((part) => part.type === "tool-call" && part.toolCallId === toolCallId);
+		if (toolCallIndex === -1) return message;
+		const parts = [...message.parts];
+		parts.splice(toolCallIndex + 1, 0, update({
+			type: "tool-result",
+			toolCallId,
+			state: "output-available"
+		}));
+		return {
+			...message,
+			parts
+		};
+	});
+};
+const upsertSourcePart = (messages, messageId, part) => {
+	return upsertMessage(messages, {
+		id: messageId,
+		role: "assistant",
+		parts: []
+	}, (message) => {
+		return message.parts.some((current) => current.type === "source" && current.sourceId === part.sourceId) ? message : {
+			...message,
+			parts: [...message.parts, part]
+		};
+	});
+};
+const parseToolContent = (content) => {
+	if (!content.trim()) return "";
+	try {
+		return JSON.parse(content);
+	} catch {
+		return content;
+	}
+};
+const createUIReducerState = (messages = []) => {
+	return { messages };
+};
+const applyUIEvent = (state, event) => {
+	if (event.type === EventType.RUN_STARTED) {
+		const messages = event.input?.messages?.filter((message) => message.role !== "system");
+		if (!messages || messages.length === 0) return state;
+		return {
+			...state,
+			messages: fromAgentMessages(messages)
+		};
+	}
+	if (event.type === EventType.TEXT_MESSAGE_START) {
+		if (state.messages.some((message) => message.id === event.messageId)) return state;
+		return {
+			...state,
+			messages: [...state.messages, {
+				id: event.messageId,
+				role: toMessageRole(event.role),
+				parts: []
+			}]
+		};
+	}
+	if (event.type === EventType.TEXT_MESSAGE_CONTENT) {
+		const messageIndex = state.messages.findIndex((message) => message.id === event.messageId);
+		const targetMessage = messageIndex === -1 ? {
+			id: event.messageId,
+			role: "assistant",
+			parts: []
+		} : state.messages[messageIndex];
+		const parts = [...targetMessage.parts];
+		const lastPart = parts[parts.length - 1];
+		if (lastPart?.type === "text") parts[parts.length - 1] = {
+			...lastPart,
+			text: lastPart.text + event.delta
+		};
+		else parts.push({
+			type: "text",
+			text: event.delta
+		});
+		const nextMessage = {
+			...targetMessage,
+			parts
+		};
+		return {
+			...state,
+			messages: messageIndex === -1 ? [...state.messages, nextMessage] : state.messages.map((message, index) => index === messageIndex ? nextMessage : message)
+		};
+	}
+	if (event.type === EventType.REASONING_MESSAGE_START) {
+		if (state.messages.some((message) => message.id === event.messageId)) return state;
+		return {
+			...state,
+			messages: [...state.messages, {
+				id: event.messageId,
+				role: "assistant",
+				parts: []
+			}]
+		};
+	}
+	if (event.type === EventType.REASONING_MESSAGE_CONTENT) {
+		const messageIndex = state.messages.findIndex((message) => message.id === event.messageId);
+		const targetMessage = messageIndex === -1 ? {
+			id: event.messageId,
+			role: "assistant",
+			parts: []
+		} : state.messages[messageIndex];
+		const parts = [...targetMessage.parts];
+		const lastPart = parts[parts.length - 1];
+		if (lastPart?.type === "reasoning") parts[parts.length - 1] = {
+			...lastPart,
+			text: lastPart.text + event.delta
+		};
+		else parts.push({
+			type: "reasoning",
+			text: event.delta
+		});
+		const nextMessage = {
+			...targetMessage,
+			parts
+		};
+		return {
+			...state,
+			messages: messageIndex === -1 ? [...state.messages, nextMessage] : state.messages.map((message, index) => index === messageIndex ? nextMessage : message)
+		};
+	}
+	if (event.type === EventType.REASONING_MESSAGE_END) return state;
+	if (event.type === EventType.MESSAGES_SNAPSHOT) return {
+		...state,
+		messages: fromAgentMessages(event.messages)
+	};
+	if (event.type === EventType.CUSTOM && event.name === "source" && event.value) {
+		const value = event.value;
+		return {
+			...state,
+			messages: upsertSourcePart(state.messages, value.messageId, {
+				type: "source",
+				sourceId: value.source.id,
+				sourceType: "url",
+				url: value.source.url,
+				...value.source.title ? { title: value.source.title } : {}
+			})
+		};
+	}
+	if (event.type === EventType.TOOL_CALL_START) {
+		if (!event.parentMessageId) return state;
+		if (state.messages.some((message) => message.parts.some((part) => part.type === "tool-call" && part.toolCallId === event.toolCallId))) return state;
+		return {
+			...state,
+			messages: upsertMessage(state.messages, {
+				id: event.parentMessageId,
+				role: "assistant",
+				parts: []
+			}, (message) => ({
+				...message,
+				parts: [...message.parts, {
+					type: "tool-call",
+					state: "input-streaming",
+					toolCallId: event.toolCallId,
+					toolName: event.toolCallName,
+					inputText: "",
+					...event.providerExecuted !== void 0 ? { providerExecuted: event.providerExecuted } : {}
+				}]
+			}))
+		};
+	}
+	if (event.type === EventType.TOOL_CALL_ARGS) return {
+		...state,
+		messages: updateToolPart(state.messages, event.toolCallId, (part) => ({
+			...part,
+			inputText: part.inputText.length === 0 ? event.delta : event.delta.startsWith(part.inputText) ? event.delta : part.inputText.endsWith(event.delta) ? part.inputText : part.inputText + event.delta
+		}))
+	};
+	if (event.type === EventType.TOOL_CALL_CHUNK) {
+		if (!event.toolCallId || !event.input || typeof event.input !== "string") return state;
+		return {
+			...state,
+			messages: updateToolPart(state.messages, event.toolCallId, (part) => ({
+				...part,
+				inputText: part.inputText.length === 0 ? event.input : event.input.startsWith(part.inputText) ? event.input : part.inputText.startsWith(event.input) ? part.inputText : event.input
+			}))
+		};
+	}
+	if (event.type === EventType.TOOL_CALL_END) return {
+		...state,
+		messages: updateToolPart(state.messages, event.toolCallId, (part) => ({
+			...part,
+			state: "input-available",
+			input: typeof part.inputText === "string" && part.inputText.length > 0 ? (() => {
+				try {
+					return JSON.parse(part.inputText);
+				} catch {
+					return part.input;
+				}
+			})() : part.input
+		}))
+	};
+	if (event.type === EventType.TOOL_CALL_RESULT) {
+		const status = "status" in event ? event.status : void 0;
+		const parsedContent = parseToolContent(event.content);
+		const deniedResult = status === "denied" && typeof parsedContent !== "string" ? void 0 : parsedContent;
+		return {
+			...state,
+			messages: upsertToolResultPartByToolCallId(state.messages, event.toolCallId, (part) => ({
+				...part,
+				state: status === "denied" ? "output-denied" : status === "error" ? "output-error" : "output-available",
+				...status === "error" ? {
+					error: event.content,
+					result: void 0
+				} : {
+					result: deniedResult,
+					error: void 0
+				}
+			}))
+		};
+	}
+	return { ...state };
+};
+
+//#endregion
+//#region src/core/browser-lifecycle.ts
+const markPageTeardown = () => {
+	if (typeof window !== "undefined") window.__baPageTeardown = true;
+};
+const ensureBrowserTeardownTracking = () => {
+	if (typeof window === "undefined") return;
+	window.__baPageTeardown ??= false;
+	if (window.__baPageTeardownInstalled) return;
+	window.__baPageTeardownInstalled = true;
+	window.addEventListener("pagehide", markPageTeardown);
+	window.addEventListener("beforeunload", markPageTeardown);
+};
+const isBrowserPageTearingDown = () => typeof window !== "undefined" && window.__baPageTeardown === true;
+
+//#endregion
+//#region src/core/controller.ts
+var AgentController = class {
+	messages;
+	stateControl;
+	status = "ready";
+	error;
+	runId;
+	threadId;
+	pendingClientTools = [];
+	pendingToolApprovals = [];
+	stateRevision = 0;
+	snapshot;
+	listeners = /* @__PURE__ */ new Set();
+	activeAbortController;
+	finishMessageStartIndex = 0;
+	stopRequested = false;
+	stopWaitTimer;
+	abortRequestedRunId;
+	started = false;
+	constructor(agent, options) {
+		this.agent = agent;
+		this.options = options;
+		ensureBrowserTeardownTracking();
+		this.messages = options.initialMessages ?? [];
+		this.stateControl = createRuntimeStateControl(options.initialState);
+		this.threadId = options.threadId;
+		this.runId = options.initialInterruptState?.runId;
+		this.pendingClientTools = [...options.initialInterruptState?.pendingClientTools ?? []];
+		this.pendingToolApprovals = [...options.initialInterruptState?.pendingToolApprovals ?? []];
+		this.status = options.initialInterruptState?.status ?? (this.pendingClientTools.length > 0 || this.pendingToolApprovals.length > 0 ? "interrupted" : "ready");
+		for (const approval of this.pendingToolApprovals) this.updateToolCallPart(approval.toolCallId, {
+			state: "approval-requested",
+			approval: {
+				interruptId: approval.interruptId,
+				needsApproval: true,
+				...approval.metadata ? { metadata: approval.metadata } : {}
+			}
+		});
+		this.snapshot = this.createSnapshot();
+	}
+	start() {
+		if (this.started) return;
+		this.started = true;
+		const shouldAutoHydrateThread = this.threadId && this.options.initialMessages === void 0 && "memory" in this.agent;
+		if (this.options.resume) (async () => {
+			try {
+				if (shouldAutoHydrateThread) await this.loadMessages(this.threadId, { beforeRunId: this.options.resume?.runId });
+				await this.resume(this.options.resume);
+			} catch {}
+		})();
+		else if (this.pendingClientTools.length > 0 && !this.hasUndecidedApprovals()) this.runPendingInterruptsWithLifecycle();
+		else if (shouldAutoHydrateThread && this.threadId) this.loadThread(this.threadId).catch(() => {});
+	}
+	getSnapshot() {
+		return this.snapshot;
+	}
+	createSnapshot() {
+		return {
+			messages: this.messages,
+			state: this.stateControl.get(),
+			status: this.status,
+			error: this.error,
+			runId: this.runId,
+			threadId: this.threadId,
+			isRunning: this.status === "submitted" || this.status === "streaming",
+			pendingClientTools: this.pendingClientTools,
+			pendingToolApprovals: this.getPendingToolApprovalsSnapshot()
+		};
+	}
+	getPendingToolApprovalsSnapshot() {
+		return this.pendingToolApprovals.filter((approval) => approval.approved === void 0);
+	}
+	isClientToolInterrupt(interrupt) {
+		return Boolean(interrupt?.reason === RuntimeInterruptReason.ClientToolPending && interrupt.toolCallId);
+	}
+	isApprovalInterrupt(interrupt) {
+		return Boolean(interrupt?.reason === RuntimeInterruptReason.ToolApprovalPending && interrupt.toolCallId);
+	}
+	getToolCallPart(toolCallId) {
+		for (const message of this.messages) {
+			const part = message.parts.find((candidate) => candidate.type === "tool-call" && candidate.toolCallId === toolCallId);
+			if (part) return part;
+		}
+	}
+	combineAbortSignals(primary, secondary) {
+		if (!secondary) return primary;
+		return AbortSignal.any([primary, secondary]);
+	}
+	hasUndecidedApprovals() {
+		return this.pendingToolApprovals.some((approval) => approval.approved === void 0);
+	}
+	subscribe(listener) {
+		this.listeners.add(listener);
+		return () => {
+			this.listeners.delete(listener);
+		};
+	}
+	setMessages(messages) {
+		this.messages = messages;
+		this.notify();
+	}
+	async loadMessages(threadId = this.threadId, options) {
+		if (!threadId) throw new BetterAgentClientError("Cannot load messages without a threadId.");
+		const memory = "memory" in this.agent ? this.agent.memory : void 0;
+		if (!memory) throw new BetterAgentClientError("Agent memory is not available.");
+		try {
+			const messages = await memory.messages.list(threadId, options);
+			this.threadId = threadId;
+			this.messages = fromAgentMessages(messages.map((message) => {
+				const { threadId: _threadId, runId: _runId, createdAt: _createdAt, ...rest } = message;
+				return rest;
+			}));
+			for (const approval of this.pendingToolApprovals) this.updateToolCallPart(approval.toolCallId, {
+				state: "approval-requested",
+				approval: {
+					interruptId: approval.interruptId,
+					needsApproval: true,
+					...approval.metadata ? { metadata: approval.metadata } : {}
+				}
+			});
+			this.error = void 0;
+			this.notify();
+		} catch (error) {
+			this.error = toBetterAgentClientError(error);
+			this.status = "error";
+			this.notify();
+			throw this.error;
+		}
+	}
+	async loadThread(threadId) {
+		const memory = "memory" in this.agent ? this.agent.memory : void 0;
+		if (!memory) throw new BetterAgentClientError("Agent memory is not available.");
+		const runtime = await memory.threads.runtime(threadId);
+		if (runtime.resumable) {
+			await this.loadMessages(threadId, { beforeRunId: runtime.resumable.runId });
+			await this.resume(runtime.resumable);
+			return;
+		}
+		await this.loadMessages(threadId);
+		if (runtime.interrupted) {
+			this.hydrateInterrupts(runtime.interrupted.runId, runtime.interrupted.interrupts);
+			if (this.pendingClientTools.length > 0 && !this.hasUndecidedApprovals()) await this.runPendingInterruptsWithLifecycle();
+		}
+	}
+	hydrateInterrupts(runId, interrupts) {
+		const approvalInterrupts = interrupts.filter((interrupt) => this.isApprovalInterrupt(interrupt));
+		const clientToolInterrupts = interrupts.filter((interrupt) => this.isClientToolInterrupt(interrupt));
+		const approvals = [];
+		for (const interrupt of approvalInterrupts) {
+			const pending = this.createPendingApproval(runId, interrupt);
+			if ("isError" in pending) return;
+			approvals.push(pending);
+			this.updateToolCallPart(interrupt.toolCallId, {
+				state: "approval-requested",
+				approval: {
+					interruptId: interrupt.id,
+					needsApproval: true,
+					...interrupt.metadata ? { metadata: interrupt.metadata } : {}
+				}
+			});
+		}
+		const clientTools = [];
+		for (const interrupt of clientToolInterrupts) {
+			const pending = this.createPendingClientTool(runId, interrupt);
+			if ("isError" in pending) return;
+			clientTools.push(pending);
+		}
+		this.runId = runId;
+		this.pendingToolApprovals = approvals;
+		this.pendingClientTools = clientTools;
+		this.status = "interrupted";
+		this.error = void 0;
+		this.notify();
+	}
+	async selectThread(threadId) {
+		this.stop();
+		await this.loadThread(threadId);
+	}
+	clearThread() {
+		this.stop();
+		this.messages = [];
+		this.threadId = void 0;
+		this.runId = void 0;
+		this.error = void 0;
+		this.pendingClientTools = [];
+		this.pendingToolApprovals = [];
+		this.status = "ready";
+		this.notify();
+	}
+	clearStopWaitTimer() {
+		if (this.stopWaitTimer) {
+			clearTimeout(this.stopWaitTimer);
+			this.stopWaitTimer = void 0;
+		}
+	}
+	resetStopRequest() {
+		this.stopRequested = false;
+		this.abortRequestedRunId = void 0;
+		this.clearStopWaitTimer();
+	}
+	abortServerRun(runId) {
+		if (this.abortRequestedRunId === runId) return;
+		this.abortRequestedRunId = runId;
+		this.agent.runs.abort(runId).catch((error) => {
+			console.error("[better-agent] abortRun failed", error);
+		});
+	}
+	abortActiveRequest() {
+		this.activeAbortController?.abort();
+		this.activeAbortController = void 0;
+	}
+	stop() {
+		this.stopRequested = true;
+		const runId = this.runId;
+		if (runId) {
+			this.clearStopWaitTimer();
+			this.abortServerRun(runId);
+			this.abortActiveRequest();
+		} else if (this.activeAbortController && !this.stopWaitTimer) {
+			const activeAbortController = this.activeAbortController;
+			this.stopWaitTimer = setTimeout(() => {
+				if (this.stopRequested && this.activeAbortController === activeAbortController) this.abortActiveRequest();
+				this.clearStopWaitTimer();
+			}, 2e3);
+		}
+		if (this.status !== "ready") {
+			this.status = "ready";
+			this.notify();
+		}
+	}
+	safeLifecycle(name, fn) {
+		try {
+			const result = fn();
+			if (result !== void 0 && typeof result === "object" && "then" in result && typeof result.then === "function") result.catch((err) => {
+				console.error(`[better-agent] ${name} callback failed`, err);
+			});
+		} catch (err) {
+			console.error(`[better-agent] ${name} callback failed`, err);
+		}
+	}
+	emitEvent(hooks, event) {
+		const onEvent = hooks.onEvent;
+		if (!onEvent) return;
+		this.safeLifecycle("onEvent", () => onEvent(event));
+	}
+	invokeLifecycleFinish(hooks, finish) {
+		this.safeLifecycle("onFinish", () => hooks.onFinish?.(finish));
+		const error = finish.error;
+		if (finish.isError && error) {
+			const onError = hooks.onError;
+			if (onError) this.safeLifecycle("onError", () => onError(error));
+		}
+	}
+	createFinish(finish) {
+		const messages = [...this.messages];
+		const generatedMessages = messages.slice(this.finishMessageStartIndex);
+		const message = generatedMessages[generatedMessages.length - 1];
+		return {
+			...message ? { message } : {},
+			generatedMessages,
+			messages,
+			runId: this.runId,
+			threadId: this.threadId,
+			pendingClientTools: finish.pendingClientTools ?? [...this.pendingClientTools],
+			pendingToolApprovals: finish.pendingToolApprovals ?? this.getPendingToolApprovalsSnapshot(),
+			...finish
+		};
+	}
+	async sendMessage(input, sendOptions) {
+		const hooks = {
+			onEvent: this.options.onEvent,
+			onFinish: this.options.onFinish,
+			onError: this.options.onError
+		};
+		let terminal;
+		this.stop();
+		this.resetStopRequest();
+		this.error = void 0;
+		this.pendingClientTools = [];
+		this.pendingToolApprovals = [];
+		this.status = "submitted";
+		const inputMessages = typeof input === "string" ? [createUserUIMessage(input)] : input;
+		this.messages = [...this.messages, ...inputMessages];
+		this.finishMessageStartIndex = this.messages.length;
+		this.notify();
+		const abortController = new AbortController();
+		this.activeAbortController = abortController;
+		const streamSignal = this.combineAbortSignals(abortController.signal, sendOptions?.signal ?? null);
+		const context = sendOptions?.context ?? this.options.context;
+		try {
+			const stream = this.agent.stream({
+				messages: toAgentMessages(this.threadId ? inputMessages : this.messages).map(({ id: _id, ...message }) => message),
+				...context !== void 0 ? { context } : {},
+				...this.stateControl.get() !== void 0 ? { state: this.stateControl.get() } : {},
+				...this.threadId !== void 0 ? { threadId: this.threadId } : {}
+			}, { signal: streamSignal });
+			terminal = await this.consumeStream(stream, hooks, streamSignal);
+		} catch (error) {
+			if (streamSignal.aborted || isBrowserPageTearingDown()) {
+				this.status = "ready";
+				this.notify();
+				terminal = this.createFinish({
+					isAbort: true,
+					isDisconnect: false,
+					isError: false,
+					isInterrupted: false
+				});
+			} else {
+				this.error = toBetterAgentClientError(error);
+				this.status = "error";
+				this.notify();
+				terminal = this.createFinish({
+					isAbort: false,
+					isDisconnect: false,
+					isError: true,
+					isInterrupted: false,
+					error: this.error
+				});
+			}
+		} finally {
+			if (this.activeAbortController === abortController) this.activeAbortController = void 0;
+			if (terminal !== void 0) this.invokeLifecycleFinish(hooks, terminal);
+		}
+	}
+	async approveToolCall(interruptId, metadata) {
+		await this.resolveApprovalDecision(interruptId, true, metadata);
+	}
+	async rejectToolCall(interruptId, metadata) {
+		await this.resolveApprovalDecision(interruptId, false, metadata);
+	}
+	async resume(resume) {
+		const nextResume = resume ?? (this.runId ? { runId: this.runId } : void 0);
+		if (!nextResume) throw new BetterAgentClientError("Cannot resume without a runId.");
+		const hooks = {
+			onEvent: this.options.onEvent,
+			onFinish: this.options.onFinish,
+			onError: this.options.onError
+		};
+		const abortController = new AbortController();
+		this.resetStopRequest();
+		this.activeAbortController?.abort();
+		this.activeAbortController = abortController;
+		this.runId = nextResume.runId;
+		this.status = "streaming";
+		this.finishMessageStartIndex = this.messages.length;
+		this.notify();
+		let terminal;
+		try {
+			const stream = this.agent.runs.resumeStream({
+				runId: nextResume.runId,
+				afterSequence: nextResume.afterSequence
+			}, { signal: abortController.signal });
+			terminal = await this.consumeStream(stream, hooks, abortController.signal);
+		} catch (error) {
+			if (abortController.signal.aborted || isBrowserPageTearingDown()) {
+				this.status = "ready";
+				this.notify();
+				terminal = this.createFinish({
+					isAbort: true,
+					isDisconnect: false,
+					isError: false,
+					isInterrupted: false
+				});
+			} else {
+				this.error = toBetterAgentClientError(error);
+				this.status = "error";
+				this.notify();
+				terminal = this.createFinish({
+					isAbort: false,
+					isDisconnect: false,
+					isError: true,
+					isInterrupted: false,
+					error: this.error
+				});
+			}
+		} finally {
+			if (this.activeAbortController === abortController) this.activeAbortController = void 0;
+			if (terminal !== void 0) this.invokeLifecycleFinish(hooks, terminal);
+		}
+	}
+	async consumeStream(stream, hooks, signal, beforeSuccessFinish) {
+		for await (const event of stream) {
+			if (signal.aborted) break;
+			const terminal = await this.processStreamEvent(event, hooks, signal);
+			if (terminal) return terminal;
+		}
+		if (signal.aborted) return this.createFinish({
+			isAbort: true,
+			isDisconnect: false,
+			isError: false,
+			isInterrupted: false
+		});
+		beforeSuccessFinish?.();
+		this.status = "ready";
+		this.notify();
+		return this.createFinish({
+			isAbort: false,
+			isDisconnect: false,
+			isError: false,
+			isInterrupted: false
+		});
+	}
+	async processStreamEvent(event, hooks, signal) {
+		if (event.type === EventType.RUN_ERROR) {
+			this.error = new BetterAgentClientError("message" in event && typeof event.message === "string" ? event.message : "Run failed.", {
+				code: "code" in event && typeof event.code === "string" ? event.code : void 0,
+				details: event
+			});
+			this.status = "error";
+			this.notify();
+			this.emitEvent(hooks, event);
+			return this.createFinish({
+				isAbort: false,
+				isDisconnect: false,
+				isError: true,
+				isInterrupted: false,
+				error: this.error
+			});
+		}
+		if (event.type === EventType.RUN_FINISHED && event.outcome === "interrupt") {
+			this.applyEvent(event);
+			this.notify();
+			this.emitEvent(hooks, event);
+			const interrupts = event.interrupts ?? [];
+			const runId = event.runId ?? this.runId;
+			if (!runId && interrupts.length > 0) {
+				this.error = new BetterAgentClientError("Interrupt missing runId.");
+				this.status = "error";
+				this.notify();
+				return this.createFinish({
+					isAbort: false,
+					isDisconnect: false,
+					isError: true,
+					isInterrupted: false,
+					error: this.error
+				});
+			}
+			if (runId && interrupts.length > 0) {
+				this.runId = runId;
+				return await this.resolveInterrupts({
+					runId,
+					interrupts,
+					hooks,
+					signal
+				});
+			}
+			this.status = "interrupted";
+			this.notify();
+			return this.createFinish({
+				isAbort: false,
+				isDisconnect: false,
+				isError: false,
+				isInterrupted: true,
+				interruptReason: "other"
+			});
+		}
+		this.applyEvent(event);
+		if (this.stopRequested) return this.createFinish({
+			isAbort: true,
+			isDisconnect: false,
+			isError: false,
+			isInterrupted: false
+		});
+		this.status = "streaming";
+		this.notify();
+		this.emitEvent(hooks, event);
+	}
+	createPendingClientTool(runId, interrupt) {
+		const toolCall = this.getToolCallPart(interrupt.toolCallId);
+		if (!toolCall) {
+			this.error = new BetterAgentClientError(`Client tool call not found for toolCallId: ${interrupt.toolCallId}`);
+			this.status = "error";
+			this.notify();
+			return this.createFinish({
+				isAbort: false,
+				isDisconnect: false,
+				isError: true,
+				isInterrupted: false,
+				error: this.error
+			});
+		}
+		return {
+			interruptId: interrupt.id,
+			runId,
+			toolCallId: interrupt.toolCallId,
+			toolName: toolCall.toolName,
+			input: toolCall.input,
+			...interrupt.expiresAt !== void 0 ? { expiresAt: interrupt.expiresAt } : {}
+		};
+	}
+	createPendingApproval(runId, interrupt) {
+		const toolCall = this.getToolCallPart(interrupt.toolCallId);
+		if (!toolCall) {
+			this.error = new BetterAgentClientError(`Approval tool call not found for toolCallId: ${interrupt.toolCallId}`);
+			this.status = "error";
+			this.notify();
+			return this.createFinish({
+				isAbort: false,
+				isDisconnect: false,
+				isError: true,
+				isInterrupted: false,
+				error: this.error
+			});
+		}
+		return {
+			interruptId: interrupt.id,
+			runId,
+			toolCallId: interrupt.toolCallId,
+			toolName: toolCall.toolName,
+			input: toolCall.input,
+			metadata: interrupt.metadata,
+			...interrupt.expiresAt !== void 0 ? { expiresAt: interrupt.expiresAt } : {}
+		};
+	}
+	async createClientToolResumeEntry(pending) {
+		const handler = this.getToolHandler(pending.toolName);
+		if (!handler) return;
+		try {
+			const payload = await handler(pending.input);
+			const resumePayload = payload === void 0 ? {
+				status: "success",
+				result: {}
+			} : {
+				status: "success",
+				result: payload
+			};
+			this.upsertToolResultPart(pending.toolCallId, {
+				state: "output-available",
+				result: typeof resumePayload.result === "string" ? resumePayload.result : JSON.stringify(resumePayload.result)
+			});
+			this.notify();
+			return {
+				interruptId: pending.interruptId,
+				status: "resolved",
+				payload: resumePayload
+			};
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			const resumePayload = {
+				status: "error",
+				error: message
+			};
+			this.upsertToolResultPart(pending.toolCallId, {
+				state: "output-error",
+				error: message
+			});
+			this.notify();
+			return {
+				interruptId: pending.interruptId,
+				status: "resolved",
+				payload: resumePayload
+			};
+		}
+	}
+	async resolveInterrupts(params) {
+		const { hooks, runId, signal } = params;
+		const approvalInterrupts = params.interrupts.filter((interrupt) => this.isApprovalInterrupt(interrupt));
+		const clientToolInterrupts = params.interrupts.filter((interrupt) => this.isClientToolInterrupt(interrupt));
+		if (approvalInterrupts.length > 0) {
+			const approvals = [];
+			for (const interrupt of approvalInterrupts) {
+				const pending = this.createPendingApproval(runId, interrupt);
+				if ("isError" in pending) return pending;
+				approvals.push(pending);
+				this.updateToolCallPart(interrupt.toolCallId, {
+					state: "approval-requested",
+					approval: {
+						interruptId: interrupt.id,
+						needsApproval: true,
+						...interrupt.metadata ? { metadata: interrupt.metadata } : {}
+					}
+				});
+			}
+			const clientTools = [];
+			for (const interrupt of clientToolInterrupts) {
+				const pending = this.createPendingClientTool(runId, interrupt);
+				if ("isError" in pending) return pending;
+				clientTools.push(pending);
+			}
+			this.pendingToolApprovals = approvals;
+			this.pendingClientTools = clientTools;
+			this.status = "interrupted";
+			this.notify();
+			return this.createFinish({
+				isAbort: false,
+				isDisconnect: false,
+				isError: false,
+				isInterrupted: true,
+				interruptReason: "tool_approval_pending"
+			});
+		}
+		if (clientToolInterrupts.length > 0) {
+			const clientTools = [];
+			for (const interrupt of clientToolInterrupts) {
+				const pending = this.createPendingClientTool(runId, interrupt);
+				if ("isError" in pending) return pending;
+				clientTools.push(pending);
+			}
+			this.pendingClientTools = clientTools;
+			this.pendingToolApprovals = [];
+			return this.resolvePendingInterruptBatch(hooks, signal);
+		}
+		this.pendingClientTools = [];
+		this.pendingToolApprovals = [];
+		this.status = "interrupted";
+		this.notify();
+		return this.createFinish({
+			isAbort: false,
+			isDisconnect: false,
+			isError: false,
+			isInterrupted: true,
+			interruptReason: "other"
+		});
+	}
+	async streamWithResume(resume, hooks, signal) {
+		const stream = this.agent.stream({
+			resume,
+			...this.stateControl.get() !== void 0 ? { state: this.stateControl.get() } : {},
+			...this.threadId !== void 0 ? { threadId: this.threadId } : {}
+		}, { signal });
+		return this.consumeStream(stream, hooks, signal, () => {
+			this.pendingClientTools = [];
+			this.pendingToolApprovals = [];
+		});
+	}
+	async runPendingInterruptsWithLifecycle() {
+		const hooks = {
+			onEvent: this.options.onEvent,
+			onFinish: this.options.onFinish,
+			onError: this.options.onError
+		};
+		const abortController = new AbortController();
+		this.resetStopRequest();
+		this.activeAbortController?.abort();
+		this.activeAbortController = abortController;
+		this.error = void 0;
+		this.finishMessageStartIndex = this.messages.length;
+		this.status = "streaming";
+		this.notify();
+		let terminal;
+		try {
+			terminal = await this.resolvePendingInterruptBatch(hooks, abortController.signal);
+		} catch (e) {
+			if (abortController.signal.aborted) terminal = this.createFinish({
+				isAbort: true,
+				isDisconnect: false,
+				isError: false,
+				isInterrupted: false
+			});
+			else {
+				this.error = toBetterAgentClientError(e);
+				this.status = "error";
+				this.notify();
+				terminal = this.createFinish({
+					isAbort: false,
+					isDisconnect: false,
+					isError: true,
+					isInterrupted: false,
+					error: this.error
+				});
+			}
+		} finally {
+			if (this.activeAbortController === abortController) this.activeAbortController = void 0;
+			if (terminal !== void 0) this.invokeLifecycleFinish(hooks, terminal);
+		}
+	}
+	async resolvePendingInterruptBatch(hooks, signal) {
+		if (this.hasUndecidedApprovals()) {
+			this.status = "interrupted";
+			this.notify();
+			return this.createFinish({
+				isAbort: false,
+				isDisconnect: false,
+				isError: false,
+				isInterrupted: true,
+				interruptReason: "tool_approval_pending"
+			});
+		}
+		const runId = this.runId ?? this.pendingToolApprovals[0]?.runId ?? this.pendingClientTools[0]?.runId;
+		if (!runId) {
+			this.error = new BetterAgentClientError("Pending interrupt missing runId.");
+			this.status = "error";
+			this.notify();
+			return this.createFinish({
+				isAbort: false,
+				isDisconnect: false,
+				isError: true,
+				isInterrupted: false,
+				error: this.error
+			});
+		}
+		const resume = this.pendingToolApprovals.map((approval) => ({
+			interruptId: approval.interruptId,
+			status: "resolved",
+			payload: {
+				approved: approval.approved,
+				...approval.responseMetadata ? { metadata: approval.responseMetadata } : {}
+			}
+		}));
+		if (this.pendingClientTools.some((pending) => !this.getToolHandler(pending.toolName))) {
+			this.status = "interrupted";
+			this.notify();
+			return this.createFinish({
+				isAbort: false,
+				isDisconnect: false,
+				isError: false,
+				isInterrupted: true,
+				interruptReason: "client_tool_pending"
+			});
+		}
+		for (const pending of this.pendingClientTools) {
+			const entry = await this.createClientToolResumeEntry(pending);
+			if (entry) resume.push(entry);
+		}
+		if (resume.length === 0) {
+			this.status = "interrupted";
+			this.notify();
+			return this.createFinish({
+				isAbort: false,
+				isDisconnect: false,
+				isError: false,
+				isInterrupted: true,
+				interruptReason: "other"
+			});
+		}
+		this.runId = runId;
+		return this.streamWithResume(resume, hooks, signal);
+	}
+	getToolHandler(toolName) {
+		return this.options.toolHandlers?.[toolName];
+	}
+	updateToolCallPart(toolCallId, update) {
+		this.messages = this.messages.map((message) => ({
+			...message,
+			parts: message.parts.map((part) => part.type === "tool-call" && part.toolCallId === toolCallId ? {
+				...part,
+				...update
+			} : part)
+		}));
+	}
+	upsertToolResultPart(toolCallId, update) {
+		this.messages = this.messages.map((message) => {
+			const existingResultIndex = message.parts.findIndex((part) => part.type === "tool-result" && part.toolCallId === toolCallId);
+			const existingToolCallIndex = message.parts.findIndex((part) => part.type === "tool-call" && part.toolCallId === toolCallId);
+			if (existingResultIndex === -1 && existingToolCallIndex === -1) return message;
+			if (existingResultIndex !== -1) return {
+				...message,
+				parts: message.parts.map((part, index) => index === existingResultIndex && part.type === "tool-result" ? {
+					...part,
+					...update
+				} : part)
+			};
+			const parts = [...message.parts];
+			const insertIndex = existingToolCallIndex + 1;
+			parts.splice(insertIndex, 0, {
+				type: "tool-result",
+				toolCallId,
+				state: "output-available",
+				...update
+			});
+			return {
+				...message,
+				parts
+			};
+		});
+	}
+	async resolveApprovalDecision(interruptId, approved, metadata) {
+		const approvalIndex = this.pendingToolApprovals.findIndex((approval) => approval.interruptId === interruptId);
+		if (approvalIndex === -1) throw new BetterAgentClientError(`Pending approval not found for interruptId: ${interruptId}`);
+		const approval = this.pendingToolApprovals[approvalIndex];
+		if (!approval) return;
+		const normalizedMetadata = typeof metadata === "string" ? { note: metadata } : metadata;
+		this.error = void 0;
+		this.pendingToolApprovals = this.pendingToolApprovals.map((pending, index) => index === approvalIndex ? {
+			...pending,
+			approved,
+			responseMetadata: normalizedMetadata
+		} : pending);
+		this.updateToolCallPart(approval.toolCallId, {
+			state: "approval-responded",
+			approval: {
+				interruptId: approval.interruptId,
+				needsApproval: true,
+				approved,
+				...normalizedMetadata ? { metadata: normalizedMetadata } : {}
+			}
+		});
+		this.notify();
+		if (this.hasUndecidedApprovals()) {
+			this.status = "interrupted";
+			this.notify();
+			return;
+		}
+		await this.runPendingInterruptsWithLifecycle();
+	}
+	applyEvent(event) {
+		const rid = "runId" in event && typeof event.runId === "string" ? event.runId : void 0;
+		const tid = "threadId" in event && typeof event.threadId === "string" && event.threadId.length > 0 ? event.threadId : void 0;
+		if (rid) {
+			this.runId = rid;
+			if (this.stopRequested) {
+				this.clearStopWaitTimer();
+				this.abortServerRun(rid);
+				this.abortActiveRequest();
+				return;
+			}
+		}
+		if (tid) this.threadId = tid;
+		if (this.stopRequested) return;
+		this.stateControl.apply(event);
+		if (event.type === EventType.STATE_SNAPSHOT || event.type === EventType.STATE_DELTA) this.stateRevision += 1;
+		this.messages = applyUIEvent(createUIReducerState(this.messages), event).messages;
+	}
+	notify() {
+		this.snapshot = this.createSnapshot();
+		for (const listener of this.listeners) listener();
+	}
+};
+function createAgentController(agent, options) {
+	return new AgentController(agent, options);
+}
+
+//#endregion
+export { BetterAgentClientError as a, toAgentMessages as i, createAgentController as n, toBetterAgentClientError as o, fromAgentMessages as r, AgentController as t };
+//# sourceMappingURL=controller-xMlzSCc7.mjs.map