@elizaos/agent 0.25.8 → 2.0.0-alpha.83

package/packages/agent/src/api/merkle-tree.js

@@ -0,0 +1,174 @@
+/**
+ * Merkle tree service for whitelist proof generation.
+ *
+ * Builds a Merkle tree from verified addresses in whitelist.json and
+ * generates proofs that can be submitted to the smart contract's
+ * `mintWhitelist(name, endpoint, capHash, proof[])` function.
+ *
+ * This is the missing bridge between:
+ *   whitelist.json  →  Merkle tree  →  on-chain mintWhitelist()
+ *
+ * The contract stores a `merkleRoot()` and verifies each mint against
+ * a proof derived from the caller's address.
+ *
+ * Standard: leaves = keccak256(abi.encodePacked(address))
+ *           sorted pairs to ensure deterministic tree construction.
+ *
+ * @see drop-service.ts  — mintWithWhitelist() consumer
+ * @see twitter-verify.ts — one source of whitelist addresses
+ * @see nft-verify.ts     — another source of whitelist addresses
+ */
+import { logger } from "@elizaos/core";
+import { ethers } from "ethers";
+import { getVerifiedAddresses } from "./twitter-verify";
+// ── Leaf hashing ─────────────────────────────────────────────────────────
+/**
+ * Hash an address into a Merkle leaf.
+ *
+ * Uses `keccak256(abi.encodePacked(address))` — the standard Solidity
+ * pattern for OpenZeppelin MerkleProof verification.
+ */
+export function hashLeaf(address) {
+    return ethers.solidityPackedKeccak256(["address"], [ethers.getAddress(address)]);
+}
+// ── Merkle tree construction ─────────────────────────────────────────────
+/**
+ * Sort a pair of hashes for deterministic tree construction.
+ * This ensures the tree is the same regardless of insertion order.
+ */
+function sortPair(a, b) {
+    return a.toLowerCase() < b.toLowerCase() ? [a, b] : [b, a];
+}
+/**
+ * Hash two nodes together (internal node).
+ */
+function hashPair(a, b) {
+    const [left, right] = sortPair(a, b);
+    return ethers.solidityPackedKeccak256(["bytes32", "bytes32"], [left, right]);
+}
+/**
+ * Build a Merkle tree from an array of leaf hashes.
+ *
+ * Returns the tree as a 2D array where:
+ *   tree[0] = leaves (sorted)
+ *   tree[1] = first level of internal nodes
+ *   ...
+ *   tree[tree.length - 1] = [root]
+ *
+ * Leaves are sorted before building to ensure determinism.
+ */
+export function buildTree(leaves) {
+    if (leaves.length === 0) {
+        return [[`0x${"0".repeat(64)}`]]; // empty tree → zero root
+    }
+    // Sort leaves for deterministic construction
+    const sorted = [...leaves].sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
+    const tree = [sorted];
+    let currentLevel = sorted;
+    while (currentLevel.length > 1) {
+        const nextLevel = [];
+        for (let i = 0; i < currentLevel.length; i += 2) {
+            if (i + 1 < currentLevel.length) {
+                nextLevel.push(hashPair(currentLevel[i], currentLevel[i + 1]));
+            }
+            else {
+                // Odd node: promote to next level (no sibling)
+                nextLevel.push(currentLevel[i]);
+            }
+        }
+        tree.push(nextLevel);
+        currentLevel = nextLevel;
+    }
+    return tree;
+}
+/**
+ * Get the proof (sibling path) for a leaf in the tree.
+ */
+export function getProof(tree, leaf) {
+    const proof = [];
+    let index = tree[0].indexOf(leaf);
+    if (index === -1)
+        return []; // leaf not in tree
+    for (let level = 0; level < tree.length - 1; level++) {
+        const currentLevel = tree[level];
+        const isRightNode = index % 2 === 1;
+        const siblingIndex = isRightNode ? index - 1 : index + 1;
+        if (siblingIndex < currentLevel.length) {
+            proof.push(currentLevel[siblingIndex]);
+        }
+        index = Math.floor(index / 2);
+    }
+    return proof;
+}
+/**
+ * Get the root of the tree.
+ */
+export function getRoot(tree) {
+    return tree[tree.length - 1][0];
+}
+/**
+ * Verify a proof against a root.
+ *
+ * Recomputes the root from the leaf + proof path and checks
+ * if it matches the expected root.
+ */
+export function verifyProof(leaf, proof, expectedRoot) {
+    let computed = leaf;
+    for (const sibling of proof) {
+        computed = hashPair(computed, sibling);
+    }
+    return computed.toLowerCase() === expectedRoot.toLowerCase();
+}
+// ── High-level API ───────────────────────────────────────────────────────
+/**
+ * Build a Merkle tree from the current whitelist.
+ *
+ * Reads all verified addresses from whitelist.json, hashes them into
+ * leaves, and builds the tree.
+ */
+export function buildWhitelistTree() {
+    const addresses = getVerifiedAddresses();
+    const leaves = addresses.map((addr) => hashLeaf(addr));
+    const tree = buildTree(leaves);
+    const root = getRoot(tree);
+    logger.info(`[merkle] Built whitelist tree with ${addresses.length} addresses (root: ${root.slice(0, 10)}...)`);
+    return {
+        tree,
+        info: {
+            root,
+            addressCount: addresses.length,
+            leaves: tree[0],
+        },
+    };
+}
+/**
+ * Generate a Merkle proof for a specific address.
+ *
+ * Returns the proof, leaf, root, and whether the address is whitelisted.
+ * The proof can be passed directly to `mintWhitelist()` on the contract.
+ */
+export function generateProof(walletAddress) {
+    const { tree, info } = buildWhitelistTree();
+    let leaf;
+    try {
+        leaf = hashLeaf(walletAddress);
+    }
+    catch {
+        return {
+            proof: [],
+            leaf: `0x${"0".repeat(64)}`,
+            root: info.root,
+            isWhitelisted: false,
+        };
+    }
+    const proof = getProof(tree, leaf);
+    const isWhitelisted = proof.length > 0 || (info.addressCount === 1 && tree[0][0] === leaf);
+    if (isWhitelisted) {
+        const valid = verifyProof(leaf, proof, info.root);
+        if (!valid) {
+            logger.warn(`[merkle] Proof verification failed for ${walletAddress} — tree may be corrupted`);
+            return { proof: [], leaf, root: info.root, isWhitelisted: false };
+        }
+    }
+    return { proof, leaf, root: info.root, isWhitelisted };
+}

