@elizaos/agent 2.0.0-alpha.97 → 2.0.0-beta.1

package/dist/packages/agent/src/runtime/agent-wallets.js

@@ -0,0 +1,308 @@
+/**
+ * Per-agent wallet keys, stored in the Eliza vault.
+ *
+ * This module is the bridge between agent identity and the vault. Each
+ * agent gets its own EVM and Solana keypair, stored under
+ * `agent.<agentId>.wallet.<chain>` as a JSON record. Private keys are
+ * sensitive and AES-GCM encrypted at rest by the vault; the vault's
+ * master key lives in the OS keychain.
+ *
+ * The runtime-wide single wallet (process.env.EVM_PRIVATE_KEY etc.) is
+ * the *user* wallet, hydrated from the OS secure store via
+ * `hydrateWalletKeysFromNodePlatformSecureStore`. Per-agent wallets are
+ * stored *inside* the vault (encrypted file), enumerable and easy to
+ * surface in the UI alongside saved logins.
+ *
+ * This module does not generate or store keys on its own; callers
+ * supply a `Vault` instance. Agent-creation lifecycle code wires this
+ * up — see `runtime/eliza.ts`.
+ */
+import { removeEntryMeta, setEntryMeta } from "@elizaos/vault";
+import { deriveEvmAddress, generateWalletForChain } from "../api/wallet.js";
+const PREFIX = "agent";
+const SEGMENT = "wallet";
+function encodeAgentSegment(agentId) {
+    if (typeof agentId !== "string" || agentId.trim().length === 0) {
+        throw new TypeError("agent-wallets: agentId must be a non-empty string");
+    }
+    // encodeURIComponent leaves `.` alone, but our vault keys split on `.`
+    // — escape it explicitly so an agent ID like "alice.bob" doesn't bleed
+    // into the layout (`agent.alice.bob.wallet.evm` has five parts, not four).
+    return encodeURIComponent(agentId.trim()).replace(/\./g, "%2E");
+}
+function decodeAgentSegment(segment) {
+    return decodeURIComponent(segment);
+}
+function walletKey(agentId, chain) {
+    return `${PREFIX}.${encodeAgentSegment(agentId)}.${SEGMENT}.${chain}`;
+}
+function agentPrefix(agentId) {
+    return `${PREFIX}.${encodeAgentSegment(agentId)}.${SEGMENT}`;
+}
+function parseAgentWalletKey(key) {
+    // Layout: agent.<encodedId>.wallet.<chain>
+    const parts = key.split(".");
+    if (parts.length !== 4)
+        return null;
+    if (parts[0] !== PREFIX || parts[2] !== SEGMENT)
+        return null;
+    const encodedAgentId = parts[1];
+    if (!encodedAgentId)
+        return null;
+    const chain = parts[3];
+    if (chain !== "evm" && chain !== "solana")
+        return null;
+    return { agentId: decodeAgentSegment(encodedAgentId), chain };
+}
+function parseStored(raw) {
+    const parsed = JSON.parse(raw);
+    if ((parsed.chain !== "evm" && parsed.chain !== "solana") ||
+        typeof parsed.address !== "string" ||
+        typeof parsed.privateKey !== "string" ||
+        typeof parsed.lastModified !== "number") {
+        throw new Error("agent-wallets: stored entry malformed (expected chain/address/privateKey/lastModified)");
+    }
+    return {
+        chain: parsed.chain,
+        address: parsed.address,
+        privateKey: parsed.privateKey,
+        lastModified: parsed.lastModified,
+    };
+}
+/**
+ * Derive the public address from a stored private key. EVM uses the
+ * existing helper; Solana stores the public key alongside the secret in
+ * `generateWalletForChain`, so the stored `address` is authoritative
+ * and we trust it for the read path.
+ */
+function deriveAddressFor(chain, privateKey) {
+    if (chain === "evm")
+        return deriveEvmAddress(privateKey);
+    // For Solana the keypair format already includes the public key; the
+    // caller is expected to have stored the public key as `address` at
+    // write time. Re-derivation would require @solana/web3.js, which we
+    // avoid pulling in here.
+    throw new Error("agent-wallets: deriveAddressFor only supports EVM; Solana addresses must be supplied at write time");
+}
+/**
+ * Read the public descriptor for an agent's wallet. Returns null when
+ * the agent has no wallet for that chain. Does NOT reveal the private
+ * key.
+ */
+export async function getAgentWalletDescriptor(vault, agentId, chain) {
+    const key = walletKey(agentId, chain);
+    if (!(await vault.has(key)))
+        return null;
+    const raw = await vault.get(key);
+    const stored = parseStored(raw);
+    return {
+        agentId,
+        chain,
+        address: stored.address,
+        lastModified: stored.lastModified,
+    };
+}
+/**
+ * Reveal the private key. Audit-logged via the vault. Use only for
+ * signing flows.
+ */
+export async function revealAgentWalletPrivateKey(vault, agentId, chain, caller) {
+    const key = walletKey(agentId, chain);
+    const raw = await vault.reveal(key, caller);
+    return parseStored(raw).privateKey;
+}
+/**
+ * Existence check. Does not reveal the key.
+ */
+export async function hasAgentWallet(vault, agentId, chain) {
+    return vault.has(walletKey(agentId, chain));
+}
+/**
+ * List every wallet descriptor for an agent (typically [evm, solana]).
+ */
+export async function listAgentWallets(vault, agentId) {
+    const keys = await vault.list(agentPrefix(agentId));
+    const out = [];
+    for (const key of keys) {
+        const parsed = parseAgentWalletKey(key);
+        if (!parsed)
+            continue;
+        const raw = await vault.get(key);
+        const stored = parseStored(raw);
+        out.push({
+            agentId: parsed.agentId,
+            chain: parsed.chain,
+            address: stored.address,
+            lastModified: stored.lastModified,
+        });
+    }
+    return out;
+}
+/**
+ * List every agent that has at least one wallet stored. Returns the
+ * agent IDs (decoded). Use for UI surfaces enumerating agent wallets.
+ */
+export async function listAgentsWithWallets(vault) {
+    const keys = await vault.list(PREFIX);
+    const agents = new Set();
+    for (const key of keys) {
+        const parsed = parseAgentWalletKey(key);
+        if (!parsed)
+            continue;
+        agents.add(parsed.agentId);
+    }
+    return [...agents];
+}
+/**
+ * Persist a wallet for an agent. Replaces any existing entry for that
+ * (agentId, chain). Stamps `lastModified`.
+ *
+ * Caller is responsible for supplying the matching address — for EVM
+ * this can be derived from the private key, for Solana the keypair
+ * generator returns it directly.
+ */
+export async function setAgentWallet(vault, agentId, chain, privateKey, address, caller) {
+    if (typeof privateKey !== "string" || privateKey.trim().length === 0) {
+        throw new TypeError("agent-wallets: privateKey required");
+    }
+    if (typeof address !== "string" || address.trim().length === 0) {
+        throw new TypeError("agent-wallets: address required");
+    }
+    const stored = {
+        chain,
+        address,
+        privateKey,
+        lastModified: Date.now(),
+    };
+    const key = walletKey(agentId, chain);
+    await vault.set(key, JSON.stringify(stored), {
+        sensitive: true,
+        ...(caller ? { caller } : {}),
+    });
+    // Surface per-agent wallets in Settings → Vault → Secrets under the
+    // "Wallet" group. Without explicit meta, the inventory categorizer
+    // falls back to "plugin" for the `agent.<id>.wallet.<chain>` shape.
+    await setEntryMeta(vault, key, {
+        category: "wallet",
+        label: `agent ${agentId} (${chain})`,
+    });
+    return {
+        agentId,
+        chain,
+        address: stored.address,
+        lastModified: stored.lastModified,
+    };
+}
+/**
+ * Generate a fresh wallet for an agent and persist it. Returns the
+ * public descriptor. Idempotent: callers should check `hasAgentWallet`
+ * first if they want to avoid replacing an existing wallet.
+ */
+export async function generateAgentWallet(vault, agentId, chain, caller) {
+    const generated = generateWalletForChain(chain);
+    return setAgentWallet(vault, agentId, chain, generated.privateKey, generated.address, caller);
+}
+/**
+ * Generate any missing wallets (EVM + Solana) for an agent. Existing
+ * wallets are left alone. Returns descriptors for every chain that now
+ * has a wallet (whether it was generated this call or was already
+ * present).
+ */
+export async function ensureAgentWallets(vault, agentId, caller) {
+    const chains = ["evm", "solana"];
+    const out = [];
+    for (const chain of chains) {
+        const existing = await getAgentWalletDescriptor(vault, agentId, chain);
+        if (existing) {
+            out.push(existing);
+            continue;
+        }
+        out.push(await generateAgentWallet(vault, agentId, chain, caller));
+    }
+    await bridgeAgentWalletsToProcessEnv(vault, agentId, out, caller);
+    return out;
+}
+/** Env var the wallet UI + EVM/Solana plugins read for the user wallet. */
+const CHAIN_TO_ENV_KEY = {
+    evm: "EVM_PRIVATE_KEY",
+    solana: "SOLANA_PRIVATE_KEY",
+};
+/**
+ * Make the per-agent wallet visible as the user wallet for THIS process.
+ *
+ * The wallet UI tab + every consumer plugin (`@elizaos/plugin-evm`,
+ * `@elizaos/plugin-solana`) reads from `process.env.EVM_PRIVATE_KEY` /
+ * `SOLANA_PRIVATE_KEY`. Per-agent wallets live in the vault, so without
+ * a bridge the UI shows "No EVM/Solana address" even though the agent
+ * has a perfectly good wallet sitting in the vault.
+ *
+ * ## Security trade-off — this is OPT-IN by default
+ *
+ * Writing a private key to `process.env` exposes it via:
+ *   - `/proc/self/environ` (readable by the same UID; some sandboxes leak more)
+ *   - crash dumps + core files
+ *   - any `JSON.stringify(process.env)` in error reports or telemetry
+ *   - inheritance into every spawned child process (default `env` for spawn)
+ *
+ * For most users on a single-user machine that's an acceptable trade —
+ * the agent IS the wallet, the box is the user's, and the convenience
+ * (wallet UI just works) outweighs the leak surface. But for shared
+ * machines, server deployments, or anyone with strict secrets hygiene,
+ * the leak surface is real.
+ *
+ * Default behavior: bridge is OFF. The wallet UI shows "No address"
+ * for the chain unless the user explicitly opts in. Opt-in flag:
+ * `ELIZA_AGENT_WALLET_AS_USER=1`. The proper fix is for consumer
+ * plugins to read from the vault directly via `getAgentWallet(agentId,
+ * chain)` instead of `process.env.*_PRIVATE_KEY` — when that
+ * migration lands, this whole bridge can be deleted.
+ *
+ * Legacy env: `ELIZA_DISABLE_AGENT_WALLET_AS_USER=1` (the previous
+ * opt-out) is still respected — if set, the bridge is forced off
+ * regardless of `ELIZA_AGENT_WALLET_AS_USER`.
+ */
+export async function bridgeAgentWalletsToProcessEnv(vault, agentId, descriptors, caller) {
+    // Hard opt-out wins over opt-in — preserves the legacy disable flag.
+    if (process.env.ELIZA_DISABLE_AGENT_WALLET_AS_USER === "1")
+        return;
+    // Default off. Skipping bridge unless explicitly opted in.
+    if (process.env.ELIZA_AGENT_WALLET_AS_USER !== "1")
+        return;
+    for (const d of descriptors) {
+        const envKey = CHAIN_TO_ENV_KEY[d.chain];
+        if (process.env[envKey]?.trim())
+            continue; // user-set wins
+        try {
+            const pk = await revealAgentWalletPrivateKey(vault, agentId, d.chain, caller ?? "agent-wallets:bridge");
+            process.env[envKey] = pk;
+        }
+        catch {
+            // Vault read failed — leave env unset; the wallet UI will show
+            // empty for that chain and the user can re-enter via Settings.
+        }
+    }
+}
+/**
+ * Remove an agent's wallet for one chain. Idempotent.
+ */
+export async function removeAgentWallet(vault, agentId, chain) {
+    const key = walletKey(agentId, chain);
+    await vault.remove(key);
+    await removeEntryMeta(vault, key);
+}
+/**
+ * Remove every wallet for an agent. Use during agent deletion.
+ */
+export async function removeAllAgentWallets(vault, agentId) {
+    const wallets = await listAgentWallets(vault, agentId);
+    for (const w of wallets) {
+        await removeAgentWallet(vault, agentId, w.chain);
+    }
+}
+// Internal helpers — exported for tests only.
+export const __test__ = {
+    walletKey,
+    agentPrefix,
+    parseAgentWalletKey,
+    deriveAddressFor,
+};

