@elizaos/agent 0.25.9 → 2.0.0-alpha.144

package/apps/app-lifeops/src/selfcontrol/service.d.ts

@@ -0,0 +1,21 @@
+import type { IAgentRuntime, Task, UUID } from "@elizaos/core";
+import { Service } from "@elizaos/core";
+import { type SelfControlStatus } from "./selfcontrol.ts";
+export declare const WEBSITE_BLOCKER_UNBLOCK_TASK_NAME: "WEBSITE_BLOCKER_UNBLOCK";
+export declare const WEBSITE_BLOCKER_UNBLOCK_TASK_TAGS: readonly ["queue", "website-blocker", "selfcontrol"];
+export declare function clearWebsiteBlockerExpiryTasks(runtime: IAgentRuntime): Promise<void>;
+export declare function syncWebsiteBlockerExpiryTask(runtime: IAgentRuntime, status?: SelfControlStatus | null): Promise<UUID | null>;
+export declare function executeWebsiteBlockerExpiryTask(runtime: IAgentRuntime, task: Task): Promise<void>;
+export declare function registerWebsiteBlockerTaskWorker(runtime: IAgentRuntime): void;
+export declare class SelfControlBlockerService extends Service {
+    static serviceType: string;
+    capabilityDescription: string;
+    stop(): Promise<void>;
+    static start(runtime: IAgentRuntime): Promise<SelfControlBlockerService>;
+}
+export declare class WebsiteBlockerService extends SelfControlBlockerService {
+    static serviceType: string;
+    capabilityDescription: string;
+    static start(runtime: IAgentRuntime): Promise<WebsiteBlockerService>;
+}
+//# sourceMappingURL=service.d.ts.map

package/apps/app-lifeops/src/selfcontrol/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/selfcontrol/service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,IAAI,EAAgB,IAAI,EAAE,MAAM,eAAe,CAAC;AAC7E,OAAO,EAAU,OAAO,EAAgB,MAAM,eAAe,CAAC;AAC9D,OAAO,EAGL,KAAK,iBAAiB,EAEvB,MAAM,kBAAkB,CAAC;AAE1B,eAAO,MAAM,iCAAiC,EAC5C,yBAAkC,CAAC;AACrC,eAAO,MAAM,iCAAiC,sDAIpC,CAAC;AAoLX,wBAAsB,8BAA8B,CAClD,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,IAAI,CAAC,CASf;AA+DD,wBAAsB,4BAA4B,CAChD,OAAO,EAAE,aAAa,EACtB,MAAM,GAAE,iBAAiB,GAAG,IAAW,GACtC,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC,CAatB;AAkCD,wBAAsB,+BAA+B,CACnD,OAAO,EAAE,aAAa,EACtB,IAAI,EAAE,IAAI,GACT,OAAO,CAAC,IAAI,CAAC,CAuBf;AAED,wBAAgB,gCAAgC,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI,CAa7E;AAED,qBAAa,yBAA0B,SAAQ,OAAO;IACpD,MAAM,CAAC,WAAW,SAAyB;IAE3C,qBAAqB,SACwE;IAEvF,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;WAEL,KAAK,CACzB,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,yBAAyB,CAAC;CActC;AAED,qBAAa,qBAAsB,SAAQ,yBAAyB;IAClE,OAAgB,WAAW,SAAqB;IAEvC,qBAAqB,SAC+D;WAEvE,KAAK,CACzB,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,qBAAqB,CAAC;CAclC"}

package/apps/app-lifeops/src/selfcontrol/service.js

