@elizaos/app-core 2.0.0-alpha.85 → 2.0.0-beta.2

package/api/client.js

@@ -1,2520 +0,0 @@
-/**
- * API client for the Milady backend.
- *
- * Thin fetch wrapper + WebSocket for real-time chat/events.
- * Replaces the gateway WebSocket protocol entirely.
- */
-import { DEFAULT_WALLET_RPC_SELECTIONS, normalizeWalletRpcProviderId, normalizeWalletRpcSelections, WALLET_RPC_PROVIDER_OPTIONS, } from "@elizaos/autonomous/contracts/wallet";
-import { stripAssistantStageDirections } from "../utils/assistant-text";
-import { mergeStreamingText } from "../utils/streaming-text";
-export { DEFAULT_WALLET_RPC_SELECTIONS, normalizeWalletRpcProviderId, normalizeWalletRpcSelections, WALLET_RPC_PROVIDER_OPTIONS, };
-export class ApiError extends Error {
-    kind;
-    status;
-    path;
-    constructor(options) {
-        super(options.message);
-        this.name = "ApiError";
-        this.kind = options.kind;
-        this.path = options.path;
-        this.status = options.status;
-        if (options.cause !== undefined) {
-            this.cause = options.cause;
-        }
-    }
-}
-export function isApiError(value) {
-    return value instanceof ApiError;
-}
-// ---------------------------------------------------------------------------
-// Client
-// ---------------------------------------------------------------------------
-const GENERIC_NO_RESPONSE_TEXT = "Sorry, I couldn't generate a response right now. Please try again.";
-const AGENT_TRANSFER_MIN_PASSWORD_LENGTH = 4;
-const DEFAULT_FETCH_TIMEOUT_MS = 10_000;
-const SESSION_STORAGE_API_BASE_KEY = "milady_api_base";
-const SESSION_STORAGE_API_TOKEN_KEY = "milady_api_token";
-export class MiladyClient {
-    _baseUrl;
-    _explicitBase;
-    _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 resolveDesktopLocalFallbackBase() {
-        if (typeof window === "undefined")
-            return "";
-        const proto = window.location.protocol;
-        // In the desktop shell the main process injects the live API base
-        // once the embedded agent has bound a port. Avoid eager localhost probes
-        // to prevent noisy ERR_CONNECTION_REFUSED logs during startup.
-        if (proto === "electrobun:")
-            return "";
-        if (proto === "file:") {
-            return "http://localhost:2138";
-        }
-        return "";
-    }
-    static generateClientId() {
-        const random = typeof globalThis.crypto?.randomUUID === "function"
-            ? globalThis.crypto.randomUUID()
-            : `${Date.now().toString(36)}${Math.random().toString(36).slice(2)}`;
-        return `ui-${random.replace(/[^a-zA-Z0-9._-]/g, "")}`;
-    }
-    constructor(baseUrl, token) {
-        this.clientId = MiladyClient.generateClientId();
-        const stored = typeof window !== "undefined"
-            ? window.sessionStorage.getItem(SESSION_STORAGE_API_TOKEN_KEY)
-            : null;
-        const storedBase = typeof window !== "undefined"
-            ? window.sessionStorage.getItem(SESSION_STORAGE_API_BASE_KEY)
-            : null;
-        this._explicitBase = baseUrl != null || Boolean(storedBase?.trim());
-        this._token = token?.trim() || stored || null;
-        // Priority: explicit arg > desktop-injected global > same origin (Vite proxy)
-        const injectedBase = typeof window !== "undefined" ? window.__MILADY_API_BASE__ : undefined;
-        this._baseUrl =
-            baseUrl ??
-                storedBase ??
-                injectedBase ??
-                MiladyClient.resolveDesktopLocalFallbackBase();
-    }
-    /**
-     * Resolve the API base URL lazily.
-     * In the desktop shell the main process injects window.__MILADY_API_BASE__ after the
-     * page loads (once the agent runtime starts). Re-checking on every call
-     * ensures we pick up the injected value even if it wasn't set at construction.
-     */
-    get baseUrl() {
-        if (!this._explicitBase && typeof window !== "undefined") {
-            const injected = window.__MILADY_API_BASE__;
-            // In the desktop shell the API base can be injected after initial render. Always
-            // prefer the injected value when present so the client can switch away
-            // from the localhost fallback once the main process publishes the real
-            // endpoint.
-            if (injected && injected !== this._baseUrl) {
-                this._baseUrl = injected;
-            }
-            else if (!this._baseUrl) {
-                this._baseUrl = MiladyClient.resolveDesktopLocalFallbackBase();
-            }
-        }
-        return this._baseUrl;
-    }
-    get apiToken() {
-        if (this._token)
-            return this._token;
-        if (typeof window === "undefined")
-            return null;
-        const injected = window.__MILADY_API_TOKEN__;
-        if (typeof injected === "string" && injected.trim())
-            return injected.trim();
-        return null;
-    }
-    hasToken() {
-        return Boolean(this.apiToken);
-    }
-    setToken(token) {
-        this._token = token?.trim() || null;
-        if (typeof window !== "undefined") {
-            if (this._token) {
-                window.__MILADY_API_TOKEN__ = this._token;
-                window.sessionStorage.setItem(SESSION_STORAGE_API_TOKEN_KEY, this._token);
-            }
-            else {
-                delete window.__MILADY_API_TOKEN__;
-                window.sessionStorage.removeItem(SESSION_STORAGE_API_TOKEN_KEY);
-            }
-        }
-    }
-    getBaseUrl() {
-        return this.baseUrl;
-    }
-    setBaseUrl(baseUrl) {
-        const normalized = baseUrl?.trim().replace(/\/+$/, "") || "";
-        this._explicitBase = normalized.length > 0;
-        this._baseUrl = normalized;
-        this.disconnectWs();
-        if (typeof window !== "undefined") {
-            if (normalized) {
-                window.__MILADY_API_BASE__ = normalized;
-                window.sessionStorage.setItem(SESSION_STORAGE_API_BASE_KEY, normalized);
-            }
-            else {
-                delete window.__MILADY_API_BASE__;
-                window.sessionStorage.removeItem(SESSION_STORAGE_API_BASE_KEY);
-            }
-        }
-    }
-    /** 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 makeRequest = async (token) => {
-            let timeoutId;
-            let abortListener;
-            const requestInit = {
-                ...init,
-                headers: {
-                    "X-Milady-Client-Id": this.clientId,
-                    ...(token ? { Authorization: `Bearer ${token}` } : {}),
-                    ...(this._uiLanguage
-                        ? { "X-Milady-UI-Language": this._uiLanguage }
-                        : {}),
-                    ...init?.headers,
-                },
-            };
-            const fetchPromise = fetch(`${this.baseUrl}${path}`, requestInit);
-            const pending = [fetchPromise];
-            pending.push(new Promise((_, reject) => {
-                timeoutId = setTimeout(() => {
-                    reject(new ApiError({
-                        kind: "timeout",
-                        path,
-                        message: `Request timed out after ${DEFAULT_FETCH_TIMEOUT_MS}ms`,
-                    }));
-                }, DEFAULT_FETCH_TIMEOUT_MS);
-            }));
-            if (init?.signal) {
-                if (init.signal.aborted) {
-                    throw new ApiError({
-                        kind: "network",
-                        path,
-                        message: "Request aborted",
-                    });
-                }
-                pending.push(new Promise((_, reject) => {
-                    abortListener = () => {
-                        reject(new ApiError({
-                            kind: "network",
-                            path,
-                            message: "Request aborted",
-                        }));
-                    };
-                    init.signal?.addEventListener("abort", abortListener, {
-                        once: true,
-                    });
-                }));
-            }
-            try {
-                return await Promise.race(pending);
-            }
-            catch (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) {
-        const res = await this.rawRequest(path, {
-            ...init,
-            headers: {
-                "Content-Type": "application/json",
-                ...init?.headers,
-            },
-        });
-        return res.json();
-    }
-    async getStatus() {
-        return this.fetch("/api/status");
-    }
-    async getAgentSelfStatus() {
-        return this.fetch("/api/agent/self-status");
-    }
-    async getRuntimeSnapshot(opts) {
-        const params = new URLSearchParams();
-        if (typeof opts?.depth === "number")
-            params.set("depth", String(opts.depth));
-        if (typeof opts?.maxArrayLength === "number") {
-            params.set("maxArrayLength", String(opts.maxArrayLength));
-        }
-        if (typeof opts?.maxObjectEntries === "number") {
-            params.set("maxObjectEntries", String(opts.maxObjectEntries));
-        }
-        if (typeof opts?.maxStringLength === "number") {
-            params.set("maxStringLength", String(opts.maxStringLength));
-        }
-        const qs = params.toString();
-        return this.fetch(`/api/runtime${qs ? `?${qs}` : ""}`);
-    }
-    async setAutomationMode(mode) {
-        return this.fetch("/api/permissions/automation-mode", {
-            method: "PUT",
-            body: JSON.stringify({ mode }),
-        });
-    }
-    async setTradeMode(mode) {
-        return this.fetch("/api/permissions/trade-mode", {
-            method: "PUT",
-            body: JSON.stringify({ mode }),
-        });
-    }
-    async playEmote(emoteId) {
-        return this.fetch("/api/emote", {
-            method: "POST",
-            body: JSON.stringify({ emoteId }),
-        });
-    }
-    async runTerminalCommand(command) {
-        return this.fetch("/api/terminal/run", {
-            method: "POST",
-            body: JSON.stringify({ command }),
-        });
-    }
-    async getOnboardingStatus() {
-        return this.fetch("/api/onboarding/status");
-    }
-    async getWalletKeys() {
-        return this.fetch("/api/wallet/keys");
-    }
-    async getAuthStatus() {
-        console.log("🚨🚨🚨 REAL CLIENT GET_AUTH_STATUS CALLED! 🚨🚨🚨");
-        // Retry with exponential backoff — the server may not be ready during boot.
-        const maxRetries = 3;
-        const baseBackoffMs = 1000;
-        let lastErr;
-        for (let attempt = 0; attempt <= maxRetries; attempt++) {
-            try {
-                return await this.fetch("/api/auth/status");
-            }
-            catch (err) {
-                const status = err?.status;
-                if (status === 401) {
-                    return { required: true, pairingEnabled: false, expiresAt: null };
-                }
-                if (status === 404) {
-                    return { required: false, pairingEnabled: false, expiresAt: null };
-                }
-                lastErr = err;
-                const kind = err?.kind;
-                if (kind === "timeout" && attempt < maxRetries) {
-                    await new Promise((r) => setTimeout(r, baseBackoffMs * 2 ** attempt));
-                    continue;
-                }
-                if (attempt >= maxRetries)
-                    break;
-            }
-        }
-        throw lastErr;
-    }
-    async pair(code) {
-        const res = await this.fetch("/api/auth/pair", {
-            method: "POST",
-            body: JSON.stringify({ code }),
-        });
-        return res;
-    }
-    async getOnboardingOptions() {
-        return this.fetch("/api/onboarding/options");
-    }
-    async submitOnboarding(data) {
-        await this.fetch("/api/onboarding", {
-            method: "POST",
-            body: JSON.stringify(data),
-        });
-    }
-    async startAnthropicLogin() {
-        return this.fetch("/api/subscription/anthropic/start", { method: "POST" });
-    }
-    async exchangeAnthropicCode(code) {
-        return this.fetch("/api/subscription/anthropic/exchange", {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({ code }),
-        });
-    }
-    async submitAnthropicSetupToken(token) {
-        return this.fetch("/api/subscription/anthropic/setup-token", {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({ token }),
-        });
-    }
-    async getSubscriptionStatus() {
-        return this.fetch("/api/subscription/status");
-    }
-    async deleteSubscription(provider) {
-        return this.fetch(`/api/subscription/${encodeURIComponent(provider)}`, {
-            method: "DELETE",
-        });
-    }
-    async switchProvider(provider, apiKey) {
-        return this.fetch("/api/provider/switch", {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({ provider, ...(apiKey ? { apiKey } : {}) }),
-        });
-    }
-    async startOpenAILogin() {
-        return this.fetch("/api/subscription/openai/start", { method: "POST" });
-    }
-    async exchangeOpenAICode(code) {
-        return this.fetch("/api/subscription/openai/exchange", {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({ code }),
-        });
-    }
-    async getSandboxPlatform() {
-        return this.fetch("/api/sandbox/platform");
-    }
-    async getSandboxBrowser() {
-        return this.fetch("/api/sandbox/browser");
-    }
-    async getSandboxScreenshot(region) {
-        if (!region) {
-            return this.fetch("/api/sandbox/screen/screenshot", {
-                method: "POST",
-            });
-        }
-        return this.fetch("/api/sandbox/screen/screenshot", {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify(region),
-        });
-    }
-    async getSandboxWindows() {
-        return this.fetch("/api/sandbox/screen/windows");
-    }
-    async startDocker() {
-        return this.fetch("/api/sandbox/docker/start", { method: "POST" });
-    }
-    async startAgent() {
-        const res = await this.fetch("/api/agent/start", {
-            method: "POST",
-        });
-        return res.status;
-    }
-    async stopAgent() {
-        const res = await this.fetch("/api/agent/stop", {
-            method: "POST",
-        });
-        return res.status;
-    }
-    async pauseAgent() {
-        const res = await this.fetch("/api/agent/pause", {
-            method: "POST",
-        });
-        return res.status;
-    }
-    async resumeAgent() {
-        const res = await this.fetch("/api/agent/resume", {
-            method: "POST",
-        });
-        return res.status;
-    }
-    async restartAgent() {
-        const res = await this.fetch("/api/agent/restart", { method: "POST" });
-        return res.status;
-    }
-    /**
-     * Restart the agent if possible, or wait for an in-progress restart to finish.
-     * Polls status until the agent state is "running".
-     */
-    async restartAndWait(maxWaitMs = 30000) {
-        // Try triggering a restart; 409 means one is already in progress
-        try {
-            await this.restartAgent();
-        }
-        catch {
-            // Already restarting — that's fine, we'll poll
-        }
-        // Poll until running
-        const start = Date.now();
-        const interval = 1000;
-        while (Date.now() - start < maxWaitMs) {
-            await new Promise((r) => setTimeout(r, interval));
-            try {
-                const status = await this.getStatus();
-                if (status.state === "running")
-                    return status;
-            }
-            catch {
-                // Server may be briefly unavailable during restart
-            }
-        }
-        // Return whatever we get after timeout
-        return this.getStatus();
-    }
-    async resetAgent() {
-        await this.fetch("/api/agent/reset", { method: "POST" });
-    }
-    async getConfig() {
-        return this.fetch("/api/config");
-    }
-    async getConfigSchema() {
-        return this.fetch("/api/config/schema");
-    }
-    async updateConfig(patch) {
-        return this.fetch("/api/config", {
-            method: "PUT",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify(patch),
-        });
-    }
-    // ── Custom VRM avatar ────────────────────────────────────────────────
-    async uploadCustomVrm(file) {
-        const buf = await file.arrayBuffer();
-        await this.fetch("/api/avatar/vrm", {
-            method: "POST",
-            headers: { "Content-Type": "application/octet-stream" },
-            body: buf,
-        });
-    }
-    /** Uses raw fetch instead of this.fetch() because HEAD returns no JSON body. */
-    async hasCustomVrm() {
-        try {
-            const res = await this.rawRequest("/api/avatar/vrm", { method: "HEAD" }, { allowNonOk: true });
-            return res.ok;
-        }
-        catch {
-            return false;
-        }
-    }
-    // ── Custom background image ─────────────────────────────────────────
-    async uploadCustomBackground(file) {
-        const buf = await file.arrayBuffer();
-        await this.fetch("/api/avatar/background", {
-            method: "POST",
-            headers: { "Content-Type": "application/octet-stream" },
-            body: buf,
-        });
-    }
-    /** Uses raw fetch instead of this.fetch() because HEAD returns no JSON body. */
-    async hasCustomBackground() {
-        try {
-            const res = await this.rawRequest("/api/avatar/background", { method: "HEAD" }, { allowNonOk: true });
-            return res.ok;
-        }
-        catch {
-            return false;
-        }
-    }
-    // ── Connectors ──────────────────────────────────────────────────────
-    async getConnectors() {
-        return this.fetch("/api/connectors");
-    }
-    async saveConnector(name, config) {
-        return this.fetch("/api/connectors", {
-            method: "POST",
-            body: JSON.stringify({ name, config }),
-        });
-    }
-    async deleteConnector(name) {
-        return this.fetch(`/api/connectors/${encodeURIComponent(name)}`, {
-            method: "DELETE",
-        });
-    }
-    async getTriggers() {
-        return this.fetch("/api/triggers");
-    }
-    async getTrigger(id) {
-        return this.fetch(`/api/triggers/${encodeURIComponent(id)}`);
-    }
-    async createTrigger(request) {
-        return this.fetch("/api/triggers", {
-            method: "POST",
-            body: JSON.stringify(request),
-        });
-    }
-    async updateTrigger(id, request) {
-        return this.fetch(`/api/triggers/${encodeURIComponent(id)}`, {
-            method: "PUT",
-            body: JSON.stringify(request),
-        });
-    }
-    async deleteTrigger(id) {
-        return this.fetch(`/api/triggers/${encodeURIComponent(id)}`, {
-            method: "DELETE",
-        });
-    }
-    async runTriggerNow(id) {
-        return this.fetch(`/api/triggers/${encodeURIComponent(id)}/execute`, {
-            method: "POST",
-        });
-    }
-    async getTriggerRuns(id) {
-        return this.fetch(`/api/triggers/${encodeURIComponent(id)}/runs`);
-    }
-    async getTriggerHealth() {
-        return this.fetch("/api/triggers/health");
-    }
-    // Fine-tuning / training
-    async getTrainingStatus() {
-        return this.fetch("/api/training/status");
-    }
-    async listTrainingTrajectories(opts) {
-        const params = new URLSearchParams();
-        if (typeof opts?.limit === "number")
-            params.set("limit", String(opts.limit));
-        if (typeof opts?.offset === "number")
-            params.set("offset", String(opts.offset));
-        const qs = params.toString();
-        return this.fetch(`/api/training/trajectories${qs ? `?${qs}` : ""}`);
-    }
-    async getTrainingTrajectory(trajectoryId) {
-        return this.fetch(`/api/training/trajectories/${encodeURIComponent(trajectoryId)}`);
-    }
-    async listTrainingDatasets() {
-        return this.fetch("/api/training/datasets");
-    }
-    async buildTrainingDataset(options) {
-        return this.fetch("/api/training/datasets/build", {
-            method: "POST",
-            body: JSON.stringify(options ?? {}),
-        });
-    }
-    async listTrainingJobs() {
-        return this.fetch("/api/training/jobs");
-    }
-    async startTrainingJob(options) {
-        return this.fetch("/api/training/jobs", {
-            method: "POST",
-            body: JSON.stringify(options ?? {}),
-        });
-    }
-    async getTrainingJob(jobId) {
-        return this.fetch(`/api/training/jobs/${encodeURIComponent(jobId)}`);
-    }
-    async cancelTrainingJob(jobId) {
-        return this.fetch(`/api/training/jobs/${encodeURIComponent(jobId)}/cancel`, {
-            method: "POST",
-        });
-    }
-    async listTrainingModels() {
-        return this.fetch("/api/training/models");
-    }
-    async importTrainingModelToOllama(modelId, options) {
-        return this.fetch(`/api/training/models/${encodeURIComponent(modelId)}/import-ollama`, {
-            method: "POST",
-            body: JSON.stringify(options ?? {}),
-        });
-    }
-    async activateTrainingModel(modelId, providerModel) {
-        return this.fetch(`/api/training/models/${encodeURIComponent(modelId)}/activate`, {
-            method: "POST",
-            body: JSON.stringify({ providerModel }),
-        });
-    }
-    async benchmarkTrainingModel(modelId) {
-        return this.fetch(`/api/training/models/${encodeURIComponent(modelId)}/benchmark`, {
-            method: "POST",
-        });
-    }
-    async getPlugins() {
-        return this.fetch("/api/plugins");
-    }
-    async fetchModels(provider, refresh = true) {
-        const params = new URLSearchParams({ provider });
-        if (refresh)
-            params.set("refresh", "true");
-        return this.fetch(`/api/models?${params.toString()}`);
-    }
-    async getCorePlugins() {
-        return this.fetch("/api/plugins/core");
-    }
-    async toggleCorePlugin(npmName, enabled) {
-        return this.fetch("/api/plugins/core/toggle", {
-            method: "POST",
-            body: JSON.stringify({ npmName, enabled }),
-        });
-    }
-    async updatePlugin(id, config) {
-        return this.fetch(`/api/plugins/${id}`, {
-            method: "PUT",
-            body: JSON.stringify(config),
-        });
-    }
-    async getSecrets() {
-        return this.fetch("/api/secrets");
-    }
-    async updateSecrets(secrets) {
-        return this.fetch("/api/secrets", {
-            method: "PUT",
-            body: JSON.stringify({ secrets }),
-        });
-    }
-    async testPluginConnection(id) {
-        return this.fetch(`/api/plugins/${encodeURIComponent(id)}/test`, {
-            method: "POST",
-        });
-    }
-    async restart() {
-        return this.fetch("/api/restart", { method: "POST" });
-    }
-    async getSkills() {
-        return this.fetch("/api/skills");
-    }
-    async refreshSkills() {
-        return this.fetch("/api/skills/refresh", { method: "POST" });
-    }
-    async getLogs(filter) {
-        const params = new URLSearchParams();
-        if (filter?.source)
-            params.set("source", filter.source);
-        if (filter?.level)
-            params.set("level", filter.level);
-        if (filter?.tag)
-            params.set("tag", filter.tag);
-        if (filter?.since)
-            params.set("since", String(filter.since));
-        const qs = params.toString();
-        return this.fetch(`/api/logs${qs ? `?${qs}` : ""}`);
-    }
-    buildSecurityAuditParams(filter, includeStream = false) {
-        const params = new URLSearchParams();
-        if (filter?.type)
-            params.set("type", filter.type);
-        if (filter?.severity)
-            params.set("severity", filter.severity);
-        if (filter?.since !== undefined) {
-            const sinceValue = filter.since instanceof Date
-                ? filter.since.toISOString()
-                : String(filter.since);
-            params.set("since", sinceValue);
-        }
-        if (filter?.limit !== undefined)
-            params.set("limit", String(filter.limit));
-        if (includeStream)
-            params.set("stream", "1");
-        return params;
-    }
-    async getSecurityAudit(filter) {
-        const qs = this.buildSecurityAuditParams(filter).toString();
-        return this.fetch(`/api/security/audit${qs ? `?${qs}` : ""}`);
-    }
-    async streamSecurityAudit(onEvent, filter, signal) {
-        if (!this.apiAvailable) {
-            throw new Error("API not available (no HTTP origin)");
-        }
-        const token = this.apiToken;
-        const qs = this.buildSecurityAuditParams(filter, true).toString();
-        const res = await fetch(`${this.baseUrl}/api/security/audit${qs ? `?${qs}` : ""}`, {
-            method: "GET",
-            headers: {
-                Accept: "text/event-stream",
-                ...(token ? { Authorization: `Bearer ${token}` } : {}),
-            },
-            signal,
-        });
-        if (!res.ok) {
-            const body = (await res
-                .json()
-                .catch(() => ({ error: res.statusText })));
-            const err = new Error(body.error ?? `HTTP ${res.status}`);
-            err.status = res.status;
-            throw err;
-        }
-        if (!res.body) {
-            throw new Error("Streaming not supported by this browser");
-        }
-        const parsePayload = (payload) => {
-            if (!payload)
-                return;
-            try {
-                const parsed = JSON.parse(payload);
-                if (parsed.type === "snapshot" || parsed.type === "entry") {
-                    onEvent(parsed);
-                }
-            }
-            catch {
-                // Ignore malformed payloads to keep stream consumption resilient.
-            }
-        };
-        const decoder = new TextDecoder();
-        const reader = res.body.getReader();
-        let buffer = "";
-        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 };
-        };
-        while (true) {
-            const { done, value } = await reader.read();
-            if (done)
-                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;
-                    parsePayload(line.slice(5).trim());
-                }
-                eventBreak = findSseEventBreak(buffer);
-            }
-        }
-        if (buffer.trim()) {
-            for (const line of buffer.split(/\r?\n/)) {
-                if (!line.startsWith("data:"))
-                    continue;
-                parsePayload(line.slice(5).trim());
-            }
-        }
-    }
-    async getAgentEvents(opts) {
-        const params = new URLSearchParams();
-        if (opts?.afterEventId)
-            params.set("after", opts.afterEventId);
-        if (typeof opts?.limit === "number")
-            params.set("limit", String(opts.limit));
-        if (opts?.runId)
-            params.set("runId", opts.runId);
-        if (typeof opts?.fromSeq === "number")
-            params.set("fromSeq", String(Math.trunc(opts.fromSeq)));
-        const qs = params.toString();
-        return this.fetch(`/api/agent/events${qs ? `?${qs}` : ""}`);
-    }
-    async getExtensionStatus() {
-        return this.fetch("/api/extension/status");
-    }
-    // Skill Catalog
-    async getSkillCatalog(opts) {
-        const params = new URLSearchParams();
-        if (opts?.page)
-            params.set("page", String(opts.page));
-        if (opts?.perPage)
-            params.set("perPage", String(opts.perPage));
-        if (opts?.sort)
-            params.set("sort", opts.sort);
-        const qs = params.toString();
-        return this.fetch(`/api/skills/catalog${qs ? `?${qs}` : ""}`);
-    }
-    async searchSkillCatalog(query, limit = 30) {
-        return this.fetch(`/api/skills/catalog/search?q=${encodeURIComponent(query)}&limit=${limit}`);
-    }
-    async getSkillCatalogDetail(slug) {
-        return this.fetch(`/api/skills/catalog/${encodeURIComponent(slug)}`);
-    }
-    async refreshSkillCatalog() {
-        return this.fetch("/api/skills/catalog/refresh", { method: "POST" });
-    }
-    async installCatalogSkill(slug, version) {
-        return this.fetch("/api/skills/catalog/install", {
-            method: "POST",
-            body: JSON.stringify({ slug, version }),
-        });
-    }
-    async uninstallCatalogSkill(slug) {
-        return this.fetch("/api/skills/catalog/uninstall", {
-            method: "POST",
-            body: JSON.stringify({ slug }),
-        });
-    }
-    // Registry / Plugin Store
-    async getRegistryPlugins() {
-        return this.fetch("/api/registry/plugins");
-    }
-    async getRegistryPluginInfo(name) {
-        return this.fetch(`/api/registry/plugins/${encodeURIComponent(name)}`);
-    }
-    async getInstalledPlugins() {
-        return this.fetch("/api/plugins/installed");
-    }
-    async installRegistryPlugin(name, autoRestart = true) {
-        return this.fetch("/api/plugins/install", {
-            method: "POST",
-            body: JSON.stringify({ name, autoRestart }),
-        });
-    }
-    async uninstallRegistryPlugin(name, autoRestart = true) {
-        return this.fetch("/api/plugins/uninstall", {
-            method: "POST",
-            body: JSON.stringify({ name, autoRestart }),
-        });
-    }
-    // Agent Export / Import
-    /**
-     * Export the agent as a password-encrypted .eliza-agent file.
-     * Returns the raw Response so the caller can stream the binary body.
-     */
-    async exportAgent(password, includeLogs = false) {
-        if (password.length < AGENT_TRANSFER_MIN_PASSWORD_LENGTH) {
-            throw new Error(`Password must be at least ${AGENT_TRANSFER_MIN_PASSWORD_LENGTH} characters.`);
-        }
-        return this.rawRequest("/api/agent/export", {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-            },
-            body: JSON.stringify({ password, includeLogs }),
-        });
-    }
-    /** Get an estimate of the export size. */
-    async getExportEstimate() {
-        return this.fetch("/api/agent/export/estimate");
-    }
-    /**
-     * Import an agent from a password-encrypted .eliza-agent file.
-     * Encodes the password and file into a binary envelope.
-     */
-    async importAgent(password, fileBuffer) {
-        if (password.length < AGENT_TRANSFER_MIN_PASSWORD_LENGTH) {
-            throw new Error(`Password must be at least ${AGENT_TRANSFER_MIN_PASSWORD_LENGTH} characters.`);
-        }
-        const passwordBytes = new TextEncoder().encode(password);
-        const envelope = new Uint8Array(4 + passwordBytes.length + fileBuffer.byteLength);
-        const view = new DataView(envelope.buffer);
-        view.setUint32(0, passwordBytes.length, false);
-        envelope.set(passwordBytes, 4);
-        envelope.set(new Uint8Array(fileBuffer), 4 + passwordBytes.length);
-        const res = await this.rawRequest("/api/agent/import", {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/octet-stream",
-            },
-            body: envelope,
-        });
-        const data = (await res.json());
-        if (!data.success) {
-            throw new Error(data.error ?? `Import failed (${res.status})`);
-        }
-        return data;
-    }
-    // Character
-    async getCharacter() {
-        return this.fetch("/api/character");
-    }
-    async getRandomName() {
-        return this.fetch("/api/character/random-name");
-    }
-    async generateCharacterField(field, context, mode) {
-        return this.fetch("/api/character/generate", {
-            method: "POST",
-            body: JSON.stringify({ field, context, mode }),
-        });
-    }
-    async updateCharacter(character) {
-        return this.fetch("/api/character", {
-            method: "PUT",
-            body: JSON.stringify(character),
-        });
-    }
-    // Wallet
-    async getWalletAddresses() {
-        return this.fetch("/api/wallet/addresses");
-    }
-    async getWalletBalances() {
-        return this.fetch("/api/wallet/balances");
-    }
-    async getWalletNfts() {
-        return this.fetch("/api/wallet/nfts");
-    }
-    async getWalletConfig() {
-        return this.fetch("/api/wallet/config");
-    }
-    async updateWalletConfig(config) {
-        return this.fetch("/api/wallet/config", {
-            method: "PUT",
-            body: JSON.stringify(config),
-        });
-    }
-    async exportWalletKeys(exportToken) {
-        return this.fetch("/api/wallet/export", {
-            method: "POST",
-            body: JSON.stringify({ confirm: true, exportToken }),
-        });
-    }
-    // BSC Trading
-    async getBscTradePreflight(tokenAddress) {
-        return this.fetch("/api/wallet/trade/preflight", {
-            method: "POST",
-            body: JSON.stringify(tokenAddress?.trim() ? { tokenAddress: tokenAddress.trim() } : {}),
-        });
-    }
-    async getBscTradeQuote(request) {
-        return this.fetch("/api/wallet/trade/quote", {
-            method: "POST",
-            body: JSON.stringify(request),
-        });
-    }
-    async executeBscTrade(request) {
-        return this.fetch("/api/wallet/trade/execute", {
-            method: "POST",
-            body: JSON.stringify(request),
-        });
-    }
-    async executeBscTransfer(request) {
-        return this.fetch("/api/wallet/transfer/execute", {
-            method: "POST",
-            body: JSON.stringify(request),
-        });
-    }
-    async getBscTradeTxStatus(hash) {
-        return this.fetch(`/api/wallet/trade/tx-status?hash=${encodeURIComponent(hash)}`);
-    }
-    async getWalletTradingProfile(window = "30d", source = "all") {
-        const params = new URLSearchParams({
-            window,
-            source,
-        });
-        return this.fetch(`/api/wallet/trading/profile?${params.toString()}`);
-    }
-    async applyProductionWalletDefaults() {
-        return this.fetch("/api/wallet/production-defaults", {
-            method: "POST",
-            body: JSON.stringify({ confirm: true }),
-        });
-    }
-    // Software Updates
-    async getUpdateStatus(force = false) {
-        return this.fetch(`/api/update/status${force ? "?force=true" : ""}`);
-    }
-    async setUpdateChannel(channel) {
-        return this.fetch("/api/update/channel", {
-            method: "PUT",
-            body: JSON.stringify({ channel }),
-        });
-    }
-    // Cloud
-    async getCloudStatus() {
-        return this.fetch("/api/cloud/status");
-    }
-    async getCloudCredits() {
-        return this.fetch("/api/cloud/credits");
-    }
-    async getCloudBillingSummary() {
-        return this.fetch("/api/cloud/billing/summary");
-    }
-    async getCloudBillingSettings() {
-        return this.fetch("/api/cloud/billing/settings");
-    }
-    async updateCloudBillingSettings(request) {
-        return this.fetch("/api/cloud/billing/settings", {
-            method: "PUT",
-            body: JSON.stringify(request),
-        });
-    }
-    async getCloudBillingPaymentMethods() {
-        return this.fetch("/api/cloud/billing/payment-methods");
-    }
-    async getCloudBillingHistory() {
-        return this.fetch("/api/cloud/billing/history");
-    }
-    async createCloudBillingCheckout(request) {
-        return this.fetch("/api/cloud/billing/checkout", {
-            method: "POST",
-            body: JSON.stringify(request),
-        });
-    }
-    async createCloudBillingCryptoQuote(request) {
-        return this.fetch("/api/cloud/billing/crypto/quote", {
-            method: "POST",
-            body: JSON.stringify(request),
-        });
-    }
-    async cloudLogin() {
-        return this.fetch("/api/cloud/login", { method: "POST" });
-    }
-    async cloudLoginPoll(sessionId) {
-        return this.fetch(`/api/cloud/login/status?sessionId=${encodeURIComponent(sessionId)}`);
-    }
-    async cloudDisconnect() {
-        return this.fetch("/api/cloud/disconnect", { method: "POST" });
-    }
-    // Cloud Compat (Eliza Cloud v2 thin-client endpoints)
-    /** List all cloud-hosted agents for the authenticated user. */
-    async getCloudCompatAgents() {
-        return this.fetch("/api/cloud/compat/agents");
-    }
-    /** Create a new cloud-hosted agent. */
-    async createCloudCompatAgent(opts) {
-        return this.fetch("/api/cloud/compat/agents", {
-            method: "POST",
-            body: JSON.stringify(opts),
-        });
-    }
-    /** Get a specific cloud-hosted agent by ID. */
-    async getCloudCompatAgent(agentId) {
-        return this.fetch(`/api/cloud/compat/agents/${encodeURIComponent(agentId)}`);
-    }
-    /** Delete a cloud-hosted agent. */
-    async deleteCloudCompatAgent(agentId) {
-        return this.fetch(`/api/cloud/compat/agents/${encodeURIComponent(agentId)}`, { method: "DELETE" });
-    }
-    /** Get status of a cloud-hosted agent. */
-    async getCloudCompatAgentStatus(agentId) {
-        return this.fetch(`/api/cloud/compat/agents/${encodeURIComponent(agentId)}/status`);
-    }
-    /** Get logs from a cloud-hosted agent. */
-    async getCloudCompatAgentLogs(agentId, tail = 100) {
-        return this.fetch(`/api/cloud/compat/agents/${encodeURIComponent(agentId)}/logs?tail=${tail}`);
-    }
-    /** Restart a cloud-hosted agent. */
-    async restartCloudCompatAgent(agentId) {
-        return this.fetch(`/api/cloud/compat/agents/${encodeURIComponent(agentId)}/restart`, { method: "POST" });
-    }
-    /** Suspend a cloud-hosted agent. */
-    async suspendCloudCompatAgent(agentId) {
-        return this.fetch(`/api/cloud/compat/agents/${encodeURIComponent(agentId)}/suspend`, { method: "POST" });
-    }
-    /** Resume a cloud-hosted agent. */
-    async resumeCloudCompatAgent(agentId) {
-        return this.fetch(`/api/cloud/compat/agents/${encodeURIComponent(agentId)}/resume`, { method: "POST" });
-    }
-    /** Launch a managed cloud agent into the Milady app. */
-    async launchCloudCompatAgent(agentId) {
-        return this.fetch(`/api/cloud/compat/agents/${encodeURIComponent(agentId)}/launch`, { method: "POST" });
-    }
-    /** Get cloud availability (capacity info). */
-    async getCloudCompatAvailability() {
-        return this.fetch("/api/cloud/compat/availability");
-    }
-    /** Poll a cloud job status by job ID. */
-    async getCloudCompatJobStatus(jobId) {
-        return this.fetch(`/api/cloud/compat/jobs/${encodeURIComponent(jobId)}`);
-    }
-    // Apps & Registry
-    async listApps() {
-        return this.fetch("/api/apps");
-    }
-    async searchApps(query) {
-        return this.fetch(`/api/apps/search?q=${encodeURIComponent(query)}`);
-    }
-    async listInstalledApps() {
-        return this.fetch("/api/apps/installed");
-    }
-    async stopApp(name) {
-        return this.fetch("/api/apps/stop", {
-            method: "POST",
-            body: JSON.stringify({ name }),
-        });
-    }
-    async getAppInfo(name) {
-        return this.fetch(`/api/apps/info/${encodeURIComponent(name)}`);
-    }
-    /** Launch an app: installs its plugin (if needed), returns viewer config for iframe. */
-    async launchApp(name) {
-        return this.fetch("/api/apps/launch", {
-            method: "POST",
-            body: JSON.stringify({ name }),
-        });
-    }
-    async listRegistryPlugins() {
-        return this.fetch("/api/apps/plugins");
-    }
-    async searchRegistryPlugins(query) {
-        return this.fetch(`/api/apps/plugins/search?q=${encodeURIComponent(query)}`);
-    }
-    async listHyperscapeEmbeddedAgents() {
-        return this.fetch("/api/apps/hyperscape/embedded-agents");
-    }
-    async createHyperscapeEmbeddedAgent(input) {
-        return this.fetch("/api/apps/hyperscape/embedded-agents", {
-            method: "POST",
-            body: JSON.stringify(input),
-        });
-    }
-    async controlHyperscapeEmbeddedAgent(characterId, action) {
-        return this.fetch(`/api/apps/hyperscape/embedded-agents/${encodeURIComponent(characterId)}/${action}`, { method: "POST" });
-    }
-    async sendHyperscapeEmbeddedAgentCommand(characterId, command, data) {
-        return this.fetch(`/api/apps/hyperscape/embedded-agents/${encodeURIComponent(characterId)}/command`, {
-            method: "POST",
-            body: JSON.stringify({ command, data }),
-        });
-    }
-    async sendHyperscapeAgentMessage(agentId, content) {
-        return this.fetch(`/api/apps/hyperscape/agents/${encodeURIComponent(agentId)}/message`, {
-            method: "POST",
-            body: JSON.stringify({ content }),
-        });
-    }
-    async getHyperscapeAgentGoal(agentId) {
-        return this.fetch(`/api/apps/hyperscape/agents/${encodeURIComponent(agentId)}/goal`);
-    }
-    async getHyperscapeAgentQuickActions(agentId) {
-        return this.fetch(`/api/apps/hyperscape/agents/${encodeURIComponent(agentId)}/quick-actions`);
-    }
-    // Skills Marketplace
-    async searchSkillsMarketplace(query, installed, limit) {
-        const params = new URLSearchParams({
-            q: query,
-            installed: String(installed),
-            limit: String(limit),
-        });
-        return this.fetch(`/api/skills/marketplace/search?${params}`);
-    }
-    async getSkillsMarketplaceConfig() {
-        return this.fetch("/api/skills/marketplace/config");
-    }
-    async updateSkillsMarketplaceConfig(apiKey) {
-        return this.fetch("/api/skills/marketplace/config", {
-            method: "PUT",
-            body: JSON.stringify({ apiKey }),
-        });
-    }
-    async installMarketplaceSkill(data) {
-        await this.fetch("/api/skills/marketplace/install", {
-            method: "POST",
-            body: JSON.stringify(data),
-        });
-    }
-    async uninstallMarketplaceSkill(skillId, autoRefresh) {
-        await this.fetch("/api/skills/marketplace/uninstall", {
-            method: "POST",
-            body: JSON.stringify({ id: skillId, autoRefresh }),
-        });
-    }
-    async updateSkill(skillId, enabled) {
-        return this.fetch(`/api/skills/${encodeURIComponent(skillId)}`, {
-            method: "PUT",
-            body: JSON.stringify({ enabled }),
-        });
-    }
-    // ── Skill CRUD & Security ────────────────────────────────────────────────
-    async createSkill(name, description) {
-        return this.fetch("/api/skills/create", {
-            method: "POST",
-            body: JSON.stringify({ name, description }),
-        });
-    }
-    async openSkill(id) {
-        return this.fetch(`/api/skills/${encodeURIComponent(id)}/open`, {
-            method: "POST",
-        });
-    }
-    async getSkillSource(id) {
-        return this.fetch(`/api/skills/${encodeURIComponent(id)}/source`);
-    }
-    async saveSkillSource(id, content) {
-        return this.fetch(`/api/skills/${encodeURIComponent(id)}/source`, {
-            method: "PUT",
-            body: JSON.stringify({ content }),
-        });
-    }
-    async deleteSkill(id) {
-        return this.fetch(`/api/skills/${encodeURIComponent(id)}`, {
-            method: "DELETE",
-        });
-    }
-    async getSkillScanReport(id) {
-        return this.fetch(`/api/skills/${encodeURIComponent(id)}/scan`);
-    }
-    async acknowledgeSkill(id, enable) {
-        return this.fetch(`/api/skills/${encodeURIComponent(id)}/acknowledge`, {
-            method: "POST",
-            body: JSON.stringify({ enable }),
-        });
-    }
-    // Workbench
-    async getWorkbenchOverview() {
-        return this.fetch("/api/workbench/overview");
-    }
-    async listWorkbenchTasks() {
-        return this.fetch("/api/workbench/tasks");
-    }
-    async getWorkbenchTask(taskId) {
-        return this.fetch(`/api/workbench/tasks/${encodeURIComponent(taskId)}`);
-    }
-    async createWorkbenchTask(data) {
-        return this.fetch("/api/workbench/tasks", {
-            method: "POST",
-            body: JSON.stringify(data),
-        });
-    }
-    async updateWorkbenchTask(taskId, data) {
-        return this.fetch(`/api/workbench/tasks/${encodeURIComponent(taskId)}`, {
-            method: "PUT",
-            body: JSON.stringify(data),
-        });
-    }
-    async deleteWorkbenchTask(taskId) {
-        return this.fetch(`/api/workbench/tasks/${encodeURIComponent(taskId)}`, {
-            method: "DELETE",
-        });
-    }
-    async listWorkbenchTodos() {
-        return this.fetch("/api/workbench/todos");
-    }
-    async getWorkbenchTodo(todoId) {
-        return this.fetch(`/api/workbench/todos/${encodeURIComponent(todoId)}`);
-    }
-    async createWorkbenchTodo(data) {
-        return this.fetch("/api/workbench/todos", {
-            method: "POST",
-            body: JSON.stringify(data),
-        });
-    }
-    async updateWorkbenchTodo(todoId, data) {
-        return this.fetch(`/api/workbench/todos/${encodeURIComponent(todoId)}`, {
-            method: "PUT",
-            body: JSON.stringify(data),
-        });
-    }
-    async setWorkbenchTodoCompleted(todoId, isCompleted) {
-        await this.fetch(`/api/workbench/todos/${encodeURIComponent(todoId)}/complete`, {
-            method: "POST",
-            body: JSON.stringify({ isCompleted }),
-        });
-    }
-    async deleteWorkbenchTodo(todoId) {
-        return this.fetch(`/api/workbench/todos/${encodeURIComponent(todoId)}`, {
-            method: "DELETE",
-        });
-    }
-    // Registry
-    async refreshRegistry() {
-        await this.fetch("/api/apps/refresh", { method: "POST" });
-    }
-    // Knowledge
-    async getKnowledgeStats() {
-        return this.fetch("/api/knowledge/stats");
-    }
-    async listKnowledgeDocuments(options) {
-        const params = new URLSearchParams();
-        if (options?.limit)
-            params.set("limit", String(options.limit));
-        if (options?.offset)
-            params.set("offset", String(options.offset));
-        const query = params.toString();
-        return this.fetch(`/api/knowledge/documents${query ? `?${query}` : ""}`);
-    }
-    async getKnowledgeDocument(documentId) {
-        return this.fetch(`/api/knowledge/documents/${encodeURIComponent(documentId)}`);
-    }
-    async deleteKnowledgeDocument(documentId) {
-        return this.fetch(`/api/knowledge/documents/${encodeURIComponent(documentId)}`, {
-            method: "DELETE",
-        });
-    }
-    async uploadKnowledgeDocument(data) {
-        return this.fetch("/api/knowledge/documents", {
-            method: "POST",
-            body: JSON.stringify(data),
-        });
-    }
-    async uploadKnowledgeDocumentsBulk(data) {
-        return this.fetch("/api/knowledge/documents/bulk", {
-            method: "POST",
-            body: JSON.stringify(data),
-        });
-    }
-    async uploadKnowledgeFromUrl(url, metadata) {
-        return this.fetch("/api/knowledge/documents/url", {
-            method: "POST",
-            body: JSON.stringify({ url, metadata }),
-        });
-    }
-    async searchKnowledge(query, options) {
-        const params = new URLSearchParams({ q: query });
-        if (options?.threshold !== undefined)
-            params.set("threshold", String(options.threshold));
-        if (options?.limit !== undefined)
-            params.set("limit", String(options.limit));
-        return this.fetch(`/api/knowledge/search?${params}`);
-    }
-    async getKnowledgeFragments(documentId) {
-        return this.fetch(`/api/knowledge/fragments/${encodeURIComponent(documentId)}`);
-    }
-    // Memory commands
-    async rememberMemory(text) {
-        return this.fetch("/api/memory/remember", {
-            method: "POST",
-            body: JSON.stringify({ text }),
-        });
-    }
-    async searchMemory(query, options) {
-        const params = new URLSearchParams({ q: query });
-        if (options?.limit !== undefined)
-            params.set("limit", String(options.limit));
-        return this.fetch(`/api/memory/search?${params}`);
-    }
-    async quickContext(query, options) {
-        const params = new URLSearchParams({ q: query });
-        if (options?.limit !== undefined)
-            params.set("limit", String(options.limit));
-        return this.fetch(`/api/context/quick?${params}`);
-    }
-    // MCP
-    async getMcpConfig() {
-        return this.fetch("/api/mcp/config");
-    }
-    async getMcpStatus() {
-        return this.fetch("/api/mcp/status");
-    }
-    async searchMcpMarketplace(query, limit) {
-        const params = new URLSearchParams({ q: query, limit: String(limit) });
-        return this.fetch(`/api/mcp/marketplace/search?${params}`);
-    }
-    async getMcpServerDetails(name) {
-        return this.fetch(`/api/mcp/marketplace/${encodeURIComponent(name)}`);
-    }
-    async addMcpServer(name, config) {
-        await this.fetch("/api/mcp/servers", {
-            method: "POST",
-            body: JSON.stringify({ name, config }),
-        });
-    }
-    async removeMcpServer(name) {
-        await this.fetch(`/api/mcp/servers/${encodeURIComponent(name)}`, {
-            method: "DELETE",
-        });
-    }
-    // Share Ingest
-    async ingestShare(payload) {
-        return this.fetch("/api/ingest/share", {
-            method: "POST",
-            body: JSON.stringify(payload),
-        });
-    }
-    async consumeShareIngest() {
-        return this.fetch("/api/share/consume", { method: "POST" });
-    }
-    // WebSocket
-    connectWs() {
-        if (this.ws?.readyState === WebSocket.OPEN)
-            return;
-        let host;
-        if (this.baseUrl) {
-            host = new URL(this.baseUrl).host;
-        }
-        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;
-        }
-        if (!host)
-            return;
-        const protocol = window.location.protocol === "https:" ? "wss:" : "ws:";
-        let url = `${protocol}//${host}/ws`;
-        const params = new URLSearchParams({ clientId: this.clientId });
-        const token = this.apiToken;
-        if (token)
-            params.set("token", token);
-        url += `?${params.toString()}`;
-        this.ws = new WebSocket(url);
-        this.ws.onopen = () => {
-            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;
-        // Stop reconnecting if we've hit max attempts
-        if (this.reconnectAttempt >= this.maxReconnectAttempts) {
-            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) {
-            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);
-        };
-    }
-    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;
-    }
-    normalizeConversationMessage(message) {
-        if (message.role !== "assistant")
-            return message;
-        const text = this.normalizeAssistantText(message.text);
-        return text === message.text ? message : { ...message, text };
-    }
-    async streamChatEndpoint(path, text, onToken, channelType = "DM", signal, images, conversationMode) {
-        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 } : {}),
-            }),
-            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 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 === "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.usage) {
-                    doneUsage = {
-                        promptTokens: parsed.usage.promptTokens ?? 0,
-                        completionTokens: parsed.usage.completionTokens ?? 0,
-                        totalTokens: parsed.usage.totalTokens ?? 0,
-                        model: parsed.usage.model,
-                    };
-                }
-                return;
-            }
-            if (parsed.type === "error") {
-                throw new Error(parsed.message ?? "generation failed");
-            }
-            // Backward compatibility with legacy stream payloads: { text: "..." }
-            if (parsed.text) {
-                fullText = mergeStreamingText(fullText, parsed.text);
-                onToken(parsed.text, fullText);
-            }
-        };
-        while (true) {
-            let done = false;
-            let value;
-            try {
-                ({ done, value } = await reader.read());
-            }
-            catch (streamErr) {
-                console.warn("[api-client] SSE stream interrupted:", streamErr);
-                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 = this.normalizeAssistantText(doneText ?? fullText);
-        return {
-            text: resolvedText,
-            agentName: doneAgentName ?? "Milady",
-            completed: receivedDone,
-            ...(doneUsage ? { usage: doneUsage } : {}),
-        };
-    }
-    /**
-     * Send a chat message via the REST endpoint (reliable — does not depend on
-     * a WebSocket connection).  Returns the agent's response text.
-     */
-    async sendChatRest(text, channelType = "DM", conversationMode) {
-        const response = await this.fetch("/api/chat", {
-            method: "POST",
-            body: JSON.stringify({
-                text,
-                channelType,
-                ...(conversationMode ? { conversationMode } : {}),
-            }),
-        });
-        return {
-            ...response,
-            text: this.normalizeAssistantText(response.text),
-        };
-    }
-    async sendChatStream(text, onToken, channelType = "DM", signal, conversationMode) {
-        return this.streamChatEndpoint("/api/chat/stream", text, onToken, channelType, signal, undefined, conversationMode);
-    }
-    // Conversations
-    async listConversations() {
-        return this.fetch("/api/conversations");
-    }
-    async createConversation(title, options) {
-        const response = await this.fetch("/api/conversations", {
-            method: "POST",
-            body: JSON.stringify({
-                title,
-                ...(options?.bootstrapGreeting === true
-                    ? { bootstrapGreeting: true }
-                    : {}),
-                ...(typeof options?.lang === "string" && options.lang.trim()
-                    ? { lang: options.lang.trim() }
-                    : {}),
-            }),
-        });
-        if (!response.greeting) {
-            return response;
-        }
-        return {
-            ...response,
-            greeting: {
-                ...response.greeting,
-                text: this.normalizeGreetingText(response.greeting.text),
-            },
-        };
-    }
-    async getConversationMessages(id) {
-        const response = await this.fetch(`/api/conversations/${encodeURIComponent(id)}/messages`);
-        return {
-            messages: response.messages.map((message) => this.normalizeConversationMessage(message)),
-        };
-    }
-    async truncateConversationMessages(id, messageId, options) {
-        return this.fetch(`/api/conversations/${encodeURIComponent(id)}/messages/truncate`, {
-            method: "POST",
-            body: JSON.stringify({
-                messageId,
-                inclusive: options?.inclusive === true,
-            }),
-        });
-    }
-    async sendConversationMessage(id, text, channelType = "DM", images, conversationMode) {
-        const response = await this.fetch(`/api/conversations/${encodeURIComponent(id)}/messages`, {
-            method: "POST",
-            body: JSON.stringify({
-                text,
-                channelType,
-                ...(images?.length ? { images } : {}),
-                ...(conversationMode ? { conversationMode } : {}),
-            }),
-        });
-        return {
-            ...response,
-            text: this.normalizeAssistantText(response.text),
-        };
-    }
-    async sendConversationMessageStream(id, text, onToken, channelType = "DM", signal, images, conversationMode) {
-        return this.streamChatEndpoint(`/api/conversations/${encodeURIComponent(id)}/messages/stream`, text, onToken, channelType, signal, images, conversationMode);
-    }
-    async requestGreeting(id, lang) {
-        const qs = lang ? `?lang=${encodeURIComponent(lang)}` : "";
-        const response = await this.fetch(`/api/conversations/${encodeURIComponent(id)}/greeting${qs}`, {
-            method: "POST",
-        });
-        return {
-            ...response,
-            text: this.normalizeGreetingText(response.text),
-        };
-    }
-    async renameConversation(id, title) {
-        return this.fetch(`/api/conversations/${encodeURIComponent(id)}`, {
-            method: "PATCH",
-            body: JSON.stringify({ title }),
-        });
-    }
-    async deleteConversation(id) {
-        return this.fetch(`/api/conversations/${encodeURIComponent(id)}`, {
-            method: "DELETE",
-        });
-    }
-    /** @deprecated Prefer {@link sendChatRest} — WebSocket chat may silently drop messages. */
-    sendChat(text) {
-        if (this.ws?.readyState === WebSocket.OPEN) {
-            this.ws.send(JSON.stringify({ type: "chat", text }));
-        }
-    }
-    // ── Database API ──────────────────────────────────────────────────────
-    async getDatabaseStatus() {
-        return this.fetch("/api/database/status");
-    }
-    async getDatabaseConfig() {
-        return this.fetch("/api/database/config");
-    }
-    async saveDatabaseConfig(config) {
-        return this.fetch("/api/database/config", {
-            method: "PUT",
-            body: JSON.stringify(config),
-        });
-    }
-    async testDatabaseConnection(creds) {
-        return this.fetch("/api/database/test", {
-            method: "POST",
-            body: JSON.stringify(creds),
-        });
-    }
-    async getDatabaseTables() {
-        return this.fetch("/api/database/tables");
-    }
-    async getDatabaseRows(table, opts) {
-        const params = new URLSearchParams();
-        if (opts?.offset != null)
-            params.set("offset", String(opts.offset));
-        if (opts?.limit != null)
-            params.set("limit", String(opts.limit));
-        if (opts?.sort)
-            params.set("sort", opts.sort);
-        if (opts?.order)
-            params.set("order", opts.order);
-        if (opts?.search)
-            params.set("search", opts.search);
-        const qs = params.toString();
-        return this.fetch(`/api/database/tables/${encodeURIComponent(table)}/rows${qs ? `?${qs}` : ""}`);
-    }
-    async insertDatabaseRow(table, data) {
-        return this.fetch(`/api/database/tables/${encodeURIComponent(table)}/rows`, {
-            method: "POST",
-            body: JSON.stringify({ data }),
-        });
-    }
-    async updateDatabaseRow(table, where, data) {
-        return this.fetch(`/api/database/tables/${encodeURIComponent(table)}/rows`, {
-            method: "PUT",
-            body: JSON.stringify({ where, data }),
-        });
-    }
-    async deleteDatabaseRow(table, where) {
-        return this.fetch(`/api/database/tables/${encodeURIComponent(table)}/rows`, {
-            method: "DELETE",
-            body: JSON.stringify({ where }),
-        });
-    }
-    async executeDatabaseQuery(sql, readOnly = true) {
-        return this.fetch("/api/database/query", {
-            method: "POST",
-            body: JSON.stringify({ sql, readOnly }),
-        });
-    }
-    // ── Trajectories ─────────────────────────────────────────────────────
-    async getTrajectories(options) {
-        const params = new URLSearchParams();
-        if (options?.limit)
-            params.set("limit", String(options.limit));
-        if (options?.offset)
-            params.set("offset", String(options.offset));
-        if (options?.source)
-            params.set("source", options.source);
-        if (options?.status)
-            params.set("status", options.status);
-        if (options?.startDate)
-            params.set("startDate", options.startDate);
-        if (options?.endDate)
-            params.set("endDate", options.endDate);
-        if (options?.search)
-            params.set("search", options.search);
-        const query = params.toString();
-        return this.fetch(`/api/trajectories${query ? `?${query}` : ""}`);
-    }
-    async getTrajectoryDetail(trajectoryId) {
-        return this.fetch(`/api/trajectories/${encodeURIComponent(trajectoryId)}`);
-    }
-    async getTrajectoryStats() {
-        return this.fetch("/api/trajectories/stats");
-    }
-    async getTrajectoryConfig() {
-        return this.fetch("/api/trajectories/config");
-    }
-    async updateTrajectoryConfig(config) {
-        return this.fetch("/api/trajectories/config", {
-            method: "PUT",
-            body: JSON.stringify(config),
-        });
-    }
-    async exportTrajectories(options) {
-        const res = await this.rawRequest("/api/trajectories/export", {
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-            },
-            body: JSON.stringify(options),
-        });
-        return res.blob();
-    }
-    async deleteTrajectories(trajectoryIds) {
-        return this.fetch("/api/trajectories", {
-            method: "DELETE",
-            body: JSON.stringify({ trajectoryIds }),
-        });
-    }
-    async clearAllTrajectories() {
-        return this.fetch("/api/trajectories", {
-            method: "DELETE",
-            body: JSON.stringify({ clearAll: true }),
-        });
-    }
-    // ═══════════════════════════════════════════════════════════════════════
-    //  System Permissions
-    // ═══════════════════════════════════════════════════════════════════════
-    /**
-     * Get all system permission states.
-     */
-    async getPermissions() {
-        return this.fetch("/api/permissions");
-    }
-    /**
-     * Get a single permission state.
-     */
-    async getPermission(id) {
-        return this.fetch(`/api/permissions/${id}`);
-    }
-    /**
-     * Request a specific permission (triggers OS prompt if applicable).
-     */
-    async requestPermission(id) {
-        return this.fetch(`/api/permissions/${id}/request`, { method: "POST" });
-    }
-    /**
-     * Open system settings for a specific permission.
-     */
-    async openPermissionSettings(id) {
-        await this.fetch(`/api/permissions/${id}/open-settings`, {
-            method: "POST",
-        });
-    }
-    /**
-     * Refresh all permission states from the OS.
-     */
-    async refreshPermissions() {
-        return this.fetch("/api/permissions/refresh", { method: "POST" });
-    }
-    /**
-     * Enable or disable shell access.
-     */
-    async setShellEnabled(enabled) {
-        return this.fetch("/api/permissions/shell", {
-            method: "PUT",
-            body: JSON.stringify({ enabled }),
-        });
-    }
-    /**
-     * Get shell enabled status.
-     */
-    async isShellEnabled() {
-        const result = await this.fetch("/api/permissions/shell");
-        return result.enabled;
-    }
-    /**
-     * Get agent automation permission mode.
-     */
-    async getAgentAutomationMode() {
-        return this.fetch("/api/permissions/automation-mode");
-    }
-    /**
-     * Set agent automation permission mode.
-     */
-    async setAgentAutomationMode(mode) {
-        return this.fetch("/api/permissions/automation-mode", {
-            method: "PUT",
-            body: JSON.stringify({ mode }),
-        });
-    }
-    /**
-     * Get wallet trade execution permission mode.
-     */
-    async getTradePermissionMode() {
-        return this.fetch("/api/permissions/trade-mode");
-    }
-    /**
-     * Set wallet trade execution permission mode.
-     */
-    async setTradePermissionMode(mode) {
-        return this.fetch("/api/permissions/trade-mode", {
-            method: "PUT",
-            body: JSON.stringify({ mode }),
-        });
-    }
-    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();
-    }
-    // ═══════════════════════════════════════════════════════════════════════
-    //  ERC-8004 Registry
-    // ═══════════════════════════════════════════════════════════════════════
-    async getRegistryStatus() {
-        return this.fetch("/api/registry/status");
-    }
-    async registerAgent(params) {
-        return this.fetch("/api/registry/register", {
-            method: "POST",
-            body: JSON.stringify(params ?? {}),
-        });
-    }
-    async updateRegistryTokenURI(tokenURI) {
-        return this.fetch("/api/registry/update-uri", {
-            method: "POST",
-            body: JSON.stringify({ tokenURI }),
-        });
-    }
-    async syncRegistryProfile(params) {
-        return this.fetch("/api/registry/sync", {
-            method: "POST",
-            body: JSON.stringify(params ?? {}),
-        });
-    }
-    async getRegistryConfig() {
-        return this.fetch("/api/registry/config");
-    }
-    // ═══════════════════════════════════════════════════════════════════════
-    //  Drop / Mint
-    // ═══════════════════════════════════════════════════════════════════════
-    async getDropStatus() {
-        return this.fetch("/api/drop/status");
-    }
-    async mintAgent(params) {
-        return this.fetch("/api/drop/mint", {
-            method: "POST",
-            body: JSON.stringify(params ?? {}),
-        });
-    }
-    async mintAgentWhitelist(params) {
-        return this.fetch("/api/drop/mint-whitelist", {
-            method: "POST",
-            body: JSON.stringify(params),
-        });
-    }
-    // ═══════════════════════════════════════════════════════════════════════
-    //  Whitelist
-    // ═══════════════════════════════════════════════════════════════════════
-    async getWhitelistStatus() {
-        return this.fetch("/api/whitelist/status");
-    }
-    async generateTwitterVerificationMessage() {
-        return this.fetch("/api/whitelist/twitter/message", { method: "POST" });
-    }
-    async verifyTwitter(tweetUrl) {
-        return this.fetch("/api/whitelist/twitter/verify", {
-            method: "POST",
-            body: JSON.stringify({ tweetUrl }),
-        });
-    }
-    // ── Custom Actions ─────────────────────────────────────────────────────
-    async listCustomActions() {
-        const data = await this.fetch("/api/custom-actions");
-        return data.actions;
-    }
-    async createCustomAction(action) {
-        const data = await this.fetch("/api/custom-actions", { method: "POST", body: JSON.stringify(action) });
-        return data.action;
-    }
-    async updateCustomAction(id, action) {
-        const data = await this.fetch(`/api/custom-actions/${encodeURIComponent(id)}`, { method: "PUT", body: JSON.stringify(action) });
-        return data.action;
-    }
-    async deleteCustomAction(id) {
-        await this.fetch(`/api/custom-actions/${encodeURIComponent(id)}`, {
-            method: "DELETE",
-        });
-    }
-    async testCustomAction(id, params) {
-        return this.fetch(`/api/custom-actions/${encodeURIComponent(id)}/test`, {
-            method: "POST",
-            body: JSON.stringify({ params }),
-        });
-    }
-    async generateCustomAction(prompt) {
-        return this.fetch("/api/custom-actions/generate", {
-            method: "POST",
-            body: JSON.stringify({ prompt }),
-        });
-    }
-    // ═══════════════════════════════════════════════════════════════════════
-    //  WhatsApp Pairing
-    // ═══════════════════════════════════════════════════════════════════════
-    async getWhatsAppStatus(accountId = "default") {
-        return this.fetch(`/api/whatsapp/status?accountId=${encodeURIComponent(accountId)}`);
-    }
-    async startWhatsAppPairing(accountId = "default") {
-        return this.fetch("/api/whatsapp/pair", {
-            method: "POST",
-            body: JSON.stringify({ accountId }),
-        });
-    }
-    async stopWhatsAppPairing(accountId = "default") {
-        return this.fetch("/api/whatsapp/pair/stop", {
-            method: "POST",
-            body: JSON.stringify({ accountId }),
-        });
-    }
-    async disconnectWhatsApp(accountId = "default") {
-        return this.fetch("/api/whatsapp/disconnect", {
-            method: "POST",
-            body: JSON.stringify({ accountId }),
-        });
-    }
-    // --- Bug Report ---
-    async checkBugReportInfo() {
-        return this.fetch("/api/bug-report/info");
-    }
-    async submitBugReport(report) {
-        return this.fetch("/api/bug-report", {
-            method: "POST",
-            body: JSON.stringify(report),
-        });
-    }
-    // ── Coding Agents ───────────────────────────────────────────────────
-    async getCodingAgentStatus() {
-        try {
-            return await this.fetch("/api/coding-agents/coordinator/status");
-        }
-        catch {
-            return null;
-        }
-    }
-    async stopCodingAgent(sessionId) {
-        try {
-            await this.fetch(`/api/coding-agents/${encodeURIComponent(sessionId)}/stop`, { method: "POST" });
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    async listCodingAgentScratchWorkspaces() {
-        try {
-            return await this.fetch("/api/coding-agents/scratch");
-        }
-        catch {
-            return [];
-        }
-    }
-    async keepCodingAgentScratchWorkspace(sessionId) {
-        try {
-            await this.fetch(`/api/coding-agents/${encodeURIComponent(sessionId)}/scratch/keep`, { method: "POST" });
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    async deleteCodingAgentScratchWorkspace(sessionId) {
-        try {
-            // Keep POST for compatibility with plugin route handlers.
-            await this.fetch(`/api/coding-agents/${encodeURIComponent(sessionId)}/scratch/delete`, { method: "POST" });
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    async promoteCodingAgentScratchWorkspace(sessionId, name) {
-        try {
-            const response = await this.fetch(`/api/coding-agents/${encodeURIComponent(sessionId)}/scratch/promote`, {
-                method: "POST",
-                body: JSON.stringify(name ? { name } : {}),
-            });
-            return response.scratch ?? null;
-        }
-        catch {
-            return null;
-        }
-    }
-    // ── PTY Terminal (xterm.js bridge) ─────────────────────────────────────
-    /** Subscribe to live PTY output for a session over WebSocket. */
-    subscribePtyOutput(sessionId) {
-        this.sendWsMessage({ type: "pty-subscribe", sessionId });
-    }
-    /** Unsubscribe from live PTY output for a session. */
-    unsubscribePtyOutput(sessionId) {
-        this.sendWsMessage({ type: "pty-unsubscribe", sessionId });
-    }
-    /** Send raw keyboard input to a PTY session. */
-    sendPtyInput(sessionId, data) {
-        this.sendWsMessage({ type: "pty-input", sessionId, data });
-    }
-    /** Resize a PTY session's terminal dimensions. */
-    resizePty(sessionId, cols, rows) {
-        this.sendWsMessage({ type: "pty-resize", sessionId, cols, rows });
-    }
-    /** Fetch buffered terminal output (raw ANSI) for xterm.js hydration. */
-    async getPtyBufferedOutput(sessionId) {
-        try {
-            const res = await this.fetch(`/api/coding-agents/${encodeURIComponent(sessionId)}/buffered-output`);
-            return res.output ?? "";
-        }
-        catch {
-            return "";
-        }
-    }
-    // ── Stream controls ─────────────────────────────────────────────────────
-    async streamGoLive() {
-        return this.fetch("/api/stream/live", { method: "POST" });
-    }
-    async streamGoOffline() {
-        return this.fetch("/api/stream/offline", { method: "POST" });
-    }
-    async streamStatus() {
-        return this.fetch("/api/stream/status");
-    }
-    async getStreamingDestinations() {
-        return this.fetch("/api/streaming/destinations");
-    }
-    async setActiveDestination(destinationId) {
-        return this.fetch("/api/streaming/destination", {
-            method: "POST",
-            body: JSON.stringify({ destinationId }),
-        });
-    }
-    async setStreamVolume(volume) {
-        return this.fetch("/api/stream/volume", {
-            method: "POST",
-            body: JSON.stringify({ volume }),
-        });
-    }
-    async muteStream() {
-        return this.fetch("/api/stream/mute", { method: "POST" });
-    }
-    async unmuteStream() {
-        return this.fetch("/api/stream/unmute", { method: "POST" });
-    }
-    // ── Stream voice (TTS) ───────────────────────────────────────────────
-    async getStreamVoice() {
-        return this.fetch("/api/stream/voice");
-    }
-    async saveStreamVoice(settings) {
-        return this.fetch("/api/stream/voice", {
-            method: "POST",
-            body: JSON.stringify(settings),
-        });
-    }
-    async streamVoiceSpeak(text) {
-        return this.fetch("/api/stream/voice/speak", {
-            method: "POST",
-            body: JSON.stringify({ text }),
-        });
-    }
-    // ── Overlay layout ────────────────────────────────────────────────────
-    async getOverlayLayout(destinationId) {
-        const qs = destinationId
-            ? `?destination=${encodeURIComponent(destinationId)}`
-            : "";
-        return this.fetch(`/api/stream/overlay-layout${qs}`);
-    }
-    async saveOverlayLayout(layout, destinationId) {
-        const qs = destinationId
-            ? `?destination=${encodeURIComponent(destinationId)}`
-            : "";
-        return this.fetch(`/api/stream/overlay-layout${qs}`, {
-            method: "POST",
-            body: JSON.stringify({ layout }),
-        });
-    }
-    // ── Stream source picker ──────────────────────────────────────────────
-    async getStreamSource() {
-        return this.fetch("/api/stream/source");
-    }
-    async setStreamSource(sourceType, customUrl) {
-        return this.fetch("/api/stream/source", {
-            method: "POST",
-            body: JSON.stringify({ sourceType, customUrl }),
-        });
-    }
-    // ── Stream visual settings (theme, avatar for headless parity) ────────
-    async getStreamSettings() {
-        return this.fetch("/api/stream/settings");
-    }
-    async saveStreamSettings(settings) {
-        return this.fetch("/api/stream/settings", {
-            method: "POST",
-            body: JSON.stringify({ settings }),
-        });
-    }
-    // ── Direct Eliza Cloud Auth (no local backend required) ─────────────
-    /**
-     * Initiate a direct login to Eliza Cloud without going through a local agent.
-     * Used in sandbox mode when no local backend exists yet.
-     */
-    async cloudLoginDirect(cloudApiBase) {
-        const sessionId = globalThis.crypto.randomUUID();
-        try {
-            const res = await fetch(`${cloudApiBase}/api/auth/cli-session`, {
-                method: "POST",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify({ sessionId }),
-            });
-            if (!res.ok) {
-                return { ok: false, error: `Login failed (${res.status})` };
-            }
-            return {
-                ok: true,
-                sessionId,
-                browserUrl: `${cloudApiBase}/auth/cli-login?session=${encodeURIComponent(sessionId)}`,
-            };
-        }
-        catch (err) {
-            return { ok: false, error: `Failed to reach Eliza Cloud: ${err instanceof Error ? err.message : String(err)}` };
-        }
-    }
-    /**
-     * Poll a direct Eliza Cloud login session for authentication status.
-     */
-    async cloudLoginPollDirect(cloudApiBase, sessionId) {
-        try {
-            const res = await fetch(`${cloudApiBase}/api/auth/cli-session/${encodeURIComponent(sessionId)}`);
-            if (!res.ok) {
-                if (res.status === 404) {
-                    return { status: "expired", error: "Auth session expired or not found" };
-                }
-                return { status: "error", error: `Poll failed (${res.status})` };
-            }
-            const data = await res.json();
-            // Map cli-session response shape to expected poll shape
-            if (data.status === "authenticated" && data.apiKey) {
-                return { status: "authenticated", token: data.apiKey, userId: data.userId };
-            }
-            return { status: data.status ?? "pending" };
-        }
-        catch {
-            return { status: "error", error: "Poll request failed" };
-        }
-    }
-    // ── Eliza Cloud Sandbox Provisioning ───────────────────────────────
-    /**
-     * Create a sandbox agent on Eliza Cloud and provision it.
-     * Returns the bridge URL when provisioning completes.
-     *
-     * Flow:
-     *   1. POST /api/v1/milady/agents — create agent record
-     *   2. POST /api/v1/milady/agents/{id}/provision — start async provisioning
-     *   3. Poll GET /api/v1/jobs/{jobId} until completed
-     *   4. Return bridgeUrl from job result
-     */
-    async provisionCloudSandbox(options) {
-        const { cloudApiBase, authToken, name, bio, onProgress } = options;
-        const headers = {
-            "Content-Type": "application/json",
-            Authorization: `Bearer ${authToken}`,
-        };
-        onProgress?.("creating", "Creating agent...");
-        // Step 1: Create agent
-        const createRes = await fetch(`${cloudApiBase}/api/v1/milady/agents`, {
-            method: "POST",
-            headers,
-            body: JSON.stringify({ name, bio }),
-        });
-        if (!createRes.ok) {
-            const err = await createRes.text().catch(() => "Unknown error");
-            throw new Error(`Failed to create cloud agent: ${err}`);
-        }
-        const createData = (await createRes.json());
-        const agentId = createData.id;
-        onProgress?.("provisioning", "Provisioning sandbox environment...");
-        // Step 2: Start provisioning
-        const provisionRes = await fetch(`${cloudApiBase}/api/v1/milady/agents/${agentId}/provision`, { method: "POST", headers });
-        if (!provisionRes.ok) {
-            const err = await provisionRes.text().catch(() => "Unknown error");
-            throw new Error(`Failed to start provisioning: ${err}`);
-        }
-        const provisionData = (await provisionRes.json());
-        const jobId = provisionData.jobId;
-        // Step 3: Poll job status
-        const deadline = Date.now() + 120_000; // 2 minute timeout
-        while (Date.now() < deadline) {
-            await new Promise((r) => setTimeout(r, 2000));
-            const jobRes = await fetch(`${cloudApiBase}/api/v1/jobs/${jobId}`, {
-                headers,
-            });
-            if (!jobRes.ok)
-                continue;
-            const jobData = (await jobRes.json());
-            if (jobData.status === "completed" && jobData.result?.bridgeUrl) {
-                onProgress?.("ready", "Sandbox ready!");
-                return { bridgeUrl: jobData.result.bridgeUrl, agentId };
-            }
-            if (jobData.status === "failed") {
-                throw new Error(`Provisioning failed: ${jobData.error ?? "Unknown error"}`);
-            }
-            onProgress?.("provisioning", `Status: ${jobData.status}...`);
-        }
-        throw new Error("Provisioning timed out after 2 minutes");
-    }
-}
-// Singleton
-export const client = new MiladyClient();