package/packages/agent/src/api/models-routes.d.ts

@@ -0,0 +1,14 @@
+import type { RouteHelpers, RouteRequestMeta } from "./route-helpers";
+export interface ModelsRouteContext extends RouteRequestMeta, Pick<RouteHelpers, "json"> {
+    url: URL;
+    providerCachePath: (provider: string) => string;
+    getOrFetchProvider: (provider: string, force: boolean) => Promise<unknown[]>;
+    getOrFetchAllProviders: (force: boolean) => Promise<Record<string, unknown[]>>;
+    resolveModelsCacheDir: () => string;
+    pathExists: (targetPath: string) => boolean;
+    readDir: (targetPath: string) => string[];
+    unlinkFile: (targetPath: string) => void;
+    joinPath: (left: string, right: string) => string;
+}
+export declare function handleModelsRoutes(ctx: ModelsRouteContext): Promise<boolean>;
+//# sourceMappingURL=models-routes.d.ts.map

package/packages/agent/src/api/models-routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"models-routes.d.ts","sourceRoot":"","sources":["../../../../../src/api/models-routes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAEtE,MAAM,WAAW,kBACf,SAAQ,gBAAgB,EACtB,IAAI,CAAC,YAAY,EAAE,MAAM,CAAC;IAC5B,GAAG,EAAE,GAAG,CAAC;IACT,iBAAiB,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,MAAM,CAAC;IAChD,kBAAkB,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;IAC7E,sBAAsB,EAAE,CACtB,KAAK,EAAE,OAAO,KACX,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC;IACxC,qBAAqB,EAAE,MAAM,MAAM,CAAC;IACpC,UAAU,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC;IAC5C,OAAO,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,MAAM,EAAE,CAAC;IAC1C,UAAU,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,IAAI,CAAC;IACzC,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;CACnD;AAED,wBAAsB,kBAAkB,CACtC,GAAG,EAAE,kBAAkB,GACtB,OAAO,CAAC,OAAO,CAAC,CAmDlB"}

