@elizaos/ui 2.0.0-alpha.526 → 2.0.0-alpha.528

package/packages/app-core/src/api/client-base.js

@@ -0,0 +1,729 @@
+/**
+ * ElizaClient class — core infrastructure only.
+ *
+ * Separated from client.ts so domain augmentation files can import the class
+ * without circular dependency issues.
+ */
+import { getBootConfig, setBootConfig } from "../config/boot-config";
+import { stripAssistantStageDirections } from "../utils/assistant-text";
+import { clearElizaApiBase, getElizaApiBase, getElizaApiToken, setElizaApiBase, } from "../utils/eliza-globals";
+import { mergeStreamingText } from "../utils/streaming-text";
+import { ApiError } from "./client-types";
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+const GENERIC_NO_RESPONSE_TEXT = "Sorry, I couldn't generate a response right now. Please try again.";
+const DEFAULT_FETCH_TIMEOUT_MS = 10_000;
+const LOCAL_STORAGE_API_BASE_KEY = "elizaos_api_base";
+// ---------------------------------------------------------------------------
+// Client
+// ---------------------------------------------------------------------------
+export class ElizaClient {
+    _baseUrl;
+    _userSetBase;
+    _token;
+    clientId;
+    ws = null;
+    wsHandlers = new Map();
+    wsSendQueue = [];
+    wsSendQueueLimit = 32;
+    reconnectTimer = null;
+    backoffMs = 500;
+    wsHasConnectedOnce = false;
+    // Connection state tracking for backend crash handling
+    connectionState = "disconnected";
+    reconnectAttempt = 0;
+    disconnectedAt = null;
+    connectionStateListeners = new Set();
+    maxReconnectAttempts = 15;
+    // UI language propagation — set by AppContext so the backend can
+    // localise responses when needed.
+    _uiLanguage = null;
+    /** Store the current UI language so it can be sent as a header on every request. */
+    setUiLanguage(lang) {
+        this._uiLanguage = lang || null;
+    }
+    static generateClientId() {
+        let random;
+        if (typeof globalThis.crypto?.randomUUID === "function") {
+            random = globalThis.crypto.randomUUID();
+        }
+        else if (typeof globalThis.crypto?.getRandomValues === "function") {
+            const buf = new Uint8Array(16);
+            globalThis.crypto.getRandomValues(buf);
+            random = `${Date.now().toString(36)}${Array.from(buf, (b) => b.toString(16).padStart(2, "0")).join("")}`;
+        }
+        else {
+            random = `${Date.now().toString(36)}${Math.random().toString(36).slice(2)}`;
+        }
+        return `ui-${random.slice(0, 256).replace(/[^a-zA-Z0-9._-]/g, "")}`;
+    }
+    constructor(baseUrl, token) {
+        this.clientId = ElizaClient.generateClientId();
+        this._token = token?.trim() || null;
+        const bootBase = getBootConfig().apiBase;
+        const injectedBase = getElizaApiBase();
+        const storedBase = typeof window !== "undefined" && window.localStorage
+            ? window.localStorage.getItem(LOCAL_STORAGE_API_BASE_KEY)
+            : null;
+        this._userSetBase = baseUrl != null;
+        // Priority: explicit arg > boot config > desktop injection > session storage > same origin.
+        // `client.setBaseUrl()` updates the boot config, so it must beat the
+        // shell-injected local default once the user has chosen a different
+        // server. Injection still beats stale session state from prior sessions.
+        this._baseUrl = baseUrl ?? bootBase ?? injectedBase ?? storedBase ?? "";
+    }
+    /**
+     * Resolve the API base URL lazily.
+     * In the desktop shell the main process injects the API base after the
+     * page loads (once the agent runtime starts). Re-checking the boot config
+     * on every call ensures we pick up the injected value even if it wasn't
+     * set at construction, or if the port changed dynamically (e.g. 2138→2139).
+     */
+    get baseUrl() {
+        // Always re-read boot config — the main process may push a port update
+        // via apiBaseUpdate RPC at any time (e.g. when the child runtime binds
+        // to a different port than initially injected in the HTML).
+        // Only skip if the user explicitly called setBaseUrl() themselves.
+        if (!this._userSetBase) {
+            const bootBase = getBootConfig().apiBase;
+            const injectedBase = getElizaApiBase();
+            const preferredBase = bootBase ?? injectedBase;
+            if (preferredBase && preferredBase !== this._baseUrl) {
+                this._baseUrl = preferredBase;
+            }
+        }
+        return this._baseUrl;
+    }
+    get apiToken() {
+        if (this._token)
+            return this._token;
+        const bootToken = getBootConfig().apiToken;
+        if (typeof bootToken === "string" && bootToken.trim())
+            return bootToken.trim();
+        const injectedToken = getElizaApiToken();
+        if (injectedToken)
+            return injectedToken;
+        return null;
+    }
+    hasToken() {
+        return Boolean(this.apiToken);
+    }
+    /**
+     * Bearer token sent on app REST requests (compat API). Used when the
+     * Electrobun main process relays HTTP so it can match the renderer-injected
+     * token in external-desktop / Vite-proxy setups.
+     */
+    getRestAuthToken() {
+        return this.apiToken;
+    }
+    setToken(token) {
+        this._token = token?.trim() || null;
+        // Update boot config so other consumers see the new token.
+        const config = getBootConfig();
+        setBootConfig({ ...config, apiToken: this._token ?? undefined });
+    }
+    getBaseUrl() {
+        return this.baseUrl;
+    }
+    setBaseUrl(baseUrl) {
+        const trimmed = baseUrl?.slice(0, 4096).trim() ?? "";
+        let end = trimmed.length;
+        while (end > 0 && trimmed.charCodeAt(end - 1) === 47)
+            end--;
+        const normalized = trimmed.slice(0, end);
+        this._userSetBase = normalized.length > 0;
+        this._baseUrl = normalized;
+        this.disconnectWs();
+        // Update boot config so other consumers (resolveApiUrl, etc.) see the new base.
+        const config = getBootConfig();
+        setBootConfig({ ...config, apiBase: normalized || undefined });
+        if (typeof window !== "undefined") {
+            if (normalized) {
+                window.localStorage.setItem(LOCAL_STORAGE_API_BASE_KEY, normalized);
+            }
+            else {
+                window.localStorage.removeItem(LOCAL_STORAGE_API_BASE_KEY);
+            }
+            // Clean up legacy sessionStorage entry (same key was used historically)
+            window.sessionStorage.removeItem(LOCAL_STORAGE_API_BASE_KEY);
+        }
+        // Mirror to window.__ELIZA_API_BASE__ so the Capacitor agent plugin's web
+        // fallback (native-plugins/agent/src/web.ts) and any other consumers that
+        // read the global directly see the same base. Electrobun's main↔renderer
+        // bridge also writes this; mirroring in setBaseUrl() makes mobile + dev-
+        // server + Electrobun behave consistently for any caller (Local Agent,
+        // Remote Agent, Eliza Cloud).
+        if (normalized) {
+            setElizaApiBase(normalized);
+        }
+        else {
+            clearElizaApiBase();
+        }
+    }
+    /** True when we have a usable HTTP(S) API endpoint. */
+    get apiAvailable() {
+        if (this.baseUrl)
+            return true;
+        if (typeof window !== "undefined") {
+            const proto = window.location.protocol;
+            return proto === "http:" || proto === "https:";
+        }
+        return false;
+    }
+    // --- REST API ---
+    async rawRequest(path, init, options) {
+        if (!this.apiAvailable) {
+            throw new ApiError({
+                kind: "network",
+                path,
+                message: "API not available (no HTTP origin)",
+            });
+        }
+        const requestUrl = (() => {
+            if (this.baseUrl) {
+                return `${this.baseUrl}${path}`;
+            }
+            if (typeof window !== "undefined") {
+                const proto = window.location.protocol;
+                if (proto === "http:" || proto === "https:") {
+                    return new URL(path, window.location.origin).toString();
+                }
+            }
+            return path;
+        })();
+        const makeRequest = async (token) => {
+            const timeoutMs = options?.timeoutMs ?? DEFAULT_FETCH_TIMEOUT_MS;
+            const abortController = new AbortController();
+            let timeoutId;
+            let timedOut = false;
+            let abortListener;
+            if (init?.signal?.aborted) {
+                throw new ApiError({
+                    kind: "network",
+                    path,
+                    message: "Request aborted",
+                });
+            }
+            timeoutId = setTimeout(() => {
+                timedOut = true;
+                abortController.abort();
+            }, timeoutMs);
+            if (init?.signal) {
+                abortListener = () => {
+                    abortController.abort();
+                };
+                init.signal.addEventListener("abort", abortListener, { once: true });
+            }
+            const requestInit = {
+                ...init,
+                signal: abortController.signal,
+                headers: {
+                    "X-ElizaOS-Client-Id": this.clientId,
+                    ...(token ? { Authorization: `Bearer ${token}` } : {}),
+                    ...(this._uiLanguage
+                        ? { "X-ElizaOS-UI-Language": this._uiLanguage }
+                        : {}),
+                    ...init?.headers,
+                },
+            };
+            try {
+                return await fetch(requestUrl, requestInit);
+            }
+            catch (err) {
+                if (timedOut) {
+                    throw new ApiError({
+                        kind: "timeout",
+                        path,
+                        message: `Request timed out after ${timeoutMs}ms`,
+                    });
+                }
+                if (abortController.signal.aborted) {
+                    throw new ApiError({
+                        kind: "network",
+                        path,
+                        message: "Request aborted",
+                        cause: err,
+                    });
+                }
+                if (err instanceof ApiError) {
+                    throw err;
+                }
+                throw new ApiError({
+                    kind: "network",
+                    path,
+                    message: err instanceof Error && err.message
+                        ? err.message
+                        : "Network request failed",
+                    cause: err,
+                });
+            }
+            finally {
+                if (timeoutId !== undefined) {
+                    clearTimeout(timeoutId);
+                }
+                if (init?.signal && abortListener) {
+                    init.signal.removeEventListener("abort", abortListener);
+                }
+            }
+        };
+        const token = this.apiToken;
+        let res = await makeRequest(token);
+        if (res.status === 401 && !token) {
+            const retryToken = this.apiToken;
+            if (retryToken) {
+                res = await makeRequest(retryToken);
+            }
+        }
+        if (!res.ok && !options?.allowNonOk) {
+            const body = (await res
+                .json()
+                .catch(() => ({ error: res.statusText })));
+            throw new ApiError({
+                kind: "http",
+                path,
+                status: res.status,
+                message: body?.error ?? `HTTP ${res.status}`,
+            });
+        }
+        return res;
+    }
+    async fetch(path, init, options) {
+        const res = await this.rawRequest(path, {
+            ...init,
+            headers: {
+                "Content-Type": "application/json",
+                ...init?.headers,
+            },
+        }, options);
+        if (res.status === 204) {
+            return undefined;
+        }
+        const text = await res.text();
+        if (text === "") {
+            return undefined;
+        }
+        try {
+            return JSON.parse(text);
+        }
+        catch (err) {
+            throw new ApiError({
+                kind: "parse",
+                path,
+                status: res.status,
+                message: err instanceof Error
+                    ? `Invalid JSON response: ${err.message}`
+                    : "Invalid JSON response",
+                cause: err,
+            });
+        }
+    }
+    // --- WebSocket ---
+    connectWs() {
+        if (this.ws?.readyState === WebSocket.OPEN ||
+            this.ws?.readyState === WebSocket.CONNECTING) {
+            return;
+        }
+        let host;
+        let wsProtocol;
+        if (this.baseUrl) {
+            const parsed = new URL(this.baseUrl);
+            host = parsed.host;
+            wsProtocol = parsed.protocol === "https:" ? "wss:" : "ws:";
+        }
+        else {
+            // In non-HTTP environments (electrobun://, file://, etc.)
+            // window.location.host may be empty or a non-routable placeholder like "-".
+            const loc = window.location;
+            if (loc.protocol !== "http:" && loc.protocol !== "https:")
+                return;
+            host = loc.host;
+            wsProtocol = loc.protocol === "https:" ? "wss:" : "ws:";
+        }
+        if (!host)
+            return;
+        // On Capacitor native (iosScheme/androidScheme = "https"), the origin host
+        // is a dummy bundle host (e.g. "localhost" with no server behind it).
+        // Skip WS if we have no explicit baseUrl and the host doesn't look like a
+        // real backend (no port, not an IP, not a known API domain).
+        if (!this.baseUrl && typeof host === "string") {
+            const hasPort = host.includes(":");
+            const isLoopback = host.startsWith("127.") || host.startsWith("localhost:");
+            if (!hasPort && !isLoopback)
+                return;
+        }
+        let url = `${wsProtocol}//${host}/ws`;
+        const params = new URLSearchParams({ clientId: this.clientId });
+        url += `?${params.toString()}`;
+        this.ws = new WebSocket(url);
+        this.ws.onopen = () => {
+            const token = this.apiToken;
+            if (token && this.ws?.readyState === WebSocket.OPEN) {
+                this.ws.send(JSON.stringify({ type: "auth", token }));
+            }
+            this.backoffMs = 500;
+            // Reset connection state on successful connection
+            this.reconnectAttempt = 0;
+            this.disconnectedAt = null;
+            this.connectionState = "connected";
+            this.emitConnectionStateChange();
+            // Notify listeners when the WS reconnects (not on the first connect)
+            // so they can re-hydrate state that may have been lost during the gap.
+            if (this.wsHasConnectedOnce) {
+                const handlers = this.wsHandlers.get("ws-reconnected");
+                if (handlers) {
+                    for (const handler of handlers) {
+                        handler({ type: "ws-reconnected" });
+                    }
+                }
+            }
+            this.wsHasConnectedOnce = true;
+            if (this.wsSendQueue.length > 0 &&
+                this.ws?.readyState === WebSocket.OPEN) {
+                const pending = this.wsSendQueue;
+                this.wsSendQueue = [];
+                for (let i = 0; i < pending.length; i++) {
+                    if (this.ws?.readyState !== WebSocket.OPEN) {
+                        this.wsSendQueue = pending.slice(i).concat(this.wsSendQueue);
+                        break;
+                    }
+                    try {
+                        this.ws.send(pending[i]);
+                    }
+                    catch {
+                        this.wsSendQueue = pending.slice(i).concat(this.wsSendQueue);
+                        break;
+                    }
+                }
+            }
+        };
+        this.ws.onmessage = (event) => {
+            try {
+                const data = JSON.parse(event.data);
+                const type = data.type;
+                const handlers = this.wsHandlers.get(type);
+                if (handlers) {
+                    for (const handler of handlers) {
+                        handler(data);
+                    }
+                }
+                // Also fire "all" handlers
+                const allHandlers = this.wsHandlers.get("*");
+                if (allHandlers) {
+                    for (const handler of allHandlers) {
+                        handler(data);
+                    }
+                }
+            }
+            catch {
+                // ignore parse errors
+            }
+        };
+        this.ws.onclose = () => {
+            this.ws = null;
+            // Track disconnection time if not already set
+            if (this.disconnectedAt === null) {
+                this.disconnectedAt = Date.now();
+            }
+            this.reconnectAttempt++;
+            // Update state based on attempt count
+            if (this.reconnectAttempt >= this.maxReconnectAttempts) {
+                this.connectionState = "failed";
+            }
+            else {
+                this.connectionState = "reconnecting";
+            }
+            this.emitConnectionStateChange();
+            this.scheduleReconnect();
+        };
+        this.ws.onerror = () => {
+            // close handler will fire
+        };
+    }
+    scheduleReconnect() {
+        if (this.reconnectTimer)
+            return;
+        // After the short backoff window is exhausted, keep probing at a
+        // low frequency so the UI can recover without a full page refresh.
+        if (this.reconnectAttempt >= this.maxReconnectAttempts) {
+            this.reconnectTimer = setTimeout(() => {
+                this.reconnectTimer = null;
+                this.connectWs();
+            }, 30_000);
+            return;
+        }
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = null;
+            this.connectWs();
+        }, this.backoffMs);
+        this.backoffMs = Math.min(this.backoffMs * 1.5, 10000);
+    }
+    emitConnectionStateChange() {
+        const state = this.getConnectionState();
+        for (const listener of this.connectionStateListeners) {
+            try {
+                listener(state);
+            }
+            catch {
+                // ignore listener errors
+            }
+        }
+    }
+    /** Get the current WebSocket connection state. */
+    getConnectionState() {
+        return {
+            state: this.connectionState,
+            reconnectAttempt: this.reconnectAttempt,
+            maxReconnectAttempts: this.maxReconnectAttempts,
+            disconnectedAt: this.disconnectedAt,
+        };
+    }
+    /** Subscribe to connection state changes. Returns an unsubscribe function. */
+    onConnectionStateChange(listener) {
+        this.connectionStateListeners.add(listener);
+        return () => {
+            this.connectionStateListeners.delete(listener);
+        };
+    }
+    /** Reset connection state and restart reconnection attempts. */
+    resetConnection() {
+        this.reconnectAttempt = 0;
+        this.disconnectedAt = null;
+        this.connectionState = "disconnected";
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        this.backoffMs = 500;
+        this.emitConnectionStateChange();
+        this.connectWs();
+    }
+    /** Send an arbitrary JSON message over the WebSocket connection. */
+    sendWsMessage(data) {
+        const payload = JSON.stringify(data);
+        if (this.ws?.readyState === WebSocket.OPEN) {
+            this.ws.send(payload);
+            return;
+        }
+        // Keep only the newest active-conversation update while disconnected.
+        if (data.type === "active-conversation") {
+            this.wsSendQueue = this.wsSendQueue.filter((queued) => {
+                try {
+                    const parsed = JSON.parse(queued);
+                    return parsed.type !== "active-conversation";
+                }
+                catch {
+                    return true;
+                }
+            });
+        }
+        if (this.wsSendQueue.length >= this.wsSendQueueLimit) {
+            const droppedType = typeof data.type === "string" ? data.type : "unknown";
+            console.warn("[ws] send queue full - dropping:", droppedType);
+            this.wsSendQueue.shift();
+        }
+        this.wsSendQueue.push(payload);
+        if (!this.ws || this.ws.readyState === WebSocket.CLOSED) {
+            this.connectWs();
+        }
+    }
+    onWsEvent(type, handler) {
+        if (!this.wsHandlers.has(type)) {
+            this.wsHandlers.set(type, new Set());
+        }
+        this.wsHandlers.get(type)?.add(handler);
+        return () => {
+            this.wsHandlers.get(type)?.delete(handler);
+        };
+    }
+    disconnectWs() {
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        this.ws?.close();
+        this.ws = null;
+        this.wsSendQueue = [];
+        // Reset connection state on intentional disconnect
+        this.reconnectAttempt = 0;
+        this.disconnectedAt = null;
+        this.connectionState = "disconnected";
+        this.emitConnectionStateChange();
+    }
+    // --- Text normalization helpers (used by chat domain methods) ---
+    normalizeAssistantText(text) {
+        const stripped = stripAssistantStageDirections(text);
+        const trimmed = stripped.trim();
+        if (trimmed.length === 0) {
+            if (text.trim().length === 0 ||
+                /^\(?no response\)?$/i.test(text.trim())) {
+                return GENERIC_NO_RESPONSE_TEXT;
+            }
+            return "";
+        }
+        if (/^\(?no response\)?$/i.test(trimmed)) {
+            return GENERIC_NO_RESPONSE_TEXT;
+        }
+        return trimmed;
+    }
+    normalizeGreetingText(text) {
+        const stripped = stripAssistantStageDirections(text);
+        const trimmed = stripped.trim();
+        if (trimmed.length === 0 || /^\(?no response\)?$/i.test(trimmed)) {
+            return "";
+        }
+        return trimmed;
+    }
+    // --- Streaming chat endpoint (used by chat domain methods) ---
+    async streamChatEndpoint(path, text, onToken, channelType = "DM", signal, images, conversationMode, metadata) {
+        const res = await this.rawRequest(path, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Accept: "text/event-stream",
+            },
+            body: JSON.stringify({
+                text,
+                channelType,
+                ...(images?.length ? { images } : {}),
+                ...(conversationMode ? { conversationMode } : {}),
+                ...(metadata ? { metadata } : {}),
+            }),
+            signal,
+        });
+        if (!res.body) {
+            throw new Error("Streaming not supported by this browser");
+        }
+        const decoder = new TextDecoder();
+        const reader = res.body.getReader();
+        let buffer = "";
+        let fullText = "";
+        let doneText = null;
+        let doneAgentName = null;
+        let doneNoResponseReason = null;
+        let doneUsage;
+        let receivedDone = false;
+        const findSseEventBreak = (chunkBuffer) => {
+            const lfBreak = chunkBuffer.indexOf("\n\n");
+            const crlfBreak = chunkBuffer.indexOf("\r\n\r\n");
+            if (lfBreak === -1 && crlfBreak === -1)
+                return null;
+            if (lfBreak === -1)
+                return { index: crlfBreak, length: 4 };
+            if (crlfBreak === -1)
+                return { index: lfBreak, length: 2 };
+            return lfBreak < crlfBreak
+                ? { index: lfBreak, length: 2 }
+                : { index: crlfBreak, length: 4 };
+        };
+        const parseDataLine = (line) => {
+            const payload = line.startsWith("data:") ? line.slice(5).trim() : "";
+            if (!payload)
+                return;
+            let parsed;
+            try {
+                parsed = JSON.parse(payload);
+            }
+            catch {
+                return;
+            }
+            if (!parsed.type && typeof parsed.text === "string") {
+                parsed.type = "token";
+            }
+            if (parsed.type === "token") {
+                const chunk = parsed.text ?? "";
+                const nextFullText = typeof parsed.fullText === "string"
+                    ? parsed.fullText
+                    : chunk
+                        ? mergeStreamingText(fullText, chunk)
+                        : fullText;
+                if (nextFullText === fullText)
+                    return;
+                fullText = nextFullText;
+                onToken(chunk, fullText);
+                return;
+            }
+            if (parsed.type === "done") {
+                receivedDone = true;
+                if (typeof parsed.fullText === "string")
+                    doneText = parsed.fullText;
+                if (typeof parsed.agentName === "string" && parsed.agentName.trim()) {
+                    doneAgentName = parsed.agentName;
+                }
+                if (parsed.noResponseReason === "ignored") {
+                    doneNoResponseReason = "ignored";
+                }
+                if (parsed.usage) {
+                    doneUsage = {
+                        promptTokens: parsed.usage.promptTokens ?? 0,
+                        completionTokens: parsed.usage.completionTokens ?? 0,
+                        totalTokens: parsed.usage.totalTokens ?? 0,
+                        model: parsed.usage.model,
+                    };
+                }
+                // Terminal event: stop reading immediately instead of waiting for the
+                // server to close the body (some stacks leave the stream open briefly).
+                void reader.cancel("elizaos-sse-terminal-done").catch(() => { });
+                return;
+            }
+            if (parsed.type === "error") {
+                throw new Error(parsed.message ?? "generation failed");
+            }
+        };
+        // Contract: the API must emit `data: {"type":"done",...}` or
+        // `data: {"type":"error",...}` and then end the response. If the server
+        // stalls mid-stream (e.g. LLM provider timeout without error propagation),
+        // the idle timeout below aborts the read so the UI doesn't hang forever.
+        const SSE_IDLE_TIMEOUT_MS = 60_000;
+        while (true) {
+            let done = false;
+            let value;
+            try {
+                const readPromise = reader.read();
+                const timeoutPromise = new Promise((_, reject) => {
+                    const id = setTimeout(() => reject(new Error("SSE idle timeout — no data for 60s")), SSE_IDLE_TIMEOUT_MS);
+                    // Clear timeout if the read resolves first
+                    void readPromise.finally(() => clearTimeout(id));
+                });
+                ({ done, value } = await Promise.race([readPromise, timeoutPromise]));
+            }
+            catch (streamErr) {
+                console.warn("[api-client] SSE stream interrupted:", streamErr);
+                void reader.cancel("elizaos-sse-idle-timeout").catch(() => { });
+                break;
+            }
+            if (done || !value)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            let eventBreak = findSseEventBreak(buffer);
+            while (eventBreak) {
+                const rawEvent = buffer.slice(0, eventBreak.index);
+                buffer = buffer.slice(eventBreak.index + eventBreak.length);
+                for (const line of rawEvent.split(/\r?\n/)) {
+                    if (!line.startsWith("data:"))
+                        continue;
+                    parseDataLine(line);
+                }
+                eventBreak = findSseEventBreak(buffer);
+            }
+        }
+        if (buffer.trim()) {
+            for (const line of buffer.split(/\r?\n/)) {
+                if (line.startsWith("data:"))
+                    parseDataLine(line);
+            }
+        }
+        const resolvedText = doneNoResponseReason === "ignored"
+            ? ""
+            : this.normalizeAssistantText(doneText ?? fullText);
+        return {
+            text: resolvedText,
+            agentName: doneAgentName ?? "Eliza",
+            completed: receivedDone,
+            ...(doneNoResponseReason
+                ? { noResponseReason: doneNoResponseReason }
+                : {}),
+            ...(doneUsage ? { usage: doneUsage } : {}),
+        };
+    }
+}