@elizaos/agent 2.0.0-alpha.98 → 2.0.0-beta.2

package/packages/agent/src/runtime/aosp-dflash-adapter.d.ts

@@ -0,0 +1,99 @@
+/**
+ * AOSP DFlash adapter.
+ *
+ * Spawns the bundled `llama-server` binary (cross-compiled per ABI by
+ * `eliza/packages/app-core/scripts/aosp/compile-libllama.mjs` and staged
+ * by `stage-android-agent.mjs` into `assets/agent/<abi>/llama-server`) and
+ * routes inference over loopback HTTP using the same OpenAI-shaped request
+ * shape that the host-side `dflash-server.ts` already speaks.
+ *
+ * Why a separate file:
+ *   The in-process FFI adapter (`AospLlamaAdapter` in `aosp-llama-adapter.ts`)
+ *   talks to a single libllama.so context and does not have a draft-model
+ *   API surface. DFlash speculative decoding wants `--model <target.gguf>
+ *   --model-draft <drafter.gguf>` on the same llama.cpp process, which the
+ *   server binary already wires up via the upstream `common_speculative_*`
+ *   helpers. Rather than re-bind the speculative C API through the shim
+ *   (path b in the porting plan), we cross-compile llama-server itself and
+ *   have bun spawn it as a child process (path a — "cheaper to validate;
+ *   path b is the production answer"). The tok/s number we capture here
+ *   informs whether path b is worth the shim work.
+ *
+ * Activation:
+ *   - `AospLlamaLoadOptions.draftModelPath` is set, OR
+ *   - `ELIZA_DFLASH=1` env var is set AND the catalog entry for the
+ *     loaded target advertises `runtime.dflash.drafterModelId`.
+ *
+ * Lifecycle:
+ *   - `loadModel({ modelPath, draftModelPath, ... })` allocates a free
+ *     loopback port, spawns `<abiAssetDir>/llama-server` with `--model`,
+ *     `--model-draft`, `--spec-type dflash`, `--port`, `--host 127.0.0.1`,
+ *     and waits for `GET /health` to return 200.
+ *   - `generate({ prompt, ... })` POSTs to `/v1/chat/completions` and
+ *     returns the assistant content.
+ *   - `unloadModel()` SIGTERMs the child, waits up to 5s for graceful exit,
+ *     then SIGKILLs.
+ *   - `embed()` is NOT supported on this backend — embeddings go through
+ *     the in-process FFI adapter or plugin-local-embedding. The dispatcher
+ *     in `registerAospLlamaLoader` keeps the FFI adapter active for embed
+ *     calls and only routes generate() to DFlash when a drafter is paired.
+ *
+ * What this is NOT:
+ *   This adapter does not duplicate the catalog/cache logic from
+ *   `dflash-server.ts`. The host-side service handles desktop/CUDA/Metal
+ *   DFlash and pulls catalog entries from registry. On AOSP we have a
+ *   single target+drafter pair per chat session, no slot-save-path (the
+ *   APK private dir is the only writable disk anyway), and no model-hash
+ *   caching across restarts (cold start re-spawns llama-server). Keeping
+ *   this file standalone means no transitive imports from app-core into
+ *   the agent bundle.
+ */
+export interface DflashLoadOptions {
+    modelPath: string;
+    draftModelPath: string;
+    contextSize?: number;
+    draftContextSize?: number;
+    draftMin?: number;
+    draftMax?: number;
+    cacheTypeK?: string;
+    cacheTypeV?: string;
+    disableThinking?: boolean;
+}
+export interface DflashGenerateOptions {
+    prompt: string;
+    stopSequences?: string[];
+    maxTokens?: number;
+    temperature?: number;
+}
+export interface DflashAdapter {
+    loadModel(args: DflashLoadOptions): Promise<void>;
+    unloadModel(): Promise<void>;
+    currentModelPath(): string | null;
+    generate(args: DflashGenerateOptions): Promise<string>;
+}
+/**
+ * Resolve `<abiAssetDir>/llama-server` for the current ABI. Mirrors
+ * `resolveAbiDir` in aosp-llama-adapter.ts but kept local so this file has
+ * no cross-module coupling beyond the @elizaos/core logger.
+ */
+export declare function resolveLlamaServerPath(arch?: NodeJS.Architecture, cwd?: string): string;
+/**
+ * Build a DFlash adapter pinned to the per-ABI llama-server binary in the
+ * agent's cwd. Returns null when the binary isn't present (graceful
+ * degradation — the caller falls back to the FFI single-model path).
+ */
+export declare function buildDflashAdapter(arch?: NodeJS.Architecture, cwd?: string): DflashAdapter | null;
+/**
+ * Decide whether a `loadModel` call should route through the DFlash
+ * adapter. True when:
+ *   - The caller passed `draftModelPath` explicitly, OR
+ *   - `ELIZA_DFLASH=1` is set in env (catalog has paired the model already
+ *     at the dispatch layer).
+ *
+ * Exported so the dispatcher in registerAospLlamaLoader can apply the same
+ * rule without re-implementing it.
+ */
+export declare function shouldRouteViaDflash(args: {
+    draftModelPath?: string;
+}): boolean;
+//# sourceMappingURL=aosp-dflash-adapter.d.ts.map