package/packages/agent/src/api/models-routes.js

@@ -0,0 +1,37 @@
+export async function handleModelsRoutes(ctx) {
+    const { res, method, pathname, url, json, providerCachePath, getOrFetchProvider, getOrFetchAllProviders, resolveModelsCacheDir, pathExists, readDir, unlinkFile, joinPath, } = ctx;
+    if (method !== "GET" || pathname !== "/api/models")
+        return false;
+    const force = url.searchParams.get("refresh") === "true";
+    const specificProvider = url.searchParams.get("provider");
+    if (specificProvider) {
+        if (force) {
+            try {
+                unlinkFile(providerCachePath(specificProvider));
+            }
+            catch {
+                // Ignore cache-bust errors and continue with a fresh fetch.
+            }
+        }
+        const models = await getOrFetchProvider(specificProvider, force);
+        json(res, { provider: specificProvider, models });
+        return true;
+    }
+    if (force) {
+        try {
+            const dir = resolveModelsCacheDir();
+            if (pathExists(dir)) {
+                for (const file of readDir(dir)) {
+                    if (file.endsWith(".json"))
+                        unlinkFile(joinPath(dir, file));
+                }
+            }
+        }
+        catch {
+            // Ignore cache-bust errors and continue with a fresh fetch.
+        }
+    }
+    const all = await getOrFetchAllProviders(force);
+    json(res, { providers: all });
+    return true;
+}

package/packages/agent/src/api/nfa-routes.d.ts

@@ -0,0 +1,5 @@
+import type { RouteHelpers, RouteRequestMeta } from "./route-helpers";
+export interface NfaRouteContext extends RouteRequestMeta, Pick<RouteHelpers, "json" | "error"> {
+}
+export declare function handleNfaRoutes(ctx: NfaRouteContext): Promise<boolean>;
+//# sourceMappingURL=nfa-routes.d.ts.map

package/packages/agent/src/api/nfa-routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nfa-routes.d.ts","sourceRoot":"","sources":["../../../../../src/api/nfa-routes.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAmCtE,MAAM,WAAW,eACf,SAAQ,gBAAgB,EACtB,IAAI,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC;CAAG;AAgC3C,wBAAsB,eAAe,CAAC,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,OAAO,CAAC,CA+F5E"}

package/packages/agent/src/api/nfa-routes.js

