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

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

@@ -0,0 +1,1442 @@
+/**
+ * Agent domain methods — lifecycle, auth, config, connectors, triggers,
+ * training, plugins, streaming/PTY, logs, character, permissions, updates.
+ */
+import { isElizaSettingsDebugEnabled, sanitizeForSettingsDebug, settingsDebugCloudSummary, } from "@elizaos/shared";
+import { getAppBlockerPlugin, getWebsiteBlockerPlugin, } from "../bridge/native-plugins";
+import { TERMINAL_STATUSES } from "../chat/coding-agent-session-state";
+import { ElizaClient } from "./client-base";
+import { mapPtySessionsToCodingAgentSessions, mapTaskThreadsToCodingAgentSessions, } from "./client-types";
+// ---------------------------------------------------------------------------
+// Module-level helpers
+// ---------------------------------------------------------------------------
+function clientSettingsDebug() {
+    let viteEnv;
+    try {
+        viteEnv = import.meta.env;
+    }
+    catch {
+        viteEnv = undefined;
+    }
+    return isElizaSettingsDebugEnabled({
+        importMetaEnv: viteEnv,
+        env: typeof process !== "undefined" ? process.env : undefined,
+    });
+}
+const WEBSITE_BLOCKING_PERMISSION_ID = "website-blocking";
+function getNativeWebsiteBlockerPluginIfAvailable() {
+    const plugin = getWebsiteBlockerPlugin();
+    return typeof plugin.getStatus === "function" &&
+        typeof plugin.startBlock === "function" &&
+        typeof plugin.stopBlock === "function" &&
+        typeof plugin.checkPermissions === "function" &&
+        typeof plugin.requestPermissions === "function" &&
+        typeof plugin.openSettings === "function"
+        ? plugin
+        : null;
+}
+function getNativeAppBlockerPluginIfAvailable() {
+    const plugin = getAppBlockerPlugin();
+    return typeof plugin.getStatus === "function" &&
+        typeof plugin.checkPermissions === "function" &&
+        typeof plugin.requestPermissions === "function" &&
+        typeof plugin.getInstalledApps === "function" &&
+        typeof plugin.selectApps === "function" &&
+        typeof plugin.blockApps === "function" &&
+        typeof plugin.unblockApps === "function"
+        ? plugin
+        : null;
+}
+function mapWebsiteBlockerPermissionResult(permission) {
+    return {
+        id: WEBSITE_BLOCKING_PERMISSION_ID,
+        status: permission.status,
+        canRequest: permission.canRequest,
+        reason: permission.reason,
+        lastChecked: Date.now(),
+    };
+}
+function mapWebsiteBlockerStatusToPermission(status) {
+    return {
+        id: WEBSITE_BLOCKING_PERMISSION_ID,
+        status: status.permissionStatus ??
+            (status.available ? "granted" : "not-determined"),
+        canRequest: status.canRequestPermission ?? status.supportsElevationPrompt,
+        reason: status.reason,
+        lastChecked: Date.now(),
+    };
+}
+function logSettingsClient(phase, detail) {
+    if (!clientSettingsDebug())
+        return;
+    console.debug(`[eliza][settings][client] ${phase}`, sanitizeForSettingsDebug(detail));
+}
+const SETTINGS_MUTATION_TIMEOUT_MS = 30_000;
+// ---------------------------------------------------------------------------
+// Prototype augmentation
+// ---------------------------------------------------------------------------
+ElizaClient.prototype.getStatus = async function () {
+    return this.fetch("/api/status");
+};
+ElizaClient.prototype.getAgentSelfStatus = async function () {
+    return this.fetch("/api/agent/self-status");
+};
+ElizaClient.prototype.getRuntimeSnapshot = async function (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}` : ""}`);
+};
+ElizaClient.prototype.setAutomationMode = async function (mode) {
+    return this.fetch("/api/permissions/automation-mode", {
+        method: "PUT",
+        body: JSON.stringify({ mode }),
+    });
+};
+ElizaClient.prototype.setTradeMode = async function (mode) {
+    return this.fetch("/api/permissions/trade-mode", {
+        method: "PUT",
+        body: JSON.stringify({ mode }),
+    });
+};
+ElizaClient.prototype.playEmote = async function (emoteId) {
+    return this.fetch("/api/emote", {
+        method: "POST",
+        body: JSON.stringify({ emoteId }),
+    });
+};
+ElizaClient.prototype.runTerminalCommand = async function (command) {
+    return this.fetch("/api/terminal/run", {
+        method: "POST",
+        body: JSON.stringify({ command }),
+    });
+};
+ElizaClient.prototype.getOnboardingStatus = async function () {
+    return this.fetch("/api/onboarding/status");
+};
+ElizaClient.prototype.getWalletKeys = async function () {
+    return this.fetch("/api/wallet/keys");
+};
+ElizaClient.prototype.getWalletOsStoreStatus = async function () {
+    return this.fetch("/api/wallet/os-store");
+};
+ElizaClient.prototype.postWalletOsStoreAction = async function (action) {
+    return this.fetch("/api/wallet/os-store", {
+        method: "POST",
+        body: JSON.stringify({ action }),
+    });
+};
+ElizaClient.prototype.getAuthStatus = async function () {
+    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;
+            if (attempt < maxRetries) {
+                await new Promise((r) => setTimeout(r, baseBackoffMs * 2 ** attempt));
+            }
+        }
+    }
+    throw lastErr;
+};
+ElizaClient.prototype.postBootstrapExchange = async function (token) {
+    // Use allowNonOk so 401/429/503 bodies are parsed rather than thrown.
+    const body = await this.fetch("/api/auth/bootstrap/exchange", {
+        method: "POST",
+        body: JSON.stringify({ token }),
+    }, { allowNonOk: true });
+    if (typeof body.sessionId === "string" &&
+        typeof body.expiresAt === "number" &&
+        typeof body.identityId === "string") {
+        return {
+            ok: true,
+            sessionId: body.sessionId,
+            expiresAt: body.expiresAt,
+            identityId: body.identityId,
+        };
+    }
+    // Map reason to an HTTP status bucket for the UI layer.
+    const reason = body.reason;
+    const status = reason === "rate_limited"
+        ? 429
+        : reason === "db_unavailable" ||
+            reason === "missing_issuer_env" ||
+            reason === "missing_container_env"
+            ? 503
+            : reason === "missing_token"
+                ? 400
+                : 401;
+    return {
+        ok: false,
+        status,
+        error: body.error ?? "exchange_failed",
+        reason,
+    };
+};
+ElizaClient.prototype.pair = async function (code) {
+    const res = await this.fetch("/api/auth/pair", {
+        method: "POST",
+        body: JSON.stringify({ code }),
+    });
+    return res;
+};
+ElizaClient.prototype.getOnboardingOptions = async function () {
+    return this.fetch("/api/onboarding/options");
+};
+ElizaClient.prototype.submitOnboarding = async function (data) {
+    await this.fetch("/api/onboarding", {
+        method: "POST",
+        body: JSON.stringify(data),
+    });
+};
+ElizaClient.prototype.startAnthropicLogin = async function () {
+    return this.fetch("/api/subscription/anthropic/start", { method: "POST" });
+};
+ElizaClient.prototype.exchangeAnthropicCode = async function (code) {
+    return this.fetch("/api/subscription/anthropic/exchange", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ code }),
+    });
+};
+ElizaClient.prototype.submitAnthropicSetupToken = async function (token) {
+    return this.fetch("/api/subscription/anthropic/setup-token", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ token }),
+    });
+};
+ElizaClient.prototype.getSubscriptionStatus = async function () {
+    return this.fetch("/api/subscription/status");
+};
+ElizaClient.prototype.deleteSubscription = async function (provider) {
+    return this.fetch(`/api/subscription/${encodeURIComponent(provider)}`, {
+        method: "DELETE",
+    });
+};
+ElizaClient.prototype.switchProvider = async function (provider, apiKey, primaryModel, options) {
+    logSettingsClient("POST /api/provider/switch → start", {
+        baseUrl: this.getBaseUrl(),
+        provider,
+        hasApiKey: Boolean(apiKey?.trim()),
+        apiKey,
+        hasPrimaryModel: Boolean(primaryModel?.trim()),
+        primaryModel,
+        useLocalEmbeddings: options?.useLocalEmbeddings,
+    });
+    const result = (await this.fetch("/api/provider/switch", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+            provider,
+            ...(apiKey ? { apiKey } : {}),
+            ...(primaryModel ? { primaryModel } : {}),
+            ...(options?.useLocalEmbeddings != null
+                ? { useLocalEmbeddings: options.useLocalEmbeddings }
+                : {}),
+        }),
+    }));
+    logSettingsClient("POST /api/provider/switch ← ok", {
+        baseUrl: this.getBaseUrl(),
+        result,
+    });
+    return result;
+};
+ElizaClient.prototype.startOpenAILogin = async function () {
+    return this.fetch("/api/subscription/openai/start", { method: "POST" });
+};
+ElizaClient.prototype.exchangeOpenAICode = async function (code) {
+    return this.fetch("/api/subscription/openai/exchange", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ code }),
+    });
+};
+ElizaClient.prototype.startAgent = async function () {
+    const res = await this.fetch("/api/agent/start", {
+        method: "POST",
+    });
+    return res.status;
+};
+ElizaClient.prototype.stopAgent = async function () {
+    const res = await this.fetch("/api/agent/stop", {
+        method: "POST",
+    });
+    return res.status;
+};
+ElizaClient.prototype.pauseAgent = async function () {
+    const res = await this.fetch("/api/agent/pause", {
+        method: "POST",
+    });
+    return res.status;
+};
+ElizaClient.prototype.resumeAgent = async function () {
+    const res = await this.fetch("/api/agent/resume", {
+        method: "POST",
+    });
+    return res.status;
+};
+ElizaClient.prototype.restartAgent = async function () {
+    try {
+        const res = await this.fetch("/api/agent/restart", {
+            method: "POST",
+        });
+        return res.status;
+    }
+    catch {
+        // Back-compat for older runtimes that still expose only the process-level
+        // restart endpoint.
+        await this.fetch("/api/restart", { method: "POST" });
+        return {
+            state: "restarting",
+            agentName: "Eliza",
+            model: undefined,
+            uptime: undefined,
+            startedAt: undefined,
+        };
+    }
+};
+ElizaClient.prototype.restartAndWait = async function (maxWaitMs = 30000) {
+    const t0 = Date.now();
+    console.info("[eliza][reset][client] restartAndWait: begin", {
+        baseUrl: this.getBaseUrl(),
+        maxWaitMs,
+    });
+    try {
+        await this.restartAgent();
+        console.info("[eliza][reset][client] restartAndWait: restart accepted");
+    }
+    catch (e) {
+        console.info("[eliza][reset][client] restartAndWait: initial restart call failed (often 409 while restarting)", e);
+    }
+    const start = Date.now();
+    const interval = 1000;
+    let pollN = 0;
+    while (Date.now() - start < maxWaitMs) {
+        await new Promise((r) => setTimeout(r, interval));
+        pollN += 1;
+        try {
+            const status = await this.getStatus();
+            if (status.state === "running") {
+                console.info("[eliza][reset][client] restartAndWait: running", {
+                    pollN,
+                    waitedMs: Date.now() - t0,
+                    port: status.port,
+                });
+                return status;
+            }
+            if (pollN === 1 || pollN % 5 === 0) {
+                console.debug("[eliza][reset][client] restartAndWait: poll", {
+                    pollN,
+                    state: status.state,
+                    waitedMs: Date.now() - t0,
+                });
+            }
+        }
+        catch (pollErr) {
+            if (pollN === 1 || pollN % 5 === 0) {
+                console.debug("[eliza][reset][client] restartAndWait: getStatus error while polling", { pollN, waitedMs: Date.now() - t0 }, pollErr);
+            }
+        }
+    }
+    const final = await this.getStatus();
+    console.warn("[eliza][reset][client] restartAndWait: timed out — returning last status", {
+        state: final.state,
+        waitedMs: Date.now() - t0,
+        maxWaitMs,
+    });
+    return final;
+};
+ElizaClient.prototype.resetAgent = async function () {
+    console.info("[eliza][reset][client] POST /api/agent/reset", {
+        baseUrl: this.getBaseUrl(),
+    });
+    await this.fetch("/api/agent/reset", { method: "POST" });
+    console.info("[eliza][reset][client] POST /api/agent/reset OK");
+};
+ElizaClient.prototype.restart = async function () {
+    return this.fetch("/api/restart", { method: "POST" });
+};
+ElizaClient.prototype.getConfig = async function () {
+    logSettingsClient("GET /api/config → start", {
+        baseUrl: this.getBaseUrl(),
+    });
+    const r = (await this.fetch("/api/config"));
+    const cloud = r.cloud;
+    logSettingsClient("GET /api/config ← ok", {
+        baseUrl: this.getBaseUrl(),
+        topKeys: Object.keys(r).sort(),
+        cloud: settingsDebugCloudSummary(cloud),
+    });
+    return r;
+};
+ElizaClient.prototype.getConfigSchema = async function () {
+    return this.fetch("/api/config/schema");
+};
+ElizaClient.prototype.updateConfig = async function (patch) {
+    logSettingsClient("PUT /api/config → start", {
+        baseUrl: this.getBaseUrl(),
+        patch,
+    });
+    const out = (await this.fetch("/api/config", {
+        method: "PUT",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(patch),
+    }, {
+        timeoutMs: SETTINGS_MUTATION_TIMEOUT_MS,
+    }));
+    const cloud = out.cloud;
+    logSettingsClient("PUT /api/config ← ok", {
+        baseUrl: this.getBaseUrl(),
+        topKeys: Object.keys(out).sort(),
+        cloud: settingsDebugCloudSummary(cloud),
+    });
+    return out;
+};
+ElizaClient.prototype.uploadCustomVrm = async function (file) {
+    const buf = await file.arrayBuffer();
+    await this.fetch("/api/avatar/vrm", {
+        method: "POST",
+        headers: { "Content-Type": "application/octet-stream" },
+        body: buf,
+    });
+};
+ElizaClient.prototype.hasCustomVrm = async function () {
+    try {
+        const res = await this.rawRequest("/api/avatar/vrm", { method: "HEAD" }, { allowNonOk: true });
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+};
+ElizaClient.prototype.uploadCustomBackground = async function (file) {
+    const buf = await file.arrayBuffer();
+    await this.fetch("/api/avatar/background", {
+        method: "POST",
+        headers: { "Content-Type": "application/octet-stream" },
+        body: buf,
+    });
+};
+ElizaClient.prototype.hasCustomBackground = async function () {
+    try {
+        const res = await this.rawRequest("/api/avatar/background", { method: "HEAD" }, { allowNonOk: true });
+        return res.ok;
+    }
+    catch {
+        return false;
+    }
+};
+ElizaClient.prototype.getConnectors = async function () {
+    return this.fetch("/api/connectors");
+};
+ElizaClient.prototype.saveConnector = async function (name, config) {
+    return this.fetch("/api/connectors", {
+        method: "POST",
+        body: JSON.stringify({ name, config }),
+    });
+};
+ElizaClient.prototype.deleteConnector = async function (name) {
+    return this.fetch(`/api/connectors/${encodeURIComponent(name)}`, {
+        method: "DELETE",
+    });
+};
+ElizaClient.prototype.getTriggers = async function () {
+    return this.fetch("/api/triggers");
+};
+ElizaClient.prototype.getTrigger = async function (id) {
+    return this.fetch(`/api/triggers/${encodeURIComponent(id)}`);
+};
+ElizaClient.prototype.createTrigger = async function (request) {
+    return this.fetch("/api/triggers", {
+        method: "POST",
+        body: JSON.stringify(request),
+    });
+};
+ElizaClient.prototype.updateTrigger = async function (id, request) {
+    return this.fetch(`/api/triggers/${encodeURIComponent(id)}`, {
+        method: "PUT",
+        body: JSON.stringify(request),
+    });
+};
+ElizaClient.prototype.deleteTrigger = async function (id) {
+    return this.fetch(`/api/triggers/${encodeURIComponent(id)}`, {
+        method: "DELETE",
+    });
+};
+ElizaClient.prototype.runTriggerNow = async function (id) {
+    return this.fetch(`/api/triggers/${encodeURIComponent(id)}/execute`, {
+        method: "POST",
+    });
+};
+ElizaClient.prototype.getTriggerRuns = async function (id) {
+    return this.fetch(`/api/triggers/${encodeURIComponent(id)}/runs`);
+};
+ElizaClient.prototype.emitTriggerEvent = async function (eventKind, payload = {}) {
+    return this.fetch(`/api/triggers/events/${encodeURIComponent(eventKind)}`, {
+        method: "POST",
+        body: JSON.stringify({ payload }),
+    });
+};
+ElizaClient.prototype.getTriggerHealth = async function () {
+    return this.fetch("/api/triggers/health");
+};
+ElizaClient.prototype.getTrainingStatus = async function () {
+    return this.fetch("/api/training/status");
+};
+ElizaClient.prototype.listTrainingTrajectories = async function (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}` : ""}`);
+};
+ElizaClient.prototype.getTrainingTrajectory = async function (trajectoryId) {
+    return this.fetch(`/api/training/trajectories/${encodeURIComponent(trajectoryId)}`);
+};
+ElizaClient.prototype.listTrainingDatasets = async function () {
+    return this.fetch("/api/training/datasets");
+};
+ElizaClient.prototype.buildTrainingDataset = async function (options) {
+    return this.fetch("/api/training/datasets/build", {
+        method: "POST",
+        body: JSON.stringify(options ?? {}),
+    });
+};
+ElizaClient.prototype.listTrainingJobs = async function () {
+    return this.fetch("/api/training/jobs");
+};
+ElizaClient.prototype.startTrainingJob = async function (options) {
+    return this.fetch("/api/training/jobs", {
+        method: "POST",
+        body: JSON.stringify(options ?? {}),
+    });
+};
+ElizaClient.prototype.getTrainingJob = async function (jobId) {
+    return this.fetch(`/api/training/jobs/${encodeURIComponent(jobId)}`);
+};
+ElizaClient.prototype.cancelTrainingJob = async function (jobId) {
+    return this.fetch(`/api/training/jobs/${encodeURIComponent(jobId)}/cancel`, {
+        method: "POST",
+    });
+};
+ElizaClient.prototype.listTrainingModels = async function () {
+    return this.fetch("/api/training/models");
+};
+ElizaClient.prototype.importTrainingModelToOllama = async function (modelId, options) {
+    return this.fetch(`/api/training/models/${encodeURIComponent(modelId)}/import-ollama`, {
+        method: "POST",
+        body: JSON.stringify(options ?? {}),
+    });
+};
+ElizaClient.prototype.activateTrainingModel = async function (modelId, providerModel) {
+    return this.fetch(`/api/training/models/${encodeURIComponent(modelId)}/activate`, {
+        method: "POST",
+        body: JSON.stringify({ providerModel }),
+    });
+};
+ElizaClient.prototype.benchmarkTrainingModel = async function (modelId) {
+    return this.fetch(`/api/training/models/${encodeURIComponent(modelId)}/benchmark`, { method: "POST" });
+};
+ElizaClient.prototype.getPlugins = async function () {
+    return this.fetch("/api/plugins");
+};
+ElizaClient.prototype.fetchModels = async function (provider, refresh = true) {
+    const params = new URLSearchParams({ provider });
+    if (refresh)
+        params.set("refresh", "true");
+    return this.fetch(`/api/models?${params.toString()}`);
+};
+ElizaClient.prototype.getCorePlugins = async function () {
+    return this.fetch("/api/plugins/core");
+};
+ElizaClient.prototype.toggleCorePlugin = async function (npmName, enabled) {
+    return this.fetch("/api/plugins/core/toggle", {
+        method: "POST",
+        body: JSON.stringify({ npmName, enabled }),
+    });
+};
+ElizaClient.prototype.updatePlugin = async function (id, config) {
+    logSettingsClient(`PUT /api/plugins/${id} → start`, {
+        baseUrl: this.getBaseUrl(),
+        body: config,
+    });
+    const result = (await this.fetch(`/api/plugins/${id}`, {
+        method: "PUT",
+        body: JSON.stringify(config),
+    }, {
+        timeoutMs: SETTINGS_MUTATION_TIMEOUT_MS,
+    }));
+    logSettingsClient(`PUT /api/plugins/${id} ← ok`, {
+        baseUrl: this.getBaseUrl(),
+        result,
+    });
+    return result;
+};
+ElizaClient.prototype.getSecrets = async function () {
+    return this.fetch("/api/secrets");
+};
+ElizaClient.prototype.updateSecrets = async function (secrets) {
+    logSettingsClient("PUT /api/secrets → start", {
+        baseUrl: this.getBaseUrl(),
+        secretMeta: Object.keys(secrets)
+            .sort()
+            .map((key) => ({
+            key,
+            hasValue: Boolean(secrets[key]),
+        })),
+    });
+    const out = (await this.fetch("/api/secrets", {
+        method: "PUT",
+        body: JSON.stringify({ secrets }),
+    }));
+    logSettingsClient("PUT /api/secrets ← ok", {
+        baseUrl: this.getBaseUrl(),
+        out,
+    });
+    return out;
+};
+ElizaClient.prototype.testPluginConnection = async function (id) {
+    return this.fetch(`/api/plugins/${encodeURIComponent(id)}/test`, {
+        method: "POST",
+    });
+};
+ElizaClient.prototype.getLogs = async function (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 is a private helper used only by agent audit methods
+function 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;
+}
+ElizaClient.prototype.getSecurityAudit = async function (filter) {
+    const qs = buildSecurityAuditParams(filter).toString();
+    return this.fetch(`/api/security/audit${qs ? `?${qs}` : ""}`);
+};
+ElizaClient.prototype.streamSecurityAudit = async function (onEvent, filter, signal) {
+    if (!this.apiAvailable) {
+        throw new Error("API not available (no HTTP origin)");
+    }
+    const token = this.apiToken;
+    const qs = 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());
+        }
+    }
+};
+ElizaClient.prototype.getAgentEvents = async function (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}` : ""}`);
+};
+ElizaClient.prototype.getExtensionStatus = async function () {
+    return this.fetch("/api/extension/status");
+};
+ElizaClient.prototype.getRelationshipsGraph = async function (query) {
+    const params = new URLSearchParams();
+    if (query?.search)
+        params.set("search", query.search);
+    if (query?.platform)
+        params.set("platform", query.platform);
+    if (query?.scope)
+        params.set("scope", query.scope);
+    if (typeof query?.limit === "number")
+        params.set("limit", String(query.limit));
+    if (typeof query?.offset === "number")
+        params.set("offset", String(query.offset));
+    const qs = params.toString();
+    const response = await this.fetch(`/api/relationships/graph${qs ? `?${qs}` : ""}`);
+    return response.data;
+};
+ElizaClient.prototype.getRelationshipsPeople = async function (query) {
+    const params = new URLSearchParams();
+    if (query?.search)
+        params.set("search", query.search);
+    if (query?.platform)
+        params.set("platform", query.platform);
+    if (query?.scope)
+        params.set("scope", query.scope);
+    if (typeof query?.limit === "number")
+        params.set("limit", String(query.limit));
+    if (typeof query?.offset === "number")
+        params.set("offset", String(query.offset));
+    const qs = params.toString();
+    const response = await this.fetch(`/api/relationships/people${qs ? `?${qs}` : ""}`);
+    return {
+        people: response.data,
+        stats: response.stats,
+    };
+};
+ElizaClient.prototype.getRelationshipsPerson = async function (id) {
+    const response = await this.fetch(`/api/relationships/people/${encodeURIComponent(id)}`);
+    return response.data;
+};
+ElizaClient.prototype.getRelationshipsActivity = async function (limit, offset) {
+    const params = new URLSearchParams();
+    if (typeof limit === "number")
+        params.set("limit", String(limit));
+    if (typeof offset === "number")
+        params.set("offset", String(offset));
+    const qs = params.toString();
+    return this.fetch(`/api/relationships/activity${qs ? `?${qs}` : ""}`);
+};
+ElizaClient.prototype.getRelationshipsCandidates = async function () {
+    const response = await this.fetch("/api/relationships/candidates");
+    return response.data;
+};
+ElizaClient.prototype.acceptRelationshipsCandidate = async function (candidateId) {
+    const response = await this.fetch(`/api/relationships/candidates/${encodeURIComponent(candidateId)}/accept`, { method: "POST" });
+    return response.data;
+};
+ElizaClient.prototype.rejectRelationshipsCandidate = async function (candidateId) {
+    const response = await this.fetch(`/api/relationships/candidates/${encodeURIComponent(candidateId)}/reject`, { method: "POST" });
+    return response.data;
+};
+ElizaClient.prototype.proposeRelationshipsLink = async function (sourceEntityId, targetEntityId, evidence) {
+    const response = await this.fetch(`/api/relationships/people/${encodeURIComponent(sourceEntityId)}/link`, {
+        method: "POST",
+        body: JSON.stringify({
+            targetEntityId,
+            evidence: evidence ?? {},
+        }),
+        headers: { "Content-Type": "application/json" },
+    });
+    return response.data;
+};
+ElizaClient.prototype.getCharacter = async function () {
+    return this.fetch("/api/character");
+};
+ElizaClient.prototype.getRandomName = async function () {
+    return this.fetch("/api/character/random-name");
+};
+ElizaClient.prototype.generateCharacterField = async function (field, context, mode) {
+    return this.fetch("/api/character/generate", {
+        method: "POST",
+        body: JSON.stringify({ field, context, mode }),
+    });
+};
+ElizaClient.prototype.updateCharacter = async function (character) {
+    return this.fetch("/api/character", {
+        method: "PUT",
+        body: JSON.stringify(character),
+    });
+};
+ElizaClient.prototype.listCharacterHistory = async function (options) {
+    const params = new URLSearchParams();
+    if (typeof options?.limit === "number") {
+        params.set("limit", String(options.limit));
+    }
+    if (typeof options?.offset === "number") {
+        params.set("offset", String(options.offset));
+    }
+    const qs = params.toString();
+    return this.fetch(`/api/character/history${qs ? `?${qs}` : ""}`);
+};
+ElizaClient.prototype.listExperiences = async function (options) {
+    const params = new URLSearchParams();
+    const appendMulti = (key, value) => {
+        if (Array.isArray(value)) {
+            value
+                .map((item) => item.trim())
+                .filter(Boolean)
+                .forEach((item) => {
+                params.append(key, item);
+            });
+            return;
+        }
+        if (typeof value === "string" && value.trim()) {
+            params.append(key, value.trim());
+        }
+    };
+    if (typeof options?.limit === "number") {
+        params.set("limit", String(options.limit));
+    }
+    if (typeof options?.offset === "number") {
+        params.set("offset", String(options.offset));
+    }
+    if (typeof options?.q === "string" && options.q.trim()) {
+        params.set("q", options.q.trim());
+    }
+    if (typeof options?.query === "string" && options.query.trim()) {
+        params.set("query", options.query.trim());
+    }
+    if (typeof options?.minConfidence === "number") {
+        params.set("minConfidence", String(options.minConfidence));
+    }
+    if (typeof options?.minImportance === "number") {
+        params.set("minImportance", String(options.minImportance));
+    }
+    if (typeof options?.includeRelated === "boolean") {
+        params.set("includeRelated", String(options.includeRelated));
+    }
+    appendMulti("type", options?.type);
+    appendMulti("outcome", options?.outcome);
+    appendMulti("domain", options?.domain);
+    options?.tags
+        ?.map((tag) => tag.trim())
+        .filter(Boolean)
+        .forEach((tag) => {
+        params.append("tag", tag);
+    });
+    const qs = params.toString();
+    const response = await this.fetch(`/api/character/experiences${qs ? `?${qs}` : ""}`);
+    return {
+        experiences: response.data,
+        total: response.total,
+    };
+};
+ElizaClient.prototype.getExperienceGraph = async function (options) {
+    const params = new URLSearchParams();
+    const appendMulti = (key, value) => {
+        if (Array.isArray(value)) {
+            value
+                .map((item) => item.trim())
+                .filter(Boolean)
+                .forEach((item) => {
+                params.append(key, item);
+            });
+            return;
+        }
+        if (typeof value === "string" && value.trim()) {
+            params.append(key, value.trim());
+        }
+    };
+    if (typeof options?.limit === "number") {
+        params.set("limit", String(options.limit));
+    }
+    if (typeof options?.q === "string" && options.q.trim()) {
+        params.set("q", options.q.trim());
+    }
+    if (typeof options?.query === "string" && options.query.trim()) {
+        params.set("query", options.query.trim());
+    }
+    if (typeof options?.minConfidence === "number") {
+        params.set("minConfidence", String(options.minConfidence));
+    }
+    if (typeof options?.minImportance === "number") {
+        params.set("minImportance", String(options.minImportance));
+    }
+    if (typeof options?.includeRelated === "boolean") {
+        params.set("includeRelated", String(options.includeRelated));
+    }
+    appendMulti("type", options?.type);
+    appendMulti("outcome", options?.outcome);
+    appendMulti("domain", options?.domain);
+    options?.tags
+        ?.map((tag) => tag.trim())
+        .filter(Boolean)
+        .forEach((tag) => {
+        params.append("tag", tag);
+    });
+    const qs = params.toString();
+    const response = await this.fetch(`/api/character/experiences/graph${qs ? `?${qs}` : ""}`);
+    return { graph: response.data };
+};
+ElizaClient.prototype.runExperienceMaintenance = async function (options) {
+    const response = await this.fetch("/api/character/experiences/maintenance", {
+        method: "POST",
+        body: JSON.stringify(options ?? {}),
+    });
+    return { result: response.data };
+};
+ElizaClient.prototype.getExperience = async function (id) {
+    const response = await this.fetch(`/api/character/experiences/${encodeURIComponent(id)}`);
+    return { experience: response.data };
+};
+ElizaClient.prototype.updateExperience = async function (id, data) {
+    const response = await this.fetch(`/api/character/experiences/${encodeURIComponent(id)}`, {
+        method: "PATCH",
+        body: JSON.stringify(data),
+    });
+    return { experience: response.data };
+};
+ElizaClient.prototype.deleteExperience = async function (id) {
+    return this.fetch(`/api/character/experiences/${encodeURIComponent(id)}`, {
+        method: "DELETE",
+    });
+};
+ElizaClient.prototype.getUpdateStatus = async function (force = false) {
+    return this.fetch(`/api/update/status${force ? "?force=true" : ""}`);
+};
+ElizaClient.prototype.setUpdateChannel = async function (channel) {
+    return this.fetch("/api/update/channel", {
+        method: "PUT",
+        body: JSON.stringify({ channel }),
+    });
+};
+ElizaClient.prototype.getAgentAutomationMode = async function () {
+    return this.fetch("/api/permissions/automation-mode");
+};
+ElizaClient.prototype.setAgentAutomationMode = async function (mode) {
+    return this.fetch("/api/permissions/automation-mode", {
+        method: "PUT",
+        body: JSON.stringify({ mode }),
+    });
+};
+ElizaClient.prototype.getTradePermissionMode = async function () {
+    return this.fetch("/api/permissions/trade-mode");
+};
+ElizaClient.prototype.setTradePermissionMode = async function (mode) {
+    return this.fetch("/api/permissions/trade-mode", {
+        method: "PUT",
+        body: JSON.stringify({ mode }),
+    });
+};
+ElizaClient.prototype.getPermissions = async function () {
+    const permissions = await this.fetch("/api/permissions");
+    const plugin = getNativeWebsiteBlockerPluginIfAvailable();
+    if (!plugin) {
+        return permissions;
+    }
+    const permission = mapWebsiteBlockerStatusToPermission(await plugin.getStatus());
+    return {
+        ...permissions,
+        [WEBSITE_BLOCKING_PERMISSION_ID]: permission,
+    };
+};
+ElizaClient.prototype.getPermission = async function (id) {
+    if (id === WEBSITE_BLOCKING_PERMISSION_ID) {
+        const plugin = getNativeWebsiteBlockerPluginIfAvailable();
+        if (plugin) {
+            return mapWebsiteBlockerStatusToPermission(await plugin.getStatus());
+        }
+    }
+    return this.fetch(`/api/permissions/${id}`);
+};
+ElizaClient.prototype.requestPermission = async function (id) {
+    if (id === WEBSITE_BLOCKING_PERMISSION_ID) {
+        const plugin = getNativeWebsiteBlockerPluginIfAvailable();
+        if (plugin) {
+            return mapWebsiteBlockerPermissionResult(await plugin.requestPermissions());
+        }
+    }
+    return this.fetch(`/api/permissions/${id}/request`, { method: "POST" });
+};
+ElizaClient.prototype.openPermissionSettings = async function (id) {
+    if (id === WEBSITE_BLOCKING_PERMISSION_ID) {
+        const plugin = getNativeWebsiteBlockerPluginIfAvailable();
+        if (plugin) {
+            await plugin.openSettings();
+            return;
+        }
+    }
+    await this.fetch(`/api/permissions/${id}/open-settings`, {
+        method: "POST",
+    });
+};
+ElizaClient.prototype.refreshPermissions = async function () {
+    const permissions = await this.fetch("/api/permissions/refresh", {
+        method: "POST",
+    });
+    const plugin = getNativeWebsiteBlockerPluginIfAvailable();
+    if (!plugin) {
+        return permissions;
+    }
+    const permission = mapWebsiteBlockerStatusToPermission(await plugin.getStatus());
+    return {
+        ...permissions,
+        [WEBSITE_BLOCKING_PERMISSION_ID]: permission,
+    };
+};
+ElizaClient.prototype.setShellEnabled = async function (enabled) {
+    return this.fetch("/api/permissions/shell", {
+        method: "PUT",
+        body: JSON.stringify({ enabled }),
+    });
+};
+ElizaClient.prototype.isShellEnabled = async function () {
+    const result = await this.fetch("/api/permissions/shell");
+    return result.enabled;
+};
+ElizaClient.prototype.getWebsiteBlockerStatus = async function () {
+    const plugin = getNativeWebsiteBlockerPluginIfAvailable();
+    if (plugin) {
+        return await plugin.getStatus();
+    }
+    return this.fetch("/api/website-blocker");
+};
+ElizaClient.prototype.startWebsiteBlock = async function (options) {
+    const plugin = getNativeWebsiteBlockerPluginIfAvailable();
+    if (plugin) {
+        return await plugin.startBlock(options);
+    }
+    return this.fetch("/api/website-blocker", {
+        method: "PUT",
+        body: JSON.stringify(options),
+    });
+};
+ElizaClient.prototype.stopWebsiteBlock = async function () {
+    const plugin = getNativeWebsiteBlockerPluginIfAvailable();
+    if (plugin) {
+        return await plugin.stopBlock();
+    }
+    return this.fetch("/api/website-blocker", {
+        method: "DELETE",
+    });
+};
+ElizaClient.prototype.getAppBlockerStatus = async function () {
+    const plugin = getNativeAppBlockerPluginIfAvailable();
+    if (plugin) {
+        return await plugin.getStatus();
+    }
+    return {
+        available: false,
+        active: false,
+        platform: "web",
+        engine: "none",
+        blockedCount: 0,
+        blockedPackageNames: [],
+        endsAt: null,
+        permissionStatus: "not-applicable",
+        reason: "App blocking is only available on iPhone and Android builds.",
+    };
+};
+ElizaClient.prototype.checkAppBlockerPermissions = async function () {
+    const plugin = getNativeAppBlockerPluginIfAvailable();
+    if (plugin) {
+        return await plugin.checkPermissions();
+    }
+    return {
+        status: "not-applicable",
+        canRequest: false,
+        reason: "App blocking is only available on iPhone and Android builds.",
+    };
+};
+ElizaClient.prototype.requestAppBlockerPermissions = async function () {
+    const plugin = getNativeAppBlockerPluginIfAvailable();
+    if (plugin) {
+        return await plugin.requestPermissions();
+    }
+    return {
+        status: "not-applicable",
+        canRequest: false,
+        reason: "App blocking is only available on iPhone and Android builds.",
+    };
+};
+ElizaClient.prototype.getInstalledAppsToBlock = async function () {
+    const plugin = getNativeAppBlockerPluginIfAvailable();
+    if (plugin) {
+        return await plugin.getInstalledApps();
+    }
+    return { apps: [] };
+};
+ElizaClient.prototype.selectAppBlockerApps = async function () {
+    const plugin = getNativeAppBlockerPluginIfAvailable();
+    if (plugin) {
+        return await plugin.selectApps();
+    }
+    return {
+        apps: [],
+        cancelled: true,
+    };
+};
+ElizaClient.prototype.startAppBlock = async function (options) {
+    const plugin = getNativeAppBlockerPluginIfAvailable();
+    if (plugin) {
+        return await plugin.blockApps(options);
+    }
+    return {
+        success: false,
+        endsAt: null,
+        blockedCount: 0,
+        error: "App blocking is only available on iPhone and Android builds.",
+    };
+};
+ElizaClient.prototype.stopAppBlock = async function () {
+    const plugin = getNativeAppBlockerPluginIfAvailable();
+    if (plugin) {
+        return await plugin.unblockApps();
+    }
+    return {
+        success: false,
+        error: "App blocking is only available on iPhone and Android builds.",
+    };
+};
+ElizaClient.prototype.getCodingAgentStatus = async function () {
+    try {
+        const status = await this.fetch("/api/coding-agents/coordinator/status");
+        if (status &&
+            (!status.tasks || status.tasks.length === 0) &&
+            Array.isArray(status.taskThreads) &&
+            status.taskThreads.length > 0) {
+            status.tasks = mapTaskThreadsToCodingAgentSessions(status.taskThreads).filter((task) => !TERMINAL_STATUSES.has(task.status));
+            status.taskCount = status.tasks.length;
+        }
+        if (status && !status.tasks) {
+            // Only fall back to the raw PTY session list when the coordinator
+            // didn't return a tasks array at all (null/undefined).  An empty
+            // array means "no tasks" — no need to hit /api/coding-agents which
+            // may not have a handler and would hang until timeout.
+            try {
+                const ptySessions = await this.fetch("/api/coding-agents");
+                if (Array.isArray(ptySessions) && ptySessions.length > 0) {
+                    status.tasks = mapPtySessionsToCodingAgentSessions(ptySessions);
+                    status.taskCount = status.tasks.length;
+                }
+            }
+            catch {
+                // /api/coding-agents may not exist — ignore
+            }
+        }
+        return status;
+    }
+    catch {
+        return null;
+    }
+};
+ElizaClient.prototype.listCodingAgentTaskThreads = function (options) {
+    const params = new URLSearchParams();
+    if (options?.includeArchived)
+        params.set("includeArchived", "true");
+    if (options?.status)
+        params.set("status", options.status);
+    if (options?.search)
+        params.set("search", options.search);
+    if (typeof options?.limit === "number" && options.limit > 0) {
+        params.set("limit", String(options.limit));
+    }
+    const query = params.toString();
+    return this.fetch(`/api/coding-agents/coordinator/threads${query ? `?${query}` : ""}`);
+};
+ElizaClient.prototype.getCodingAgentTaskThread = function (threadId) {
+    return this.fetch(`/api/coding-agents/coordinator/threads/${encodeURIComponent(threadId)}`);
+};
+ElizaClient.prototype.archiveCodingAgentTaskThread = async function (threadId) {
+    await this.fetch(`/api/coding-agents/coordinator/threads/${encodeURIComponent(threadId)}/archive`, { method: "POST" });
+    return true;
+};
+ElizaClient.prototype.reopenCodingAgentTaskThread = async function (threadId) {
+    await this.fetch(`/api/coding-agents/coordinator/threads/${encodeURIComponent(threadId)}/reopen`, { method: "POST" });
+    return true;
+};
+ElizaClient.prototype.stopCodingAgent = async function (sessionId) {
+    try {
+        await this.fetch(`/api/coding-agents/${encodeURIComponent(sessionId)}/stop`, { method: "POST" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+ElizaClient.prototype.listCodingAgentScratchWorkspaces = async function () {
+    try {
+        return await this.fetch("/api/coding-agents/scratch");
+    }
+    catch (err) {
+        console.warn("[api-client] Failed to list coding agent scratch workspaces:", err);
+        return [];
+    }
+};
+ElizaClient.prototype.keepCodingAgentScratchWorkspace = async function (sessionId) {
+    try {
+        await this.fetch(`/api/coding-agents/${encodeURIComponent(sessionId)}/scratch/keep`, { method: "POST" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+ElizaClient.prototype.deleteCodingAgentScratchWorkspace = async function (sessionId) {
+    try {
+        await this.fetch(`/api/coding-agents/${encodeURIComponent(sessionId)}/scratch/delete`, { method: "POST" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+ElizaClient.prototype.promoteCodingAgentScratchWorkspace = async function (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;
+    }
+};
+ElizaClient.prototype.spawnShellSession = async function (workdir) {
+    const res = await this.fetch("/api/coding-agents/spawn", {
+        method: "POST",
+        body: JSON.stringify({
+            agentType: "shell",
+            ...(workdir ? { workdir } : {}),
+        }),
+    });
+    return { sessionId: res.sessionId };
+};
+ElizaClient.prototype.subscribePtyOutput = function (sessionId) {
+    this.sendWsMessage({ type: "pty-subscribe", sessionId });
+};
+ElizaClient.prototype.unsubscribePtyOutput = function (sessionId) {
+    this.sendWsMessage({ type: "pty-unsubscribe", sessionId });
+};
+ElizaClient.prototype.sendPtyInput = function (sessionId, data) {
+    this.sendWsMessage({ type: "pty-input", sessionId, data });
+};
+ElizaClient.prototype.resizePty = function (sessionId, cols, rows) {
+    this.sendWsMessage({ type: "pty-resize", sessionId, cols, rows });
+};
+ElizaClient.prototype.getPtyBufferedOutput = async function (sessionId) {
+    try {
+        const res = await this.fetch(`/api/coding-agents/${encodeURIComponent(sessionId)}/buffered-output`);
+        return res.output ?? "";
+    }
+    catch {
+        return "";
+    }
+};
+ElizaClient.prototype.streamGoLive = async function () {
+    return this.fetch("/api/stream/live", { method: "POST" });
+};
+ElizaClient.prototype.streamGoOffline = async function () {
+    return this.fetch("/api/stream/offline", { method: "POST" });
+};
+ElizaClient.prototype.streamStatus = async function () {
+    return this.fetch("/api/stream/status");
+};
+ElizaClient.prototype.getStreamingDestinations = async function () {
+    return this.fetch("/api/streaming/destinations");
+};
+ElizaClient.prototype.setActiveDestination = async function (destinationId) {
+    return this.fetch("/api/streaming/destination", {
+        method: "POST",
+        body: JSON.stringify({ destinationId }),
+    });
+};
+ElizaClient.prototype.setStreamVolume = async function (volume) {
+    return this.fetch("/api/stream/volume", {
+        method: "POST",
+        body: JSON.stringify({ volume }),
+    });
+};
+ElizaClient.prototype.muteStream = async function () {
+    return this.fetch("/api/stream/mute", { method: "POST" });
+};
+ElizaClient.prototype.unmuteStream = async function () {
+    return this.fetch("/api/stream/unmute", { method: "POST" });
+};
+ElizaClient.prototype.getStreamVoice = async function () {
+    return this.fetch("/api/stream/voice");
+};
+ElizaClient.prototype.saveStreamVoice = async function (settings) {
+    return this.fetch("/api/stream/voice", {
+        method: "POST",
+        body: JSON.stringify(settings),
+    });
+};
+ElizaClient.prototype.streamVoiceSpeak = async function (text) {
+    return this.fetch("/api/stream/voice/speak", {
+        method: "POST",
+        body: JSON.stringify({ text }),
+    });
+};
+ElizaClient.prototype.getOverlayLayout = async function (destinationId) {
+    const qs = destinationId
+        ? `?destination=${encodeURIComponent(destinationId)}`
+        : "";
+    return this.fetch(`/api/stream/overlay-layout${qs}`);
+};
+ElizaClient.prototype.saveOverlayLayout = async function (layout, destinationId) {
+    const qs = destinationId
+        ? `?destination=${encodeURIComponent(destinationId)}`
+        : "";
+    return this.fetch(`/api/stream/overlay-layout${qs}`, {
+        method: "POST",
+        body: JSON.stringify({ layout }),
+    });
+};
+ElizaClient.prototype.getStreamSource = async function () {
+    return this.fetch("/api/stream/source");
+};
+ElizaClient.prototype.setStreamSource = async function (sourceType, customUrl) {
+    return this.fetch("/api/stream/source", {
+        method: "POST",
+        body: JSON.stringify({ sourceType, customUrl }),
+    });
+};
+ElizaClient.prototype.getStreamSettings = async function () {
+    return this.fetch("/api/stream/settings");
+};
+ElizaClient.prototype.saveStreamSettings = async function (settings) {
+    return this.fetch("/api/stream/settings", {
+        method: "POST",
+        body: JSON.stringify({ settings }),
+    });
+};
+// ---------------------------------------------------------------------------
+// Multi-account routes (WS3)
+// ---------------------------------------------------------------------------
+ElizaClient.prototype.listAccounts = async function () {
+    return this.fetch("/api/accounts");
+};
+ElizaClient.prototype.createApiKeyAccount = async function (providerId, body) {
+    return this.fetch(`/api/accounts/${encodeURIComponent(providerId)}`, {
+        method: "POST",
+        body: JSON.stringify({ source: "api-key", ...body }),
+    });
+};
+ElizaClient.prototype.patchAccount = async function (providerId, accountId, body) {
+    return this.fetch(`/api/accounts/${encodeURIComponent(providerId)}/${encodeURIComponent(accountId)}`, {
+        method: "PATCH",
+        body: JSON.stringify(body),
+    });
+};
+ElizaClient.prototype.deleteAccount = async function (providerId, accountId) {
+    return this.fetch(`/api/accounts/${encodeURIComponent(providerId)}/${encodeURIComponent(accountId)}`, { method: "DELETE" });
+};
+ElizaClient.prototype.testAccount = async function (providerId, accountId) {
+    return this.fetch(`/api/accounts/${encodeURIComponent(providerId)}/${encodeURIComponent(accountId)}/test`, { method: "POST" });
+};
+ElizaClient.prototype.refreshAccountUsage = async function (providerId, accountId) {
+    return this.fetch(`/api/accounts/${encodeURIComponent(providerId)}/${encodeURIComponent(accountId)}/refresh-usage`, { method: "POST" });
+};
+ElizaClient.prototype.startAccountOAuth = async function (providerId, body) {
+    return this.fetch(`/api/accounts/${encodeURIComponent(providerId)}/oauth/start`, {
+        method: "POST",
+        body: JSON.stringify(body),
+    });
+};
+ElizaClient.prototype.submitAccountOAuthCode = async function (providerId, body) {
+    return this.fetch(`/api/accounts/${encodeURIComponent(providerId)}/oauth/submit-code`, {
+        method: "POST",
+        body: JSON.stringify(body),
+    });
+};
+ElizaClient.prototype.cancelAccountOAuth = async function (providerId, body) {
+    return this.fetch(`/api/accounts/${encodeURIComponent(providerId)}/oauth/cancel`, {
+        method: "POST",
+        body: JSON.stringify(body),
+    });
+};
+ElizaClient.prototype.patchProviderStrategy = async function (providerId, body) {
+    return this.fetch(`/api/providers/${encodeURIComponent(providerId)}/strategy`, {
+        method: "PATCH",
+        body: JSON.stringify(body),
+    });
+};