@elizaos/app-core 2.0.0-alpha.73 → 2.0.0-alpha.75

package/api/client.js

@@ -0,0 +1,2492 @@
+/**
+ * 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 getAuthStatus() {
+        // 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 res = await fetch(`${cloudApiBase}/api/v1/auth/login`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+        });
+        if (!res.ok) {
+            return { ok: false, error: `Login failed (${res.status})` };
+        }
+        return res.json();
+    }
+    /**
+     * Poll a direct Eliza Cloud login session for authentication status.
+     */
+    async cloudLoginPollDirect(cloudApiBase, sessionId) {
+        const res = await fetch(`${cloudApiBase}/api/v1/auth/login/status?sessionId=${encodeURIComponent(sessionId)}`);
+        if (!res.ok) {
+            return { status: "error", error: `Poll failed (${res.status})` };
+        }
+        return res.json();
+    }
+    // ── 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();