@elizaos/ui 2.0.0-beta.2 → 2.0.3-beta.2

package/api/client-agent.js

@@ -1,12 +1,15 @@
 /**
  * Agent domain methods — lifecycle, auth, config, connectors, triggers,
- * training, plugins, streaming/PTY, logs, character, permissions, updates.
+ * training, plugins, streaming, logs, character, permissions, updates.
  */
 import { isElizaSettingsDebugEnabled, sanitizeForSettingsDebug, settingsDebugCloudSummary, } from "@elizaos/shared";
+import { invokeDesktopBridgeRequest, invokeDesktopBridgeRequestWithTimeout, } from "../bridge/electrobun-rpc.js";
 import { getAppBlockerPlugin, getWebsiteBlockerPlugin, } from "../bridge/native-plugins.js";
 import { TERMINAL_STATUSES } from "../chat/coding-agent-session-state.js";
+import { androidNativeAgentLifecycleForUrl } from "./android-native-agent-transport.js";
 import { ElizaClient } from "./client-base.js";
-import { mapPtySessionsToCodingAgentSessions, mapTaskThreadsToCodingAgentSessions, } from "./client-types.js";
+import { isDirectCloudSharedAgentBase } from "./client-cloud.js";
+import { ApiError, mapAcpSessionsToCodingAgentSessions, mapTaskThreadsToCodingAgentSessions, } from "./client-types.js";
 // ---------------------------------------------------------------------------
 // Module-level helpers
 // ---------------------------------------------------------------------------
@@ -23,6 +26,12 @@ function clientSettingsDebug() {
         env: typeof process !== "undefined" ? process.env : undefined,
     });
 }