@@ -0,0 +1,268 @@
+import { logger, Service, stringToUuid } from "@elizaos/core";
+import { getSelfControlStatus, reconcileSelfControlBlockState, stopSelfControlBlock, } from "./selfcontrol.js";
+export const WEBSITE_BLOCKER_UNBLOCK_TASK_NAME = "WEBSITE_BLOCKER_UNBLOCK";
+export const WEBSITE_BLOCKER_UNBLOCK_TASK_TAGS = [
+    "queue",
+    "website-blocker",
+    "selfcontrol",
+];
+const WEBSITE_BLOCKER_UNBLOCK_RETRY_MS = 60_000;
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function haveSameWebsiteSet(left, right) {
+    if (left.length !== right.length) {
+        return false;
+    }
+    const leftSorted = [...left].sort();
+    const rightSorted = [...right].sort();
+    return leftSorted.every((website, index) => website === rightSorted[index]);
+}
+function getWebsiteBlockerTaskRoomId(runtime) {
+    return stringToUuid(`website-blocker-unblock-${runtime.agentId}`);
+}
+function getRetryCount(task) {
+    const descriptor = readWebsiteBlockerTaskDescriptor(task);
+    return descriptor?.retryCount ?? 0;
+}
+function readWebsiteBlockerTaskDescriptor(task) {
+    const metadata = isRecord(task.metadata) ? task.metadata : null;
+    const descriptor = metadata?.websiteBlockerUnblock;
+    if (!isRecord(descriptor)) {
+        return null;
+    }
+    if (descriptor.kind !== "scheduled_unblock" ||
+        descriptor.version !== 1 ||
+        typeof descriptor.endsAt !== "string" ||
+        !Array.isArray(descriptor.websites)) {
+        return null;
+    }
+    const websites = descriptor.websites.filter((website) => typeof website === "string");
+    if (websites.length === 0) {
+        return null;
+    }
+    return {
+        kind: "scheduled_unblock",
+        version: 1,
+        startedAt: typeof descriptor.startedAt === "string" &&
+            descriptor.startedAt.length > 0
+            ? descriptor.startedAt
+            : null,
+        endsAt: descriptor.endsAt,
+        websites,
+        retryCount: typeof descriptor.retryCount === "number" &&
+            Number.isFinite(descriptor.retryCount) &&
+            descriptor.retryCount >= 0
+            ? descriptor.retryCount
+            : 0,
+    };
+}
+function isWebsiteBlockerUnblockTask(task) {
+    return (task.name === WEBSITE_BLOCKER_UNBLOCK_TASK_NAME &&
+        readWebsiteBlockerTaskDescriptor(task) !== null);
+}
+function buildWebsiteBlockerTaskMetadata(status, existing = null, retryCount = 0) {
+    if (!status.endsAt) {
+        throw new Error("Cannot build a website blocker task without an end time.");
+    }
+    return {
+        ...(existing ?? {}),
+        blocking: true,
+        websiteBlockerUnblock: {
+            kind: "scheduled_unblock",
+            version: 1,
+            startedAt: status.startedAt,
+            endsAt: status.endsAt,
+            websites: [...status.websites],
+            retryCount,
+        },
+    };
+}
+function buildWebsiteBlockerTaskDescription(status) {
+    const websites = status.websites.length > 0
+        ? status.websites.join(", ")
+        : "blocked websites";
+    return `Automatically unblock ${websites} at ${status.endsAt ?? "the scheduled end time"}`;
+}
+function isTaskOwnedByRuntime(runtime, status) {
+    return (!status.scheduledByAgentId ||
+        status.scheduledByAgentId === String(runtime.agentId));
+}
+function statusMatchesTask(status, descriptor) {
+    if (!status.active || status.endsAt !== descriptor.endsAt) {
+        return false;
+    }
+    if (descriptor.startedAt && status.startedAt !== descriptor.startedAt) {
+        return false;
+    }
+    return haveSameWebsiteSet(status.websites, descriptor.websites);
+}
+async function waitForTaskStoreReady(runtime, maxAttempts = 3, delayMs = 250) {
+    for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+        try {
+            await runtime.getTasks({
+                agentIds: [runtime.agentId],
+                tags: ["__website_blocker_ready_probe__"],
+            });
+            return;
+        }
+        catch {
+            if (attempt < maxAttempts - 1) {
+                await new Promise((resolve) => setTimeout(resolve, delayMs));
+            }
+        }
+    }
+}
+async function listWebsiteBlockerUnblockTasks(runtime) {
+    const tasks = await runtime.getTasks({
+        agentIds: [runtime.agentId],
+        tags: [...WEBSITE_BLOCKER_UNBLOCK_TASK_TAGS],
+    });
+    return tasks.filter(isWebsiteBlockerUnblockTask);
+}
+export async function clearWebsiteBlockerExpiryTasks(runtime) {
+    await waitForTaskStoreReady(runtime);
+    const tasks = await listWebsiteBlockerUnblockTasks(runtime);
+    for (const task of tasks) {
+        if (!task.id) {
+            continue;
+        }
+        await runtime.deleteTask(task.id);
+    }
+}
+async function upsertWebsiteBlockerExpiryTask(runtime, status, retryCount = 0) {
+    if (!status.active ||
+        !status.endsAt ||
+        !isTaskOwnedByRuntime(runtime, status)) {
+        await clearWebsiteBlockerExpiryTasks(runtime);
+        return null;
+    }
+    const dueAtMs = Date.parse(status.endsAt);
+    if (!Number.isFinite(dueAtMs)) {
+        await clearWebsiteBlockerExpiryTasks(runtime);
+        return null;
+    }
+    await waitForTaskStoreReady(runtime);
+    const tasks = await listWebsiteBlockerUnblockTasks(runtime);
+    const matchingTask = tasks.find((task) => {
+        const descriptor = readWebsiteBlockerTaskDescriptor(task);
+        return descriptor ? statusMatchesTask(status, descriptor) : false;
+    });
+    for (const task of tasks) {
+        if (!task.id || task.id === matchingTask?.id) {
+            continue;
+        }
+        await runtime.deleteTask(task.id);
+    }
+    const metadata = buildWebsiteBlockerTaskMetadata(status, isRecord(matchingTask?.metadata) ? matchingTask.metadata : null, retryCount);
+    const description = buildWebsiteBlockerTaskDescription(status);
+    const dueAt = Math.max(dueAtMs, Date.now());
+    if (matchingTask?.id) {
+        await runtime.updateTask(matchingTask.id, {
+            description,
+            dueAt,
+            metadata,
+        });
+        return matchingTask.id;
+    }
+    return runtime.createTask({
+        name: WEBSITE_BLOCKER_UNBLOCK_TASK_NAME,
+        description,
+        roomId: getWebsiteBlockerTaskRoomId(runtime),
+        tags: [...WEBSITE_BLOCKER_UNBLOCK_TASK_TAGS],
+        dueAt,
+        metadata,
+    });
+}
+export async function syncWebsiteBlockerExpiryTask(runtime, status = null) {
+    registerWebsiteBlockerTaskWorker(runtime);
+    const nextStatus = status ?? (await reconcileSelfControlBlockState());
+    if (!nextStatus.active ||
+        !nextStatus.endsAt ||
+        !isTaskOwnedByRuntime(runtime, nextStatus)) {
+        await clearWebsiteBlockerExpiryTasks(runtime);
+        return null;
+    }
+    return upsertWebsiteBlockerExpiryTask(runtime, nextStatus);
+}
+async function scheduleWebsiteBlockerRetryTask(runtime, task, status) {
+    const descriptor = readWebsiteBlockerTaskDescriptor(task);
+    if (!descriptor ||
+        !status.active ||
+        !status.endsAt ||
+        !statusMatchesTask(status, descriptor)) {
+        return null;
+    }
+    return runtime.createTask({
+        name: WEBSITE_BLOCKER_UNBLOCK_TASK_NAME,
+        description: buildWebsiteBlockerTaskDescription(status),
+        roomId: getWebsiteBlockerTaskRoomId(runtime),
+        tags: [...WEBSITE_BLOCKER_UNBLOCK_TASK_TAGS],
+        dueAt: Date.now() + WEBSITE_BLOCKER_UNBLOCK_RETRY_MS,
+        metadata: buildWebsiteBlockerTaskMetadata({
+            ...status,
+            endsAt: status.endsAt,
+        }, null, getRetryCount(task) + 1),
+    });
+}
+export async function executeWebsiteBlockerExpiryTask(runtime, task) {
+    const descriptor = readWebsiteBlockerTaskDescriptor(task);
+    if (!descriptor) {
+        return;
+    }
+    const status = await getSelfControlStatus();
+    if (!statusMatchesTask(status, descriptor)) {
+        return;
+    }
+    const stopResult = await stopSelfControlBlock();
+    if (stopResult.success === true) {
+        logger.info(`[selfcontrol] Automatically removed the website block scheduled for ${descriptor.endsAt}.`);
+        return;
+    }
+    await scheduleWebsiteBlockerRetryTask(runtime, task, status);
+    logger.warn(`[selfcontrol] Failed to remove the scheduled website block at ${descriptor.endsAt}; queued a retry in ${WEBSITE_BLOCKER_UNBLOCK_RETRY_MS / 1000}s: ${stopResult.error}`);
+}
+export function registerWebsiteBlockerTaskWorker(runtime) {
+    if (runtime.getTaskWorker(WEBSITE_BLOCKER_UNBLOCK_TASK_NAME)) {
+        return;
+    }
+    runtime.registerTaskWorker({
+        name: WEBSITE_BLOCKER_UNBLOCK_TASK_NAME,
+        shouldRun: async () => true,
+        execute: async (rt, _options, task) => {
+            await executeWebsiteBlockerExpiryTask(rt, task);
+            return undefined;
+        },
+    });
+}
+export class SelfControlBlockerService extends Service {
+    static serviceType = "selfcontrol_blocker";
+    capabilityDescription = "Maintains the local hosts-file website blocker and clears timed blocks when they expire.";
+    async stop() { }
+    static async start(runtime) {
+        registerWebsiteBlockerTaskWorker(runtime);
+        try {
+            const status = await reconcileSelfControlBlockState();
+            await syncWebsiteBlockerExpiryTask(runtime, status);
+        }
+        catch (error) {
+            logger.warn(`[selfcontrol] Failed to reconcile hosts-file blocker state: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        return new SelfControlBlockerService(runtime);
+    }
+}
+export class WebsiteBlockerService extends SelfControlBlockerService {
+    static serviceType = "website_blocker";
+    capabilityDescription = "Maintains the local hosts-file website blocker and clears timed blocks when they expire.";
+    static async start(runtime) {
+        registerWebsiteBlockerTaskWorker(runtime);
+        try {
+            const status = await reconcileSelfControlBlockState();
+            await syncWebsiteBlockerExpiryTask(runtime, status);
+        }
+        catch (error) {
+            logger.warn(`[selfcontrol] Failed to reconcile hosts-file blocker state: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        return new WebsiteBlockerService(runtime);
+    }
+}

package/apps/app-lifeops/src/service.d.ts

@@ -0,0 +1,8 @@
+import { type IAgentRuntime, Service } from "@elizaos/core";
+export declare class LifeOpsBrowserPluginService extends Service {
+    static serviceType: string;
+    capabilityDescription: string;
+    static start(runtime: IAgentRuntime): Promise<LifeOpsBrowserPluginService>;
+    stop(): Promise<void>;
+}
+//# sourceMappingURL=service.d.ts.map

package/apps/app-lifeops/src/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../../../../../apps/app-lifeops/src/service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,aAAa,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAE5D,qBAAa,2BAA4B,SAAQ,OAAO;IACtD,MAAM,CAAC,WAAW,SAA4B;IAE9C,qBAAqB,SACuG;WAEtG,KAAK,CACzB,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,2BAA2B,CAAC;IAIjC,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAG5B"}

package/apps/app-lifeops/src/service.js

@@ -0,0 +1,11 @@
+import { Service } from "@elizaos/core";
+export class LifeOpsBrowserPluginService extends Service {
+    static serviceType = "lifeops_browser_plugin";
+    capabilityDescription = "Surfaces the user's personal LifeOps Browser state and creates browser sessions for their Chrome and Safari companions.";
+    static async start(runtime) {
+        return new LifeOpsBrowserPluginService(runtime);
+    }
+    async stop() {
+        // No resources to clean up.
+    }
+}

package/apps/app-steward/src/api/wallet-capability.d.ts

@@ -0,0 +1,28 @@
+import type { ElizaConfig } from "@elizaos/agent/config/config";
+import type { AgentRuntime } from "@elizaos/core";
+import { getWalletAddresses } from "./wallet";
+export declare const EVM_PLUGIN_PACKAGE = "@elizaos/plugin-evm";
+export interface WalletCapabilityStatus {
+    walletSource: "local" | "managed" | "none";
+    walletNetwork: "mainnet" | "testnet";
+    evmAddress: string | null;
+    solanaAddress: string | null;
+    hasWallet: boolean;
+    hasEvm: boolean;
+    localSignerAvailable: boolean;
+    rpcReady: boolean;
+    automationMode: "full" | "connectors-only";
+    pluginEvmLoaded: boolean;
+    pluginEvmRequired: boolean;
+    executionReady: boolean;
+    executionBlockedReason: string | null;
+}
+export declare function isPluginLoadedByName(runtime: AgentRuntime | null, pluginName: string): boolean;
+export declare function resolveWalletAutomationMode(config: ElizaConfig): "full" | "connectors-only";
+export declare function resolvePluginEvmLoaded(runtime: AgentRuntime | null): boolean;
+export declare function resolveWalletCapabilityStatus(state: {
+    config: ElizaConfig;
+    runtime: AgentRuntime | null;
+    getWalletAddresses?: typeof getWalletAddresses;
+}): WalletCapabilityStatus;
+//# sourceMappingURL=wallet-capability.d.ts.map

package/apps/app-steward/src/api/wallet-capability.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wallet-capability.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-steward/src/api/wallet-capability.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAChE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAElD,OAAO,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAG9C,eAAO,MAAM,kBAAkB,wBAAwB,CAAC;AAExD,MAAM,WAAW,sBAAsB;IACrC,YAAY,EAAE,OAAO,GAAG,SAAS,GAAG,MAAM,CAAC;IAC3C,aAAa,EAAE,SAAS,GAAG,SAAS,CAAC;IACrC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,SAAS,EAAE,OAAO,CAAC;IACnB,MAAM,EAAE,OAAO,CAAC;IAChB,oBAAoB,EAAE,OAAO,CAAC;IAC9B,QAAQ,EAAE,OAAO,CAAC;IAClB,cAAc,EAAE,MAAM,GAAG,iBAAiB,CAAC;IAC3C,eAAe,EAAE,OAAO,CAAC;IACzB,iBAAiB,EAAE,OAAO,CAAC;IAC3B,cAAc,EAAE,OAAO,CAAC;IACxB,sBAAsB,EAAE,MAAM,GAAG,IAAI,CAAC;CACvC;AAmBD,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,YAAY,GAAG,IAAI,EAC5B,UAAU,EAAE,MAAM,GACjB,OAAO,CAcT;AAED,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,WAAW,GAClB,MAAM,GAAG,iBAAiB,CAc5B;AAED,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,YAAY,GAAG,IAAI,GAAG,OAAO,CAM5E;AAED,wBAAgB,6BAA6B,CAAC,KAAK,EAAE;IACnD,MAAM,EAAE,WAAW,CAAC;IACpB,OAAO,EAAE,YAAY,GAAG,IAAI,CAAC;IAC7B,kBAAkB,CAAC,EAAE,OAAO,kBAAkB,CAAC;CAChD,GAAG,sBAAsB,CA6CzB"}

package/apps/app-steward/src/api/wallet-capability.js

@@ -0,0 +1,94 @@
+import { isStewardEvmBridgeActive } from "../services/steward-evm-bridge";
+import { getWalletAddresses } from "./wallet";
+import { resolveWalletRpcReadiness } from "./wallet-rpc";
+export const EVM_PLUGIN_PACKAGE = "@elizaos/plugin-evm";
+function hasRuntimeEvmService(runtime) {
+    if (!runtime ||
+        typeof runtime.getService !== "function") {
+        return false;
+    }
+    try {
+        return Boolean(runtime.getService("evm"));
+    }
+    catch {
+        return false;
+    }
+}
+export function isPluginLoadedByName(runtime, pluginName) {
+    if (!runtime || !Array.isArray(runtime.plugins))
+        return false;
+    const shortId = pluginName.replace("@elizaos/plugin-", "");
+    const packageSuffix = `plugin-${shortId}`;
+    return runtime.plugins.some((plugin) => {
+        const name = typeof plugin?.name === "string" ? plugin.name : "";
+        return (name === pluginName ||
+            name === shortId ||
+            name === packageSuffix ||
+            name.endsWith(`/${packageSuffix}`) ||
+            name.includes(shortId));
+    });
+}
+export function resolveWalletAutomationMode(config) {
+    const features = config.features && typeof config.features === "object"
+        ? config.features
+        : null;
+    const agentAutomation = features?.agentAutomation &&
+        typeof features.agentAutomation === "object" &&
+        !Array.isArray(features.agentAutomation)
+        ? features.agentAutomation
+        : null;
+    return agentAutomation?.mode === "connectors-only"
+        ? "connectors-only"
+        : "full";
+}
+export function resolvePluginEvmLoaded(runtime) {
+    return (isPluginLoadedByName(runtime, EVM_PLUGIN_PACKAGE) ||
+        hasRuntimeEvmService(runtime) ||
+        isStewardEvmBridgeActive());
+}
+export function resolveWalletCapabilityStatus(state) {
+    const addrs = (state.getWalletAddresses ?? getWalletAddresses)();
+    const rpcReadiness = resolveWalletRpcReadiness(state.config);
+    const automationMode = resolveWalletAutomationMode(state.config);
+    const localSignerAvailable = Boolean(process.env.EVM_PRIVATE_KEY?.trim());
+    const hasWallet = Boolean(addrs.evmAddress || addrs.solanaAddress);
+    const hasEvm = Boolean(addrs.evmAddress);
+    const pluginEvmLoaded = resolvePluginEvmLoaded(state.runtime);
+    const pluginEvmRequired = hasEvm || localSignerAvailable;
+    const rpcReady = Boolean(rpcReadiness.managedBscRpcReady);
+    const walletSource = localSignerAvailable
+        ? "local"
+        : hasWallet
+            ? "managed"
+            : "none";
+    let executionBlockedReason = null;
+    if (!hasEvm) {
+        executionBlockedReason = "No EVM wallet is active yet.";
+    }
+    else if (!rpcReady) {
+        executionBlockedReason = "BSC RPC is not configured.";
+    }
+    else if (!pluginEvmLoaded) {
+        executionBlockedReason =
+            "plugin-evm is not loaded, so EVM wallet execution is unavailable.";
+    }
+    else if (automationMode !== "full") {
+        executionBlockedReason =
+            "Agent automation is in connectors-only mode, so wallet execution is blocked in chat.";
+    }
+    return {
+        walletSource,
+        walletNetwork: rpcReadiness.walletNetwork,
+        evmAddress: addrs.evmAddress ?? null,
+        solanaAddress: addrs.solanaAddress ?? null,
+        hasWallet,
+        hasEvm,
+        localSignerAvailable,
+        rpcReady,
+        automationMode,
+        pluginEvmLoaded,
+        pluginEvmRequired,
+        executionReady: hasEvm && rpcReady && pluginEvmLoaded && automationMode === "full",
+        executionBlockedReason,
+    };
+}

package/apps/app-steward/src/api/wallet-dex-prices.d.ts

@@ -0,0 +1,43 @@
+export declare const DEXSCREENER_CHAIN_MAP: Record<number, string>;
+export declare const DEXPAPRIKA_CHAIN_MAP: Record<number, string>;
+/** Wrapped native token addresses for pricing native balances via DEX APIs. */
+export declare const WRAPPED_NATIVE: Record<number, string>;
+export declare const DEX_PRICE_TIMEOUT_MS = 10000;
+export interface DexScreenerPair {
+    baseToken?: {
+        address?: string;
+    };
+    priceUsd?: string | null;
+    liquidity?: {
+        usd?: number;
+    };
+    info?: {
+        imageUrl?: string;
+    };
+}
+/** Price + optional logo URL from DEX aggregators. */
+export interface DexTokenMeta {
+    price: string;
+    logoUrl?: string;
+}
+/**
+ * Batch-fetch USD prices from DexScreener.
+ * Returns a map of lowercased contract address → price USD string.
+ */
+export declare function fetchDexScreenerPrices(chainId: number, addresses: string[]): Promise<Map<string, DexTokenMeta>>;
+/**
+ * Fetch individual token prices from DexPaprika as fallback.
+ * Only called for addresses that DexScreener couldn't price.
+ */
+export declare function fetchDexPaprikaPrices(chainId: number, addresses: string[]): Promise<Map<string, DexTokenMeta>>;
+/**
+ * Fetch USD prices for a list of token addresses using DexScreener (primary)
+ * with DexPaprika fallback. Returns a map of lowercased address → price string.
+ */
+export declare function fetchDexPrices(chainId: number, addresses: string[]): Promise<Map<string, DexTokenMeta>>;
+/**
+ * Compute USD value from a formatted balance string and a price string.
+ * Returns "0" if either value is invalid.
+ */
+export declare function computeValueUsd(balance: string, priceUsd: string): string;
+//# sourceMappingURL=wallet-dex-prices.d.ts.map

package/apps/app-steward/src/api/wallet-dex-prices.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wallet-dex-prices.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-steward/src/api/wallet-dex-prices.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,qBAAqB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAQxD,CAAC;AAEF,eAAO,MAAM,oBAAoB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAQvD,CAAC;AAEF,+EAA+E;AAC/E,eAAO,MAAM,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAQjD,CAAC;AAEF,eAAO,MAAM,oBAAoB,QAAS,CAAC;AAI3C,MAAM,WAAW,eAAe;IAC9B,SAAS,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACjC,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,SAAS,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAC7B,IAAI,CAAC,EAAE;QAAE,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CAC9B;AAED,sDAAsD;AACtD,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAID;;;GAGG;AACH,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,EAAE,GAClB,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC,CAsDpC;AAID;;;GAGG;AACH,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,EAAE,GAClB,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC,CA2BpC;AAID;;;GAGG;AACH,wBAAsB,cAAc,CAClC,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,EAAE,GAClB,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC,CAgBpC;AAID;;;GAGG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAWzE"}

package/apps/app-steward/src/api/wallet-dex-prices.js

@@ -0,0 +1,149 @@
+/**
+ * DEX Price Oracle — DexScreener (primary) + DexPaprika (fallback).
+ *
+ * Fetches USD token prices from on-chain DEX aggregators.
+ * Used by the wallet balance modules to annotate token rows with USD values.
+ */
+import { logger } from "@elizaos/core";
+// ── Chain ID → DEX API slug mappings ──────────────────────────────────
+export const DEXSCREENER_CHAIN_MAP = {
+    1: "ethereum",
+    56: "bsc",
+    8453: "base",
+    42161: "arbitrum",
+    10: "optimism",
+    137: "polygon",
+    43114: "avalanche",
+};
+export const DEXPAPRIKA_CHAIN_MAP = {
+    1: "ethereum",
+    56: "bsc",
+    8453: "base",
+    42161: "arbitrum_one",
+    10: "optimism",
+    137: "polygon_pos",
+    43114: "avalanche",
+};
+/** Wrapped native token addresses for pricing native balances via DEX APIs. */
+export const WRAPPED_NATIVE = {
+    1: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+    56: "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c",
+    8453: "0x4200000000000000000000000000000000000006",
+    42161: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
+    10: "0x4200000000000000000000000000000000000006",
+    137: "0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270",
+    43114: "0xB31f66AA3C1e785363F0875A1B74E27b85FD66c7",
+};
+export const DEX_PRICE_TIMEOUT_MS = 10_000;
+// ── DexScreener ───────────────────────────────────────────────────────
+/**
+ * Batch-fetch USD prices from DexScreener.
+ * Returns a map of lowercased contract address → price USD string.
+ */
+export async function fetchDexScreenerPrices(chainId, addresses) {
+    const results = new Map();
+    const chain = DEXSCREENER_CHAIN_MAP[chainId];
+    if (!chain || addresses.length === 0)
+        return results;
+    // DexScreener supports up to 30 addresses per request.
+    const batches = [];
+    for (let i = 0; i < addresses.length; i += 30) {
+        batches.push(addresses.slice(i, i + 30));
+    }
+    await Promise.allSettled(batches.map(async (batch) => {
+        try {
+            const joined = batch.join(",");
+            const res = await fetch(`https://api.dexscreener.com/tokens/v1/${chain}/${joined}`, { signal: AbortSignal.timeout(DEX_PRICE_TIMEOUT_MS) });
+            if (!res.ok)
+                return;
+            const pairs = await res.json();
+            if (!Array.isArray(pairs))
+                return;
+            // Group by base token address; pick the pair with highest liquidity.
+            const best = new Map();
+            for (const pair of pairs) {
+                const addr = pair.baseToken?.address?.toLowerCase();
+                if (!addr || !pair.priceUsd)
+                    continue;
+                const existing = best.get(addr);
+                if (!existing ||
+                    (pair.liquidity?.usd ?? 0) > (existing.liquidity?.usd ?? 0)) {
+                    best.set(addr, pair);
+                }
+            }
+            for (const [addr, pair] of best) {
+                if (pair.priceUsd) {
+                    const logoUrl = pair.info?.imageUrl?.trim() || undefined;
+                    results.set(addr, { price: String(pair.priceUsd), logoUrl });
+                }
+            }
+            logger.info(`[wallet] DexScreener: ${best.size} prices for chain ${chain}`);
+        }
+        catch (err) {
+            logger.warn(`[wallet] DexScreener fetch failed for chain ${chain}: ${String(err)}`);
+        }
+    }));
+    return results;
+}
+// ── DexPaprika (fallback) ─────────────────────────────────────────────
+/**
+ * Fetch individual token prices from DexPaprika as fallback.
+ * Only called for addresses that DexScreener couldn't price.
+ */
+export async function fetchDexPaprikaPrices(chainId, addresses) {
+    const results = new Map();
+    const network = DEXPAPRIKA_CHAIN_MAP[chainId];
+    if (!network || addresses.length === 0)
+        return results;
+    await Promise.allSettled(addresses.slice(0, 20).map(async (addr) => {
+        try {
+            const res = await fetch(`https://api.dexpaprika.com/networks/${network}/tokens/${addr}`, { signal: AbortSignal.timeout(DEX_PRICE_TIMEOUT_MS) });
+            if (!res.ok)
+                return;
+            const data = await res.json();
+            const price = Number(data.price_usd);
+            if (Number.isFinite(price) && price > 0) {
+                results.set(addr.toLowerCase(), { price: price.toString() });
+            }
+        }
+        catch (err) {
+            logger.warn(`[wallet] DexPaprika fetch failed for ${addr}: ${String(err)}`);
+        }
+    }));
+    return results;
+}
+// ── Combined price fetcher ────────────────────────────────────────────
+/**
+ * Fetch USD prices for a list of token addresses using DexScreener (primary)
+ * with DexPaprika fallback. Returns a map of lowercased address → price string.
+ */
+export async function fetchDexPrices(chainId, addresses) {
+    if (addresses.length === 0)
+        return new Map();
+    const lowerAddresses = addresses.map((a) => a.toLowerCase());
+    const results = await fetchDexScreenerPrices(chainId, lowerAddresses);
+    // Fallback to DexPaprika for tokens DexScreener couldn't price.
+    const missing = lowerAddresses.filter((a) => !results.has(a));
+    if (missing.length > 0) {
+        const fallback = await fetchDexPaprikaPrices(chainId, missing);
+        for (const [addr, meta] of fallback) {
+            results.set(addr, meta);
+        }
+    }
+    return results;
+}
+// ── Helpers ───────────────────────────────────────────────────────────
+/**
+ * Compute USD value from a formatted balance string and a price string.
+ * Returns "0" if either value is invalid.
+ */
+export function computeValueUsd(balance, priceUsd) {
+    const bal = Number.parseFloat(balance);
+    const price = Number.parseFloat(priceUsd);
+    if (!Number.isFinite(bal) ||
+        !Number.isFinite(price) ||
+        bal <= 0 ||
+        price <= 0)
+        return "0";
+    return (bal * price).toFixed(2);
+}