miladyai 2.0.0-alpha.27

package/dist/tui/eliza-tui-bridge.js

@@ -0,0 +1,606 @@
+import { miladyMarkdownTheme, tuiTheme } from "./theme.js";
+import { AssistantMessageComponent } from "./components/assistant-message.js";
+import { ToolExecutionComponent } from "./components/tool-execution.js";
+import { UserMessageComponent } from "./components/user-message.js";
+import "./components/index.js";
+import { drainSseEvents, extractSseDataPayloads, parseConversationStreamPayload } from "./sse-parser.js";
+import { ApiModeWsClient } from "./ws-client.js";
+import process from "node:process";
+import { ChannelType, EventType, createMessageMemory, stringToUuid } from "@elizaos/core";
+import crypto from "node:crypto";
+import { CancellableLoader, Spacer, Text } from "@mariozechner/pi-tui";
+
+//#region src/tui/eliza-tui-bridge.ts
+const TUI_USER_ID = stringToUuid("milady-tui-user");
+var ElizaTUIBridge = class {
+	constructor(runtime, tui, opts = {}) {
+		this.runtime = runtime;
+		this.tui = tui;
+		this.isProcessing = false;
+		this.showThinking = process.env.MILADY_TUI_SHOW_THINKING === "1";
+		this.showStructuredResponse = process.env.MILADY_TUI_SHOW_STRUCTURED_RESPONSE === "1";
+		this.debugActionRouting = process.env.MILADY_TUI_DEBUG_ACTION_ROUTING === "1";
+		this.abortController = null;
+		this.streamedText = "";
+		this.thinkingText = "";
+		this.structuredThoughtText = "";
+		this.currentAssistant = null;
+		this.lastAssistantForTurn = null;
+		this.assistantFinalizedForTurn = false;
+		this.pendingRender = null;
+		this.pendingActions = /* @__PURE__ */ new Map();
+		this.allToolComponents = /* @__PURE__ */ new Set();
+		this.conversationId = null;
+		this.conversationRoomId = null;
+		this.conversationInitPromise = null;
+		this.apiWsClient = null;
+		this.pendingProactiveMessages = [];
+		this.lastCompletedAssistantText = "";
+		this.lastCompletedAssistantAt = 0;
+		this.seenProactiveMessageIds = /* @__PURE__ */ new Set();
+		this.seenProactiveMessageOrder = [];
+		this.proactiveMessageIdLimit = 128;
+		this.disposed = false;
+		const agentScope = String(this.runtime.agentId);
+		this.worldId = stringToUuid(`milady-tui-world:${agentScope}`);
+		this.roomId = stringToUuid(`milady-tui-room:${agentScope}`);
+		this.channelId = `milady-tui:${agentScope}`;
+		this.apiBaseUrl = opts.apiBaseUrl?.trim().replace(/\/+$/, "") || null;
+		this.apiTokenOverride = opts.apiToken;
+		this.conversationTitle = opts.conversationTitle?.trim() || "TUI Chat";
+	}
+	getAbortSignal() {
+		return this.abortController?.signal;
+	}
+	getIsProcessing() {
+		return this.isProcessing;
+	}
+	getPiTuiCompat() {
+		return this.tui.getTUI();
+	}
+	getActionEventRouteDecision(payload) {
+		const payloadRoomId = payload.roomId ? String(payload.roomId) : "";
+		const activeRoomId = this.apiBaseUrl ? this.conversationRoomId ?? "" : String(this.roomId);
+		if (!payloadRoomId) return {
+			shouldHandle: false,
+			reason: "missing_payload_room",
+			payloadRoomId,
+			activeRoomId
+		};
+		if (!this.apiBaseUrl) {
+			const shouldHandle = payloadRoomId === activeRoomId;
+			return {
+				shouldHandle,
+				reason: shouldHandle ? "runtime_room_match" : "runtime_room_mismatch",
+				payloadRoomId,
+				activeRoomId
+			};
+		}
+		if (!activeRoomId) return {
+			shouldHandle: false,
+			reason: "conversation_room_unresolved",
+			payloadRoomId,
+			activeRoomId
+		};
+		const shouldHandle = payloadRoomId === activeRoomId;
+		return {
+			shouldHandle,
+			reason: shouldHandle ? "conversation_room_match" : "conversation_room_mismatch",
+			payloadRoomId,
+			activeRoomId
+		};
+	}
+	logActionRoute(eventType, actionName, decision) {
+		if (!this.debugActionRouting) return;
+		const mode = this.apiBaseUrl ? "api" : "runtime";
+		const payloadRoom = decision.payloadRoomId || "(none)";
+		const activeRoom = decision.activeRoomId || "(unset)";
+		process.stderr.write(`[milady-tui] ${eventType} action=${actionName} mode=${mode} payloadRoom=${payloadRoom} activeRoom=${activeRoom} handled=${decision.shouldHandle} reason=${decision.reason}\n`);
+	}
+	async initialize() {
+		if (this.disposed) return;
+		if (!this.apiBaseUrl) {
+			await this.runtime.ensureWorldExists({
+				id: this.worldId,
+				name: "Milady TUI",
+				agentId: this.runtime.agentId
+			});
+			await this.runtime.ensureRoomExists({
+				id: this.roomId,
+				name: "Milady TUI",
+				type: ChannelType.DM,
+				source: "milady-tui",
+				worldId: this.worldId,
+				channelId: this.channelId,
+				metadata: { ownership: { ownerId: TUI_USER_ID } }
+			});
+			await this.runtime.ensureConnection({
+				entityId: TUI_USER_ID,
+				roomId: this.roomId,
+				worldId: this.worldId,
+				worldName: "Milady TUI",
+				userName: "User",
+				name: "User",
+				source: "milady-tui",
+				type: ChannelType.DM,
+				channelId: this.channelId,
+				metadata: { ownership: { ownerId: TUI_USER_ID } }
+			});
+		} else {
+			this.apiWsClient = new ApiModeWsClient({
+				apiBaseUrl: this.apiBaseUrl,
+				getAuthToken: () => this.getApiToken(),
+				onMessage: (data) => this.handleApiWsMessage(data),
+				onError: (error) => {
+					process.stderr.write(`[milady-tui] websocket error: ${error.message}\n`);
+				}
+			});
+			this.apiWsClient.connect();
+		}
+		const SKIP_ACTIONS = new Set([
+			"reply",
+			"respond",
+			"continue",
+			"ignore",
+			"none",
+			"wait",
+			"action"
+		]);
+		this.runtime.registerEvent(EventType.ACTION_STARTED, async (payload) => {
+			const p = payload;
+			const actionName = p.content.actions?.[0] ?? "action";
+			const route = this.getActionEventRouteDecision(p);
+			if (!route.shouldHandle) {
+				this.logActionRoute("ACTION_STARTED", actionName, route);
+				return;
+			}
+			if (SKIP_ACTIONS.has(actionName.toLowerCase())) {
+				this.logActionRoute("ACTION_STARTED", actionName, {
+					...route,
+					shouldHandle: false,
+					reason: "internal_action_skipped"
+				});
+				return;
+			}
+			this.logActionRoute("ACTION_STARTED", actionName, route);
+			const actionId = p.content.actionId ?? p.messageId ?? `${actionName}-${Date.now()}`;
+			const component = new ToolExecutionComponent(actionName, {}, this.getPiTuiCompat());
+			component.setExpanded(this.tui.getToolOutputExpanded());
+			this.pendingActions.set(actionId, component);
+			this.allToolComponents.add(component);
+			this.tui.addToChatContainer(component);
+			this.tui.requestRender();
+		});
+		this.runtime.registerEvent(EventType.ACTION_COMPLETED, async (payload) => {
+			const p = payload;
+			const actionName = p.content.actions?.[0] ?? "action";
+			const route = this.getActionEventRouteDecision(p);
+			if (!route.shouldHandle) {
+				this.logActionRoute("ACTION_COMPLETED", actionName, route);
+				return;
+			}
+			if (SKIP_ACTIONS.has(actionName.toLowerCase())) {
+				this.logActionRoute("ACTION_COMPLETED", actionName, {
+					...route,
+					shouldHandle: false,
+					reason: "internal_action_skipped"
+				});
+				return;
+			}
+			this.logActionRoute("ACTION_COMPLETED", actionName, route);
+			let resolvedKey = p.content.actionId ?? p.messageId;
+			let component = resolvedKey ? this.pendingActions.get(resolvedKey) : void 0;
+			if (!component) {
+				const fallback = [...this.pendingActions.entries()].reverse().find(([, c]) => c.render(120)[0]?.includes(actionName));
+				if (fallback) {
+					resolvedKey = fallback[0];
+					component = fallback[1];
+				}
+			}
+			if (!component) return;
+			const isError = p.content.actionStatus === "failed";
+			const actionResult = p.content.actionResult;
+			const text = p.content.text ?? (actionResult ? JSON.stringify(actionResult, null, 2) : "");
+			component.updateResult({
+				text,
+				isError
+			});
+			if (resolvedKey) this.pendingActions.delete(resolvedKey);
+			this.tui.requestRender();
+		});
+	}
+	dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		this.abortInFlight();
+		this.pendingProactiveMessages = [];
+		if (this.pendingRender) {
+			clearTimeout(this.pendingRender);
+			this.pendingRender = null;
+		}
+		this.apiWsClient?.close();
+		this.apiWsClient = null;
+	}
+	abortInFlight() {
+		if (this.abortController) this.abortController.abort();
+	}
+	setShowThinking(enabled) {
+		this.showThinking = enabled;
+	}
+	setToolOutputExpanded(expanded) {
+		for (const component of this.allToolComponents) component.setExpanded(expanded);
+		this.tui.requestRender();
+	}
+	async handleUserInput(text) {
+		if (this.isProcessing) return;
+		this.isProcessing = true;
+		this.tui.setBusy(true);
+		this.abortController = new AbortController();
+		this.streamedText = "";
+		this.thinkingText = "";
+		this.structuredThoughtText = "";
+		this.currentAssistant = null;
+		this.lastAssistantForTurn = null;
+		this.assistantFinalizedForTurn = false;
+		try {
+			this.tui.addToChatContainer(new UserMessageComponent(text));
+			const loader = new CancellableLoader(this.getPiTuiCompat(), (spinner) => tuiTheme.info(spinner), (msg) => tuiTheme.muted(msg), "Thinking… (Esc to cancel)");
+			loader.onAbort = () => {
+				this.abortInFlight();
+			};
+			this.tui.setEphemeralStatus(loader);
+			this.tui.getStatusBar().update({ isStreaming: true });
+			if (this.apiBaseUrl) await this.handleUserInputViaApi(text);
+			else await this.handleUserInputViaRuntime(text);
+		} catch (error) {
+			if (this.abortController?.signal.aborted) return;
+			const errText = error instanceof Error ? error.message : String(error);
+			this.tui.addToChatContainer(new Text(tuiTheme.error(`Error: ${errText}`), 1, 0));
+			this.tui.addToChatContainer(new Spacer(1));
+		} finally {
+			this.tui.clearEphemeralStatus();
+			this.tui.getStatusBar().update({ isStreaming: false });
+			this.tui.setBusy(false);
+			this.abortController = null;
+			this.isProcessing = false;
+			this.flushPendingProactiveMessages();
+		}
+	}
+	onStreamEvent(event) {
+		if (this.apiBaseUrl) return;
+		switch (event.type) {
+			case "token":
+				if (!event.text) return;
+				this.tui.clearEphemeralStatus();
+				this.tui.getStatusBar().update({ isStreaming: true });
+				this.streamedText += event.text;
+				this.ensureAssistantComponent();
+				this.scheduleAssistantUpdate();
+				break;
+			case "thinking":
+				if (!event.text) return;
+				this.thinkingText += event.text;
+				this.currentAssistant?.updateThinking(this.getCombinedThinkingText());
+				this.scheduleAssistantUpdate();
+				break;
+			case "usage":
+				if (!event.usage) return;
+				this.tui.getStatusBar().update({
+					inputTokens: event.usage.inputTokens,
+					outputTokens: event.usage.outputTokens,
+					isStreaming: false
+				});
+				this.tui.requestRender();
+				break;
+			case "done":
+				this.tui.clearEphemeralStatus();
+				this.tui.getStatusBar().update({ isStreaming: false });
+				this.updateAssistantFromText();
+				this.finalizeAssistantForTurn();
+				this.tui.requestRender();
+				break;
+			case "error": {
+				this.tui.clearEphemeralStatus();
+				this.tui.getStatusBar().update({ isStreaming: false });
+				const msg = event.error ?? "Model error";
+				this.tui.addToChatContainer(new Text(tuiTheme.error(`Error: ${msg}`), 1, 0));
+				this.tui.addToChatContainer(new Spacer(1));
+				this.tui.requestRender();
+				break;
+			}
+		}
+	}
+	async handleUserInputViaRuntime(text) {
+		const message = createMessageMemory({
+			id: crypto.randomUUID(),
+			entityId: TUI_USER_ID,
+			agentId: this.runtime.agentId,
+			roomId: this.roomId,
+			content: {
+				text,
+				source: "milady-tui",
+				channelType: ChannelType.DM
+			}
+		});
+		if (!this.runtime.messageService) throw new Error("runtime.messageService is not available");
+		await this.runtime.messageService.handleMessage(this.runtime, message, async (response) => {
+			if (response.text) {
+				this.streamedText = response.text;
+				if (!(this.currentAssistant ?? this.lastAssistantForTurn ?? null)) this.ensureAssistantComponent();
+				this.updateAssistantFromText();
+				this.finalizeAssistantForTurn();
+			}
+			return [];
+		}, { abortSignal: this.abortController?.signal });
+	}
+	async handleUserInputViaApi(text) {
+		const conversationId = await this.ensureConversationId();
+		await this.streamConversationMessage(conversationId, text, this.abortController?.signal);
+		if (!this.currentAssistant && !this.lastAssistantForTurn && this.streamedText.trim().length > 0) this.ensureAssistantComponent();
+		this.updateAssistantFromText();
+		this.finalizeAssistantForTurn();
+		this.tui.requestRender();
+	}
+	async ensureConversationId() {
+		if (this.conversationId) {
+			this.apiWsClient?.setActiveConversationId(this.conversationId);
+			return this.conversationId;
+		}
+		if (!this.conversationInitPromise) this.conversationInitPromise = this.resolveConversationId().finally(() => {
+			this.conversationInitPromise = null;
+		});
+		const resolved = await this.conversationInitPromise;
+		this.conversationId = resolved;
+		this.apiWsClient?.setActiveConversationId(resolved);
+		return resolved;
+	}
+	async resolveConversationId() {
+		const list = await this.apiFetchJson("/api/conversations");
+		const title = this.conversationTitle.trim().toLowerCase();
+		const existing = [...list.conversations ?? []].filter((c) => typeof c?.id === "string" && c.id.trim().length > 0).filter((c) => c.title?.trim().toLowerCase() === title && typeof c.roomId === "string" && c.roomId.trim().length > 0).sort((a, b) => this.parseTimestamp(b.updatedAt) - this.parseTimestamp(a.updatedAt))[0];
+		if (existing?.id) {
+			this.conversationRoomId = existing.roomId?.trim() || null;
+			return existing.id;
+		}
+		const created = await this.apiFetchJson("/api/conversations", {
+			method: "POST",
+			body: JSON.stringify({ title: this.conversationTitle })
+		});
+		const createdId = created.conversation?.id?.trim();
+		if (!createdId) throw new Error("Failed to create TUI conversation");
+		this.conversationRoomId = created.conversation?.roomId?.trim() || null;
+		return createdId;
+	}
+	parseTimestamp(value) {
+		const ms = Date.parse(value);
+		return Number.isFinite(ms) ? ms : 0;
+	}
+	async streamConversationMessage(conversationId, text, signal) {
+		const res = await this.apiFetch(`/api/conversations/${encodeURIComponent(conversationId)}/messages/stream`, {
+			method: "POST",
+			headers: { Accept: "text/event-stream" },
+			body: JSON.stringify({ text }),
+			signal
+		});
+		if (!res.body) throw new Error("Streaming not supported by this runtime");
+		const reader = res.body.getReader();
+		const decoder = new TextDecoder();
+		let buffer = "";
+		let fullText = "";
+		let doneText = null;
+		const parsePayload = (payload) => {
+			const parsed = parseConversationStreamPayload(payload);
+			if (!parsed) return;
+			if (parsed.type === "token") {
+				const chunk = parsed.text ?? "";
+				if (!chunk) return;
+				this.tui.clearEphemeralStatus();
+				this.tui.getStatusBar().update({ isStreaming: true });
+				fullText += chunk;
+				this.streamedText += chunk;
+				this.ensureAssistantComponent();
+				this.scheduleAssistantUpdate();
+				return;
+			}
+			if (parsed.type === "done") {
+				if (typeof parsed.fullText === "string") doneText = parsed.fullText;
+				return;
+			}
+			if (parsed.type === "error") throw new Error(parsed.message ?? "generation failed");
+			if (parsed.text) {
+				this.tui.clearEphemeralStatus();
+				this.tui.getStatusBar().update({ isStreaming: true });
+				fullText += parsed.text;
+				this.streamedText += parsed.text;
+				this.ensureAssistantComponent();
+				this.scheduleAssistantUpdate();
+			}
+		};
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			buffer += decoder.decode(value, { stream: true });
+			const drained = drainSseEvents(buffer);
+			buffer = drained.remaining;
+			for (const rawEvent of drained.events) for (const payload of extractSseDataPayloads(rawEvent)) parsePayload(payload);
+		}
+		if (buffer.trim()) for (const payload of extractSseDataPayloads(buffer)) parsePayload(payload);
+		if (typeof doneText === "string") this.streamedText = doneText;
+		else if (!this.streamedText && fullText) this.streamedText = fullText;
+	}
+	getApiToken() {
+		if (this.apiTokenOverride !== void 0) return this.apiTokenOverride?.trim() || null;
+		return process.env.MILADY_API_TOKEN?.trim() || null;
+	}
+	handleApiWsMessage(data) {
+		if (this.disposed) return;
+		if (data.type !== "proactive-message") return;
+		const conversationId = typeof data.conversationId === "string" ? data.conversationId.trim() : "";
+		if (!conversationId || !this.conversationId) return;
+		if (conversationId !== this.conversationId) return;
+		const rawMessage = data.message;
+		if (!rawMessage || typeof rawMessage !== "object" || Array.isArray(rawMessage)) return;
+		const message = rawMessage;
+		const messageId = typeof message.id === "string" ? message.id.trim() : "";
+		if (messageId) {
+			if (this.seenProactiveMessageIds.has(messageId)) return;
+			this.rememberProactiveMessageId(messageId);
+		}
+		const text = typeof message.text === "string" ? message.text.trim() : "";
+		if (!text) return;
+		if (this.isLikelyDuplicateAssistantText(text)) return;
+		if (this.isProcessing) {
+			this.queuePendingProactiveMessage(text);
+			return;
+		}
+		this.renderProactiveAssistantMessage(text);
+	}
+	rememberProactiveMessageId(id) {
+		this.seenProactiveMessageIds.add(id);
+		this.seenProactiveMessageOrder.push(id);
+		if (this.seenProactiveMessageOrder.length <= this.proactiveMessageIdLimit) return;
+		const oldest = this.seenProactiveMessageOrder.shift();
+		if (oldest) this.seenProactiveMessageIds.delete(oldest);
+	}
+	queuePendingProactiveMessage(text) {
+		this.pendingProactiveMessages.push(text);
+		if (this.pendingProactiveMessages.length > 32) this.pendingProactiveMessages.shift();
+	}
+	flushPendingProactiveMessages() {
+		if (this.disposed) return;
+		if (this.pendingProactiveMessages.length < 1) return;
+		const pending = this.pendingProactiveMessages;
+		this.pendingProactiveMessages = [];
+		for (const text of pending) {
+			if (this.isLikelyDuplicateAssistantText(text)) continue;
+			this.renderProactiveAssistantMessage(text);
+		}
+	}
+	isLikelyDuplicateAssistantText(text) {
+		const normalized = text.trim();
+		if (!normalized) return true;
+		if (this.isProcessing && this.streamedText.trim() === normalized) return true;
+		if (this.lastCompletedAssistantText === normalized && Date.now() - this.lastCompletedAssistantAt < 1500) return true;
+		return false;
+	}
+	renderProactiveAssistantMessage(text) {
+		if (this.disposed) return;
+		const component = new AssistantMessageComponent(this.showThinking, miladyMarkdownTheme, this.runtime.character?.name ?? "milady");
+		component.updateContent(text);
+		component.finalize();
+		this.tui.addToChatContainer(component);
+		this.tui.requestRender();
+		this.lastCompletedAssistantText = text.trim();
+		this.lastCompletedAssistantAt = Date.now();
+	}
+	async apiFetch(path, init) {
+		if (!this.apiBaseUrl) throw new Error("API transport is not configured");
+		const headers = new Headers(init?.headers);
+		if (init?.body != null && !headers.has("Content-Type")) headers.set("Content-Type", "application/json");
+		const token = this.getApiToken();
+		if (token && !headers.has("Authorization")) headers.set("Authorization", `Bearer ${token}`);
+		const res = await fetch(`${this.apiBaseUrl}${path}`, {
+			...init,
+			headers
+		});
+		if (!res.ok) {
+			const message = await this.readApiError(res);
+			throw new Error(message);
+		}
+		return res;
+	}
+	async apiFetchJson(path, init) {
+		return (await this.apiFetch(path, init)).json();
+	}
+	async readApiError(res) {
+		try {
+			const body = await res.json();
+			if (typeof body.error === "string" && body.error.trim()) return body.error;
+		} catch {}
+		try {
+			const text = await res.text();
+			if (text.trim()) return text.trim();
+		} catch {}
+		return `HTTP ${res.status}`;
+	}
+	ensureAssistantComponent() {
+		if (this.currentAssistant) return;
+		this.currentAssistant = new AssistantMessageComponent(this.showThinking, miladyMarkdownTheme, this.runtime.character?.name ?? "milady");
+		this.lastAssistantForTurn = this.currentAssistant;
+		this.tui.addToChatContainer(this.currentAssistant);
+		this.tui.requestRender();
+	}
+	scheduleAssistantUpdate() {
+		if (this.pendingRender) return;
+		this.pendingRender = setTimeout(() => {
+			this.pendingRender = null;
+			this.updateAssistantFromText();
+			this.tui.requestRender();
+		}, 33);
+	}
+	finalizeAssistantForTurn() {
+		if (this.assistantFinalizedForTurn) return;
+		const component = this.currentAssistant ?? this.lastAssistantForTurn;
+		if (!component) return;
+		if (this.pendingRender) {
+			clearTimeout(this.pendingRender);
+			this.pendingRender = null;
+		}
+		component.finalize();
+		const completedText = this.normalizeAssistantText(this.streamedText).text.trim();
+		if (completedText) {
+			this.lastCompletedAssistantText = completedText;
+			this.lastCompletedAssistantAt = Date.now();
+		}
+		this.streamedText = "";
+		this.currentAssistant = null;
+		this.assistantFinalizedForTurn = true;
+	}
+	updateAssistantFromText() {
+		const component = this.currentAssistant ?? this.lastAssistantForTurn;
+		if (!component) return;
+		const normalized = this.normalizeAssistantText(this.streamedText);
+		this.structuredThoughtText = normalized.thoughtText;
+		component.updateThinking(this.getCombinedThinkingText());
+		component.updateContent(normalized.text);
+	}
+	getCombinedThinkingText() {
+		return [this.thinkingText, this.structuredThoughtText].map((p) => p.trim()).filter((p) => p.length > 0).join("\n");
+	}
+	normalizeAssistantText(raw) {
+		if (this.showStructuredResponse) return {
+			text: raw,
+			thoughtText: ""
+		};
+		if (raw.indexOf("<response>") < 0) return {
+			text: raw,
+			thoughtText: ""
+		};
+		const thought = this.extractXmlTag(raw, "thought") ?? "";
+		const text = this.extractXmlTag(raw, "text", { allowPartial: true });
+		if (text !== null) return {
+			text: text.trimStart(),
+			thoughtText: thought.trim()
+		};
+		return {
+			text: "",
+			thoughtText: thought.trim()
+		};
+	}
+	extractXmlTag(raw, tag, opts) {
+		const open = `<${tag}>`;
+		const close = `</${tag}>`;
+		const start = raw.indexOf(open);
+		if (start < 0) return null;
+		const contentStart = start + open.length;
+		const end = raw.indexOf(close, contentStart);
+		if (end < 0) {
+			if (opts?.allowPartial) return raw.slice(contentStart);
+			return null;
+		}
+		return raw.slice(contentStart, end);
+	}
+};
+
+//#endregion
+export { ElizaTUIBridge };