+function isTradePermissionMode(value) {
+    return (value === "user-sign-only" ||
+        value === "manual-local-key" ||
+        value === "agent-auto" ||
+        value === "disabled");
+}
 const WEBSITE_BLOCKING_PERMISSION_ID = "website-blocking";
 function getNativeWebsiteBlockerPluginIfAvailable() {
     const plugin = getWebsiteBlockerPlugin();
@@ -84,16 +93,106 @@ function logSettingsClient(phase, detail) {
     console.debug(`[eliza][settings][client] ${phase}`, sanitizeForSettingsDebug(detail));
 }
 const SETTINGS_MUTATION_TIMEOUT_MS = 30_000;
+const DESKTOP_STATUS_RPC_TIMEOUT_MS = 1_500;
+async function getDesktopStatusRpc(rpcMethod, params) {
+    const outcome = await invokeDesktopBridgeRequestWithTimeout({
+        rpcMethod,
+        ipcChannel: "agent",
+        params,
+        timeoutMs: DESKTOP_STATUS_RPC_TIMEOUT_MS,
+    });
+    return outcome.status === "ok" && outcome.value ? outcome.value : null;
+}
 // ---------------------------------------------------------------------------
 // Prototype augmentation
 // ---------------------------------------------------------------------------
 ElizaClient.prototype.getStatus = async function () {
+    // A shared-runtime cloud agent is provisioned and running cloud-side with no
+    // agent server, so /api/status 404s and the readiness poll would wedge on
+    // "Initializing agent…". Report it running (the provision response confirms
+    // status:"running") so startup proceeds to chat — its REST adapter already
+    // serves /api/conversations + /api/conversations/:id/messages.
+    if (isDirectCloudSharedAgentBase(this.getBaseUrl())) {
+        return {
+            state: "running",
+            agentName: "Eliza",
+            model: undefined,
+            // Cloud-shared agent is provisioned + serving cloud-side — first-turn
+            // capability is online, so the composer should be live immediately.
+            canRespond: true,
+            uptime: undefined,
+            startedAt: undefined,
+        };
+    }
+    try {
+        const viaRpc = await getDesktopStatusRpc("getAgentStatus");
+        if (viaRpc)
+            return viaRpc;
+    }
+    catch {
+        /* fall through */
+    }
+    const nativeAgent = await androidNativeAgentLifecycleForUrl(this.getBaseUrl());
+    if (nativeAgent?.getStatus) {
+        const native = (await nativeAgent.getStatus());
+        // The native lifecycle plugin reports the bun *process* state but not the
+        // agent's first-turn readiness (`canRespond`) or loaded `model` — those
+        // exist only in the HTTP `/api/status` the running agent serves. Without
+        // them `deriveAgentReady` never flips, so the chat's `ready` gate stays
+        // false forever ("waking up…") and voice / hands-free is blocked even though
+        // the agent can answer. When the process is up but its status doesn't yet
+        // confirm `canRespond`, fill the readiness fields from `/api/status`.
+        if (native.state === "running" && native.canRespond !== true) {
+            try {
+                const http = (await this.fetch("/api/status"));
+                if (http && typeof http === "object") {
+                    return { ...native, ...http };
+                }
+            }
+            catch {
+                /* /api/status unreachable — fall back to the native lifecycle status */
+            }
+        }
+        return native;
+    }
     return this.fetch("/api/status");
 };
+ElizaClient.prototype.getBootProgress = async function () {
+    try {
+        return await getDesktopStatusRpc("bootProgress");
+    }
+    catch {
+        return null;
+    }
+};
+ElizaClient.prototype.getLaunchProgress = async function () {
+    try {
+        return await getDesktopStatusRpc("launchProgress");
+    }
+    catch {
+        return null;
+    }
+};
 ElizaClient.prototype.getAgentSelfStatus = async function () {
+    try {
+        const viaRpc = await getDesktopStatusRpc("getAgentSelfStatus");
+        if (viaRpc)
+            return viaRpc;
+    }
+    catch {
+        /* fall through */
+    }
     return this.fetch("/api/agent/self-status");
 };
 ElizaClient.prototype.getRuntimeSnapshot = async function (opts) {
+    try {
+        const viaRpc = await getDesktopStatusRpc("getRuntimeSnapshot", opts);
+        if (viaRpc)
+            return viaRpc;
+    }
+    catch {
+        /* fall through */
+    }
     const params = new URLSearchParams();
     if (typeof opts?.depth === "number")
         params.set("depth", String(opts.depth));
@@ -110,12 +209,42 @@ ElizaClient.prototype.getRuntimeSnapshot = async function (opts) {
     return this.fetch(`/api/runtime${qs ? `?${qs}` : ""}`);
 };
 ElizaClient.prototype.setAutomationMode = async function (mode) {
+    try {
+        const viaRpc = await invokeDesktopBridgeRequest({
+            rpcMethod: "setAgentAutomationMode",
+            ipcChannel: "agent:setAgentAutomationMode",
+            params: { mode },
+        });
+        if (viaRpc)
+            return { mode: viaRpc.mode };
+    }
+    catch {
+        /* fall through */
+    }
     return this.fetch("/api/permissions/automation-mode", {
         method: "PUT",
         body: JSON.stringify({ mode }),
     });
 };
 ElizaClient.prototype.setTradeMode = async function (mode) {
+    if (isTradePermissionMode(mode)) {
+        try {
+            const viaRpc = await invokeDesktopBridgeRequest({
+                rpcMethod: "setTradePermissionMode",
+                ipcChannel: "agent:setTradePermissionMode",
+                params: { mode },
+            });
+            if (viaRpc) {
+                return {
+                    ok: viaRpc.ok ?? true,
+                    tradePermissionMode: viaRpc.tradePermissionMode,
+                };
+            }
+        }
+        catch {
+            /* fall through */
+        }
+    }
     return this.fetch("/api/permissions/trade-mode", {
         method: "PUT",
         body: JSON.stringify({ mode }),
@@ -133,8 +262,30 @@ ElizaClient.prototype.runTerminalCommand = async function (command) {
         body: JSON.stringify({ command }),
     });
 };
-ElizaClient.prototype.getOnboardingStatus = async function () {
-    return this.fetch("/api/onboarding/status");
+ElizaClient.prototype.getFirstRunStatus = async function () {
+    // A shared-runtime cloud agent is provisioned on our behalf, so first-run is
+    // complete by definition AND its REST adapter has no /api/first-run* surface.
+    // Short-circuit here: otherwise the native-bridge RPC path (a local on-device
+    // agent that auto-starts on stock phones) answers with ITS first-run state
+    // ({complete:false}), and the HTTP path 404s — either way the app wrongly
+    // re-enters onboarding instead of going to the cloud chat.
+    if (isDirectCloudSharedAgentBase(this.getBaseUrl())) {
+        return { complete: true, cloudProvisioned: true };
+    }
+    // Prefer typed Electrobun RPC. The bun-side composer throws
+    // AgentNotReadyError if the agent has no port yet; we catch and
+    // fall through to HTTP so the renderer's polling loop sees the
+    // same "transport not ready" semantic as before RPC was wired.
+    // Server contract: eliza/packages/agent/src/api/first-run-routes.ts.
+    try {
+        const viaRpc = await invokeDesktopBridgeRequest({ rpcMethod: "getFirstRunStatus", ipcChannel: "agent" });
+        if (viaRpc)
+            return viaRpc;
+    }
+    catch {
+        /* AgentNotReadyError or any RPC failure → fall through to HTTP */
+    }
+    return this.fetch("/api/first-run/status");
 };
 ElizaClient.prototype.getWalletKeys = async function () {
     return this.fetch("/api/wallet/keys");
@@ -149,6 +300,20 @@ ElizaClient.prototype.postWalletOsStoreAction = async function (action) {
     });
 };
 ElizaClient.prototype.getAuthStatus = async function () {
+    // Prefer typed Electrobun RPC. Throws AgentNotReadyError when the
+    // agent has no port yet — we catch and fall through to HTTP so the
+    // existing retry/backoff loop handles the "not ready" semantic
+    // exactly as it did before RPC was in the picture. NEVER fabricates
+    // a 401-shaped fallback response (see the auth-client.ts authMe wrapper
+    // history if you need the bug story).
+    try {
+        const viaRpc = await invokeDesktopBridgeRequest({ rpcMethod: "getAuthStatus", ipcChannel: "agent" });
+        if (viaRpc)
+            return viaRpc;
+    }
+    catch {
+        /* AgentNotReadyError or any RPC failure → fall through to HTTP */
+    }
     const maxRetries = 3;
     const baseBackoffMs = 1000;
     let lastErr;
@@ -213,11 +378,22 @@ ElizaClient.prototype.pair = async function (code) {
     });
     return res;
 };
-ElizaClient.prototype.getOnboardingOptions = async function () {
-    return this.fetch("/api/onboarding/options");
+ElizaClient.prototype.getFirstRunOptions = async function () {
+    try {
+        const viaRpc = await invokeDesktopBridgeRequest({
+            rpcMethod: "getFirstRunOptions",
+            ipcChannel: "agent",
+        });
+        if (viaRpc)
+            return viaRpc;
+    }
+    catch {
+        /* AgentNotReadyError or any RPC failure → fall through to HTTP */
+    }
+    return this.fetch("/api/first-run/options");
 };
-ElizaClient.prototype.submitOnboarding = async function (data) {
-    await this.fetch("/api/onboarding", {
+ElizaClient.prototype.submitFirstRun = async function (data) {
+    await this.fetch("/api/first-run", {
         method: "POST",
         body: JSON.stringify(data),
     });
@@ -240,6 +416,17 @@ ElizaClient.prototype.submitAnthropicSetupToken = async function (token) {
     });
 };
 ElizaClient.prototype.getSubscriptionStatus = async function () {
+    try {
+        const viaRpc = await invokeDesktopBridgeRequest({
+            rpcMethod: "getSubscriptionStatus",
+            ipcChannel: "agent",
+        });
+        if (viaRpc)
+            return viaRpc;
+    }
+    catch {
+        /* fall through */
+    }
     return this.fetch("/api/subscription/status");
 };
 ElizaClient.prototype.deleteSubscription = async function (provider) {
@@ -247,7 +434,7 @@ ElizaClient.prototype.deleteSubscription = async function (provider) {
         method: "DELETE",
     });
 };
-ElizaClient.prototype.switchProvider = async function (provider, apiKey, primaryModel, options) {
+ElizaClient.prototype.switchProvider = async function (provider, apiKey, primaryModel) {
     logSettingsClient("POST /api/provider/switch → start", {
         baseUrl: this.getBaseUrl(),
         provider,
@@ -255,7 +442,6 @@ ElizaClient.prototype.switchProvider = async function (provider, apiKey, primary
         apiKey,
         hasPrimaryModel: Boolean(primaryModel?.trim()),
         primaryModel,
-        useLocalEmbeddings: options?.useLocalEmbeddings,
     });
     const result = (await this.fetch("/api/provider/switch", {
         method: "POST",
@@ -264,9 +450,6 @@ ElizaClient.prototype.switchProvider = async function (provider, apiKey, primary
             provider,
             ...(apiKey ? { apiKey } : {}),
             ...(primaryModel ? { primaryModel } : {}),
-            ...(options?.useLocalEmbeddings != null
-                ? { useLocalEmbeddings: options.useLocalEmbeddings }
-                : {}),
         }),
     }));
     logSettingsClient("POST /api/provider/switch ← ok", {
@@ -286,12 +469,26 @@ ElizaClient.prototype.exchangeOpenAICode = async function (code) {
     });
 };
 ElizaClient.prototype.startAgent = async function () {
+    const nativeAgent = await androidNativeAgentLifecycleForUrl(this.getBaseUrl());
+    if (nativeAgent?.start) {
+        return (await nativeAgent.start());
+    }
     const res = await this.fetch("/api/agent/start", {
         method: "POST",
     });
     return res.status;
 };
 ElizaClient.prototype.stopAgent = async function () {
+    const nativeAgent = await androidNativeAgentLifecycleForUrl(this.getBaseUrl());
+    if (nativeAgent?.stop) {
+        await nativeAgent.stop();
+        return {
+            state: "stopped",
+            agentName: "Eliza",
+            port: undefined,
+            startedAt: undefined,
+        };
+    }
     const res = await this.fetch("/api/agent/stop", {
         method: "POST",
     });
@@ -310,6 +507,13 @@ ElizaClient.prototype.resumeAgent = async function () {
     return res.status;
 };
 ElizaClient.prototype.restartAgent = async function () {
+    const nativeAgent = await androidNativeAgentLifecycleForUrl(this.getBaseUrl());
+    if (nativeAgent?.start) {
+        if (nativeAgent.stop) {
+            await nativeAgent.stop();
+        }
+        return (await nativeAgent.start());
+    }
     try {
         const res = await this.fetch("/api/agent/restart", {
             method: "POST",
@@ -330,62 +534,30 @@ ElizaClient.prototype.restartAgent = async function () {
     }
 };
 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);
+    catch {
+        // 409 is expected while already restarting; poll will detect running state
     }
     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);
-            }
+        catch {
+            // getStatus may fail while agent is restarting; keep polling
         }
     }
-    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;
+    return this.getStatus();
 };
 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" });
@@ -394,16 +566,38 @@ ElizaClient.prototype.getConfig = async function () {
     logSettingsClient("GET /api/config → start", {
         baseUrl: this.getBaseUrl(),
     });
-    const r = (await this.fetch("/api/config"));
+    let viaRpc = null;
+    try {
+        viaRpc = await invokeDesktopBridgeRequest({
+            rpcMethod: "getConfig",
+            ipcChannel: "agent",
+        });
+    }
+    catch {
+        /* AgentNotReadyError or any RPC failure → fall through to HTTP */
+    }
+    const r = viaRpc ?? (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),
+        transport: viaRpc ? "rpc" : "http",
     });
     return r;
 };
 ElizaClient.prototype.getConfigSchema = async function () {
+    try {
+        const viaRpc = await invokeDesktopBridgeRequest({
+            rpcMethod: "getConfigSchema",
+            ipcChannel: "agent",
+        });
+        if (viaRpc)
+            return viaRpc;
+    }
+    catch {
+        /* fall through */
+    }
     return this.fetch("/api/config/schema");
 };
 ElizaClient.prototype.updateConfig = async function (patch) {
@@ -411,18 +605,34 @@ ElizaClient.prototype.updateConfig = async function (patch) {
         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,
-    }));
+    let out = null;
+    let transport = "rpc";
+    try {
+        out = await invokeDesktopBridgeRequest({
+            rpcMethod: "updateConfig",
+            ipcChannel: "agent:updateConfig",
+            params: patch,
+        });
+    }
+    catch {
+        out = null;
+    }
+    if (!out) {
+        transport = "http";
+        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),
+        transport,
     });
     return out;
 };
