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

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

@@ -0,0 +1,410 @@
+/**
+ * Cloud domain methods — cloud billing, compat agents, sandbox,
+ * export/import, direct cloud auth, bug reports.
+ */
+import { ElizaClient } from "./client-base";
+// ---------------------------------------------------------------------------
+// Module-level constants
+// ---------------------------------------------------------------------------
+const AGENT_TRANSFER_MIN_PASSWORD_LENGTH = 4;
+function isCloudRouteNotFound(error) {
+    return (error instanceof Error &&
+        "status" in error &&
+        error.status === 404);
+}
+// ---------------------------------------------------------------------------
+// Prototype augmentation
+// ---------------------------------------------------------------------------
+ElizaClient.prototype.getCloudStatus = async function () {
+    return this.fetch("/api/cloud/status");
+};
+ElizaClient.prototype.getCloudCredits = async function () {
+    return this.fetch("/api/cloud/credits");
+};
+ElizaClient.prototype.getCloudBillingSummary = async function () {
+    return this.fetch("/api/cloud/billing/summary");
+};
+ElizaClient.prototype.getCloudBillingSettings = async function () {
+    return this.fetch("/api/cloud/billing/settings");
+};
+ElizaClient.prototype.updateCloudBillingSettings = async function (request) {
+    return this.fetch("/api/cloud/billing/settings", {
+        method: "PUT",
+        body: JSON.stringify(request),
+    });
+};
+ElizaClient.prototype.getCloudBillingPaymentMethods = async function () {
+    return this.fetch("/api/cloud/billing/payment-methods");
+};
+ElizaClient.prototype.getCloudBillingHistory = async function () {
+    return this.fetch("/api/cloud/billing/history");
+};
+ElizaClient.prototype.createCloudBillingCheckout = async function (request) {
+    return this.fetch("/api/cloud/billing/checkout", {
+        method: "POST",
+        body: JSON.stringify(request),
+    });
+};
+ElizaClient.prototype.createCloudBillingCryptoQuote = async function (request) {
+    return this.fetch("/api/cloud/billing/crypto/quote", {
+        method: "POST",
+        body: JSON.stringify(request),
+    });
+};
+ElizaClient.prototype.cloudLogin = async function () {
+    return this.fetch("/api/cloud/login", { method: "POST" });
+};
+ElizaClient.prototype.cloudLoginPoll = async function (sessionId) {
+    return this.fetch(`/api/cloud/login/status?sessionId=${encodeURIComponent(sessionId)}`);
+};
+ElizaClient.prototype.cloudLoginPersist = async function (apiKey, identity) {
+    return this.fetch("/api/cloud/login/persist", {
+        method: "POST",
+        body: JSON.stringify({
+            apiKey,
+            ...(identity?.organizationId
+                ? { organizationId: identity.organizationId }
+                : {}),
+            ...(identity?.userId ? { userId: identity.userId } : {}),
+        }),
+    });
+};
+ElizaClient.prototype.cloudDisconnect = async function () {
+    return this.fetch("/api/cloud/disconnect", { method: "POST" });
+};
+ElizaClient.prototype.getCloudCompatAgents = async function () {
+    return this.fetch("/api/cloud/compat/agents");
+};
+ElizaClient.prototype.createCloudCompatAgent = async function (opts) {
+    return this.fetch("/api/cloud/compat/agents", {
+        method: "POST",
+        body: JSON.stringify(opts),
+    });
+};
+ElizaClient.prototype.ensureCloudCompatManagedDiscordAgent = async function () {
+    return this.fetch("/api/cloud/v1/app/discord/gateway-agent", {
+        method: "POST",
+    });
+};
+ElizaClient.prototype.provisionCloudCompatAgent = async function (agentId) {
+    return this.fetch(`/api/cloud/v1/app/agents/${encodeURIComponent(agentId)}/provision`, { method: "POST" }, { allowNonOk: true });
+};
+ElizaClient.prototype.getCloudCompatAgent = async function (agentId) {
+    return this.fetch(`/api/cloud/compat/agents/${encodeURIComponent(agentId)}`);
+};
+ElizaClient.prototype.getCloudCompatAgentManagedDiscord = async function (agentId) {
+    return this.fetch(`/api/cloud/v1/app/agents/${encodeURIComponent(agentId)}/discord`);
+};
+ElizaClient.prototype.createCloudCompatAgentManagedDiscordOauth =
+    async function (agentId, request = {}) {
+        return this.fetch(`/api/cloud/v1/app/agents/${encodeURIComponent(agentId)}/discord/oauth`, {
+            method: "POST",
+            body: JSON.stringify(request),
+        });
+    };
+ElizaClient.prototype.disconnectCloudCompatAgentManagedDiscord =
+    async function (agentId) {
+        return this.fetch(`/api/cloud/v1/app/agents/${encodeURIComponent(agentId)}/discord`, {
+            method: "DELETE",
+        });
+    };
+ElizaClient.prototype.getCloudCompatAgentDiscordConfig = async function (agentId) {
+    return this.fetch(`/api/cloud/v1/app/agents/${encodeURIComponent(agentId)}/discord/config`);
+};
+ElizaClient.prototype.updateCloudCompatAgentDiscordConfig = async function (agentId, config) {
+    return this.fetch(`/api/cloud/v1/app/agents/${encodeURIComponent(agentId)}/discord/config`, {
+        method: "PATCH",
+        body: JSON.stringify(config),
+    });
+};
+ElizaClient.prototype.getCloudCompatAgentManagedGithub = async function (agentId) {
+    return this.fetch(`/api/cloud/v1/app/agents/${encodeURIComponent(agentId)}/github`);
+};
+ElizaClient.prototype.createCloudCompatAgentManagedGithubOauth =
+    async function (agentId, request = {}) {
+        try {
+            return await this.fetch(`/api/cloud/v1/app/agents/${encodeURIComponent(agentId)}/github/oauth`, {
+                method: "POST",
+                body: JSON.stringify(request),
+            });
+        }
+        catch (error) {
+            if (!isCloudRouteNotFound(error)) {
+                throw error;
+            }
+            const params = new URLSearchParams({
+                target: "agent",
+                agent_id: agentId,
+            });
+            if (request.postMessage) {
+                params.set("post_message", "1");
+            }
+            if (request.returnUrl) {
+                params.set("return_url", request.returnUrl);
+            }
+            const fallback = await this.initiateCloudOauth("github", {
+                redirectUrl: `/api/v1/milady/lifeops/github-complete?${params.toString()}`,
+                connectionRole: "agent",
+                scopes: request.scopes,
+            });
+            return {
+                success: true,
+                data: {
+                    authorizeUrl: fallback.authUrl,
+                },
+            };
+        }
+    };
+ElizaClient.prototype.linkCloudCompatAgentManagedGithub = async function (agentId, connectionId) {
+    return this.fetch(`/api/cloud/v1/app/agents/${encodeURIComponent(agentId)}/github/link`, {
+        method: "POST",
+        body: JSON.stringify({ connectionId }),
+    });
+};
+ElizaClient.prototype.disconnectCloudCompatAgentManagedGithub = async function (agentId) {
+    return this.fetch(`/api/cloud/v1/app/agents/${encodeURIComponent(agentId)}/github`, {
+        method: "DELETE",
+    });
+};
+ElizaClient.prototype.listCloudOauthConnections = async function (args) {
+    const params = new URLSearchParams();
+    if (args?.platform) {
+        params.set("platform", args.platform);
+    }
+    if (args?.connectionRole) {
+        params.set("connectionRole", args.connectionRole);
+    }
+    const query = params.toString();
+    return this.fetch(`/api/cloud/v1/oauth/connections${query ? `?${query}` : ""}`);
+};
+ElizaClient.prototype.initiateCloudOauth = async function (platform, request) {
+    try {
+        return await this.fetch(`/api/cloud/v1/oauth/${encodeURIComponent(platform)}/initiate`, {
+            method: "POST",
+            body: JSON.stringify(request ?? {}),
+        });
+    }
+    catch (error) {
+        if (!isCloudRouteNotFound(error)) {
+            throw error;
+        }
+        return this.fetch(`/api/cloud/v1/oauth/initiate?provider=${encodeURIComponent(platform)}`, {
+            method: "POST",
+            body: JSON.stringify(request ?? {}),
+        });
+    }
+};
+ElizaClient.prototype.disconnectCloudOauthConnection = async function (connectionId) {
+    return this.fetch(`/api/cloud/v1/oauth/connections/${encodeURIComponent(connectionId)}`, {
+        method: "DELETE",
+    });
+};
+ElizaClient.prototype.getCloudCompatAgentGithubToken = async function (agentId) {
+    return this.fetch(`/api/cloud/v1/app/agents/${encodeURIComponent(agentId)}/github/token`);
+};
+ElizaClient.prototype.deleteCloudCompatAgent = async function (agentId) {
+    return this.fetch(`/api/cloud/compat/agents/${encodeURIComponent(agentId)}`, {
+        method: "DELETE",
+    });
+};
+ElizaClient.prototype.getCloudCompatAgentStatus = async function (agentId) {
+    return this.fetch(`/api/cloud/compat/agents/${encodeURIComponent(agentId)}/status`);
+};
+ElizaClient.prototype.getCloudCompatAgentLogs = async function (agentId, tail = 100) {
+    return this.fetch(`/api/cloud/compat/agents/${encodeURIComponent(agentId)}/logs?tail=${tail}`);
+};
+ElizaClient.prototype.restartCloudCompatAgent = async function (agentId) {
+    return this.fetch(`/api/cloud/compat/agents/${encodeURIComponent(agentId)}/restart`, { method: "POST" });
+};
+ElizaClient.prototype.suspendCloudCompatAgent = async function (agentId) {
+    return this.fetch(`/api/cloud/compat/agents/${encodeURIComponent(agentId)}/suspend`, { method: "POST" });
+};
+ElizaClient.prototype.resumeCloudCompatAgent = async function (agentId) {
+    return this.fetch(`/api/cloud/compat/agents/${encodeURIComponent(agentId)}/resume`, { method: "POST" });
+};
+ElizaClient.prototype.launchCloudCompatAgent = async function (agentId) {
+    return this.fetch(`/api/cloud/compat/agents/${encodeURIComponent(agentId)}/launch`, { method: "POST" });
+};
+ElizaClient.prototype.getCloudCompatPairingToken = async function (agentId) {
+    return this.fetch(`/api/cloud/v1/app/agents/${encodeURIComponent(agentId)}/pairing-token`, { method: "POST" });
+};
+ElizaClient.prototype.getCloudCompatAvailability = async function () {
+    return this.fetch("/api/cloud/compat/availability");
+};
+ElizaClient.prototype.getCloudCompatJobStatus = async function (jobId) {
+    return this.fetch(`/api/cloud/compat/jobs/${encodeURIComponent(jobId)}`);
+};
+ElizaClient.prototype.exportAgent = async function (password, includeLogs = false) {
+    if (password.length < AGENT_TRANSFER_MIN_PASSWORD_LENGTH) {
+        throw new Error(`Password must be at least ${AGENT_TRANSFER_MIN_PASSWORD_LENGTH} characters.`);
+    }
+    return this.rawRequest("/api/agent/export", {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify({ password, includeLogs }),
+    });
+};
+ElizaClient.prototype.getExportEstimate = async function () {
+    return this.fetch("/api/agent/export/estimate");
+};
+ElizaClient.prototype.importAgent = async function (password, fileBuffer) {
+    if (password.length < AGENT_TRANSFER_MIN_PASSWORD_LENGTH) {
+        throw new Error(`Password must be at least ${AGENT_TRANSFER_MIN_PASSWORD_LENGTH} characters.`);
+    }
+    const passwordBytes = new TextEncoder().encode(password);
+    const envelope = new Uint8Array(4 + passwordBytes.length + fileBuffer.byteLength);
+    const view = new DataView(envelope.buffer);
+    view.setUint32(0, passwordBytes.length, false);
+    envelope.set(passwordBytes, 4);
+    envelope.set(new Uint8Array(fileBuffer), 4 + passwordBytes.length);
+    const res = await this.rawRequest("/api/agent/import", {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/octet-stream",
+        },
+        body: envelope,
+    });
+    const data = (await res.json());
+    if (!data.success) {
+        throw new Error(data.error ?? `Import failed (${res.status})`);
+    }
+    return data;
+};
+ElizaClient.prototype.getSandboxPlatform = async function () {
+    return this.fetch("/api/sandbox/platform");
+};
+ElizaClient.prototype.getSandboxBrowser = async function () {
+    return this.fetch("/api/sandbox/browser");
+};
+ElizaClient.prototype.getSandboxScreenshot = async function (region) {
+    if (!region) {
+        return this.fetch("/api/sandbox/screen/screenshot", {
+            method: "POST",
+        });
+    }
+    return this.fetch("/api/sandbox/screen/screenshot", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(region),
+    });
+};
+ElizaClient.prototype.getSandboxWindows = async function () {
+    return this.fetch("/api/sandbox/screen/windows");
+};
+ElizaClient.prototype.startDocker = async function () {
+    return this.fetch("/api/sandbox/docker/start", { method: "POST" });
+};
+ElizaClient.prototype.cloudLoginDirect = async function (cloudApiBase) {
+    const sessionId = globalThis.crypto.randomUUID();
+    try {
+        const res = await fetch(`${cloudApiBase}/api/auth/cli-session`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ sessionId }),
+        });
+        if (!res.ok) {
+            return { ok: false, error: `Login failed (${res.status})` };
+        }
+        return {
+            ok: true,
+            sessionId,
+            browserUrl: `${cloudApiBase}/auth/cli-login?session=${encodeURIComponent(sessionId)}`,
+        };
+    }
+    catch (err) {
+        return {
+            ok: false,
+            error: `Failed to reach Eliza Cloud: ${err instanceof Error ? err.message : String(err)}`,
+        };
+    }
+};
+ElizaClient.prototype.cloudLoginPollDirect = async function (cloudApiBase, sessionId) {
+    try {
+        const res = await fetch(`${cloudApiBase}/api/auth/cli-session/${encodeURIComponent(sessionId)}`);
+        if (!res.ok) {
+            if (res.status === 404) {
+                return {
+                    status: "expired",
+                    error: "Auth session expired or not found",
+                };
+            }
+            return {
+                status: "error",
+                error: `Poll failed (${res.status})`,
+            };
+        }
+        const data = await res.json();
+        if (data.status === "authenticated" && data.apiKey) {
+            return {
+                status: "authenticated",
+                organizationId: data.organizationId,
+                token: data.apiKey,
+                userId: data.userId,
+            };
+        }
+        return { status: data.status ?? "pending" };
+    }
+    catch {
+        return { status: "error", error: "Poll request failed" };
+    }
+};
+ElizaClient.prototype.provisionCloudSandbox = async function (options) {
+    const { cloudApiBase, authToken, name, bio, onProgress } = options;
+    const headers = {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${authToken}`,
+    };
+    onProgress?.("creating", "Creating agent...");
+    // Step 1: Create agent
+    const createRes = await fetch(`${cloudApiBase}/api/v1/app/agents`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({ name, bio }),
+    });
+    if (!createRes.ok) {
+        const err = await createRes.text().catch(() => "Unknown error");
+        throw new Error(`Failed to create cloud agent: ${err}`);
+    }
+    const createData = (await createRes.json());
+    const agentId = createData.id;
+    onProgress?.("provisioning", "Provisioning sandbox environment...");
+    // Step 2: Start provisioning
+    const provisionRes = await fetch(`${cloudApiBase}/api/v1/app/agents/${agentId}/provision`, { method: "POST", headers });
+    if (!provisionRes.ok) {
+        const err = await provisionRes.text().catch(() => "Unknown error");
+        throw new Error(`Failed to start provisioning: ${err}`);
+    }
+    const provisionData = (await provisionRes.json());
+    const jobId = provisionData.jobId;
+    // Step 3: Poll job status
+    const deadline = Date.now() + 120_000;
+    while (Date.now() < deadline) {
+        await new Promise((r) => setTimeout(r, 2000));
+        const jobRes = await fetch(`${cloudApiBase}/api/v1/jobs/${jobId}`, {
+            headers,
+        });
+        if (!jobRes.ok)
+            continue;
+        const jobData = (await jobRes.json());
+        if (jobData.status === "completed" && jobData.result?.bridgeUrl) {
+            onProgress?.("ready", "Sandbox ready!");
+            return { bridgeUrl: jobData.result.bridgeUrl, agentId };
+        }
+        if (jobData.status === "failed") {
+            throw new Error(`Provisioning failed: ${jobData.error ?? "Unknown error"}`);
+        }
+        onProgress?.("provisioning", `Status: ${jobData.status}...`);
+    }
+    throw new Error("Provisioning timed out after 2 minutes");
+};
+ElizaClient.prototype.checkBugReportInfo = async function () {
+    return this.fetch("/api/bug-report/info");
+};
+ElizaClient.prototype.submitBugReport = async function (report) {
+    return this.fetch("/api/bug-report", {
+        method: "POST",
+        body: JSON.stringify(report),
+    });
+};

package/packages/app-core/src/api/client-computeruse.d.ts

@@ -0,0 +1,32 @@
+export type ComputerUseApprovalMode = "full_control" | "smart_approve" | "approve_all" | "off";
+export interface ComputerUsePendingApproval {
+    id: string;
+    command: string;
+    parameters: Record<string, unknown>;
+    requestedAt: string;
+}
+export interface ComputerUseApprovalSnapshot {
+    mode: ComputerUseApprovalMode;
+    pendingCount: number;
+    pendingApprovals: ComputerUsePendingApproval[];
+}
+export interface ComputerUseApprovalResolution {
+    id: string;
+    command: string;
+    approved: boolean;
+    cancelled: boolean;
+    mode: ComputerUseApprovalMode;
+    requestedAt: string;
+    resolvedAt: string;
+    reason?: string;
+}
+declare module "./client-base" {
+    interface ElizaClient {
+        getComputerUseApprovals(): Promise<ComputerUseApprovalSnapshot>;
+        respondToComputerUseApproval(id: string, approved: boolean, reason?: string): Promise<ComputerUseApprovalResolution>;
+        setComputerUseApprovalMode(mode: ComputerUseApprovalMode): Promise<{
+            mode: ComputerUseApprovalMode;
+        }>;
+    }
+}
+//# sourceMappingURL=client-computeruse.d.ts.map

package/packages/app-core/src/api/client-computeruse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-computeruse.d.ts","sourceRoot":"","sources":["../../../../../../app-core/src/api/client-computeruse.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,uBAAuB,GAC/B,cAAc,GACd,eAAe,GACf,aAAa,GACb,KAAK,CAAC;AAEV,MAAM,WAAW,0BAA0B;IACzC,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACpC,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,2BAA2B;IAC1C,IAAI,EAAE,uBAAuB,CAAC;IAC9B,YAAY,EAAE,MAAM,CAAC;IACrB,gBAAgB,EAAE,0BAA0B,EAAE,CAAC;CAChD;AAED,MAAM,WAAW,6BAA6B;IAC5C,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,OAAO,CAAC;IAClB,SAAS,EAAE,OAAO,CAAC;IACnB,IAAI,EAAE,uBAAuB,CAAC;IAC9B,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,OAAO,QAAQ,eAAe,CAAC;IAC7B,UAAU,WAAW;QACnB,uBAAuB,IAAI,OAAO,CAAC,2BAA2B,CAAC,CAAC;QAChE,4BAA4B,CAC1B,EAAE,EAAE,MAAM,EACV,QAAQ,EAAE,OAAO,EACjB,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,6BAA6B,CAAC,CAAC;QAC1C,0BAA0B,CACxB,IAAI,EAAE,uBAAuB,GAC5B,OAAO,CAAC;YAAE,IAAI,EAAE,uBAAuB,CAAA;SAAE,CAAC,CAAC;KAC/C;CACF"}

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

@@ -0,0 +1,16 @@
+import { ElizaClient } from "./client-base";
+ElizaClient.prototype.getComputerUseApprovals = async function () {
+    return this.fetch("/api/computer-use/approvals");
+};
+ElizaClient.prototype.respondToComputerUseApproval = async function (id, approved, reason) {
+    return this.fetch(`/api/computer-use/approvals/${encodeURIComponent(id)}`, {
+        method: "POST",
+        body: JSON.stringify({ approved, reason }),
+    });
+};
+ElizaClient.prototype.setComputerUseApprovalMode = async function (mode) {
+    return this.fetch("/api/computer-use/approval-mode", {
+        method: "POST",
+        body: JSON.stringify({ mode }),
+    });
+};

package/packages/app-core/src/api/client-imessage.d.ts

@@ -0,0 +1,68 @@
+export interface IMessageApiStatus {
+    available: boolean;
+    connected: boolean;
+    bridgeType?: "native" | "imsg" | "bluebubbles" | "none";
+    hostPlatform?: "darwin" | "linux" | "win32" | "unknown";
+    diagnostics?: string[];
+    error?: string | null;
+    chatDbAvailable?: boolean;
+    sendOnly?: boolean;
+    chatDbPath?: string;
+    reason?: string | null;
+    permissionAction?: {
+        type: "full_disk_access";
+        label: string;
+        url: string;
+        instructions: string[];
+    } | null;
+}
+export interface IMessageApiMessage {
+    id: string;
+    text: string;
+    handle: string;
+    chatId: string;
+    timestamp: number;
+    isFromMe: boolean;
+    hasAttachments: boolean;
+    attachmentPaths?: string[];
+}
+export interface IMessageApiChat {
+    chatId: string;
+    chatType: "direct" | "group";
+    displayName?: string;
+    participants: Array<{
+        handle: string;
+        isPhoneNumber: boolean;
+    }>;
+}
+export interface GetIMessageMessagesOptions {
+    chatId?: string;
+    limit?: number;
+}
+export interface SendIMessageRequest {
+    to: string;
+    text: string;
+    attachmentPaths?: string[];
+    mediaUrl?: string;
+}
+export interface SendIMessageResponse {
+    success: boolean;
+    messageId?: string;
+    chatId?: string;
+    error?: string;
+}
+declare module "./client-base" {
+    interface ElizaClient {
+        getIMessageStatus(): Promise<IMessageApiStatus>;
+        getIMessageMessages(options?: GetIMessageMessagesOptions): Promise<{
+            messages: IMessageApiMessage[];
+            count: number;
+        }>;
+        listIMessageChats(): Promise<{
+            chats: IMessageApiChat[];
+            count: number;
+        }>;
+        sendIMessage(request: SendIMessageRequest): Promise<SendIMessageResponse>;
+    }
+}
+//# sourceMappingURL=client-imessage.d.ts.map

package/packages/app-core/src/api/client-imessage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-imessage.d.ts","sourceRoot":"","sources":["../../../../../../app-core/src/api/client-imessage.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,OAAO,CAAC;IACnB,SAAS,EAAE,OAAO,CAAC;IACnB,UAAU,CAAC,EAAE,QAAQ,GAAG,MAAM,GAAG,aAAa,GAAG,MAAM,CAAC;IACxD,YAAY,CAAC,EAAE,QAAQ,GAAG,OAAO,GAAG,OAAO,GAAG,SAAS,CAAC;IACxD,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,gBAAgB,CAAC,EAAE;QACjB,IAAI,EAAE,kBAAkB,CAAC;QACzB,KAAK,EAAE,MAAM,CAAC;QACd,GAAG,EAAE,MAAM,CAAC;QACZ,YAAY,EAAE,MAAM,EAAE,CAAC;KACxB,GAAG,IAAI,CAAC;CACV;AAED,MAAM,WAAW,kBAAkB;IACjC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,OAAO,CAAC;IAClB,cAAc,EAAE,OAAO,CAAC;IACxB,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;CAC5B;AAED,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC;IAC7B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,KAAK,CAAC;QAClB,MAAM,EAAE,MAAM,CAAC;QACf,aAAa,EAAE,OAAO,CAAC;KACxB,CAAC,CAAC;CACJ;AAED,MAAM,WAAW,0BAA0B;IACzC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,mBAAmB;IAClC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AA8BD,OAAO,QAAQ,eAAe,CAAC;IAC7B,UAAU,WAAW;QACnB,iBAAiB,IAAI,OAAO,CAAC,iBAAiB,CAAC,CAAC;QAChD,mBAAmB,CACjB,OAAO,CAAC,EAAE,0BAA0B,GACnC,OAAO,CAAC;YAAE,QAAQ,EAAE,kBAAkB,EAAE,CAAC;YAAC,KAAK,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC;QAC9D,iBAAiB,IAAI,OAAO,CAAC;YAAE,KAAK,EAAE,eAAe,EAAE,CAAC;YAAC,KAAK,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC;QAC1E,YAAY,CAAC,OAAO,EAAE,mBAAmB,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAAC;KAC3E;CACF"}

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

@@ -0,0 +1,74 @@
+import { ElizaClient } from "./client-base";
+function buildQuery(params) {
+    const query = params.toString();
+    return query.length > 0 ? `?${query}` : "";
+}
+ElizaClient.prototype.getIMessageStatus = async function () {
+    return this.fetch("/api/lifeops/connectors/imessage/status");
+};
+function normalizeLifeOpsMessage(message) {
+    const attachmentPaths = message.attachments
+        ?.map((attachment) => attachment.path)
+        .filter((path) => typeof path === "string") ?? [];
+    return {
+        id: message.id,
+        text: message.text,
+        handle: message.isFromMe
+            ? (message.toHandles[0] ?? "")
+            : message.fromHandle,
+        chatId: message.chatId ?? "",
+        timestamp: Date.parse(message.sentAt) || 0,
+        isFromMe: message.isFromMe,
+        hasAttachments: attachmentPaths.length > 0,
+        ...(attachmentPaths.length > 0 ? { attachmentPaths } : {}),
+    };
+}
+function normalizeLifeOpsChat(chat) {
+    return {
+        chatId: chat.id,
+        chatType: chat.participants.length > 1 ? "group" : "direct",
+        displayName: chat.name,
+        participants: chat.participants.map((handle) => ({
+            handle,
+            isPhoneNumber: /^\+?[0-9()\s.-]+$/.test(handle),
+        })),
+    };
+}
+ElizaClient.prototype.getIMessageMessages = async function (options = {}) {
+    const params = new URLSearchParams();
+    if (options.chatId?.trim()) {
+        params.set("chatId", options.chatId.trim());
+    }
+    if (typeof options.limit === "number" && Number.isFinite(options.limit)) {
+        params.set("limit", String(options.limit));
+    }
+    const result = await this.fetch(`/api/lifeops/connectors/imessage/messages${buildQuery(params)}`);
+    return {
+        messages: result.messages.map(normalizeLifeOpsMessage),
+        count: result.count,
+    };
+};
+ElizaClient.prototype.listIMessageChats = async function () {
+    const result = await this.fetch("/api/lifeops/connectors/imessage/chats");
+    return {
+        chats: result.chats.map(normalizeLifeOpsChat),
+        count: result.count,
+    };
+};
+ElizaClient.prototype.sendIMessage = async function (request) {
+    const attachmentPaths = request.attachmentPaths ??
+        (request.mediaUrl ? [request.mediaUrl] : undefined);
+    const body = {
+        to: request.to,
+        text: request.text,
+        ...(attachmentPaths ? { attachmentPaths } : {}),
+    };
+    const result = await this.fetch("/api/lifeops/connectors/imessage/send", {
+        method: "POST",
+        body: JSON.stringify(body),
+    });
+    return {
+        success: result.ok,
+        messageId: result.messageId,
+    };
+};

package/packages/app-core/src/api/client-local-inference.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Client-side helpers for the local-inference endpoints. Mirrors the
+ * structure used by `client-computeruse.ts`: augments `ElizaClient` via
+ * declaration merging so callers get typed methods without reaching into
+ * raw `fetch` from UI code.
+ */
+import type { DeviceBridgeStatus } from "../services/local-inference/device-bridge";
+import type { PublicRegistration } from "../services/local-inference/handler-registry";
+import type { ProviderStatus } from "../services/local-inference/providers";
+import type { RoutingPolicy, RoutingPreferences } from "../services/local-inference/routing-preferences";
+import type { ActiveModelState, AgentModelSlot, CatalogModel, DownloadJob, HardwareProbe, InstalledModel, ModelAssignments, ModelBucket, ModelHubSnapshot } from "../services/local-inference/types";
+import type { VerifyResult } from "../services/local-inference/verify";
+export type { ActiveModelState, AgentModelSlot, CatalogModel, DeviceBridgeStatus, DownloadJob, HardwareProbe, InstalledModel, ModelAssignments, ModelBucket, ModelHubSnapshot, ProviderStatus, PublicRegistration, RoutingPolicy, RoutingPreferences, VerifyResult, };
+declare module "./client-base" {
+    interface ElizaClient {
+        getLocalInferenceHub(): Promise<ModelHubSnapshot>;
+        getLocalInferenceHardware(): Promise<HardwareProbe>;
+        getLocalInferenceCatalog(): Promise<{
+            models: CatalogModel[];
+        }>;
+        getLocalInferenceInstalled(): Promise<{
+            models: InstalledModel[];
+        }>;
+        startLocalInferenceDownload(modelIdOrSpec: string | CatalogModel): Promise<{
+            job: DownloadJob;
+        }>;
+        searchHuggingFaceGguf(query: string, limit?: number): Promise<{
+            models: CatalogModel[];
+        }>;
+        cancelLocalInferenceDownload(modelId: string): Promise<{
+            cancelled: boolean;
+        }>;
+        getLocalInferenceActive(): Promise<ActiveModelState>;
+        setLocalInferenceActive(modelId: string): Promise<ActiveModelState>;
+        clearLocalInferenceActive(): Promise<ActiveModelState>;
+        uninstallLocalInferenceModel(id: string): Promise<{
+            removed: boolean;
+        }>;
+        getLocalInferenceDeviceStatus(): Promise<DeviceBridgeStatus>;
+        getLocalInferenceProviders(): Promise<{
+            providers: ProviderStatus[];
+        }>;
+        getLocalInferenceAssignments(): Promise<{
+            assignments: ModelAssignments;
+        }>;
+        setLocalInferenceAssignment(slot: AgentModelSlot, modelId: string | null): Promise<{
+            assignments: ModelAssignments;
+        }>;
+        verifyLocalInferenceModel(id: string): Promise<VerifyResult>;
+        getLocalInferenceRouting(): Promise<{
+            registrations: PublicRegistration[];
+            preferences: RoutingPreferences;
+        }>;
+        setLocalInferencePreferredProvider(slot: AgentModelSlot, provider: string | null): Promise<{
+            preferences: RoutingPreferences;
+        }>;
+        setLocalInferencePolicy(slot: AgentModelSlot, policy: RoutingPolicy | null): Promise<{
+            preferences: RoutingPreferences;
+        }>;
+    }
+}
+//# sourceMappingURL=client-local-inference.d.ts.map