package/dist/packages/agent/src/runtime/analysis-mode-flag.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Analysis mode (Westworld nod) — per-room debug flag.
+ *
+ * When a user types `analysis` in chat, that conversation flips into
+ * analysis mode: subsequent assistant turns attach a structured debug
+ * sidecar (thinking, planned actions, simple-mode flag, evaluator output,
+ * followup decision) to the response. The user types `as you were` to
+ * disable it.
+ *
+ * SCAFFOLD ONLY. The runtime has not yet been wired to consult this flag
+ * or attach the sidecar. This module exists so the activation parsing,
+ * lifetime, and gating logic are pinned down with tests before the
+ * cross-cutting integration is written. See
+ * `/tmp/lifeops-assessment/15-analysis-mode.md` for the full design.
+ *
+ * Privacy contract:
+ *   - Analysis sidecars contain raw thinking, prompt fragments, evaluator
+ *     output (facts/relationships about real people), and follow-up timing.
+ *     They MUST NOT be forwarded to remote chat surfaces (Telegram,
+ *     Discord, WeChat, etc.).
+ *   - `isAnalysisModeAllowed()` returns false unless the runtime is local
+ *     (loopback API) AND development mode is on, OR the operator opted in
+ *     via `MILADY_ENABLE_ANALYSIS_MODE=1`.
+ *
+ * Storage:
+ *   - In-memory `Map<roomId, AnalysisModeState>`. Process-local.
+ *     Restarts clear the flag — that is intentional. Analysis mode is a
+ *     transient debug toggle, not a persisted preference. If we later
+ *     decide to persist it, write to `Room.metadata.analysisMode`, not
+ *     to a new table.
+ */
+export type AnalysisToken = "enable" | "disable" | null;
+export interface AnalysisModeState {
+    enabled: boolean;
+    enabledAt: number;
+    /** Optional cap so we never leave analysis on forever in a dev session. */
+    expiresAt?: number;
+}
+export interface AnalysisModeOptions {
+    /**
+     * If set, analysis mode auto-disables this many ms after enable. Default:
+     * undefined (no auto-expire). Suggest 1h (3_600_000) when wiring.
+     */
+    ttlMs?: number;
+    /** Override `Date.now` for tests. */
+    now?: () => number;
+}
+/**
+ * Detect activation tokens. Returns:
+ *   - "enable"  for messages whose entire text is the literal `analysis`
+ *   - "disable" for messages whose entire text is the literal `as you were`
+ *   - null      otherwise
+ *
+ * The match is intentionally strict (whole-message, case-insensitive,
+ * surrounding whitespace allowed) so normal conversation that mentions
+ * "analysis" or "as you were" inside a sentence does not flip the flag.
+ */
+export declare function parseAnalysisToken(text: string | undefined | null): AnalysisToken;
+/**
+ * Per-room analysis-mode flag store. Process-local. One instance per
+ * runtime is sufficient — the runtime should hold it as a singleton on
+ * a known property (e.g. `runtime.analysisModeFlags`) once wired.
+ */
+export declare class AnalysisModeFlagStore {
+    private readonly flags;
+    private readonly ttlMs;
+    private readonly now;
+    constructor(options?: AnalysisModeOptions);
+    enable(roomId: string): AnalysisModeState;
+    disable(roomId: string): void;
+    /**
+     * Read the current state. Returns false if disabled, never set, or
+     * expired (and clears the entry on read in the expired case).
+     */
+    isEnabled(roomId: string): boolean;
+    /** Apply a parsed token to the store. Returns the new enabled state. */
+    applyToken(roomId: string, token: AnalysisToken): boolean;
+    /** Test helper. */
+    size(): number;
+    /** Test helper. */
+    clear(): void;
+}
+/**
+ * Gate analysis-mode payload emission. Returns true only when:
+ *   - the operator has explicitly opted in via env, OR
+ *   - we are in NODE_ENV=development AND the source is loopback API.
+ *
+ * The runtime wiring (not yet implemented) MUST consult this before
+ * attaching any sidecar. Sidecars contain raw thinking, evaluator
+ * output, and prompt fragments — never forward to remote connectors.
+ */
+export declare function isAnalysisModeAllowed(env?: NodeJS.ProcessEnv): boolean;
+//# sourceMappingURL=analysis-mode-flag.d.ts.map

