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

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

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