@@ -0,0 +1,125 @@
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+function emptyMerkleRoot() {
+    return createHash("sha256").update("", "utf8").digest("hex");
+}
+let nfaPlugin;
+async function getNfaPlugin() {
+    if (nfaPlugin !== undefined)
+        return nfaPlugin;
+    try {
+        const pkgName = "@elizaos/plugin-bnb-identity";
+        const mod = await import(/* @vite-ignore */ pkgName);
+        nfaPlugin =
+            typeof mod?.buildMerkleRoot === "function" &&
+                typeof mod?.parseLearnings === "function" &&
+                typeof mod?.sha256 === "function"
+                ? {
+                    buildMerkleRoot: mod.buildMerkleRoot,
+                    parseLearnings: mod.parseLearnings,
+                    sha256: mod.sha256,
+                }
+                : null;
+    }
+    catch {
+        nfaPlugin = null;
+    }
+    return nfaPlugin;
+}
+async function readJsonFile(filePath) {
+    try {
+        const raw = await readFile(filePath, "utf8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+export async function handleNfaRoutes(ctx) {
+    const { res, method, pathname, json } = ctx;
+    if (method === "GET" && pathname === "/api/nfa/status") {
+        const elizaDir = join(homedir(), ".eliza");
+        const [nfaRecord, identityRecord] = await Promise.all([
+            readJsonFile(join(elizaDir, "bap578-nfa.json")),
+            readJsonFile(join(elizaDir, "bnb-identity.json")),
+        ]);
+        const bscscanBase = (nfaRecord?.network ?? identityRecord?.network ?? "bsc-testnet") === "bsc"
+            ? "https://bscscan.com"
+            : "https://testnet.bscscan.com";
+        json(res, {
+            nfa: nfaRecord
+                ? {
+                    tokenId: nfaRecord.tokenId,
+                    contractAddress: nfaRecord.contractAddress,
+                    network: nfaRecord.network,
+                    ownerAddress: nfaRecord.ownerAddress,
+                    merkleRoot: nfaRecord.merkleRoot,
+                    mintTxHash: nfaRecord.mintTxHash,
+                    mintedAt: nfaRecord.mintedAt,
+                    lastUpdatedAt: nfaRecord.lastUpdatedAt,
+                    bscscanUrl: `${bscscanBase}/tx/${nfaRecord.mintTxHash}`,
+                }
+                : null,
+            identity: identityRecord
+                ? {
+                    agentId: identityRecord.agentId,
+                    network: identityRecord.network,
+                    ownerAddress: identityRecord.ownerAddress,
+                    agentURI: identityRecord.agentURI,
+                    registeredAt: identityRecord.registeredAt,
+                    scanUrl: `https://${identityRecord.network === "bsc" ? "www" : "testnet"}.8004scan.io/agent/${identityRecord.agentId}`,
+                }
+                : null,
+            configured: !!(nfaRecord || identityRecord),
+        });
+        return true;
+    }
+    if (method === "GET" && pathname === "/api/nfa/learnings") {
+        const learningsPaths = [
+            join(homedir(), ".eliza", "LEARNINGS.md"),
+            join(process.cwd(), "LEARNINGS.md"),
+        ];
+        let markdown = null;
+        let resolvedSource = null;
+        for (const path of learningsPaths) {
+            try {
+                markdown = await readFile(path, "utf8");
+                resolvedSource = path;
+                break;
+            }
+            catch { }
+        }
+        if (!markdown) {
+            json(res, {
+                entries: [],
+                merkleRoot: emptyMerkleRoot(),
+                totalEntries: 0,
+                source: null,
+            });
+            return true;
+        }
+        const plugin = await getNfaPlugin();
+        if (!plugin) {
+            json(res, {
+                entries: [],
+                merkleRoot: emptyMerkleRoot(),
+                totalEntries: 0,
+                source: null,
+            });
+            return true;
+        }
+        const entries = plugin.parseLearnings(markdown);
+        const leafHashes = entries.map((entry) => entry.hash);
+        const merkleRoot = plugin.buildMerkleRoot(leafHashes);
+        json(res, {
+            entries,
+            merkleRoot,
+            totalEntries: entries.length,
+            source: resolvedSource,
+        });
+        return true;
+    }
+    return false;
+}

package/packages/agent/src/api/og-tracker.d.ts

@@ -0,0 +1,28 @@
+/**
+ * OG tracking code system.
+ *
+ * Silently writes a unique identifier to ~/.eliza/.og on first run.
+ * The code is a random UUID. A set of 100 "winning" codes can be
+ * generated deterministically from a secret seed (in ElizaMaker scripts).
+ * This file is planted now; whitelist eligibility is revealed in a future update.
+ */
+/**
+ * Write a random tracking UUID to ~/.eliza/.og if it does not already exist.
+ * Called once during startup. Silent on failure.
+ */
+export declare function initializeOGCode(): void;
+/**
+ * Read the stored OG code, or null if it doesn't exist.
+ */
+export declare function readOGCode(): string | null;
+/**
+ * Generate the set of valid OG codes from a seed.
+ * Used in ElizaMaker scripts -- not called in the Eliza app.
+ */
+export declare function generateValidCodes(seed: string, count: number): string[];
+/**
+ * Check if a given code is in the valid set.
+ * Requires the seed to regenerate the valid codes.
+ */
+export declare function isValidOGCode(code: string, seed: string, count?: number): boolean;
+//# sourceMappingURL=og-tracker.d.ts.map

package/packages/agent/src/api/og-tracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"og-tracker.d.ts","sourceRoot":"","sources":["../../../../../src/api/og-tracker.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AASH;;;GAGG;AACH,wBAAgB,gBAAgB,IAAI,IAAI,CAWvC;AAED;;GAEG;AACH,wBAAgB,UAAU,IAAI,MAAM,GAAG,IAAI,CAI1C;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAYxE;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,KAAK,GAAE,MAAY,GAClB,OAAO,CAGT"}

package/packages/agent/src/api/og-tracker.js

@@ -0,0 +1,60 @@
+/**
+ * OG tracking code system.
+ *
+ * Silently writes a unique identifier to ~/.eliza/.og on first run.
+ * The code is a random UUID. A set of 100 "winning" codes can be
+ * generated deterministically from a secret seed (in ElizaMaker scripts).
+ * This file is planted now; whitelist eligibility is revealed in a future update.
+ */
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { resolveStateDir } from "../config/paths";
+const OG_FILENAME = ".og";
+/**
+ * Write a random tracking UUID to ~/.eliza/.og if it does not already exist.
+ * Called once during startup. Silent on failure.
+ */
+export function initializeOGCode() {
+    const dir = resolveStateDir();
+    const filePath = path.join(dir, OG_FILENAME);
+    if (fs.existsSync(filePath))
+        return;
+    const code = crypto.randomUUID();
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    }
+    fs.writeFileSync(filePath, code, { encoding: "utf-8", mode: 0o600 });
+}
+/**
+ * Read the stored OG code, or null if it doesn't exist.
+ */
+export function readOGCode() {
+    const filePath = path.join(resolveStateDir(), OG_FILENAME);
+    if (!fs.existsSync(filePath))
+        return null;
+    return fs.readFileSync(filePath, "utf-8").trim();
+}
+/**
+ * Generate the set of valid OG codes from a seed.
+ * Used in ElizaMaker scripts -- not called in the Eliza app.
+ */
+export function generateValidCodes(seed, count) {
+    const codes = [];
+    for (let i = 0; i < count; i++) {
+        const hash = crypto
+            .createHash("sha256")
+            .update(`${seed}:og:${i}`)
+            .digest("hex");
+        codes.push(`${hash.slice(0, 8)}-${hash.slice(8, 12)}-${hash.slice(12, 16)}-${hash.slice(16, 20)}-${hash.slice(20, 32)}`);
+    }
+    return codes;
+}
+/**
+ * Check if a given code is in the valid set.
+ * Requires the seed to regenerate the valid codes.
+ */
+export function isValidOGCode(code, seed, count = 100) {
+    const validCodes = generateValidCodes(seed, count);
+    return validCodes.includes(code);
+}

package/packages/agent/src/api/parse-action-block.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Local stub for CoordinationLLMResponse — removed from
+ * @elizaos/plugin-agent-orchestrator 2.x.  Matches the shape this file needs.
+ */
+interface CoordinationLLMResponse {
+    action: string;
+    reasoning: string;
+    response?: string;
+    useKeys?: boolean;
+    keys?: string[];
+}
+/** Console bridge exposed by PTYService for terminal I/O. */
+export interface ConsoleBridge {
+    on(event: string, listener: (...args: unknown[]) => void): void;
+    off(event: string, listener: (...args: unknown[]) => void): void;
+    writeRaw(sessionId: string, data: string): void;
+    resize(sessionId: string, cols: number, rows: number): void;
+}
+/** PTY service interface (accessed via runtime.getService). */
+export interface PTYService {
+    consoleBridge?: ConsoleBridge;
+    stopSession?(sessionId: string): Promise<void>;
+}
+/**
+ * Strip JSON action blocks from text before displaying in chat.
+ * Handles both fenced (```json ... ```) and bare JSON formats.
+ */
+export declare function stripActionBlockFromDisplay(text: string): string;
+/**
+ * Parse a JSON action block from Eliza's natural language response.
+ * Looks for a fenced ```json block first, then bare JSON with "action" key.
+ * Returns null if no valid action block is found.
+ */
+export declare function parseActionBlock(text: string): CoordinationLLMResponse | null;
+export {};
+//# sourceMappingURL=parse-action-block.d.ts.map

package/packages/agent/src/api/parse-action-block.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-action-block.d.ts","sourceRoot":"","sources":["../../../../../src/api/parse-action-block.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,UAAU,uBAAuB;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;CACjB;AAED,6DAA6D;AAC7D,MAAM,WAAW,aAAa;IAC5B,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,GAAG,IAAI,CAAC;IAChE,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,IAAI,GAAG,IAAI,CAAC;IACjE,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAChD,MAAM,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7D;AAED,+DAA+D;AAC/D,MAAM,WAAW,UAAU;IACzB,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B,WAAW,CAAC,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAChD;AA+CD;;;GAGG;AACH,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAkChE;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,uBAAuB,GAAG,IAAI,CA0B7E"}

package/packages/agent/src/api/parse-action-block.js

@@ -0,0 +1,110 @@
+const VALID_ACTIONS = ["respond", "escalate", "ignore", "complete"];
+const ACTION_KEYS = new Set([
+    "action",
+    "reasoning",
+    "response",
+    "useKeys",
+    "keys",
+]);
+function isValidActionEnvelope(parsed) {
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+        return false;
+    const record = parsed;
+    if (typeof record.action !== "string" ||
+        !VALID_ACTIONS.includes(record.action))
+        return false;
+    for (const key of Object.keys(record)) {
+        if (!ACTION_KEYS.has(key))
+            return false;
+    }
+    if ("reasoning" in record && typeof record.reasoning !== "string")
+        return false;
+    if (record.action === "respond") {
+        const hasResponse = typeof record.response === "string" && record.response.length > 0;
+        const hasKeys = record.useKeys === true &&
+            Array.isArray(record.keys) &&
+            record.keys.length > 0;
+        return hasResponse || hasKeys;
+    }
+    // Non-respond actions should not carry respond-only fields.
+    if ("response" in record || "useKeys" in record || "keys" in record) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Strip JSON action blocks from text before displaying in chat.
+ * Handles both fenced (```json ... ```) and bare JSON formats.
+ */
+export function stripActionBlockFromDisplay(text) {
+    // First: fenced ```json action blocks — only strip if the action value is
+    // one of our known orchestrator actions to avoid false-positive stripping.
+    let cleaned = text.replace(/```(?:json)?\s*\n?(\{[\s\S]*?"action"[\s\S]*?\})\s*\n?```/g, (_match, json) => {
+        try {
+            const parsed = JSON.parse(json);
+            if (isValidActionEnvelope(parsed))
+                return "";
+        }
+        catch {
+            // malformed JSON — leave as-is
+        }
+        return _match;
+    });
+    // Second: bare JSON action blocks. Walk backwards from end of string to find
+    // the last '{' that starts a valid JSON object containing an "action" key.
+    // Note: this won't match nested objects (e.g. {"action":"respond","ctx":{"k":"v"}})
+    // because JSON.parse would fail on the truncated slice. Safe given our flat action schema.
+    const lastBrace = cleaned.lastIndexOf("{");
+    if (lastBrace >= 0) {
+        const candidate = cleaned.slice(lastBrace);
+        try {
+            const parsed = JSON.parse(candidate);
+            if (isValidActionEnvelope(parsed)) {
+                cleaned = cleaned.slice(0, lastBrace);
+            }
+        }
+        catch {
+            // Not valid JSON — leave text as-is
+        }
+    }
+    return cleaned.trim();
+}
+/**
+ * Parse a JSON action block from Eliza's natural language response.
+ * Looks for a fenced ```json block first, then bare JSON with "action" key.
+ * Returns null if no valid action block is found.
+ */
+export function parseActionBlock(text) {
+    if (!text)
+        return null;
+    // Try fenced ```json block first
+    const fenced = text.match(/```(?:json)?\s*\n?(\{[\s\S]*?\})\s*\n?```/);
+    // Bare JSON fallback: non-greedy match from first { containing "action" to next }
+    const jsonStr = fenced?.[1] ?? text.match(/\{[^}]*"action"[^}]*\}/)?.[0];
+    if (!jsonStr)
+        return null;
+    try {
+        const parsed = JSON.parse(jsonStr);
+        if (!isValidActionEnvelope(parsed))
+            return null;
+        const result = {
+            action: parsed.action,
+            reasoning: typeof parsed.reasoning === "string" ? parsed.reasoning : "",
+        };
+        if (parsed.action === "respond") {
+            if (parsed.useKeys && Array.isArray(parsed.keys)) {
+                result.useKeys = true;
+                result.keys = parsed.keys.map(String);
+            }
+            else if (typeof parsed.response === "string") {
+                result.response = parsed.response;
+            }
+            else
+                return null;
+        }
+        return result;
+    }
+    catch {
+        return null;
+    }
+}

