@elizaos/agent 2.0.0-alpha.520 → 2.0.0-alpha.521

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

@@ -1,729 +0,0 @@
-/**
- * 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 } : {}),
-        };
-    }
-}