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

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

@@ -0,0 +1 @@
+{"version":3,"file":"client-local-inference.d.ts","sourceRoot":"","sources":["../../../../../../app-core/src/api/client-local-inference.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,87 @@
+/**
+ * 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 { ElizaClient } from "./client-base";
+ElizaClient.prototype.getLocalInferenceHub = async function () {
+    return this.fetch("/api/local-inference/hub");
+};
+ElizaClient.prototype.getLocalInferenceHardware = async function () {
+    return this.fetch("/api/local-inference/hardware");
+};
+ElizaClient.prototype.getLocalInferenceCatalog = async function () {
+    return this.fetch("/api/local-inference/catalog");
+};
+ElizaClient.prototype.getLocalInferenceInstalled = async function () {
+    return this.fetch("/api/local-inference/installed");
+};
+ElizaClient.prototype.startLocalInferenceDownload = async function (modelIdOrSpec) {
+    const body = typeof modelIdOrSpec === "string"
+        ? { modelId: modelIdOrSpec }
+        : { spec: modelIdOrSpec };
+    return this.fetch("/api/local-inference/downloads", {
+        method: "POST",
+        body: JSON.stringify(body),
+    });
+};
+ElizaClient.prototype.searchHuggingFaceGguf = async function (query, limit) {
+    const params = new URLSearchParams({ q: query });
+    if (limit != null)
+        params.set("limit", String(limit));
+    return this.fetch(`/api/local-inference/hf-search?${params.toString()}`);
+};
+ElizaClient.prototype.cancelLocalInferenceDownload = async function (modelId) {
+    return this.fetch(`/api/local-inference/downloads/${encodeURIComponent(modelId)}`, { method: "DELETE" });
+};
+ElizaClient.prototype.getLocalInferenceActive = async function () {
+    return this.fetch("/api/local-inference/active");
+};
+ElizaClient.prototype.setLocalInferenceActive = async function (modelId) {
+    return this.fetch("/api/local-inference/active", {
+        method: "POST",
+        body: JSON.stringify({ modelId }),
+    });
+};
+ElizaClient.prototype.clearLocalInferenceActive = async function () {
+    return this.fetch("/api/local-inference/active", {
+        method: "DELETE",
+    });
+};
+ElizaClient.prototype.uninstallLocalInferenceModel = async function (id) {
+    return this.fetch(`/api/local-inference/installed/${encodeURIComponent(id)}`, { method: "DELETE" });
+};
+ElizaClient.prototype.getLocalInferenceDeviceStatus = async function () {
+    return this.fetch("/api/local-inference/device");
+};
+ElizaClient.prototype.getLocalInferenceProviders = async function () {
+    return this.fetch("/api/local-inference/providers");
+};
+ElizaClient.prototype.getLocalInferenceAssignments = async function () {
+    return this.fetch("/api/local-inference/assignments");
+};
+ElizaClient.prototype.setLocalInferenceAssignment = async function (slot, modelId) {
+    return this.fetch("/api/local-inference/assignments", {
+        method: "POST",
+        body: JSON.stringify({ slot, modelId }),
+    });
+};
+ElizaClient.prototype.verifyLocalInferenceModel = async function (id) {
+    return this.fetch(`/api/local-inference/installed/${encodeURIComponent(id)}/verify`, { method: "POST" });
+};
+ElizaClient.prototype.getLocalInferenceRouting = async function () {
+    return this.fetch("/api/local-inference/routing");
+};
+ElizaClient.prototype.setLocalInferencePreferredProvider = async function (slot, provider) {
+    return this.fetch("/api/local-inference/routing/preferred", {
+        method: "POST",
+        body: JSON.stringify({ slot, provider }),
+    });
+};
+ElizaClient.prototype.setLocalInferencePolicy = async function (slot, policy) {
+    return this.fetch("/api/local-inference/routing/policy", {
+        method: "POST",
+        body: JSON.stringify({ slot, policy }),
+    });
+};

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

@@ -0,0 +1,27 @@
+/**
+ * n8n domain methods — status, workflow CRUD, sidecar start.
+ *
+ * All routes hit `/api/n8n/*` on the local agent server.
+ * The workflow CRUD routes are served by the n8n plugin itself
+ * but exposed through the same base URL via the plugin's route registration.
+ */
+import type { N8nStatusResponse, N8nWorkflow, N8nWorkflowGenerateRequest, N8nWorkflowGenerateResponse, N8nWorkflowWriteRequest } from "./client-types-chat";
+declare module "./client-base" {
+    interface ElizaClient {
+        getN8nStatus(): Promise<N8nStatusResponse>;
+        getN8nWorkflow(id: string): Promise<N8nWorkflow>;
+        listN8nWorkflows(): Promise<N8nWorkflow[]>;
+        createN8nWorkflow(request: N8nWorkflowWriteRequest): Promise<N8nWorkflow>;
+        updateN8nWorkflow(id: string, request: N8nWorkflowWriteRequest): Promise<N8nWorkflow>;
+        generateN8nWorkflow(request: N8nWorkflowGenerateRequest): Promise<N8nWorkflowGenerateResponse>;
+        activateN8nWorkflow(id: string): Promise<N8nWorkflow>;
+        deactivateN8nWorkflow(id: string): Promise<N8nWorkflow>;
+        deleteN8nWorkflow(id: string): Promise<{
+            ok: boolean;
+        }>;
+        startN8nSidecar(): Promise<{
+            ok: boolean;
+        }>;
+    }
+}
+//# sourceMappingURL=client-n8n.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"client-n8n.d.ts","sourceRoot":"","sources":["../../../../../../app-core/src/api/client-n8n.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,EACV,iBAAiB,EACjB,WAAW,EACX,0BAA0B,EAC1B,2BAA2B,EAC3B,uBAAuB,EACxB,MAAM,qBAAqB,CAAC;AAM7B,OAAO,QAAQ,eAAe,CAAC;IAC7B,UAAU,WAAW;QACnB,YAAY,IAAI,OAAO,CAAC,iBAAiB,CAAC,CAAC;QAC3C,cAAc,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;QACjD,gBAAgB,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC;QAC3C,iBAAiB,CAAC,OAAO,EAAE,uBAAuB,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;QAC1E,iBAAiB,CACf,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,uBAAuB,GAC/B,OAAO,CAAC,WAAW,CAAC,CAAC;QACxB,mBAAmB,CACjB,OAAO,EAAE,0BAA0B,GAClC,OAAO,CAAC,2BAA2B,CAAC,CAAC;QACxC,mBAAmB,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;QACtD,qBAAqB,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;QACxD,iBAAiB,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC;YAAE,EAAE,EAAE,OAAO,CAAA;SAAE,CAAC,CAAC;QACxD,eAAe,IAAI,OAAO,CAAC;YAAE,EAAE,EAAE,OAAO,CAAA;SAAE,CAAC,CAAC;KAC7C;CACF"}

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

@@ -0,0 +1,61 @@
+/**
+ * n8n domain methods — status, workflow CRUD, sidecar start.
+ *
+ * All routes hit `/api/n8n/*` on the local agent server.
+ * The workflow CRUD routes are served by the n8n plugin itself
+ * but exposed through the same base URL via the plugin's route registration.
+ */
+import { ElizaClient } from "./client-base";
+// ---------------------------------------------------------------------------
+// Implementations
+// ---------------------------------------------------------------------------
+ElizaClient.prototype.getN8nStatus = async function () {
+    return this.fetch("/api/n8n/status");
+};
+ElizaClient.prototype.getN8nWorkflow = async function (id) {
+    return this.fetch(`/api/n8n/workflows/${encodeURIComponent(id)}`);
+};
+ElizaClient.prototype.listN8nWorkflows = async function () {
+    const res = await this.fetch("/api/n8n/workflows");
+    return res.workflows ?? [];
+};
+ElizaClient.prototype.createN8nWorkflow = async function (request) {
+    return this.fetch("/api/n8n/workflows", {
+        method: "POST",
+        body: JSON.stringify(request),
+    });
+};
+ElizaClient.prototype.updateN8nWorkflow = async function (id, request) {
+    return this.fetch(`/api/n8n/workflows/${encodeURIComponent(id)}`, {
+        method: "PUT",
+        body: JSON.stringify(request),
+    });
+};
+ElizaClient.prototype.generateN8nWorkflow = async function (request) {
+    // LLM-driven workflow generation runs keyword extraction, node search,
+    // generation, multiple correction passes, and feasibility assessment
+    // sequentially — easily 30-90s on a cold cache. The 10s default fetch
+    // timeout is far too aggressive and surfaces as
+    // "Request timed out after 10000ms" in the Automations UI even when
+    // the backend would have succeeded a few seconds later.
+    return this.fetch("/api/n8n/workflows/generate", {
+        method: "POST",
+        body: JSON.stringify(request),
+    }, { timeoutMs: 120_000 });
+};
+ElizaClient.prototype.activateN8nWorkflow = async function (id) {
+    return this.fetch(`/api/n8n/workflows/${encodeURIComponent(id)}/activate`, {
+        method: "POST",
+    });
+};
+ElizaClient.prototype.deactivateN8nWorkflow = async function (id) {
+    return this.fetch(`/api/n8n/workflows/${encodeURIComponent(id)}/deactivate`, { method: "POST" });
+};
+ElizaClient.prototype.deleteN8nWorkflow = async function (id) {
+    return this.fetch(`/api/n8n/workflows/${encodeURIComponent(id)}`, { method: "DELETE" });
+};
+ElizaClient.prototype.startN8nSidecar = async function () {
+    return this.fetch("/api/n8n/sidecar/start", {
+        method: "POST",
+    });
+};

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

@@ -0,0 +1,475 @@
+/**
+ * Skills domain methods — skills, catalog, marketplace, apps, Babylon,
+ * custom actions, WhatsApp, agent events.
+ */
+import type { CustomActionDef } from "@elizaos/agent";
+import type { AppLaunchResult, AppRunActionResult, AppRunSummary, AppSessionActionResult, AppSessionControlAction, AppSessionState, AppStopResult, CatalogSearchResult, CatalogSkill, InstalledAppInfo, InstalledPlugin, PluginInstallResult, PluginMutationResult, RegistryAppInfo, RegistryPlugin, RegistryPluginItem, SkillInfo, SkillMarketplaceResult, SkillScanReportSummary } from "./client-types";
+import type { BabylonActivityFeed, BabylonAgentGoal, BabylonAgentStats, BabylonAgentStatus, BabylonAgentSummary, BabylonChat, BabylonChatMessage, BabylonChatMessagesResponse, BabylonChatResponse, BabylonChatsResponse, BabylonLogEntry, BabylonPerpMarket, BabylonPerpPosition, BabylonPerpTradeResult, BabylonPostResult, BabylonPostsResponse, BabylonPredictionMarket, BabylonPredictionMarketsResponse, BabylonSendMessageResult, BabylonTeamChatInfo, BabylonTeamResponse, BabylonToggleResponse, BabylonTradeResult, BabylonWallet } from "./client-types-babylon";
+export type AppRunSteeringDisposition = "accepted" | "queued" | "rejected" | "unsupported";
+export interface AppRunSteeringResult {
+    success: boolean;
+    message: string;
+    disposition: AppRunSteeringDisposition;
+    status: number;
+    run?: AppRunSummary | null;
+    session?: AppSessionState | null;
+}
+declare module "./client-base" {
+    interface ElizaClient {
+        getSkills(): Promise<{
+            skills: SkillInfo[];
+        }>;
+        refreshSkills(): Promise<{
+            ok: boolean;
+            skills: SkillInfo[];
+        }>;
+        getSkillCatalog(opts?: {
+            page?: number;
+            perPage?: number;
+            sort?: string;
+        }): Promise<{
+            total: number;
+            page: number;
+            perPage: number;
+            totalPages: number;
+            skills: CatalogSkill[];
+        }>;
+        searchSkillCatalog(query: string, limit?: number): Promise<{
+            query: string;
+            count: number;
+            results: CatalogSearchResult[];
+        }>;
+        getSkillCatalogDetail(slug: string): Promise<{
+            skill: CatalogSkill;
+        }>;
+        refreshSkillCatalog(): Promise<{
+            ok: boolean;
+            count: number;
+        }>;
+        installCatalogSkill(slug: string, version?: string): Promise<{
+            ok: boolean;
+            slug: string;
+            message: string;
+            alreadyInstalled?: boolean;
+        }>;
+        uninstallCatalogSkill(slug: string): Promise<{
+            ok: boolean;
+            slug: string;
+            message: string;
+        }>;
+        getRegistryPlugins(): Promise<{
+            count: number;
+            plugins: RegistryPlugin[];
+        }>;
+        getRegistryPluginInfo(name: string): Promise<{
+            plugin: RegistryPlugin;
+        }>;
+        getInstalledPlugins(): Promise<{
+            count: number;
+            plugins: InstalledPlugin[];
+        }>;
+        installRegistryPlugin(name: string, autoRestart?: boolean, options?: {
+            stream?: "latest" | "alpha";
+            version?: string;
+        }): Promise<PluginInstallResult>;
+        updateRegistryPlugin(name: string, autoRestart?: boolean, options?: {
+            stream?: "latest" | "alpha";
+            version?: string;
+        }): Promise<PluginInstallResult>;
+        uninstallRegistryPlugin(name: string, autoRestart?: boolean): Promise<PluginMutationResult & {
+            pluginName: string;
+        }>;
+        searchSkillsMarketplace(query: string, installed: boolean, limit: number): Promise<{
+            results: SkillMarketplaceResult[];
+        }>;
+        getSkillsMarketplaceConfig(): Promise<{
+            keySet: boolean;
+        }>;
+        updateSkillsMarketplaceConfig(apiKey: string): Promise<{
+            keySet: boolean;
+        }>;
+        installMarketplaceSkill(data: {
+            slug?: string;
+            githubUrl?: string;
+            repository?: string;
+            path?: string;
+            name?: string;
+            description?: string;
+            source: string;
+            autoRefresh?: boolean;
+        }): Promise<void>;
+        uninstallMarketplaceSkill(skillId: string, autoRefresh: boolean): Promise<void>;
+        enableSkill(skillId: string): Promise<{
+            ok: boolean;
+            skill: SkillInfo;
+            scanStatus: string | null;
+        }>;
+        disableSkill(skillId: string): Promise<{
+            ok: boolean;
+            skill: SkillInfo;
+            scanStatus: string | null;
+        }>;
+        createSkill(name: string, description: string): Promise<{
+            ok: boolean;
+            skill: SkillInfo;
+            path: string;
+        }>;
+        openSkill(id: string): Promise<{
+            ok: boolean;
+            path: string;
+        }>;
+        getSkillSource(id: string): Promise<{
+            ok: boolean;
+            skillId: string;
+            content: string;
+            path: string;
+        }>;
+        saveSkillSource(id: string, content: string): Promise<{
+            ok: boolean;
+            skillId: string;
+            skill: SkillInfo;
+        }>;
+        deleteSkill(id: string): Promise<{
+            ok: boolean;
+            skillId: string;
+            source: string;
+        }>;
+        getSkillScanReport(id: string): Promise<{
+            ok: boolean;
+            report: SkillScanReportSummary | null;
+            acknowledged: boolean;
+            acknowledgment: {
+                acknowledgedAt: string;
+                findingCount: number;
+            } | null;
+        }>;
+        acknowledgeSkill(id: string, enable: boolean): Promise<{
+            ok: boolean;
+            skillId: string;
+            acknowledged: boolean;
+            enabled: boolean;
+            findingCount: number;
+        }>;
+        listApps(): Promise<RegistryAppInfo[]>;
+        listCatalogApps(): Promise<RegistryAppInfo[]>;
+        searchApps(query: string): Promise<RegistryAppInfo[]>;
+        listInstalledApps(): Promise<InstalledAppInfo[]>;
+        listAppRuns(): Promise<AppRunSummary[]>;
+        getAppRun(runId: string): Promise<AppRunSummary>;
+        attachAppRun(runId: string): Promise<AppRunActionResult>;
+        detachAppRun(runId: string): Promise<AppRunActionResult>;
+        stopApp(name: string): Promise<AppStopResult>;
+        stopAppRun(runId: string): Promise<AppStopResult>;
+        /**
+         * Cheap liveness ping for an app run. The server's stale-run sweeper
+         * uses the heartbeat to decide whether to reap a run whose UI tab has
+         * gone away. Returns the refreshed run summary on success, or throws
+         * if the run no longer exists (e.g. the sweeper already reaped it,
+         * or another window pressed Stop).
+         */
+        heartbeatAppRun(runId: string): Promise<{
+            ok: boolean;
+            run: AppRunSummary;
+        }>;
+        getAppInfo(name: string): Promise<RegistryAppInfo>;
+        launchApp(name: string): Promise<AppLaunchResult>;
+        sendAppRunMessage(runId: string, content: string): Promise<AppRunSteeringResult>;
+        controlAppRun(runId: string, action: AppSessionControlAction): Promise<AppRunSteeringResult>;
+        getAppSessionState(appName: string, sessionId: string): Promise<AppSessionState>;
+        sendAppSessionMessage(appName: string, sessionId: string, content: string): Promise<AppSessionActionResult>;
+        controlAppSession(appName: string, sessionId: string, action: AppSessionControlAction): Promise<AppSessionActionResult>;
+        listRegistryPlugins(): Promise<RegistryPluginItem[]>;
+        searchRegistryPlugins(query: string): Promise<RegistryPluginItem[]>;
+        listCustomActions(): Promise<CustomActionDef[]>;
+        createCustomAction(action: Omit<CustomActionDef, "id" | "createdAt" | "updatedAt">): Promise<CustomActionDef>;
+        updateCustomAction(id: string, action: Partial<CustomActionDef>): Promise<CustomActionDef>;
+        deleteCustomAction(id: string): Promise<void>;
+        testCustomAction(id: string, params: Record<string, string>): Promise<{
+            ok: boolean;
+            output: string;
+            error?: string;
+            durationMs: number;
+        }>;
+        generateCustomAction(prompt: string): Promise<{
+            ok: boolean;
+            generated: Record<string, unknown>;
+        }>;
+        getWhatsAppStatus(accountId?: string, options?: {
+            authScope?: "platform" | "lifeops";
+        }): Promise<{
+            accountId: string;
+            authScope?: "platform" | "lifeops";
+            status: string;
+            authExists: boolean;
+            serviceConnected: boolean;
+            servicePhone: string | null;
+        }>;
+        startWhatsAppPairing(accountId?: string, options?: {
+            configurePlugin?: boolean;
+            authScope?: "platform" | "lifeops";
+        }): Promise<{
+            ok: boolean;
+            accountId: string;
+            authScope?: "platform" | "lifeops";
+            status: string;
+            error?: string;
+        }>;
+        stopWhatsAppPairing(accountId?: string, options?: {
+            authScope?: "platform" | "lifeops";
+        }): Promise<{
+            ok: boolean;
+            accountId: string;
+            authScope?: "platform" | "lifeops";
+            status: string;
+        }>;
+        disconnectWhatsApp(accountId?: string, options?: {
+            configurePlugin?: boolean;
+            authScope?: "platform" | "lifeops";
+        }): Promise<{
+            ok: boolean;
+            accountId: string;
+            authScope?: "platform" | "lifeops";
+        }>;
+        getSignalStatus(accountId?: string): Promise<{
+            accountId: string;
+            status: string;
+            authExists: boolean;
+            serviceConnected: boolean;
+            qrDataUrl: string | null;
+            phoneNumber: string | null;
+            error: string | null;
+        }>;
+        startSignalPairing(accountId?: string): Promise<{
+            ok: boolean;
+            accountId: string;
+            status: string;
+            error?: string;
+        }>;
+        stopSignalPairing(accountId?: string): Promise<{
+            ok: boolean;
+            accountId: string;
+            status: string;
+        }>;
+        disconnectSignal(accountId?: string): Promise<{
+            ok: boolean;
+            accountId: string;
+        }>;
+        getTelegramAccountStatus(): Promise<{
+            available: boolean;
+            status: string;
+            configured: boolean;
+            sessionExists: boolean;
+            serviceConnected: boolean;
+            restartRequired: boolean;
+            hasAppCredentials: boolean;
+            phone: string | null;
+            isCodeViaApp: boolean;
+            account: {
+                id: string;
+                username: string | null;
+                firstName: string | null;
+                lastName: string | null;
+                phone: string | null;
+            } | null;
+            error: string | null;
+        }>;
+        startTelegramAccountAuth(phone?: string): Promise<{
+            available: boolean;
+            status: string;
+            configured: boolean;
+            sessionExists: boolean;
+            serviceConnected: boolean;
+            restartRequired: boolean;
+            hasAppCredentials: boolean;
+            phone: string | null;
+            isCodeViaApp: boolean;
+            account: {
+                id: string;
+                username: string | null;
+                firstName: string | null;
+                lastName: string | null;
+                phone: string | null;
+            } | null;
+            error: string | null;
+        }>;
+        submitTelegramAccountAuth(input: {
+            provisioningCode?: string;
+            telegramCode?: string;
+            password?: string;
+        }): Promise<{
+            available: boolean;
+            status: string;
+            configured: boolean;
+            sessionExists: boolean;
+            serviceConnected: boolean;
+            restartRequired: boolean;
+            hasAppCredentials: boolean;
+            phone: string | null;
+            isCodeViaApp: boolean;
+            account: {
+                id: string;
+                username: string | null;
+                firstName: string | null;
+                lastName: string | null;
+                phone: string | null;
+            } | null;
+            error: string | null;
+        }>;
+        disconnectTelegramAccount(): Promise<{
+            ok: boolean;
+            available: boolean;
+            status: string;
+            configured: boolean;
+            sessionExists: boolean;
+            serviceConnected: boolean;
+            restartRequired: boolean;
+            hasAppCredentials: boolean;
+            phone: string | null;
+            isCodeViaApp: boolean;
+            account: {
+                id: string;
+                username: string | null;
+                firstName: string | null;
+                lastName: string | null;
+                phone: string | null;
+            } | null;
+            error: string | null;
+        }>;
+        getDiscordLocalStatus(): Promise<{
+            available: boolean;
+            connected: boolean;
+            authenticated: boolean;
+            currentUser?: {
+                id: string;
+                username: string;
+                global_name?: string | null;
+                avatar?: string | null;
+            } | null;
+            subscribedChannelIds: string[];
+            configuredChannelIds: string[];
+            scopes: string[];
+            lastError: string | null;
+            ipcPath: string | null;
+        }>;
+        authorizeDiscordLocal(): Promise<{
+            available: boolean;
+            connected: boolean;
+            authenticated: boolean;
+            currentUser?: {
+                id: string;
+                username: string;
+                global_name?: string | null;
+                avatar?: string | null;
+            } | null;
+            subscribedChannelIds: string[];
+            configuredChannelIds: string[];
+            scopes: string[];
+            lastError: string | null;
+            ipcPath: string | null;
+        }>;
+        disconnectDiscordLocal(): Promise<{
+            ok: boolean;
+        }>;
+        listDiscordLocalGuilds(): Promise<{
+            guilds: Array<{
+                id: string;
+                name: string;
+            }>;
+            count: number;
+        }>;
+        listDiscordLocalChannels(guildId: string): Promise<{
+            channels: Array<{
+                id: string;
+                guild_id?: string | null;
+                type?: number;
+                name?: string | null;
+                recipients?: Array<{
+                    id: string;
+                    username: string;
+                    global_name?: string | null;
+                    avatar?: string | null;
+                }>;
+            }>;
+            count: number;
+        }>;
+        saveDiscordLocalSubscriptions(channelIds: string[]): Promise<{
+            subscribedChannelIds: string[];
+        }>;
+        getBlueBubblesStatus(): Promise<{
+            available: boolean;
+            connected: boolean;
+            webhookPath: string;
+            reason?: string;
+        }>;
+        getBabylonAgentStatus(): Promise<BabylonAgentStatus>;
+        getBabylonAgentActivity(opts?: {
+            limit?: number;
+            type?: string;
+        }): Promise<BabylonActivityFeed>;
+        getBabylonAgentLogs(opts?: {
+            type?: string;
+            level?: string;
+        }): Promise<BabylonLogEntry[]>;
+        getBabylonAgentWallet(): Promise<BabylonWallet>;
+        getBabylonTeam(): Promise<BabylonTeamResponse>;
+        getBabylonTeamChat(): Promise<BabylonTeamChatInfo>;
+        sendBabylonTeamChat(content: string, mentions?: string[]): Promise<BabylonChatResponse>;
+        toggleBabylonAgent(action: "pause" | "resume" | "toggle"): Promise<BabylonToggleResponse>;
+        toggleBabylonAgentAutonomy(opts: {
+            trading?: boolean;
+            posting?: boolean;
+            commenting?: boolean;
+            dms?: boolean;
+        }): Promise<BabylonToggleResponse>;
+        getBabylonPredictionMarkets(opts?: {
+            page?: number;
+            pageSize?: number;
+            status?: string;
+            category?: string;
+        }): Promise<BabylonPredictionMarketsResponse>;
+        getBabylonPredictionMarket(marketId: string): Promise<BabylonPredictionMarket>;
+        buyBabylonPredictionShares(marketId: string, side: "yes" | "no", amount: number): Promise<BabylonTradeResult>;
+        sellBabylonPredictionShares(marketId: string, side: "yes" | "no", amount: number): Promise<BabylonTradeResult>;
+        getBabylonPerpMarkets(): Promise<BabylonPerpMarket[]>;
+        getBabylonOpenPerpPositions(): Promise<BabylonPerpPosition[]>;
+        closeBabylonPerpPosition(positionId: string): Promise<BabylonPerpTradeResult>;
+        getBabylonPosts(opts?: {
+            page?: number;
+            limit?: number;
+            feed?: string;
+        }): Promise<BabylonPostsResponse>;
+        createBabylonPost(content: string, marketId?: string): Promise<BabylonPostResult>;
+        commentOnBabylonPost(postId: string, content: string): Promise<BabylonPostResult>;
+        likeBabylonPost(postId: string): Promise<{
+            ok: boolean;
+        }>;
+        getBabylonChats(): Promise<BabylonChatsResponse>;
+        getBabylonChatMessages(chatId: string): Promise<BabylonChatMessagesResponse>;
+        sendBabylonChatMessage(chatId: string, content: string): Promise<BabylonSendMessageResult>;
+        getBabylonDM(userId: string): Promise<BabylonChat>;
+        getBabylonAgentGoals(): Promise<BabylonAgentGoal[]>;
+        getBabylonAgentStats(): Promise<BabylonAgentStats>;
+        getBabylonAgentSummary(): Promise<BabylonAgentSummary>;
+        getBabylonAgentRecentTrades(): Promise<BabylonActivityFeed>;
+        getBabylonAgentTradingBalance(): Promise<{
+            balance: number;
+        }>;
+        sendBabylonAgentChat(content: string): Promise<BabylonChatResponse>;
+        getBabylonAgentChat(): Promise<{
+            messages: BabylonChatMessage[];
+        }>;
+        getBabylonFeedForYou(): Promise<BabylonPostsResponse>;
+        getBabylonFeedHot(): Promise<BabylonPostsResponse>;
+        getBabylonTrades(): Promise<BabylonActivityFeed>;
+        discoverBabylonAgents(): Promise<BabylonTeamResponse>;
+        getBabylonTeamDashboard(): Promise<Record<string, unknown>>;
+        getBabylonTeamConversations(): Promise<Record<string, unknown>>;
+        pauseAllBabylonAgents(): Promise<{
+            ok: boolean;
+        }>;
+        resumeAllBabylonAgents(): Promise<{
+            ok: boolean;
+        }>;
+    }
+}
+//# sourceMappingURL=client-skills.d.ts.map