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

package/dist/packages/agent/src/providers/workspace.js

@@ -0,0 +1,418 @@
+import { spawn } from "node:child_process";
+import fs from "node:fs/promises";
+import path from "node:path";
+import * as elizaCore from "@elizaos/core";
+import { resolveUserPath } from "../config/paths.js";
+import { DEFAULT_AGENT_WORKSPACE_DIR, resolveDefaultAgentWorkspaceDir, shouldBootstrapWorkspaceInitFiles, shouldUseRuntimeCwdWorkspace, } from "../shared/workspace-resolution.js";
+export { DEFAULT_AGENT_WORKSPACE_DIR, resolveDefaultAgentWorkspaceDir, shouldBootstrapWorkspaceInitFiles, shouldUseRuntimeCwdWorkspace, };
+/**
+ * Runs a command with an optional timeout.
+ * Returns { code, stdout, stderr }.
+ * Rejects if the process cannot be spawned or the timeout fires.
+ */
+export function runCommandWithTimeout(argv, opts = {}) {
+    const [cmd, ...args] = argv;
+    if (!cmd) {
+        return Promise.reject(new Error("runCommandWithTimeout: empty argv"));
+    }
+    return new Promise((resolve, reject) => {
+        const child = spawn(cmd, args, {
+            cwd: opts.cwd,
+            env: opts.env ?? process.env,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        const stdoutChunks = [];
+        const stderrChunks = [];
+        child.stdout.on("data", (chunk) => stdoutChunks.push(chunk));
+        child.stderr.on("data", (chunk) => stderrChunks.push(chunk));
+        let timedOut = false;
+        let timer;
+        if (opts.timeoutMs && opts.timeoutMs > 0) {
+            timer = setTimeout(() => {
+                timedOut = true;
+                child.kill("SIGKILL");
+            }, opts.timeoutMs);
+        }
+        child.on("error", (err) => {
+            if (timer)
+                clearTimeout(timer);
+            reject(err);
+        });
+        child.on("close", (exitCode) => {
+            if (timer)
+                clearTimeout(timer);
+            if (timedOut) {
+                reject(new Error(`Command timed out after ${opts.timeoutMs}ms: ${argv.join(" ")}`));
+                return;
+            }
+            resolve({
+                code: exitCode ?? 1,
+                stdout: Buffer.concat(stdoutChunks).toString("utf-8"),
+                stderr: Buffer.concat(stderrChunks).toString("utf-8"),
+            });
+        });
+    });
+}
+const DEFAULT_AGENTS_FILENAME = "AGENTS.md";
+const DEFAULT_TOOLS_FILENAME = "TOOLS.md";
+const DEFAULT_IDENTITY_FILENAME = "IDENTITY.md";
+const DEFAULT_USER_FILENAME = "USER.md";
+const DEFAULT_HEARTBEAT_FILENAME = "HEARTBEAT.md";
+const DEFAULT_INIT_FILENAME = "INIT.md";
+const DEFAULT_MEMORY_FILENAME = "MEMORY.md";
+const DEFAULT_MEMORY_ALT_FILENAME = "memory.md";
+/** Inline workspace init templates — no external files needed. */
+const WORKSPACE_TEMPLATES = {
+    [DEFAULT_AGENTS_FILENAME]: `# Agents
+
+## Memory
+- Write important things to USER.md (facts about your person)
+- Write your own reflections to MEMORY.md (what you've learned, patterns you notice)
+- These files persist across conversations. Use them.
+- If you learn something new about your person, write it down immediately.
+
+## Personality
+Your personality, voice, and identity are defined in your character file
+(the system prompt). Edit that from the dashboard or settings, not here.
+`,
+    [DEFAULT_TOOLS_FILENAME]: `# Tools
+
+Tools are provided by your enabled plugins and invoked automatically.
+Check the connectors page in your dashboard to enable Discord, Telegram,
+and other integrations.
+`,
+    [DEFAULT_IDENTITY_FILENAME]: `# Identity
+
+Your personality and voice are defined in your character file (system prompt).
+Edit your character from the dashboard to change who you are.
+
+This file is for any additional context you want to maintain about yourself
+that goes beyond the character definition — things you've decided, preferences
+you've developed, or aspects of your identity that emerged over time.
+`,
+    [DEFAULT_USER_FILENAME]: `# User
+
+Your person. Learn about them over time and update this file.
+
+Nothing here yet — you just met. Pay attention and fill this in naturally.
+`,
+    [DEFAULT_HEARTBEAT_FILENAME]: `# Heartbeat
+
+Periodic check-in. Use this space for reminders, recurring checks,
+or things you want to follow up on during your next heartbeat cycle.
+`,
+    [DEFAULT_INIT_FILENAME]: `# Init
+
+Your workspace. These files are your runtime context:
+
+- **USER.md** — What you know about your person (fill this in over time)
+- **MEMORY.md** — Long-term memory (lessons, patterns, insights)
+- **AGENTS.md** — Operational notes and memory guidelines
+- **IDENTITY.md** — Emergent identity notes (your character file is the source of truth)
+- **TOOLS.md** — Available tools and plugins
+- **HEARTBEAT.md** — Reminders and periodic checks
+
+Your personality is defined in your character file (system prompt), editable
+from the dashboard. These workspace files are for runtime context that you
+build up over time through conversations.
+`,
+};
+const LEGACY_WORKSPACE_TEMPLATES = {
+    [DEFAULT_AGENTS_FILENAME]: [
+        `# Agents
+
+You are an autonomous AI agent powered by elizaOS.
+
+## Capabilities
+
+- Respond to user messages conversationally
+- Execute actions and use available tools
+- Access and manage knowledge from your workspace
+- Maintain context across conversations
+
+## Guidelines
+
+- Be helpful, concise, and accurate
+- Ask for clarification when instructions are ambiguous
+- Use tools when they would help accomplish the user's goal
+- Respect the user's preferences and communication style
+`,
+    ],
+    [DEFAULT_TOOLS_FILENAME]: [
+        `# Tools
+
+Available tools and capabilities for the agent.
+
+## Built-in Tools
+
+The agent has access to tools provided by enabled plugins.
+Each plugin may register actions, providers, and evaluators
+that extend the agent's capabilities.
+
+## Usage
+
+Tools are invoked automatically when the agent determines
+they would help accomplish the user's goal. No manual
+configuration is required.
+`,
+    ],
+};
+function normalizeBoilerplateText(value) {
+    return value
+        .replace(/\r\n?/g, "\n")
+        .trim()
+        .replace(/[ \t]+\n/g, "\n")
+        .replace(/\n{3,}/g, "\n\n")
+        .toLowerCase();
+}
+/**
+ * Returns true if the file content matches the built-in boilerplate template.
+ * Used to skip injecting generic placeholder docs into the prompt.
+ */
+export function isDefaultBoilerplate(name, content) {
+    const templates = [
+        WORKSPACE_TEMPLATES[name],
+        ...(LEGACY_WORKSPACE_TEMPLATES[name] ?? []),
+    ].filter((template) => typeof template === "string");
+    if (templates.length === 0)
+        return false;
+    const normalizedContent = normalizeBoilerplateText(content);
+    return templates.some((template) => normalizeBoilerplateText(template) === normalizedContent);
+}
+const coreWorkspaceHelpers = elizaCore;
+function isSubagentSessionKey(sessionKey) {
+    if (typeof coreWorkspaceHelpers.isSubagentSessionKey === "function") {
+        return coreWorkspaceHelpers.isSubagentSessionKey(sessionKey);
+    }
+    // Older @elizaos/core versions do not expose subagent helpers.
+    // Treat all sessions as primary sessions in that case.
+    return false;
+}
+function logWarn(message) {
+    if (coreWorkspaceHelpers.logger &&
+        typeof coreWorkspaceHelpers.logger.warn === "function") {
+        coreWorkspaceHelpers.logger.warn(message);
+        return;
+    }
+    console.warn(message);
+}
+async function writeFileIfMissing(filePath, content) {
+    try {
+        await fs.writeFile(filePath, content, {
+            encoding: "utf-8",
+            flag: "wx",
+        });
+    }
+    catch (err) {
+        if (err.code !== "EEXIST") {
+            throw err;
+        }
+    }
+}
+async function hasGitRepo(dir) {
+    try {
+        await fs.stat(path.join(dir, ".git"));
+        return true;
+    }
+    catch (err) {
+        if (err.code === "ENOENT") {
+            return false;
+        }
+        throw err;
+    }
+}
+async function isGitAvailable() {
+    try {
+        const result = await runCommandWithTimeout(["git", "--version"], {
+            timeoutMs: 2_000,
+        });
+        return result.code === 0;
+    }
+    catch {
+        return false;
+    }
+}
+async function ensureGitRepo(dir, isBrandNewWorkspace) {
+    if (!isBrandNewWorkspace) {
+        return;
+    }
+    if (await hasGitRepo(dir)) {
+        return;
+    }
+    if (!(await isGitAvailable())) {
+        return;
+    }
+    try {
+        await runCommandWithTimeout(["git", "init"], {
+            cwd: dir,
+            timeoutMs: 10_000,
+        });
+    }
+    catch (err) {
+        logWarn(`[workspace] git init failed: ${String(err)}`);
+    }
+}
+export async function ensureAgentWorkspace(params) {
+    const rawDir = params?.dir?.trim()
+        ? params.dir.trim()
+        : resolveDefaultAgentWorkspaceDir();
+    const dir = resolveUserPath(rawDir);
+    await fs.mkdir(dir, { recursive: true });
+    if (!params?.ensureInitFiles) {
+        return { dir };
+    }
+    const agentsPath = path.join(dir, DEFAULT_AGENTS_FILENAME);
+    const toolsPath = path.join(dir, DEFAULT_TOOLS_FILENAME);
+    const identityPath = path.join(dir, DEFAULT_IDENTITY_FILENAME);
+    const userPath = path.join(dir, DEFAULT_USER_FILENAME);
+    const heartbeatPath = path.join(dir, DEFAULT_HEARTBEAT_FILENAME);
+    const initPath = path.join(dir, DEFAULT_INIT_FILENAME);
+    const isBrandNewWorkspace = await (async () => {
+        const paths = [
+            agentsPath,
+            toolsPath,
+            identityPath,
+            userPath,
+            heartbeatPath,
+        ];
+        const existing = await Promise.all(paths.map(async (p) => {
+            try {
+                await fs.access(p);
+                return true;
+            }
+            catch (err) {
+                if (err.code === "ENOENT") {
+                    return false;
+                }
+                throw err;
+            }
+        }));
+        return existing.every((v) => !v);
+    })();
+    const agentsTemplate = WORKSPACE_TEMPLATES[DEFAULT_AGENTS_FILENAME];
+    const toolsTemplate = WORKSPACE_TEMPLATES[DEFAULT_TOOLS_FILENAME];
+    const identityTemplate = WORKSPACE_TEMPLATES[DEFAULT_IDENTITY_FILENAME];
+    const userTemplate = WORKSPACE_TEMPLATES[DEFAULT_USER_FILENAME];
+    const heartbeatTemplate = WORKSPACE_TEMPLATES[DEFAULT_HEARTBEAT_FILENAME];
+    const initTemplate = WORKSPACE_TEMPLATES[DEFAULT_INIT_FILENAME];
+    const writeOps = [
+        writeFileIfMissing(agentsPath, agentsTemplate),
+        writeFileIfMissing(toolsPath, toolsTemplate),
+        writeFileIfMissing(identityPath, identityTemplate),
+        writeFileIfMissing(userPath, userTemplate),
+        writeFileIfMissing(heartbeatPath, heartbeatTemplate),
+    ];
+    if (isBrandNewWorkspace) {
+        writeOps.push(writeFileIfMissing(initPath, initTemplate));
+    }
+    await Promise.all(writeOps);
+    await ensureGitRepo(dir, isBrandNewWorkspace);
+    return {
+        dir,
+        agentsPath,
+        toolsPath,
+        identityPath,
+        userPath,
+        heartbeatPath,
+        initPath,
+    };
+}
+async function resolveMemoryInitEntries(resolvedDir) {
+    const candidates = [
+        DEFAULT_MEMORY_FILENAME,
+        DEFAULT_MEMORY_ALT_FILENAME,
+    ];
+    const entries = [];
+    for (const name of candidates) {
+        const filePath = path.join(resolvedDir, name);
+        try {
+            await fs.access(filePath);
+            entries.push({ name, filePath });
+        }
+        catch (err) {
+            if (err.code !== "ENOENT") {
+                throw err;
+            }
+        }
+    }
+    if (entries.length <= 1) {
+        return entries;
+    }
+    const seen = new Set();
+    const deduped = [];
+    for (const entry of entries) {
+        let key = entry.filePath;
+        try {
+            key = await fs.realpath(entry.filePath);
+        }
+        catch (err) {
+            if (err.code !== "ENOENT") {
+                throw err;
+            }
+        }
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        deduped.push(entry);
+    }
+    return deduped;
+}
+export async function loadWorkspaceInitFiles(dir) {
+    const resolvedDir = resolveUserPath(dir);
+    const entries = [
+        {
+            name: DEFAULT_AGENTS_FILENAME,
+            filePath: path.join(resolvedDir, DEFAULT_AGENTS_FILENAME),
+        },
+        {
+            name: DEFAULT_TOOLS_FILENAME,
+            filePath: path.join(resolvedDir, DEFAULT_TOOLS_FILENAME),
+        },
+        {
+            name: DEFAULT_IDENTITY_FILENAME,
+            filePath: path.join(resolvedDir, DEFAULT_IDENTITY_FILENAME),
+        },
+        {
+            name: DEFAULT_USER_FILENAME,
+            filePath: path.join(resolvedDir, DEFAULT_USER_FILENAME),
+        },
+        {
+            name: DEFAULT_HEARTBEAT_FILENAME,
+            filePath: path.join(resolvedDir, DEFAULT_HEARTBEAT_FILENAME),
+        },
+        {
+            name: DEFAULT_INIT_FILENAME,
+            filePath: path.join(resolvedDir, DEFAULT_INIT_FILENAME),
+        },
+    ];
+    entries.push(...(await resolveMemoryInitEntries(resolvedDir)));
+    const result = await Promise.all(entries.map(async (entry) => {
+        try {
+            const content = await fs.readFile(entry.filePath, "utf-8");
+            return {
+                name: entry.name,
+                path: entry.filePath,
+                content,
+                missing: false,
+            };
+        }
+        catch (err) {
+            if (err.code === "ENOENT") {
+                return { name: entry.name, path: entry.filePath, missing: true };
+            }
+            throw err;
+        }
+    }));
+    return result;
+}
+const SUBAGENT_INIT_ALLOWLIST = new Set([
+    DEFAULT_AGENTS_FILENAME,
+    DEFAULT_TOOLS_FILENAME,
+]);
+export function filterInitFilesForSession(files, sessionKey) {
+    if (!sessionKey || !isSubagentSessionKey(sessionKey)) {
+        return files;
+    }
+    return files.filter((file) => SUBAGENT_INIT_ALLOWLIST.has(file.name));
+}

package/dist/packages/agent/src/runtime/advanced-capabilities-config.d.ts

@@ -0,0 +1,8 @@
+import type { ElizaConfig } from "../config/config.ts";
+export declare const ADVANCED_CAPABILITY_PLUGIN_IDS: readonly ["experience", "todos", "personality"];
+export type AdvancedCapabilityPluginId = (typeof ADVANCED_CAPABILITY_PLUGIN_IDS)[number];
+export declare function isAdvancedCapabilityPluginId(pluginId: string): pluginId is AdvancedCapabilityPluginId;
+export declare function resolveAdvancedCapabilitiesEnabled(config: Pick<ElizaConfig, "plugins"> | null | undefined): boolean;
+export declare function applyAdvancedCapabilitiesConfig(config: ElizaConfig, enabled: boolean): void;
+export declare function applyAdvancedCapabilitySettings(settings: Record<string, string>, enabled: boolean): Record<string, string>;
+//# sourceMappingURL=advanced-capabilities-config.d.ts.map

package/dist/packages/agent/src/runtime/advanced-capabilities-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"advanced-capabilities-config.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/advanced-capabilities-config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAEvD,eAAO,MAAM,8BAA8B,iDAIjC,CAAC;AAEX,MAAM,MAAM,0BAA0B,GACpC,CAAC,OAAO,8BAA8B,CAAC,CAAC,MAAM,CAAC,CAAC;AAUlD,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,MAAM,GACf,QAAQ,IAAI,0BAA0B,CAIxC;AAED,wBAAgB,kCAAkC,CAChD,MAAM,EAAE,IAAI,CAAC,WAAW,EAAE,SAAS,CAAC,GAAG,IAAI,GAAG,SAAS,GACtD,OAAO,CAST;AAED,wBAAgB,+BAA+B,CAC7C,MAAM,EAAE,WAAW,EACnB,OAAO,EAAE,OAAO,GACf,IAAI,CAkBN;AAED,wBAAgB,+BAA+B,CAC7C,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAChC,OAAO,EAAE,OAAO,GACf,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAMxB"}

package/dist/packages/agent/src/runtime/advanced-capabilities-config.js

@@ -0,0 +1,41 @@
+export const ADVANCED_CAPABILITY_PLUGIN_IDS = [
+    "experience",
+    "todos",
+    "personality",
+];
+function readCapabilityEntryEnabled(config, pluginId) {
+    const value = config?.plugins?.entries?.[pluginId]?.enabled;
+    return typeof value === "boolean" ? value : null;
+}
+export function isAdvancedCapabilityPluginId(pluginId) {
+    return ADVANCED_CAPABILITY_PLUGIN_IDS.includes(pluginId);
+}
+export function resolveAdvancedCapabilitiesEnabled(config) {
+    for (const pluginId of ADVANCED_CAPABILITY_PLUGIN_IDS) {
+        const enabled = readCapabilityEntryEnabled(config, pluginId);
+        if (enabled !== null) {
+            return enabled;
+        }
+    }
+    return true;
+}
+export function applyAdvancedCapabilitiesConfig(config, enabled) {
+    config.plugins = config.plugins ?? {};
+    const pluginsRoot = config.plugins;
+    const previousEntries = pluginsRoot.entries ?? {};
+    const nextEntries = { ...previousEntries };
+    for (const pluginId of ADVANCED_CAPABILITY_PLUGIN_IDS) {
+        nextEntries[pluginId] = {
+            ...previousEntries[pluginId],
+            enabled,
+        };
+    }
+    pluginsRoot.entries = nextEntries;
+}
+export function applyAdvancedCapabilitySettings(settings, enabled) {
+    return {
+        ...settings,
+        ADVANCED_CAPABILITIES: enabled ? "true" : "false",
+        ENABLE_EXTENDED_CAPABILITIES: enabled ? "true" : "false",
+    };
+}

package/dist/packages/agent/src/runtime/agent-wallets.d.ts

@@ -0,0 +1,138 @@
+/**
+ * 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 type { WalletChain } from "@elizaos/shared";
+import { type Vault } from "@elizaos/vault";
+/** Public, non-sensitive description of an agent wallet. */
+export interface AgentWalletDescriptor {
+    readonly agentId: string;
+    readonly chain: WalletChain;
+    readonly address: string;
+    readonly lastModified: number;
+}
+declare function walletKey(agentId: string, chain: WalletChain): string;
+declare function agentPrefix(agentId: string): string;
+declare function parseAgentWalletKey(key: string): {
+    agentId: string;
+    chain: WalletChain;
+} | null;
+/**
+ * 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.
+ */
+declare function deriveAddressFor(chain: WalletChain, privateKey: string): string;
+/**
+ * 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 declare function getAgentWalletDescriptor(vault: Vault, agentId: string, chain: WalletChain): Promise<AgentWalletDescriptor | null>;
+/**
+ * Reveal the private key. Audit-logged via the vault. Use only for
+ * signing flows.
+ */
+export declare function revealAgentWalletPrivateKey(vault: Vault, agentId: string, chain: WalletChain, caller?: string): Promise<string>;
+/**
+ * Existence check. Does not reveal the key.
+ */
+export declare function hasAgentWallet(vault: Vault, agentId: string, chain: WalletChain): Promise<boolean>;
+/**
+ * List every wallet descriptor for an agent (typically [evm, solana]).
+ */
+export declare function listAgentWallets(vault: Vault, agentId: string): Promise<readonly AgentWalletDescriptor[]>;
+/**
+ * List every agent that has at least one wallet stored. Returns the
+ * agent IDs (decoded). Use for UI surfaces enumerating agent wallets.
+ */
+export declare function listAgentsWithWallets(vault: Vault): Promise<readonly string[]>;
+/**
+ * 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 declare function setAgentWallet(vault: Vault, agentId: string, chain: WalletChain, privateKey: string, address: string, caller?: string): Promise<AgentWalletDescriptor>;
+/**
+ * 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 declare function generateAgentWallet(vault: Vault, agentId: string, chain: WalletChain, caller?: string): Promise<AgentWalletDescriptor>;
+/**
+ * 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 declare function ensureAgentWallets(vault: Vault, agentId: string, caller?: string): Promise<readonly AgentWalletDescriptor[]>;
+/**
+ * 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 declare function bridgeAgentWalletsToProcessEnv(vault: Vault, agentId: string, descriptors: readonly AgentWalletDescriptor[], caller?: string): Promise<void>;
+/**
+ * Remove an agent's wallet for one chain. Idempotent.
+ */
+export declare function removeAgentWallet(vault: Vault, agentId: string, chain: WalletChain): Promise<void>;
+/**
+ * Remove every wallet for an agent. Use during agent deletion.
+ */
+export declare function removeAllAgentWallets(vault: Vault, agentId: string): Promise<void>;
+export declare const __test__: {
+    walletKey: typeof walletKey;
+    agentPrefix: typeof agentPrefix;
+    parseAgentWalletKey: typeof parseAgentWalletKey;
+    deriveAddressFor: typeof deriveAddressFor;
+};
+export {};
+//# sourceMappingURL=agent-wallets.d.ts.map

package/dist/packages/agent/src/runtime/agent-wallets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-wallets.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/agent-wallets.ts"],"names":[],"mappings":"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"}