package/dist/packages/agent/src/runtime/analysis-mode-flag.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analysis-mode-flag.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/analysis-mode-flag.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAKH,MAAM,MAAM,aAAa,GAAG,QAAQ,GAAG,SAAS,GAAG,IAAI,CAAC;AAExD,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,2EAA2E;IAC3E,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,mBAAmB;IAClC;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,qCAAqC;IACrC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;CACpB;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,GAC9B,aAAa,CAKf;AAED;;;;GAIG;AACH,qBAAa,qBAAqB;IAChC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAwC;IAC9D,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAqB;IAC3C,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAe;gBAEvB,OAAO,GAAE,mBAAwB;IAK7C,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,iBAAiB;IAczC,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAI7B;;;OAGG;IACH,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAUlC,wEAAwE;IACxE,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,GAAG,OAAO;IAYzD,mBAAmB;IACnB,IAAI,IAAI,MAAM;IAId,mBAAmB;IACnB,KAAK,IAAI,IAAI;CAGd;AAED;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CACnC,GAAG,GAAE,MAAM,CAAC,UAAwB,GACnC,OAAO,CAIT"}

package/dist/packages/agent/src/runtime/analysis-mode-flag.js

@@ -0,0 +1,131 @@
+/**
+ * Analysis mode (Westworld nod) — per-room debug flag.
+ *
+ * When a user types `analysis` in chat, that conversation flips into
+ * analysis mode: subsequent assistant turns attach a structured debug
+ * sidecar (thinking, planned actions, simple-mode flag, evaluator output,
+ * followup decision) to the response. The user types `as you were` to
+ * disable it.
+ *
+ * SCAFFOLD ONLY. The runtime has not yet been wired to consult this flag
+ * or attach the sidecar. This module exists so the activation parsing,
+ * lifetime, and gating logic are pinned down with tests before the
+ * cross-cutting integration is written. See
+ * `/tmp/lifeops-assessment/15-analysis-mode.md` for the full design.
+ *
+ * Privacy contract:
+ *   - Analysis sidecars contain raw thinking, prompt fragments, evaluator
+ *     output (facts/relationships about real people), and follow-up timing.
+ *     They MUST NOT be forwarded to remote chat surfaces (Telegram,
+ *     Discord, WeChat, etc.).
+ *   - `isAnalysisModeAllowed()` returns false unless the runtime is local
+ *     (loopback API) AND development mode is on, OR the operator opted in
+ *     via `MILADY_ENABLE_ANALYSIS_MODE=1`.
+ *
+ * Storage:
+ *   - In-memory `Map<roomId, AnalysisModeState>`. Process-local.
+ *     Restarts clear the flag — that is intentional. Analysis mode is a
+ *     transient debug toggle, not a persisted preference. If we later
+ *     decide to persist it, write to `Room.metadata.analysisMode`, not
+ *     to a new table.
+ */
+const ANALYSIS_TOKEN = /^\s*analysis\s*$/i;
+const AS_YOU_WERE_TOKEN = /^\s*as\s+you\s+were\s*$/i;
+/**
+ * Detect activation tokens. Returns:
+ *   - "enable"  for messages whose entire text is the literal `analysis`
+ *   - "disable" for messages whose entire text is the literal `as you were`
+ *   - null      otherwise
+ *
+ * The match is intentionally strict (whole-message, case-insensitive,
+ * surrounding whitespace allowed) so normal conversation that mentions
+ * "analysis" or "as you were" inside a sentence does not flip the flag.
+ */
+export function parseAnalysisToken(text) {
+    if (typeof text !== "string")
+        return null;
+    if (ANALYSIS_TOKEN.test(text))
+        return "enable";
+    if (AS_YOU_WERE_TOKEN.test(text))
+        return "disable";
+    return null;
+}
+/**
+ * Per-room analysis-mode flag store. Process-local. One instance per
+ * runtime is sufficient — the runtime should hold it as a singleton on
+ * a known property (e.g. `runtime.analysisModeFlags`) once wired.
+ */
+export class AnalysisModeFlagStore {
+    flags = new Map();
+    ttlMs;
+    now;
+    constructor(options = {}) {
+        this.ttlMs = options.ttlMs;
+        this.now = options.now ?? Date.now;
+    }
+    enable(roomId) {
+        const enabledAt = this.now();
+        const state = {
+            enabled: true,
+            enabledAt,
+            expiresAt: typeof this.ttlMs === "number" && this.ttlMs > 0
+                ? enabledAt + this.ttlMs
+                : undefined,
+        };
+        this.flags.set(roomId, state);
+        return state;
+    }
+    disable(roomId) {
+        this.flags.delete(roomId);
+    }
+    /**
+     * Read the current state. Returns false if disabled, never set, or
+     * expired (and clears the entry on read in the expired case).
+     */
+    isEnabled(roomId) {
+        const state = this.flags.get(roomId);
+        if (!state)
+            return false;
+        if (typeof state.expiresAt === "number" && state.expiresAt <= this.now()) {
+            this.flags.delete(roomId);
+            return false;
+        }
+        return state.enabled;
+    }
+    /** Apply a parsed token to the store. Returns the new enabled state. */
+    applyToken(roomId, token) {
+        if (token === "enable") {
+            this.enable(roomId);
+            return true;
+        }
+        if (token === "disable") {
+            this.disable(roomId);
+            return false;
+        }
+        return this.isEnabled(roomId);
+    }
+    /** Test helper. */
+    size() {
+        return this.flags.size;
+    }
+    /** Test helper. */
+    clear() {
+        this.flags.clear();
+    }
+}
+/**
+ * Gate analysis-mode payload emission. Returns true only when:
+ *   - the operator has explicitly opted in via env, OR
+ *   - we are in NODE_ENV=development AND the source is loopback API.
+ *
+ * The runtime wiring (not yet implemented) MUST consult this before
+ * attaching any sidecar. Sidecars contain raw thinking, evaluator
+ * output, and prompt fragments — never forward to remote connectors.
+ */
+export function isAnalysisModeAllowed(env = process.env) {
+    if (env.MILADY_ENABLE_ANALYSIS_MODE === "1")
+        return true;
+    if (env.MILADY_ENABLE_ANALYSIS_MODE === "0")
+        return false;
+    return env.NODE_ENV === "development";
+}