@@ -531,23 +741,38 @@ function normalizeConnectorPurposeList(value) {
         .map((item) => (typeof item === "string" ? item.trim() : ""))
         .filter((item) => Boolean(item) && !isConnectorRoleValue(item));
 }
-function normalizeConnectorAccountRecord(provider, connectorId, raw) {
-    const record = raw && typeof raw === "object" && !Array.isArray(raw)
+function recordFromUnknown(raw) {
+    return raw && typeof raw === "object" && !Array.isArray(raw)
         ? raw
         : {};
+}
+function nonEmptyString(value) {
+    return typeof value === "string" && value.trim() ? value : null;
+}
+function connectorAccountLabel(record) {
+    return (nonEmptyString(record.label) ??
+        nonEmptyString(record.displayHandle) ??
+        nonEmptyString(record.handle) ??
+        nonEmptyString(record.externalId) ??
+        String(record.id ?? "unknown"));
+}
+function connectorAccountHandle(record) {
+    return typeof record.handle === "string"
+        ? record.handle
+        : typeof record.displayHandle === "string"
+            ? record.displayHandle
+            : null;
+}
+function connectorAccountMetadata(record) {
+    return record.metadata && typeof record.metadata === "object"
+        ? record.metadata
+        : undefined;
+}
+function normalizeConnectorAccountRecord(provider, connectorId, raw) {
+    const record = recordFromUnknown(raw);
     const role = normalizeConnectorAccountRole(record.role) ??
         normalizeConnectorAccountRole(record.purpose) ??
         "OWNER";
-    const purpose = normalizeConnectorPurposeList(record.purpose);
-    const label = typeof record.label === "string" && record.label.trim()
-        ? record.label
-        : typeof record.displayHandle === "string" && record.displayHandle.trim()
-            ? record.displayHandle
-            : typeof record.handle === "string" && record.handle.trim()
-                ? record.handle
-                : typeof record.externalId === "string" && record.externalId.trim()
-                    ? record.externalId
-                    : String(record.id ?? "unknown");
     return {
         ...record,
         id: String(record.id ?? ""),
@@ -555,21 +780,15 @@ function normalizeConnectorAccountRecord(provider, connectorId, raw) {
             ? record.provider
             : provider,
         connectorId,
-        label,
-        handle: typeof record.handle === "string"
-            ? record.handle
-            : typeof record.displayHandle === "string"
-                ? record.displayHandle
-                : null,
+        label: connectorAccountLabel(record),
+        handle: connectorAccountHandle(record),
         externalId: typeof record.externalId === "string" ? record.externalId : null,
         status: normalizeConnectorStatus(record.status),
         role,
-        purpose,
+        purpose: normalizeConnectorPurposeList(record.purpose),
         isDefault: record.isDefault === true,
         enabled: record.enabled !== false,
-        metadata: record.metadata && typeof record.metadata === "object"
-            ? record.metadata
-            : undefined,
+        metadata: connectorAccountMetadata(record),
     };
 }
 function normalizeConnectorAccountsListResponse(provider, connectorId, raw) {
@@ -594,20 +813,12 @@ function normalizeConnectorAccountsListResponse(provider, connectorId, raw) {
     };
 }
 function normalizeConnectorAccountActionResult(provider, connectorId, raw) {
-    const record = raw && typeof raw === "object" && !Array.isArray(raw)
-        ? raw
-        : {};
+    const record = recordFromUnknown(raw);
     const account = record.account ?? (typeof record.id === "string" ? record : null);
-    const flow = record.flow &&
-        typeof record.flow === "object" &&
-        !Array.isArray(record.flow)
-        ? record.flow
-        : null;
+    const flow = recordFromUnknown(record.flow);
     return {
         ...record,
-        ok: typeof record.ok === "boolean"
-            ? record.ok
-            : record.deleted === true || (!("error" in record) && account !== null),
+        ok: normalizeConnectorActionOk(record, account),
         account: account
             ? normalizeConnectorAccountRecord(provider, connectorId, account)
             : undefined,
@@ -617,20 +828,30 @@ function normalizeConnectorAccountActionResult(provider, connectorId, raw) {
         defaultAccountId: typeof record.defaultAccountId === "string"
             ? record.defaultAccountId
             : null,
-        flow: flow ?? undefined,
-        authUrl: typeof record.authUrl === "string"
-            ? record.authUrl
-            : typeof flow?.authUrl === "string"
-                ? flow.authUrl
-                : undefined,
-        status: typeof record.status === "string"
-            ? normalizeConnectorStatus(record.status)
-            : typeof flow?.status === "string"
-                ? normalizeConnectorStatus(flow.status)
-                : undefined,
+        flow: Object.keys(flow).length > 0 ? flow : undefined,
+        authUrl: connectorActionAuthUrl(record, flow),
+        status: connectorActionStatus(record, flow),
         error: typeof record.error === "string" ? record.error : undefined,
     };
 }
+function normalizeConnectorActionOk(record, account) {
+    return typeof record.ok === "boolean"
+        ? record.ok
+        : record.deleted === true || (!("error" in record) && account !== null);
+}
+function connectorActionAuthUrl(record, flow) {
+    if (typeof record.authUrl === "string")
+        return record.authUrl;
+    return typeof flow.authUrl === "string" ? flow.authUrl : undefined;
+}
+function connectorActionStatus(record, flow) {
+    if (typeof record.status === "string") {
+        return normalizeConnectorStatus(record.status);
+    }
+    return typeof flow.status === "string"
+        ? normalizeConnectorStatus(flow.status)
+        : undefined;
+}
 function connectorAccountAuditPath(provider, query = {}) {
     const params = new URLSearchParams();
     if (query.accountId)
@@ -727,6 +948,17 @@ ElizaClient.prototype.emitTriggerEvent = async function (eventKind, payload = {}
     });
 };
 ElizaClient.prototype.getTriggerHealth = async function () {
+    try {
+        const viaRpc = await invokeDesktopBridgeRequest({
+            rpcMethod: "getTriggerHealth",
+            ipcChannel: "agent",
+        });
+        if (viaRpc)
+            return viaRpc;
+    }
+    catch {
+        /* fall through */
+    }
     return this.fetch("/api/triggers/health");
 };
 ElizaClient.prototype.getTrainingStatus = async function () {
@@ -770,8 +1002,49 @@ ElizaClient.prototype.cancelTrainingJob = async function (jobId) {
         method: "POST",
     });
 };
+function trainingModelRecordFromVastRegistry(item, loadedAt) {
+    const entry = item.entry;
+    const id = item.short_name ?? entry?.eliza_short_name;
+    if (!id || !entry)
+        return null;
+    return {
+        id,
+        createdAt: loadedAt ?? "",
+        jobId: `vast-registry:${id}`,
+        outputDir: entry.gguf_repo_id ?? entry.eliza_repo_id ?? "",
+        modelPath: entry.gguf_repo_id ?? entry.eliza_repo_id ?? id,
+        adapterPath: null,
+        sourceModel: entry.base_hf_id ?? null,
+        backend: "cuda",
+        ollamaModel: null,
+        active: false,
+        benchmark: {
+            status: "not_run",
+            lastRunAt: null,
+            output: entry.tier
+                ? `Eliza-1 ${entry.tier} registry entry`
+                : "Eliza-1 registry entry",
+        },
+    };
+}
 ElizaClient.prototype.listTrainingModels = async function () {
-    return this.fetch("/api/training/models");
+    const listed = await this.fetch("/api/training/models");
+    if (Array.isArray(listed.models) && listed.models.length > 0) {
+        return { models: listed.models };
+    }
+    try {
+        const registry = await this.fetch("/api/training/vast/models");
+        const registryModels = (registry.entries ?? [])
+            .map((item) => trainingModelRecordFromVastRegistry(item, registry.loaded_at))
+            .filter((model) => model !== null);
+        if (registryModels.length > 0)
+            return { models: registryModels };
+    }
+    catch {
+        // The legacy training service and Vast registry are optional independent
+        // surfaces; keep the legacy response when the registry is unavailable.
+    }
+    return { models: listed.models ?? [] };
 };
 ElizaClient.prototype.importTrainingModelToOllama = async function (modelId, options) {
     return this.fetch(`/api/training/models/${encodeURIComponent(modelId)}/import-ollama`, {
@@ -788,6 +1061,77 @@ ElizaClient.prototype.activateTrainingModel = async function (modelId, providerM
 ElizaClient.prototype.benchmarkTrainingModel = async function (modelId) {
     return this.fetch(`/api/training/models/${encodeURIComponent(modelId)}/benchmark`, { method: "POST" });
 };
+ElizaClient.prototype.buildTrainingAnalysisIndex = async function (options) {
+    return this.fetch("/api/training/analysis/index", {
+        method: "POST",
+        body: JSON.stringify(options ?? {}),
+    });
+};
+ElizaClient.prototype.buildTrainingReadinessReport = async function (options) {
+    return this.fetch("/api/training/analysis/readiness", {
+        method: "POST",
+        body: JSON.stringify(options ?? {}),
+    });
+};
+ElizaClient.prototype.ingestHuggingFaceTrainingDataset = async function (options) {
+    return this.fetch("/api/training/datasets/ingest-hf", {
+        method: "POST",
+        body: JSON.stringify(options ?? {}),
+    });
+};
+ElizaClient.prototype.stageEliza1Bundle = async function (options) {
+    return this.fetch("/api/training/models/stage-eliza1-bundle", {
+        method: "POST",
+        body: JSON.stringify(options ?? {}),
+    });
+};
+ElizaClient.prototype.runFeedTrainingGeneration = async function (options) {
+    return this.fetch("/api/training/feed/generate", {
+        method: "POST",
+        body: JSON.stringify(options ?? {}),
+    });
+};
+ElizaClient.prototype.runTrainingScenarios = async function (options) {
+    return this.fetch("/api/training/scenarios/run", {
+        method: "POST",
+        body: JSON.stringify(options ?? {}),
+    });
+};
+ElizaClient.prototype.runTrainingActionBenchmark = async function (options) {
+    return this.fetch("/api/training/benchmarks/action-selection/run", {
+        method: "POST",
+        body: JSON.stringify(options ?? {}),
+    });
+};
+ElizaClient.prototype.runTrainingBenchmarkVsCerebras = async function (options) {
+    return this.fetch("/api/training/benchmarks/run-vs-cerebras", {
+        method: "POST",
+        body: JSON.stringify(options ?? {}),
+    });
+};
+ElizaClient.prototype.runTrainingLocalEvalComparison = async function (options) {
+    return this.fetch("/api/training/evals/run-local-comparison", {
+        method: "POST",
+        body: JSON.stringify(options ?? {}),
+    });
+};
+ElizaClient.prototype.runTrainingCollection = async function (options) {
+    return this.fetch("/api/training/collect", {
+        method: "POST",
+        body: JSON.stringify(options ?? {}),
+    });
+};
+ElizaClient.prototype.listTrainingCollections = async function (options) {
+    const params = new URLSearchParams();
+    if (options?.limit !== undefined) {
+        params.set("limit", String(options.limit));
+    }
+    if (options?.root) {
+        params.set("root", options.root);
+    }
+    const query = params.toString();
+    return this.fetch(`/api/training/collections${query ? `?${query}` : ""}`);
+};
 ElizaClient.prototype.getPlugins = async function () {
     return this.fetch("/api/plugins");
 };
@@ -798,6 +1142,17 @@ ElizaClient.prototype.fetchModels = async function (provider, refresh = true) {
     return this.fetch(`/api/models?${params.toString()}`);
 };
 ElizaClient.prototype.getCorePlugins = async function () {
+    try {
+        const viaRpc = await invokeDesktopBridgeRequest({
+            rpcMethod: "getCorePlugins",
+            ipcChannel: "agent",
+        });
+        if (viaRpc)
+            return viaRpc;
+    }
+    catch {
+        /* fall through */
+    }
     return this.fetch("/api/plugins/core");
 };
 ElizaClient.prototype.toggleCorePlugin = async function (npmName, enabled) {
@@ -883,6 +1238,67 @@ function buildSecurityAuditParams(filter, includeStream = false) {
         params.set("stream", "1");
     return params;
 }
+async function throwSecurityAuditResponseError(res) {
+    const body = (await res
+        .json()
+        .catch(() => ({ error: res.statusText })));
+    const err = new Error(body?.error ?? `HTTP ${res.status}`);
+    err.status = res.status;
+    throw err;
+}
+function 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 };
+}
+function parseSecurityAuditPayload(payload, onEvent) {
+    if (!payload)
+        return;
+    try {
+        const parsed = JSON.parse(payload);
+        if (parsed.type === "snapshot" || parsed.type === "entry") {
+            onEvent(parsed);
+        }
+    }
+    catch (error) {
+        console.warn("[client-agent] dropped malformed security audit stream frame", { payload, error });
+    }
+}
+function consumeSecurityAuditEvent(rawEvent, onEvent) {
+    for (const line of rawEvent.split(/\r?\n/)) {
+        if (!line.startsWith("data:"))
+            continue;
+        parseSecurityAuditPayload(line.slice(5).trim(), onEvent);
+    }
+}
+async function readSecurityAuditStream(body, onEvent) {
+    const decoder = new TextDecoder();
+    const reader = body.getReader();
+    let buffer = "";
+    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);
+            consumeSecurityAuditEvent(rawEvent, onEvent);
+            eventBreak = findSseEventBreak(buffer);
+        }
+    }
+    if (buffer.trim())
+        consumeSecurityAuditEvent(buffer, onEvent);
+}
 ElizaClient.prototype.getSecurityAudit = async function (filter) {
     const qs = buildSecurityAuditParams(filter).toString();
     return this.fetch(`/api/security/audit${qs ? `?${qs}` : ""}`);
@@ -893,78 +1309,21 @@ ElizaClient.prototype.streamSecurityAudit = async function (onEvent, filter, sig
     }
     const token = this.apiToken;
     const qs = buildSecurityAuditParams(filter, true).toString();
-    const res = await fetch(`${this.baseUrl}/api/security/audit${qs ? `?${qs}` : ""}`, {
+    const res = await this.rawRequest(`/api/security/audit${qs ? `?${qs}` : ""}`, {
         method: "GET",
         headers: {
             Accept: "text/event-stream",
             ...(token ? { Authorization: `Bearer ${token}` } : {}),
         },
         signal,
-    });
+    }, { allowNonOk: true });
     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;
+        await throwSecurityAuditResponseError(res);
     }
     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());