package/packages/agent/src/runtime/aosp-dflash-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aosp-dflash-adapter.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/aosp-dflash-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AAWH,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,aAAa;IAC5B,SAAS,CAAC,IAAI,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAClD,WAAW,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7B,gBAAgB,IAAI,MAAM,GAAG,IAAI,CAAC;IAClC,QAAQ,CAAC,IAAI,EAAE,qBAAqB,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CACxD;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CACpC,IAAI,GAAE,MAAM,CAAC,YAA2B,EACxC,GAAG,GAAE,MAAsB,GAC1B,MAAM,CASR;AAoQD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,GAAE,MAAM,CAAC,YAA2B,EACxC,GAAG,GAAE,MAAsB,GAC1B,aAAa,GAAG,IAAI,CAwBtB;AAED;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE;IACzC,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB,GAAG,OAAO,CAIV"}

package/packages/agent/src/runtime/aosp-dflash-adapter.js

@@ -0,0 +1,332 @@
+/**
+ * AOSP DFlash adapter.
+ *
+ * Spawns the bundled `llama-server` binary (cross-compiled per ABI by
+ * `eliza/packages/app-core/scripts/aosp/compile-libllama.mjs` and staged
+ * by `stage-android-agent.mjs` into `assets/agent/<abi>/llama-server`) and
+ * routes inference over loopback HTTP using the same OpenAI-shaped request
+ * shape that the host-side `dflash-server.ts` already speaks.
+ *
+ * Why a separate file:
+ *   The in-process FFI adapter (`AospLlamaAdapter` in `aosp-llama-adapter.ts`)
+ *   talks to a single libllama.so context and does not have a draft-model
+ *   API surface. DFlash speculative decoding wants `--model <target.gguf>
+ *   --model-draft <drafter.gguf>` on the same llama.cpp process, which the
+ *   server binary already wires up via the upstream `common_speculative_*`
+ *   helpers. Rather than re-bind the speculative C API through the shim
+ *   (path b in the porting plan), we cross-compile llama-server itself and
+ *   have bun spawn it as a child process (path a — "cheaper to validate;
+ *   path b is the production answer"). The tok/s number we capture here
+ *   informs whether path b is worth the shim work.
+ *
+ * Activation:
+ *   - `AospLlamaLoadOptions.draftModelPath` is set, OR
+ *   - `ELIZA_DFLASH=1` env var is set AND the catalog entry for the
+ *     loaded target advertises `runtime.dflash.drafterModelId`.
+ *
+ * Lifecycle:
+ *   - `loadModel({ modelPath, draftModelPath, ... })` allocates a free
+ *     loopback port, spawns `<abiAssetDir>/llama-server` with `--model`,
+ *     `--model-draft`, `--spec-type dflash`, `--port`, `--host 127.0.0.1`,
+ *     and waits for `GET /health` to return 200.
+ *   - `generate({ prompt, ... })` POSTs to `/v1/chat/completions` and
+ *     returns the assistant content.
+ *   - `unloadModel()` SIGTERMs the child, waits up to 5s for graceful exit,
+ *     then SIGKILLs.
+ *   - `embed()` is NOT supported on this backend — embeddings go through
+ *     the in-process FFI adapter or plugin-local-embedding. The dispatcher
+ *     in `registerAospLlamaLoader` keeps the FFI adapter active for embed
+ *     calls and only routes generate() to DFlash when a drafter is paired.
+ *
+ * What this is NOT:
+ *   This adapter does not duplicate the catalog/cache logic from
+ *   `dflash-server.ts`. The host-side service handles desktop/CUDA/Metal
+ *   DFlash and pulls catalog entries from registry. On AOSP we have a
+ *   single target+drafter pair per chat session, no slot-save-path (the
+ *   APK private dir is the only writable disk anyway), and no model-hash
+ *   caching across restarts (cold start re-spawns llama-server). Keeping
+ *   this file standalone means no transitive imports from app-core into
+ *   the agent bundle.
+ */
+import { spawn as spawnChild } from "node:child_process";
+import { existsSync, statSync } from "node:fs";
+import net from "node:net";
+import path from "node:path";
+import { logger } from "@elizaos/core";
+const DFLASH_HOST = "127.0.0.1";
+const DEFAULT_START_TIMEOUT_MS = 60_000;
+/**
+ * Resolve `<abiAssetDir>/llama-server` for the current ABI. Mirrors
+ * `resolveAbiDir` in aosp-llama-adapter.ts but kept local so this file has
+ * no cross-module coupling beyond the @elizaos/core logger.
+ */
+export function resolveLlamaServerPath(arch = process.arch, cwd = process.cwd()) {
+    const abiDir = arch === "arm64" ? "arm64-v8a" : arch === "x64" ? "x86_64" : null;
+    if (abiDir === null) {
+        throw new Error(`[aosp-dflash] Unsupported process.arch for AOSP build: ${arch}`);
+    }
+    return path.join(cwd, abiDir, "llama-server");
+}
+function findFreePort() {
+    return new Promise((resolve, reject) => {
+        const server = net.createServer();
+        server.unref();
+        server.on("error", reject);
+        server.listen(0, DFLASH_HOST, () => {
+            const address = server.address();
+            server.close(() => {
+                if (address && typeof address === "object") {
+                    resolve(address.port);
+                }
+                else {
+                    reject(new Error("[aosp-dflash] Could not allocate a loopback port for llama-server"));
+                }
+            });
+        });
+    });
+}
+async function sleep(ms) {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function waitForHealth(baseUrl, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    let lastError = null;
+    while (Date.now() < deadline) {
+        try {
+            const res = await fetch(`${baseUrl}/health`, {
+                method: "GET",
+            });
+            if (res.ok)
+                return;
+            lastError = new Error(`HTTP ${res.status}`);
+        }
+        catch (err) {
+            lastError = err;
+        }
+        await sleep(500);
+    }
+    const detail = lastError instanceof Error ? lastError.message : String(lastError);
+    throw new Error(`[aosp-dflash] llama-server did not become healthy within ${timeoutMs}ms (${detail})`);
+}
+class AospDflashAdapter {
+    child = null;
+    baseUrl = null;
+    loadedTarget = null;
+    loadedDrafter = null;
+    llamaServerPath;
+    libDir;
+    stderrTail = [];
+    constructor(llamaServerPath) {
+        this.llamaServerPath = llamaServerPath;
+        this.libDir = path.dirname(llamaServerPath);
+    }
+    currentModelPath() {
+        return this.loadedTarget;
+    }
+    async loadModel(args) {
+        if (this.child &&
+            this.loadedTarget === args.modelPath &&
+            this.loadedDrafter === args.draftModelPath) {
+            return;
+        }
+        await this.unloadModel();
+        if (!existsSync(args.modelPath)) {
+            throw new Error(`[aosp-dflash] Target model not found: ${args.modelPath}`);
+        }
+        if (!existsSync(args.draftModelPath)) {
+            throw new Error(`[aosp-dflash] Drafter model not found: ${args.draftModelPath}`);
+        }
+        if (!existsSync(this.llamaServerPath)) {
+            throw new Error(`[aosp-dflash] llama-server binary not found at ${this.llamaServerPath}. ` +
+                `Rebuild with \`node packages/app-core/scripts/aosp/compile-libllama.mjs\`.`);
+        }
+        const port = await findFreePort();
+        const baseUrl = `http://${DFLASH_HOST}:${port}`;
+        const argv = [
+            "--model",
+            args.modelPath,
+            "--model-draft",
+            args.draftModelPath,
+            "--spec-type",
+            "dflash",
+            "--host",
+            DFLASH_HOST,
+            "--port",
+            String(port),
+            "--ctx-size",
+            String(args.contextSize ?? 4096),
+            "--ctx-size-draft",
+            String(args.draftContextSize ?? args.contextSize ?? 4096),
+            "--draft-min",
+            String(args.draftMin ?? 4),
+            "--draft-max",
+            String(args.draftMax ?? 16),
+            "--n-gpu-layers",
+            "0",
+            "--n-gpu-layers-draft",
+            "0",
+            "--metrics",
+            "--jinja",
+        ];
+        if (args.disableThinking) {
+            argv.push("--reasoning", "off");
+        }
+        if (args.cacheTypeK)
+            argv.push("--cache-type-k", args.cacheTypeK);
+        if (args.cacheTypeV)
+            argv.push("--cache-type-v", args.cacheTypeV);
+        logger.info(`[aosp-dflash] Spawning llama-server: ${this.llamaServerPath} ${argv.join(" ")}`);
+        // LD_LIBRARY_PATH must include the per-ABI asset dir so llama-server
+        // resolves its NEEDED libllama.so + libggml*.so siblings the same way
+        // the in-process FFI loader does.
+        const env = {
+            ...process.env,
+            LD_LIBRARY_PATH: this.libDir,
+        };
+        const child = spawnChild(this.llamaServerPath, argv, {
+            env,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        this.child = child;
+        child.stderr?.setEncoding("utf8");
+        child.stdout?.setEncoding("utf8");
+        child.stderr?.on("data", (chunk) => {
+            const lines = chunk.split(/\r?\n/);
+            for (const line of lines) {
+                if (!line.trim())
+                    continue;
+                this.stderrTail.push(line);
+                if (this.stderrTail.length > 200)
+                    this.stderrTail.shift();
+                logger.debug(`[aosp-dflash] llama-server stderr: ${line}`);
+            }
+        });
+        child.stdout?.on("data", (chunk) => {
+            const lines = chunk.split(/\r?\n/);
+            for (const line of lines) {
+                if (!line.trim())
+                    continue;
+                logger.debug(`[aosp-dflash] llama-server stdout: ${line}`);
+            }
+        });
+        let exitedEarly = null;
+        child.on("exit", (code, signal) => {
+            exitedEarly = { code, signal };
+            this.child = null;
+            this.baseUrl = null;
+        });
+        try {
+            await waitForHealth(baseUrl, DEFAULT_START_TIMEOUT_MS);
+        }
+        catch (err) {
+            const tail = this.stderrTail.slice(-10).join("\n");
+            const exitDetail = exitedEarly
+                ? ` (process exited with code=${exitedEarly.code} signal=${exitedEarly.signal})`
+                : "";
+            throw new Error(`${err instanceof Error ? err.message : String(err)}${exitDetail}\n` +
+                `--- llama-server stderr tail ---\n${tail}`);
+        }
+        this.baseUrl = baseUrl;
+        this.loadedTarget = args.modelPath;
+        this.loadedDrafter = args.draftModelPath;
+        logger.info(`[aosp-dflash] llama-server ready at ${baseUrl} (target=${path.basename(args.modelPath)}, drafter=${path.basename(args.draftModelPath)})`);
+    }
+    async unloadModel() {
+        const child = this.child;
+        if (!child)
+            return;
+        this.child = null;
+        this.baseUrl = null;
+        this.loadedTarget = null;
+        this.loadedDrafter = null;
+        if (!child.killed && child.exitCode === null) {
+            child.kill("SIGTERM");
+            const exited = await Promise.race([
+                new Promise((resolve) => child.once("exit", () => resolve())),
+                sleep(5000).then(() => false),
+            ]);
+            if (exited === false) {
+                try {
+                    child.kill("SIGKILL");
+                }
+                catch {
+                    // ignore — process may have just exited
+                }
+            }
+        }
+    }
+    async generate(args) {
+        if (!this.child || !this.baseUrl) {
+            throw new Error("[aosp-dflash] generate called before loadModel");
+        }
+        const url = `${this.baseUrl}/v1/chat/completions`;
+        const body = {
+            messages: [{ role: "user", content: args.prompt }],
+            temperature: args.temperature ?? 0.7,
+            max_tokens: args.maxTokens ?? 512,
+            stop: args.stopSequences ?? [],
+            stream: false,
+        };
+        const res = await fetch(url, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify(body),
+        });
+        if (!res.ok) {
+            const errBody = await res.text().catch(() => "");
+            throw new Error(`[aosp-dflash] llama-server returned HTTP ${res.status}: ${errBody}`);
+        }
+        const json = (await res.json());
+        const content = json.choices?.[0]?.message?.content;
+        if (typeof content !== "string") {
+            throw new Error(`[aosp-dflash] llama-server returned no content: ${JSON.stringify(json).slice(0, 300)}`);
+        }
+        return content;
+    }
+}
+/**
+ * Build a DFlash adapter pinned to the per-ABI llama-server binary in the
+ * agent's cwd. Returns null when the binary isn't present (graceful
+ * degradation — the caller falls back to the FFI single-model path).
+ */
+export function buildDflashAdapter(arch = process.arch, cwd = process.cwd()) {
+    let llamaServerPath;
+    try {
+        llamaServerPath = resolveLlamaServerPath(arch, cwd);
+    }
+    catch {
+        return null;
+    }
+    if (!existsSync(llamaServerPath)) {
+        return null;
+    }
+    // Sanity check the binary is executable. statSync doesn't have an isExec
+    // helper in node fs, so we mask the mode bits ourselves.
+    try {
+        const mode = statSync(llamaServerPath).mode;
+        if ((mode & 0o111) === 0) {
+            logger.warn(`[aosp-dflash] ${llamaServerPath} is not executable (mode=${mode.toString(8)}); refusing to spawn.`);
+            return null;
+        }
+    }
+    catch {
+        return null;
+    }
+    return new AospDflashAdapter(llamaServerPath);
+}
+/**
+ * Decide whether a `loadModel` call should route through the DFlash
+ * adapter. True when:
+ *   - The caller passed `draftModelPath` explicitly, OR
+ *   - `ELIZA_DFLASH=1` is set in env (catalog has paired the model already
+ *     at the dispatch layer).
+ *
+ * Exported so the dispatcher in registerAospLlamaLoader can apply the same
+ * rule without re-implementing it.
+ */
+export function shouldRouteViaDflash(args) {
+    if (args.draftModelPath)
+        return true;
+    const env = process.env.ELIZA_DFLASH?.trim().toLowerCase();
+    return env === "1" || env === "true" || env === "yes";
+}

package/packages/agent/src/runtime/build-character-config.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=build-character-config.d.ts.map

package/packages/agent/src/runtime/build-character-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-character-config.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/build-character-config.ts"],"names":[],"mappings":""}

package/packages/agent/src/runtime/build-character-config.js

@@ -0,0 +1,176 @@
+import { defaultCharacterSystemTemplate, mergeCharacterDefaults, } from "@elizaos/core";
+import { getDefaultStylePreset, normalizeCharacterLanguage, resolveStylePresetByAvatarIndex, resolveStylePresetById, resolveStylePresetByName, } from "@elizaos/shared";
+import { applyAdvancedCapabilitySettings, resolveAdvancedCapabilitiesEnabled, } from "./advanced-capabilities-config.js";
+/**
+ * Build a Character object from the runtime ElizaConfig.
+ *
+ * The character is the initial runtime identity — name, bio, system prompt,
+ * secrets, and capability settings. It is NOT the persisted agent record in the
+ * database — not the config file — so we only provide sensible defaults here
+ * for the initial setup.
+ */
+/** @internal Exported for testing. */
+export function buildCharacterFromConfig(config) {
+    const agentEntry = config.agents?.list?.[0];
+    const uiConfig = (config.ui ?? {});
+    const language = normalizeCharacterLanguage(uiConfig.language);
+    const configuredUiName = uiConfig.assistant?.name?.trim();
+    const configuredAgentName = agentEntry?.name?.trim();
+    // Prefer the UI-level assistant name when it diverges from the bundled
+    // preset entry so renames take effect immediately across prompts/logging.
+    const configuredName = configuredUiName || configuredAgentName;
+    const bundledPreset = resolveStylePresetById(uiConfig.presetId, language) ??
+        resolveStylePresetByAvatarIndex(uiConfig.avatarIndex, language) ??
+        resolveStylePresetByName(configuredName, language) ??
+        (configuredName ? undefined : getDefaultStylePreset(language));
+    const name = configuredName ??
+        bundledPreset?.name ??
+        getDefaultStylePreset(language).name;
+    const bio = agentEntry?.bio ??
+        bundledPreset?.bio ?? [
+        "{{name}} is an AI assistant powered by Eliza and elizaOS.",
+    ];
+    const systemPrompt = agentEntry?.system ??
+        bundledPreset?.system ??
+        defaultCharacterSystemTemplate;
+    const style = agentEntry?.style ?? bundledPreset?.style;
+    const adjectives = agentEntry?.adjectives ?? bundledPreset?.adjectives;
+    const topics = agentEntry?.topics && agentEntry.topics.length > 0
+        ? agentEntry.topics
+        : bundledPreset?.topics;
+    const postExamples = agentEntry?.postExamples ?? bundledPreset?.postExamples;
+    const messageExamples = agentEntry?.messageExamples ?? bundledPreset?.messageExamples;
+    const advancedMemory = agentEntry?.advancedMemory ??
+        config.agents?.defaults?.advancedMemory ??
+        true;
+    const advancedCapabilitiesEnabled = resolveAdvancedCapabilitiesEnabled(config);
+    const settings = applyAdvancedCapabilitySettings({
+        MEMORY_SUMMARY_MODEL_TYPE: process.env.MEMORY_SUMMARY_MODEL_TYPE?.trim() || "TEXT_SMALL",
+        MEMORY_REFLECTION_MODEL_TYPE: process.env.MEMORY_REFLECTION_MODEL_TYPE?.trim() || "TEXT_LARGE",
+    }, advancedCapabilitiesEnabled);
+    // Collect secrets from process.env (API keys the plugins need)
+    const secretKeys = [
+        "ANTHROPIC_API_KEY",
+        "OPENAI_API_KEY",
+        "GEMINI_API_KEY",
+        "GOOGLE_API_KEY",
+        "GOOGLE_GENERATIVE_AI_API_KEY",
+        "GROQ_API_KEY",
+        "XAI_API_KEY",
+        "OPENROUTER_API_KEY",
+        "AI_GATEWAY_API_KEY",
+        "AIGATEWAY_API_KEY",
+        "AI_GATEWAY_BASE_URL",
+        "AI_GATEWAY_SMALL_MODEL",
+        "AI_GATEWAY_LARGE_MODEL",
+        "AI_GATEWAY_EMBEDDING_MODEL",
+        "AI_GATEWAY_EMBEDDING_DIMENSIONS",
+        "AI_GATEWAY_IMAGE_MODEL",
+        "AI_GATEWAY_TIMEOUT_MS",
+        "OLLAMA_BASE_URL",
+        "DISCORD_API_TOKEN",
+        "DISCORD_APPLICATION_ID",
+        "DISCORD_BOT_TOKEN",
+        "TELEGRAM_BOT_TOKEN",
+        "WHATSAPP_ACCESS_TOKEN",
+        "WHATSAPP_PHONE_NUMBER_ID",
+        "WHATSAPP_AUTH_DIR",
+        "WHATSAPP_SESSION_PATH",
+        "WHATSAPP_WEBHOOK_VERIFY_TOKEN",
+        "WHATSAPP_API_VERSION",
+        "WHATSAPP_DM_POLICY",
+        "WHATSAPP_GROUP_POLICY",
+        "WHATSAPP_ALLOW_FROM",
+        "WHATSAPP_GROUP_ALLOW_FROM",
+        "TELEGRAM_ACCOUNT_PHONE",
+        "TELEGRAM_ACCOUNT_APP_ID",
+        "TELEGRAM_ACCOUNT_APP_HASH",
+        "TELEGRAM_ACCOUNT_DEVICE_MODEL",
+        "TELEGRAM_ACCOUNT_SYSTEM_VERSION",
+        "SLACK_BOT_TOKEN",
+        "SLACK_APP_TOKEN",
+        "SLACK_USER_TOKEN",
+        "SIGNAL_ACCOUNT_NUMBER",
+        "MSTEAMS_APP_ID",
+        "MSTEAMS_APP_PASSWORD",
+        "MATTERMOST_BOT_TOKEN",
+        "MATTERMOST_BASE_URL",
+        // ElizaCloud secrets
+        "ELIZAOS_CLOUD_API_KEY",
+        "ELIZAOS_CLOUD_BASE_URL",
+        "ELIZAOS_CLOUD_ENABLED",
+        // Wallet / blockchain secrets
+        "EVM_PRIVATE_KEY",
+        "SOLANA_PRIVATE_KEY",
+        "ALCHEMY_API_KEY",
+        "HELIUS_API_KEY",
+        "BIRDEYE_API_KEY",
+        "SOLANA_RPC_URL",
+        "X402_PRIVATE_KEY",
+        "X402_NETWORK",
+        "X402_PAY_TO",
+        "X402_FACILITATOR_URL",
+        "X402_MAX_PAYMENT_USD",
+        "X402_MAX_TOTAL_USD",
+        "X402_ENABLED",
+        "X402_DB_PATH",
+        // GitHub access for coding agent plugin
+        "GITHUB_TOKEN",
+        "GITHUB_OAUTH_CLIENT_ID",
+    ];
+    const secrets = {};
+    for (const key of secretKeys) {
+        const value = process.env[key];
+        if (value?.trim()) {
+            secrets[key] = value;
+        }
+    }
+    // Normalise messageExamples to the {examples: [{name,content}]} shape
+    // that @elizaos/core expects.  Config may contain EITHER format:
+    //   OLD (preset/onboarding): [[{user, content}, ...], ...]
+    //   NEW (@elizaos/core):     [{examples: [{name, content}, ...]}, ...]
+    const mappedExamples = messageExamples?.map((item) => {
+        // Already in new format — pass through
+        if (item &&
+            typeof item === "object" &&
+            "examples" in item) {
+            return item;
+        }
+        // Old format — array of {user, content} entries
+        const arr = item;
+        return {
+            examples: arr.map((msg) => ({
+                name: msg.name ?? msg.user ?? "",
+                content: msg.content,
+            })),
+        };
+    });
+    // Capability hints — append short descriptions of features the runtime has
+    // auto-enabled so the model knows about new actions/tools without requiring
+    // the user to hand-edit the system prompt. Kept terse (one sentence per
+    // capability) to stay out of the way of the preset's voice.
+    const capabilityHints = [];
+    const workflowMasterEnabled = config.workflow?.enabled !== false;
+    const workflowExplicitlyDisabled = config.plugins?.entries?.workflow?.enabled === false;
+    if (workflowMasterEnabled && !workflowExplicitlyDisabled) {
+        capabilityHints.push("You can create, activate, deactivate, and delete workflows via natural language using the workflow actions.");
+    }
+    capabilityHints.push("You have a persistent task manager and can create scheduled or one-off tasks when the user asks; do not claim you lack tasks, memory, persistence, or scheduling when those actions are available.");
+    const effectiveSystemPrompt = capabilityHints.length > 0
+        ? `${systemPrompt}\n\n${capabilityHints.join("\n")}`
+        : systemPrompt;
+    return mergeCharacterDefaults({
+        name,
+        ...(agentEntry?.username ? { username: agentEntry.username } : {}),
+        bio,
+        system: effectiveSystemPrompt,
+        ...(topics ? { topics } : {}),
+        ...(style ? { style } : {}),
+        ...(adjectives ? { adjectives } : {}),
+        ...(postExamples ? { postExamples } : {}),
+        ...(mappedExamples ? { messageExamples: mappedExamples } : {}),
+        advancedMemory,
+        settings,
+        secrets,
+    });
+}