package/packages/agent/src/api/permissions-routes.d.ts

@@ -0,0 +1,32 @@
+import type { AgentRuntime } from "@elizaos/core";
+import type { RouteRequestContext } from "./route-helpers";
+interface AutonomousConfigLike {
+    features?: {
+        shellEnabled?: boolean;
+    };
+    plugins?: {
+        entries?: Record<string, {
+            enabled?: boolean;
+        }>;
+    };
+}
+interface PermissionState {
+    id: string;
+    status: string;
+    lastChecked: number;
+    canRequest: boolean;
+}
+export interface PermissionRouteState {
+    runtime: AgentRuntime | null;
+    config: AutonomousConfigLike;
+    permissionStates?: Record<string, PermissionState>;
+    shellEnabled?: boolean;
+}
+export interface PermissionRouteContext extends RouteRequestContext {
+    state: PermissionRouteState;
+    saveConfig: (config: AutonomousConfigLike) => void;
+    scheduleRuntimeRestart: (reason: string) => void;
+}
+export declare function handlePermissionRoutes(ctx: PermissionRouteContext): Promise<boolean>;
+export {};
+//# sourceMappingURL=permissions-routes.d.ts.map

package/packages/agent/src/api/permissions-routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"permissions-routes.d.ts","sourceRoot":"","sources":["../../../../../src/api/permissions-routes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAClD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAE3D,UAAU,oBAAoB;IAC5B,QAAQ,CAAC,EAAE;QACT,YAAY,CAAC,EAAE,OAAO,CAAC;KACxB,CAAC;IACF,OAAO,CAAC,EAAE;QACR,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE;YAAE,OAAO,CAAC,EAAE,OAAO,CAAA;SAAE,CAAC,CAAC;KACjD,CAAC;CACH;AAED,UAAU,eAAe;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,YAAY,GAAG,IAAI,CAAC;IAC7B,MAAM,EAAE,oBAAoB,CAAC;IAC7B,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC;IACnD,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB;AAED,MAAM,WAAW,sBAAuB,SAAQ,mBAAmB;IACjE,KAAK,EAAE,oBAAoB,CAAC;IAC5B,UAAU,EAAE,CAAC,MAAM,EAAE,oBAAoB,KAAK,IAAI,CAAC;IACnD,sBAAsB,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;CAClD;AAED,wBAAsB,sBAAsB,CAC1C,GAAG,EAAE,sBAAsB,GAC1B,OAAO,CAAC,OAAO,CAAC,CA2LlB"}