-        }
-    }
+    await readSecurityAuditStream(res.body, onEvent);
 };
 ElizaClient.prototype.getAgentEvents = async function (opts) {
     const params = new URLSearchParams();
@@ -980,6 +1339,17 @@ ElizaClient.prototype.getAgentEvents = async function (opts) {
     return this.fetch(`/api/agent/events${qs ? `?${qs}` : ""}`);
 };
 ElizaClient.prototype.getExtensionStatus = async function () {
+    try {
+        const viaRpc = await invokeDesktopBridgeRequest({
+            rpcMethod: "getExtensionStatus",
+            ipcChannel: "agent",
+        });
+        if (viaRpc)
+            return viaRpc;
+    }
+    catch {
+        /* fall through */
+    }
     return this.fetch("/api/extension/status");
 };
 ElizaClient.prototype.getRelationshipsGraph = async function (query) {
@@ -1054,6 +1424,18 @@ ElizaClient.prototype.proposeRelationshipsLink = async function (sourceEntityId,
     return response.data;
 };
 ElizaClient.prototype.getCharacter = async function () {
+    // RPC composer forwards the `/api/character` body verbatim, so the
+    // wire shape is `{ character, agentName }` — bun-side just types it
+    // loosely as Record. Catch swallows AgentNotReadyError + transport
+    // failure → fall through to HTTP.
+    try {
+        const viaRpc = await invokeDesktopBridgeRequest({ rpcMethod: "getCharacter", ipcChannel: "agent" });
+        if (viaRpc)
+            return viaRpc;
+    }
+    catch {
+        /* fall through */
+    }
     return this.fetch("/api/character");
 };
 ElizaClient.prototype.getRandomName = async function () {
@@ -1082,52 +1464,62 @@ ElizaClient.prototype.listCharacterHistory = async function (options) {
     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));
+function appendMultiQueryParam(params, key, value) {
+    if (Array.isArray(value)) {
+        value
+            .map((item) => item.trim())
+            .filter(Boolean)
+            .forEach((item) => {
+            params.append(key, item);
+        });
+        return;
     }
-    if (typeof options?.includeRelated === "boolean") {
-        params.set("includeRelated", String(options.includeRelated));
+    if (typeof value === "string" && value.trim()) {
+        params.append(key, value.trim());
     }
-    appendMulti("type", options?.type);
-    appendMulti("outcome", options?.outcome);
-    appendMulti("domain", options?.domain);
+}
+function appendTrimmedQueryParam(params, key, value) {
+    const trimmed = typeof value === "string" ? value.trim() : "";
+    if (trimmed)
+        params.set(key, trimmed);
+}
+function appendNumberQueryParam(params, key, value) {
+    if (typeof value === "number")
+        params.set(key, String(value));
+}
+function appendBooleanQueryParam(params, key, value) {
+    if (typeof value === "boolean")
+        params.set(key, String(value));
+}
+function appendExperienceScalarParams(params, options, includeOffset) {
+    appendNumberQueryParam(params, "limit", options?.limit);
+    if (includeOffset)
+        appendNumberQueryParam(params, "offset", options?.offset);
+    appendTrimmedQueryParam(params, "q", options?.q);
+    appendTrimmedQueryParam(params, "query", options?.query);
+    appendNumberQueryParam(params, "minConfidence", options?.minConfidence);
+    appendNumberQueryParam(params, "minImportance", options?.minImportance);
+    appendBooleanQueryParam(params, "includeRelated", options?.includeRelated);
+}
+function appendExperienceCollectionParams(params, options) {
+    appendMultiQueryParam(params, "type", options?.type);
+    appendMultiQueryParam(params, "outcome", options?.outcome);
+    appendMultiQueryParam(params, "domain", options?.domain);
     options?.tags
         ?.map((tag) => tag.trim())
         .filter(Boolean)
         .forEach((tag) => {
         params.append("tag", tag);
     });
+}
+function buildExperienceQueryParams(options, includeOffset) {
+    const params = new URLSearchParams();
+    appendExperienceScalarParams(params, options, includeOffset);
+    appendExperienceCollectionParams(params, options);
+    return params;
+}
+ElizaClient.prototype.listExperiences = async function (options) {
+    const params = buildExperienceQueryParams(options, true);
     const qs = params.toString();
     const response = await this.fetch(`/api/character/experiences${qs ? `?${qs}` : ""}`);
     return {
@@ -1136,48 +1528,7 @@ ElizaClient.prototype.listExperiences = async function (options) {
     };
 };
 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 params = buildExperienceQueryParams(options, false);
     const qs = params.toString();
     const response = await this.fetch(`/api/character/experiences/graph${qs ? `?${qs}` : ""}`);
     return { graph: response.data };
@@ -1206,6 +1557,18 @@ ElizaClient.prototype.deleteExperience = async function (id) {
     });
 };
 ElizaClient.prototype.getUpdateStatus = async function (force = false) {
+    try {
+        const viaRpc = await invokeDesktopBridgeRequest({
+            rpcMethod: "getUpdateStatus",
+            ipcChannel: "agent",
+            params: { force },
+        });
+        if (viaRpc)
+            return viaRpc;
+    }
+    catch {
+        /* fall through */
+    }
     return this.fetch(`/api/update/status${force ? "?force=true" : ""}`);
 };
 ElizaClient.prototype.setUpdateChannel = async function (channel) {
@@ -1215,18 +1578,64 @@ ElizaClient.prototype.setUpdateChannel = async function (channel) {
     });
 };
 ElizaClient.prototype.getAgentAutomationMode = async function () {
+    try {
+        const viaRpc = await invokeDesktopBridgeRequest({
+            rpcMethod: "getAgentAutomationMode",
+            ipcChannel: "agent:getAgentAutomationMode",
+        });
+        if (viaRpc)
+            return viaRpc;
+    }
+    catch {
+        /* fall through */
+    }
     return this.fetch("/api/permissions/automation-mode");
 };
 ElizaClient.prototype.setAgentAutomationMode = async function (mode) {
+    try {
+        const viaRpc = await invokeDesktopBridgeRequest({
+            rpcMethod: "setAgentAutomationMode",
+            ipcChannel: "agent:setAgentAutomationMode",
+            params: { mode },
+        });
+        if (viaRpc)
+            return viaRpc;
+    }
+    catch {
+        /* fall through */
+    }
     return this.fetch("/api/permissions/automation-mode", {
         method: "PUT",
         body: JSON.stringify({ mode }),
     });
 };
 ElizaClient.prototype.getTradePermissionMode = async function () {
+    try {
+        const viaRpc = await invokeDesktopBridgeRequest({
+            rpcMethod: "getTradePermissionMode",
+            ipcChannel: "agent:getTradePermissionMode",
+        });
+        if (viaRpc)
+            return viaRpc;
+    }
+    catch {
+        /* fall through */
+    }
     return this.fetch("/api/permissions/trade-mode");
 };
 ElizaClient.prototype.setTradePermissionMode = async function (mode) {
+    try {
+        const viaRpc = await invokeDesktopBridgeRequest({
+            rpcMethod: "setTradePermissionMode",
+            ipcChannel: "agent:setTradePermissionMode",
+            params: { mode },
+        });
+        if (viaRpc)
+            return viaRpc;
+    }
+    catch {
+        /* fall through */
+    }
     return this.fetch("/api/permissions/trade-mode", {
         method: "PUT",
         body: JSON.stringify({ mode }),
@@ -1301,14 +1710,14 @@ ElizaClient.prototype.isShellEnabled = async function () {
 ElizaClient.prototype.getWebsiteBlockerStatus = async function () {
     const plugin = getNativeWebsiteBlockerPluginIfAvailable();
     if (plugin) {
-        return await plugin.getStatus();
+        return 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 plugin.startBlock(options);
     }
     return this.fetch("/api/website-blocker", {
         method: "PUT",
@@ -1318,7 +1727,7 @@ ElizaClient.prototype.startWebsiteBlock = async function (options) {
 ElizaClient.prototype.stopWebsiteBlock = async function () {
     const plugin = getNativeWebsiteBlockerPluginIfAvailable();
     if (plugin) {
-        return await plugin.stopBlock();
+        return plugin.stopBlock();
     }
     return this.fetch("/api/website-blocker", {
         method: "DELETE",
@@ -1327,7 +1736,7 @@ ElizaClient.prototype.stopWebsiteBlock = async function () {
 ElizaClient.prototype.getAppBlockerStatus = async function () {
     const plugin = getNativeAppBlockerPluginIfAvailable();
     if (plugin) {
-        return await plugin.getStatus();
+        return plugin.getStatus();
     }
     return {
         available: false,
@@ -1344,7 +1753,7 @@ ElizaClient.prototype.getAppBlockerStatus = async function () {
 ElizaClient.prototype.checkAppBlockerPermissions = async function () {
     const plugin = getNativeAppBlockerPluginIfAvailable();
     if (plugin) {
-        return await plugin.checkPermissions();
+        return plugin.checkPermissions();
     }
     return {
         status: "not-applicable",
@@ -1355,7 +1764,7 @@ ElizaClient.prototype.checkAppBlockerPermissions = async function () {
 ElizaClient.prototype.requestAppBlockerPermissions = async function () {
     const plugin = getNativeAppBlockerPluginIfAvailable();
     if (plugin) {
-        return await plugin.requestPermissions();
+        return plugin.requestPermissions();
     }
     return {
         status: "not-applicable",
@@ -1366,14 +1775,14 @@ ElizaClient.prototype.requestAppBlockerPermissions = async function () {
 ElizaClient.prototype.getInstalledAppsToBlock = async function () {
     const plugin = getNativeAppBlockerPluginIfAvailable();
     if (plugin) {
-        return await plugin.getInstalledApps();
+        return plugin.getInstalledApps();
     }
     return { apps: [] };
 };
 ElizaClient.prototype.selectAppBlockerApps = async function () {
     const plugin = getNativeAppBlockerPluginIfAvailable();
     if (plugin) {
-        return await plugin.selectApps();
+        return plugin.selectApps();
     }
     return {
         apps: [],
@@ -1383,7 +1792,7 @@ ElizaClient.prototype.selectAppBlockerApps = async function () {
 ElizaClient.prototype.startAppBlock = async function (options) {
     const plugin = getNativeAppBlockerPluginIfAvailable();
     if (plugin) {
-        return await plugin.blockApps(options);
+        return plugin.blockApps(options);
     }
     return {
         success: false,
@@ -1395,7 +1804,7 @@ ElizaClient.prototype.startAppBlock = async function (options) {
 ElizaClient.prototype.stopAppBlock = async function () {
     const plugin = getNativeAppBlockerPluginIfAvailable();
     if (plugin) {
-        return await plugin.unblockApps();
+        return plugin.unblockApps();
     }
     return {
         success: false,
@@ -1403,38 +1812,49 @@ ElizaClient.prototype.stopAppBlock = async function () {
     };
 };
 ElizaClient.prototype.getCodingAgentStatus = async function () {
+    const [acpResult, orchestratorStatusResult, taskThreadsResult] = await Promise.allSettled([
+        this.fetch("/api/coding-agents"),
+        this.getOrchestratorStatus(),
+        this.listCodingAgentTaskThreads({ limit: 20 }),
+    ]);
+    const acpSessions = acpResult.status === "fulfilled" && Array.isArray(acpResult.value)
+        ? acpResult.value
+        : null;
+    const taskThreads = taskThreadsResult.status === "fulfilled" &&
+        Array.isArray(taskThreadsResult.value)
+        ? taskThreadsResult.value
+        : null;
+    const orchestratorStatus = orchestratorStatusResult.status === "fulfilled"
+        ? orchestratorStatusResult.value
+        : null;
+    if (!acpSessions && !taskThreads && !orchestratorStatus) {
+        return null;
+    }
+    const acpTasks = acpSessions
+        ? mapAcpSessionsToCodingAgentSessions(acpSessions).filter((task) => !TERMINAL_STATUSES.has(task.status))
+        : [];
+    const taskThreadSessions = taskThreads
+        ? mapTaskThreadsToCodingAgentSessions(taskThreads).filter((task) => !TERMINAL_STATUSES.has(task.status))
+        : [];
+    const tasks = [...acpTasks, ...taskThreadSessions];
+    const taskThreadCount = typeof orchestratorStatus?.taskCount === "number"
+        ? orchestratorStatus.taskCount
+        : (taskThreads?.length ?? 0);
     try {
-        const status = await this.fetch("/api/coding-agents/coordinator/status");
-        if (status &&
-            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;
+        return {
+            supervisionLevel: acpSessions ? "acp" : "orchestrator",
+            taskCount: tasks.length,
+            tasks,
+            pendingConfirmations: 0,
+            taskThreadCount,
+            taskThreads: taskThreads ?? [],
+        };
     }
     catch {
         return null;
     }
 };
-ElizaClient.prototype.listCodingAgentTaskThreads = function (options) {
+ElizaClient.prototype.listCodingAgentTaskThreads = async function (options) {
     const params = new URLSearchParams();
     if (options?.includeArchived)
         params.set("includeArchived", "true");
@@ -1442,23 +1862,284 @@ ElizaClient.prototype.listCodingAgentTaskThreads = function (options) {
         params.set("status", options.status);
     if (options?.search)
         params.set("search", options.search);
-    if (typeof options?.limit === "number" && options.limit > 0) {
+    if (typeof options?.limit === "number") {
         params.set("limit", String(options.limit));
     }
-    const query = params.toString();
-    return this.fetch(`/api/coding-agents/coordinator/threads${query ? `?${query}` : ""}`);
+    const qs = params.toString();
+    const res = await this.fetch(`/api/orchestrator/tasks${qs ? `?${qs}` : ""}`);
+    return res.tasks;
 };
-ElizaClient.prototype.getCodingAgentTaskThread = function (threadId) {
-    return this.fetch(`/api/coding-agents/coordinator/threads/${encodeURIComponent(threadId)}`);
+ElizaClient.prototype.getCodingAgentTaskThread = async function (threadId) {
+    try {
+        return await this.fetch(`/api/orchestrator/tasks/${encodeURIComponent(threadId)}`);
+    }
+    catch (error) {
+        // A task that no longer exists (deleted between list and detail fetch) is a
+        // normal "no detail" outcome, not a load failure. Every other error
+        // propagates so the caller can surface it.
+        if (error instanceof ApiError && error.status === 404) {
+            return null;
+        }
+        throw error;
+    }
 };
 ElizaClient.prototype.archiveCodingAgentTaskThread = async function (threadId) {
-    await this.fetch(`/api/coding-agents/coordinator/threads/${encodeURIComponent(threadId)}/archive`, { method: "POST" });
+    await this.fetch(`/api/orchestrator/tasks/${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" });
+    await this.fetch(`/api/orchestrator/tasks/${encodeURIComponent(threadId)}/reopen`, { method: "POST" });
+    return true;
+};
+// --- Orchestrator-native task operations (/api/orchestrator/*) -------------
+// The four methods above are the compatibility surface the legacy coding-agent
+// panel binds to. The methods below are the orchestrator workbench vocabulary.
+// A task that vanished resolves to null on detail reads so the rail can refresh.
+ElizaClient.prototype.getOrchestratorStatus = async function () {
+    return this.fetch("/api/orchestrator/status");
+};
+ElizaClient.prototype.getOrchestratorAccounts = async function () {
+    return this.fetch("/api/orchestrator/accounts");
+};
+ElizaClient.prototype.getOrchestratorRooms = async function () {
+    return this.fetch("/api/orchestrator/rooms");
+};
+ElizaClient.prototype.createOrchestratorTask = function (input) {
+    return this.fetch("/api/orchestrator/tasks", {
+        method: "POST",
+        body: JSON.stringify(input),
+        headers: { "Content-Type": "application/json" },
+    });
+};
+ElizaClient.prototype.pauseOrchestratorTask = async function (taskId) {
+    try {
+        return await this.fetch(`/api/orchestrator/tasks/${encodeURIComponent(taskId)}/pause`, { method: "POST" });
+    }
+    catch (error) {
+        if (error instanceof ApiError && error.status === 404)
+            return null;
+        throw error;
+    }
+};
+ElizaClient.prototype.resumeOrchestratorTask = async function (taskId) {
+    try {
+        return await this.fetch(`/api/orchestrator/tasks/${encodeURIComponent(taskId)}/resume`, { method: "POST" });
+    }
+    catch (error) {
+        if (error instanceof ApiError && error.status === 404)
+            return null;
+        throw error;
+    }
+};
+ElizaClient.prototype.deleteOrchestratorTask = async function (taskId) {
+    await this.fetch(`/api/orchestrator/tasks/${encodeURIComponent(taskId)}`, { method: "DELETE" });
+    return true;
+};
+ElizaClient.prototype.forkOrchestratorTask = async function (taskId, input) {
+    try {
+        return await this.fetch(`/api/orchestrator/tasks/${encodeURIComponent(taskId)}/fork`, {
+            method: "POST",
+            body: JSON.stringify(input ?? {}),
+            headers: { "Content-Type": "application/json" },
+        });
+    }
+    catch (error) {
+        if (error instanceof ApiError && error.status === 404)
+            return null;
+        throw error;
+    }
+};
+ElizaClient.prototype.updateOrchestratorTask = async function (taskId, input) {
+    try {
+        return await this.fetch(`/api/orchestrator/tasks/${encodeURIComponent(taskId)}`, {
+            method: "PATCH",
+            body: JSON.stringify(input),
+            headers: { "Content-Type": "application/json" },
+        });
+    }
+    catch (error) {
+        if (error instanceof ApiError && error.status === 404)
+            return null;
+        throw error;
+    }
+};
+ElizaClient.prototype.validateOrchestratorTask = async function (taskId, input) {
+    try {
+        return await this.fetch(`/api/orchestrator/tasks/${encodeURIComponent(taskId)}/validate`, {
+            method: "POST",
+            body: JSON.stringify(input),
+            headers: { "Content-Type": "application/json" },
+        });
+    }
+    catch (error) {
+        if (error instanceof ApiError && error.status === 404)
+            return null;
+        throw error;
+    }
+};
+ElizaClient.prototype.addOrchestratorAgent = async function (taskId, input) {
+    try {
+        return await this.fetch(`/api/orchestrator/tasks/${encodeURIComponent(taskId)}/agents`, {
+            method: "POST",
+            body: JSON.stringify(input),
+            headers: { "Content-Type": "application/json" },
+        });
+    }
+    catch (error) {
+        if (error instanceof ApiError && error.status === 404)
+            return null;
+        throw error;
+    }
+};
+ElizaClient.prototype.stopOrchestratorAgent = async function (taskId, sessionId) {
+    await this.fetch(`/api/orchestrator/tasks/${encodeURIComponent(taskId)}/agents/${encodeURIComponent(sessionId)}/stop`, { method: "POST" });
     return true;
 };
+ElizaClient.prototype.retryOrchestratorTaskTurn = async function (taskId, input) {
+    try {
+        return await this.fetch(`/api/orchestrator/tasks/${encodeURIComponent(taskId)}/retry-turn`, {
+            method: "POST",
+            body: JSON.stringify(input),
+            headers: { "Content-Type": "application/json" },
+        });
+    }
+    catch (error) {
+        if (error instanceof ApiError && error.status === 404)
+            return null;
+        throw error;
+    }
+};
+ElizaClient.prototype.rerunOrchestratorTaskFromEvent = async function (taskId, input) {
+    try {
+        return await this.fetch(`/api/orchestrator/tasks/${encodeURIComponent(taskId)}/rerun-from-event`, {
+            method: "POST",
+            body: JSON.stringify(input),
+            headers: { "Content-Type": "application/json" },
+        });
+    }
+    catch (error) {
+        if (error instanceof ApiError && error.status === 404)
+            return null;
+        throw error;
+    }
+};
+ElizaClient.prototype.restartOrchestratorTask = async function (taskId, input) {
+    try {
+        return await this.fetch(`/api/orchestrator/tasks/${encodeURIComponent(taskId)}/restart`, {
+            method: "POST",
+            body: JSON.stringify(input ?? {}),
+            headers: { "Content-Type": "application/json" },
+        });
+    }
+    catch (error) {
+        if (error instanceof ApiError && error.status === 404)
+            return null;
+        throw error;
+    }
+};
+ElizaClient.prototype.restartOrchestratorTaskWithEditedPlan = async function (taskId, input) {
+    try {
+        return await this.fetch(`/api/orchestrator/tasks/${encodeURIComponent(taskId)}/restart-with-edited-plan`, {
+            method: "POST",
+            body: JSON.stringify(input),
+            headers: { "Content-Type": "application/json" },
+        });
+    }
+    catch (error) {
+        if (error instanceof ApiError && error.status === 404)
+            return null;
+        throw error;
+    }
+};
+ElizaClient.prototype.listOrchestratorTaskPlanRevisions = function (taskId, options) {
+    const params = new URLSearchParams();
+    if (options?.cursor)
+        params.set("cursor", options.cursor);
+    if (typeof options?.limit === "number") {
+        params.set("limit", String(options.limit));
+    }
+    const qs = params.toString();
+    return this.fetch(`/api/orchestrator/tasks/${encodeURIComponent(taskId)}/plan-revisions${qs ? `?${qs}` : ""}`);
+};
+ElizaClient.prototype.createOrchestratorTaskPlanRevision = async function (taskId, input) {
+    try {
+        return await this.fetch(`/api/orchestrator/tasks/${encodeURIComponent(taskId)}/plan-revisions`, {
+            method: "POST",
+            body: JSON.stringify(input),
+            headers: { "Content-Type": "application/json" },
+        });
+    }
+    catch (error) {
+        if (error instanceof ApiError && error.status === 404)
+            return null;
+        throw error;
+    }
+};
+ElizaClient.prototype.listOrchestratorTaskMessages = function (taskId, options) {
+    const params = new URLSearchParams();
+    if (options?.cursor)
+        params.set("cursor", options.cursor);
+    if (typeof options?.limit === "number") {
+        params.set("limit", String(options.limit));
+    }
+    const qs = params.toString();
+    return this.fetch(`/api/orchestrator/tasks/${encodeURIComponent(taskId)}/messages${qs ? `?${qs}` : ""}`);
+};
+ElizaClient.prototype.postOrchestratorTaskMessage = async function (taskId, content) {
+    const result = await this.fetch(`/api/orchestrator/tasks/${encodeURIComponent(taskId)}/messages`, {
+        method: "POST",
+        body: JSON.stringify({ content }),
+        headers: { "Content-Type": "application/json" },
+    });
+    return result.recorded && (result.failedTo?.length ?? 0) === 0;
+};
+ElizaClient.prototype.listOrchestratorTaskEvents = function (taskId, options) {
+    const params = new URLSearchParams();
+    if (options?.cursor)
+        params.set("cursor", options.cursor);
+    if (typeof options?.limit === "number") {
+        params.set("limit", String(options.limit));
+    }
+    const qs = params.toString();
+    return this.fetch(`/api/orchestrator/tasks/${encodeURIComponent(taskId)}/events${qs ? `?${qs}` : ""}`);
+};
+ElizaClient.prototype.listOrchestratorTaskTimeline = function (taskId, options) {
+    const params = new URLSearchParams();
+    if (options?.cursor)
+        params.set("cursor", options.cursor);
+    if (typeof options?.limit === "number") {
+        params.set("limit", String(options.limit));
+    }
+    const qs = params.toString();
+    return this.fetch(`/api/orchestrator/tasks/${encodeURIComponent(taskId)}/timeline${qs ? `?${qs}` : ""}`);
+};
+ElizaClient.prototype.streamOrchestratorTask = function (taskId, onChange) {
+    if (typeof EventSource === "undefined")
+        return () => { };
+    const url = `${this.baseUrl || ""}/api/orchestrator/tasks/${encodeURIComponent(taskId)}/stream`;
+    const source = new EventSource(url);
+    source.onmessage = (event) => {
+        try {
+            const data = JSON.parse(event.data);
+            // The stream pings `{type:"change"}` on every room mutation; the caller
+            // refetches the tail. `ready` and heartbeat comments are ignored.
+            if (data && data.type === "change")
+                onChange();
+        }
+        catch {
+            // ignore non-JSON frames
+        }
+    };
+    return () => source.close();
+};
+ElizaClient.prototype.pauseAllOrchestratorTasks = async function () {
+    const res = await this.fetch("/api/orchestrator/pause-all", { method: "POST" });
+    return res.paused;
+};
+ElizaClient.prototype.resumeAllOrchestratorTasks = async function () {
+    const res = await this.fetch("/api/orchestrator/resume-all", { method: "POST" });
+    return res.resumed;
+};
 ElizaClient.prototype.stopCodingAgent = async function (sessionId) {
     try {
         await this.fetch(`/api/coding-agents/${encodeURIComponent(sessionId)}/stop`, { method: "POST" });
@@ -1472,8 +2153,7 @@ 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);
+    catch {
         return [];
     }
 };
@@ -1583,6 +2263,17 @@ ElizaClient.prototype.streamVoiceSpeak = async function (text) {
         body: JSON.stringify({ text }),
     });
 };
+ElizaClient.prototype.synthesizeFirstRunSpeech = async function (lineId) {
+    const res = await this.rawRequest("/api/tts/first-run/speak", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ lineId }),
+    });
+    if (!res.ok) {
+        throw new Error(`first-run TTS ${res.status}`);
+    }
+    return res.arrayBuffer();
+};
 ElizaClient.prototype.getOverlayLayout = async function (destinationId) {
     const qs = destinationId
         ? `?destination=${encodeURIComponent(destinationId)}`