package/dist/packages/agent/src/runtime/android-app-plugins.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Android-only overlay-app runtime plugin registration.
+ *
+ * This file is only a mobile bundle escape hatch: it imports the runtime
+ * owning app package barrels, applies the agent-side hosted app session gate,
+ * and pins those modules into STATIC_ELIZA_PLUGINS for the custom AOSP bundle.
+ * The action/provider implementations live in `plugins/app-{wifi,contacts,phone}`
+ * so desktop/server builds do not carry duplicate Android stubs here.
+ */
+export declare const appWifiPlugin: import("@elizaos/core").Plugin;
+export declare const appContactsPlugin: import("@elizaos/core").Plugin;
+export declare const appPhonePlugin: import("@elizaos/core").Plugin;
+//# sourceMappingURL=android-app-plugins.d.ts.map

package/dist/packages/agent/src/runtime/android-app-plugins.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"android-app-plugins.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/android-app-plugins.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAsBH,eAAO,MAAM,aAAa,gCAGzB,CAAC;AACF,eAAO,MAAM,iBAAiB,gCAG7B,CAAC;AACF,eAAO,MAAM,cAAc,gCAG1B,CAAC"}

package/dist/packages/agent/src/runtime/android-app-plugins.js

@@ -0,0 +1,48 @@
+/**
+ * Android-only overlay-app runtime plugin registration.
+ *
+ * This file is only a mobile bundle escape hatch: it imports the runtime
+ * owning app package barrels, applies the agent-side hosted app session gate,
+ * and pins those modules into STATIC_ELIZA_PLUGINS for the custom AOSP bundle.
+ * The action/provider implementations live in `plugins/app-{wifi,contacts,phone}`
+ * so desktop/server builds do not carry duplicate Android stubs here.
+ */
+import { contactsProvider, appContactsPlugin as rawContactsPlugin, } from "@elizaos/app-contacts";
+import { phoneCallLogProvider, placeCallAction, appPhonePlugin as rawPhonePlugin, } from "@elizaos/app-phone";
+import { appWifiPlugin as rawWifiPlugin, wifiNetworksProvider, } from "@elizaos/app-wifi";
+import { gatePluginSessionForHostedApp } from "../services/app-session-gate.js";
+import { STATIC_ELIZA_PLUGINS } from "./plugin-types.js";
+const WIFI_APP_NAME = "@elizaos/app-wifi";
+const CONTACTS_APP_NAME = "@elizaos/app-contacts";
+const PHONE_APP_NAME = "@elizaos/app-phone";
+export const appWifiPlugin = gatePluginSessionForHostedApp(rawWifiPlugin, WIFI_APP_NAME);
+export const appContactsPlugin = gatePluginSessionForHostedApp(rawContactsPlugin, CONTACTS_APP_NAME);
+export const appPhonePlugin = gatePluginSessionForHostedApp(rawPhonePlugin, PHONE_APP_NAME);
+const appWifiPluginModule = {
+    default: appWifiPlugin,
+    appWifiPlugin,
+    wifiNetworksProvider,
+};
+const appContactsPluginModule = {
+    default: appContactsPlugin,
+    appContactsPlugin,
+    contactsProvider,
+};
+const appPhonePluginModule = {
+    default: appPhonePlugin,
+    appPhonePlugin,
+    placeCallAction,
+    phoneCallLogProvider,
+};
+Object.assign(STATIC_ELIZA_PLUGINS, {
+    [WIFI_APP_NAME]: appWifiPluginModule,
+    [CONTACTS_APP_NAME]: appContactsPluginModule,
+    [PHONE_APP_NAME]: appPhonePluginModule,
+});
+// Pin to globalThis so Bun.build's tree-shaker keeps the symbols even though
+// the runtime resolves plugins by name.
+globalThis.__elizaAndroidAppPlugins = {
+    wifi: appWifiPluginModule,
+    contacts: appContactsPluginModule,
+    phone: appPhonePluginModule,
+};