miladyai 2.0.0-alpha.27

package/dist/providers/workspace.js

@@ -0,0 +1,348 @@
+import { resolveUserPath } from "../config/paths.js";
+import os from "node:os";
+import path from "node:path";
+import * as elizaCore from "@elizaos/core";
+import { spawn } from "node:child_process";
+import fs from "node:fs/promises";
+
+//#region src/providers/workspace.ts
+/**
+* Runs a command with an optional timeout.
+* Returns { code, stdout, stderr }.
+* Rejects if the process cannot be spawned or the timeout fires.
+*/
+function runCommandWithTimeout(argv, opts = {}) {
+	const [cmd, ...args] = argv;
+	if (!cmd) return Promise.reject(/* @__PURE__ */ 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(/* @__PURE__ */ 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")
+			});
+		});
+	});
+}
+function resolveDefaultAgentWorkspaceDir(env = process.env, homedir = os.homedir) {
+	const profile = env.MILADY_PROFILE?.trim();
+	if (profile && profile.toLowerCase() !== "default") return path.join(homedir(), ".milady", `workspace-${profile}`);
+	return path.join(homedir(), ".milady", "workspace");
+}
+const DEFAULT_AGENT_WORKSPACE_DIR = resolveDefaultAgentWorkspaceDir();
+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_BOOTSTRAP_FILENAME = "BOOTSTRAP.md";
+const DEFAULT_MEMORY_FILENAME = "MEMORY.md";
+const DEFAULT_MEMORY_ALT_FILENAME = "memory.md";
+/** Inline workspace bootstrap templates — no external files needed. */
+const 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.
+`,
+	[DEFAULT_IDENTITY_FILENAME]: `# Identity
+
+Your character and personality settings.
+
+Customize this file to define your agent's personality,
+tone, and behavior style.
+`,
+	[DEFAULT_USER_FILENAME]: `# User
+
+User context and preferences.
+
+This file stores information about the user to help
+personalize interactions.
+`,
+	[DEFAULT_HEARTBEAT_FILENAME]: `# Heartbeat
+
+The heartbeat system enables autonomous agent behavior.
+
+## Scheduling
+
+When autonomy is enabled, the agent periodically evaluates
+whether to take proactive actions based on its goals,
+pending tasks, and environmental changes.
+
+## Triggers
+
+- Scheduled intervals (configurable)
+- External events from connected channels
+- System notifications and alerts
+`,
+	[DEFAULT_BOOTSTRAP_FILENAME]: `# Bootstrap
+
+Initial workspace setup for a new agent.
+
+## Getting Started
+
+This workspace was automatically created for your agent.
+You can customize it by editing the markdown files in this
+directory:
+
+- **AGENTS.md** — Agent behavior and capabilities
+- **TOOLS.md** — Available tools and plugins
+- **IDENTITY.md** — Character and personality
+- **USER.md** — User context and preferences
+- **HEARTBEAT.md** — Autonomous behavior settings
+
+## Configuration
+
+Agent configuration is managed through \`~/.milady/milady.json\`
+or the Milady Control UI.
+`
+};
+const coreWorkspaceHelpers = elizaCore;
+function isSubagentSessionKey(sessionKey) {
+	if (typeof coreWorkspaceHelpers.isSubagentSessionKey === "function") return coreWorkspaceHelpers.isSubagentSessionKey(sessionKey);
+	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 {
+		return (await runCommandWithTimeout(["git", "--version"], { timeoutMs: 2e3 })).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: 1e4
+		});
+	} catch (err) {
+		logWarn(`[workspace] git init failed: ${err instanceof Error ? err.message : err}`);
+	}
+}
+async function ensureAgentWorkspace(params) {
+	const dir = resolveUserPath(params?.dir?.trim() ? params.dir.trim() : DEFAULT_AGENT_WORKSPACE_DIR);
+	await fs.mkdir(dir, { recursive: true });
+	if (!params?.ensureBootstrapFiles) 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 bootstrapPath = path.join(dir, DEFAULT_BOOTSTRAP_FILENAME);
+	const isBrandNewWorkspace = await (async () => {
+		const paths = [
+			agentsPath,
+			toolsPath,
+			identityPath,
+			userPath,
+			heartbeatPath
+		];
+		return (await Promise.all(paths.map(async (p) => {
+			try {
+				await fs.access(p);
+				return true;
+			} catch (err) {
+				if (err.code === "ENOENT") return false;
+				throw err;
+			}
+		}))).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 bootstrapTemplate = WORKSPACE_TEMPLATES[DEFAULT_BOOTSTRAP_FILENAME];
+	const writeOps = [
+		writeFileIfMissing(agentsPath, agentsTemplate),
+		writeFileIfMissing(toolsPath, toolsTemplate),
+		writeFileIfMissing(identityPath, identityTemplate),
+		writeFileIfMissing(userPath, userTemplate),
+		writeFileIfMissing(heartbeatPath, heartbeatTemplate)
+	];
+	if (isBrandNewWorkspace) writeOps.push(writeFileIfMissing(bootstrapPath, bootstrapTemplate));
+	await Promise.all(writeOps);
+	await ensureGitRepo(dir, isBrandNewWorkspace);
+	return {
+		dir,
+		agentsPath,
+		toolsPath,
+		identityPath,
+		userPath,
+		heartbeatPath,
+		bootstrapPath
+	};
+}
+async function resolveMemoryBootstrapEntries(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 = /* @__PURE__ */ 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;
+}
+async function loadWorkspaceBootstrapFiles(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_BOOTSTRAP_FILENAME,
+			filePath: path.join(resolvedDir, DEFAULT_BOOTSTRAP_FILENAME)
+		}
+	];
+	entries.push(...await resolveMemoryBootstrapEntries(resolvedDir));
+	return 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;
+		}
+	}));
+}
+const SUBAGENT_BOOTSTRAP_ALLOWLIST = new Set([DEFAULT_AGENTS_FILENAME, DEFAULT_TOOLS_FILENAME]);
+function filterBootstrapFilesForSession(files, sessionKey) {
+	if (!sessionKey || !isSubagentSessionKey(sessionKey)) return files;
+	return files.filter((file) => SUBAGENT_BOOTSTRAP_ALLOWLIST.has(file.name));
+}
+
+//#endregion
+export { DEFAULT_AGENT_WORKSPACE_DIR, ensureAgentWorkspace, filterBootstrapFilesForSession, loadWorkspaceBootstrapFiles, resolveDefaultAgentWorkspaceDir };

package/dist/registry-routes.js

@@ -0,0 +1,86 @@
+import { parseClampedInteger } from "./utils/number-parsing.js";
+
+//#region src/api/registry-routes.ts
+async function handleRegistryRoutes(ctx) {
+	const { res, method, pathname, url, json, error, getPluginManager, getLoadedPluginNames, getBundledPluginIds } = ctx;
+	if (method === "GET" && pathname === "/api/registry/plugins") {
+		try {
+			const pluginManager = getPluginManager();
+			const registry = await pluginManager.refreshRegistry();
+			const installed = await pluginManager.listInstalledPlugins();
+			const installedNames = new Set(installed.map((plugin) => plugin.name));
+			const loadedNames = new Set(getLoadedPluginNames());
+			const bundledIds = getBundledPluginIds();
+			const plugins = Array.from(registry.values()).map((plugin) => {
+				const shortId = plugin.name.replace(/^@[^/]+\/plugin-/, "").replace(/^@[^/]+\//, "").replace(/^plugin-/, "");
+				return {
+					...plugin,
+					installed: installedNames.has(plugin.name),
+					installedVersion: installed.find((entry) => entry.name === plugin.name)?.version ?? null,
+					loaded: loadedNames.has(plugin.name) || loadedNames.has(plugin.name.replace("@elizaos/", "")),
+					bundled: bundledIds.has(shortId)
+				};
+			});
+			json(res, {
+				count: plugins.length,
+				plugins
+			});
+		} catch (err) {
+			error(res, `Failed to fetch registry: ${err instanceof Error ? err.message : String(err)}`, 502);
+		}
+		return true;
+	}
+	if (method === "GET" && pathname.startsWith("/api/registry/plugins/") && pathname.length > 22) {
+		const name = decodeURIComponent(pathname.slice(22));
+		try {
+			const info = await getPluginManager().getRegistryPlugin(name);
+			if (!info) {
+				error(res, `Plugin "${name}" not found in registry`, 404);
+				return true;
+			}
+			json(res, { plugin: info });
+		} catch (err) {
+			error(res, `Failed to look up plugin: ${err instanceof Error ? err.message : String(err)}`, 502);
+		}
+		return true;
+	}
+	if (method === "GET" && pathname === "/api/registry/search") {
+		const query = url.searchParams.get("q") || "";
+		if (!query.trim()) {
+			error(res, "Query parameter 'q' is required", 400);
+			return true;
+		}
+		try {
+			const limitParam = url.searchParams.get("limit");
+			const limit = limitParam ? parseClampedInteger(limitParam, {
+				min: 1,
+				max: 50,
+				fallback: 15
+			}) : 15;
+			const results = await getPluginManager().searchRegistry(query, limit);
+			json(res, {
+				query,
+				count: results.length,
+				results
+			});
+		} catch (err) {
+			error(res, `Search failed: ${err instanceof Error ? err.message : String(err)}`, 502);
+		}
+		return true;
+	}
+	if (method === "POST" && pathname === "/api/registry/refresh") {
+		try {
+			json(res, {
+				ok: true,
+				count: (await getPluginManager().refreshRegistry()).size
+			});
+		} catch (err) {
+			error(res, `Refresh failed: ${err instanceof Error ? err.message : String(err)}`, 502);
+		}
+		return true;
+	}
+	return false;
+}
+
+//#endregion
+export { handleRegistryRoutes };

package/dist/registry-service.js

@@ -0,0 +1,164 @@
+import { logger } from "@elizaos/core";
+import { ethers } from "ethers";
+
+//#region src/api/registry-service.ts
+/**
+* ERC-8004 Agent Identity Registry service.
+*
+* Handles all interactions with the MiladyAgentRegistry contract:
+* - Registration (self and delegated)
+* - Profile updates
+* - Metadata (tokenURI) management
+* - Status queries
+*/
+const REGISTRY_ABI = [
+	"function registerAgent(string,string,bytes32,string) external returns (uint256)",
+	"function registerAgentFor(address,string,string,bytes32,string) external returns (uint256)",
+	"function updateAgent(string,bytes32) external",
+	"function updateAgentProfile(string,string,bytes32,string) external",
+	"function updateTokenURI(uint256,string) external",
+	"function deactivateAgent() external",
+	"function reactivateAgent() external",
+	"function getAgentInfo(uint256) view returns (string,string,bytes32,bool)",
+	"function addressToTokenId(address) view returns (uint256)",
+	"function isRegistered(address) view returns (bool)",
+	"function getTokenId(address) view returns (uint256)",
+	"function totalAgents() view returns (uint256)",
+	"function isEndpointTaken(string) view returns (bool)",
+	"function balanceOf(address) view returns (uint256)",
+	"function ownerOf(uint256) view returns (address)",
+	"function tokenURI(uint256) view returns (string)",
+	"event AgentRegistered(uint256 indexed tokenId, address indexed owner, string name, string endpoint)",
+	"event AgentUpdated(uint256 indexed tokenId, string endpoint, bytes32 capabilitiesHash)"
+];
+const DEFAULT_CAPABILITIES_HASH = ethers.id("milady-agent");
+var RegistryService = class {
+	constructor(txService, registryAddress) {
+		this.txService = txService;
+		this.registryAddress = registryAddress;
+		this.contract = txService.getContract(registryAddress, REGISTRY_ABI);
+	}
+	get address() {
+		return this.txService.address;
+	}
+	get contractAddress() {
+		return this.registryAddress;
+	}
+	async getChainId() {
+		return this.txService.getChainId();
+	}
+	/**
+	* Get the full registration status for the current wallet.
+	*/
+	async getStatus() {
+		const addr = this.txService.address;
+		const [registered, totalAgentsBN] = await Promise.all([this.contract.isRegistered(addr), this.contract.totalAgents()]);
+		if (!registered) return {
+			registered: false,
+			tokenId: 0,
+			agentName: "",
+			agentEndpoint: "",
+			capabilitiesHash: "",
+			isActive: false,
+			tokenURI: "",
+			walletAddress: addr,
+			totalAgents: Number(totalAgentsBN)
+		};
+		const tokenId = Number(await this.contract.getTokenId(addr));
+		const [[name, endpoint, capHash, isActive], uri] = await Promise.all([this.contract.getAgentInfo(tokenId), this.contract.tokenURI(tokenId)]);
+		return {
+			registered: true,
+			tokenId,
+			agentName: name,
+			agentEndpoint: endpoint,
+			capabilitiesHash: capHash,
+			isActive,
+			tokenURI: uri,
+			walletAddress: addr,
+			totalAgents: Number(totalAgentsBN)
+		};
+	}
+	/**
+	* Register the current wallet as an agent.
+	* The NFT is minted to the wallet address stored in EVM_PRIVATE_KEY.
+	*/
+	async register(params) {
+		const capHash = params.capabilitiesHash || DEFAULT_CAPABILITIES_HASH;
+		logger.info(`[registry] Registering agent "${params.name}" from ${this.txService.address}`);
+		const nonce = await this.txService.getFreshNonce();
+		const tx = await this.contract.registerAgent(params.name, params.endpoint, capHash, params.tokenURI, { nonce });
+		logger.info(`[registry] Registration tx submitted: ${tx.hash}`);
+		const receipt = await tx.wait();
+		const iface = new ethers.Interface(REGISTRY_ABI);
+		let tokenId = 0;
+		for (const log of receipt.logs) {
+			const parsed = iface.parseLog({
+				topics: log.topics,
+				data: log.data
+			});
+			if (parsed && parsed.name === "AgentRegistered") {
+				tokenId = Number(parsed.args[0]);
+				break;
+			}
+		}
+		if (tokenId === 0) tokenId = Number(await this.contract.getTokenId(this.txService.address));
+		logger.info(`[registry] Agent registered: tokenId=${tokenId} txHash=${receipt.hash}`);
+		return {
+			tokenId,
+			txHash: receipt.hash
+		};
+	}
+	/**
+	* Update the tokenURI (metadata pointer) for the current wallet's agent.
+	* Called when the character is edited.
+	*/
+	async updateTokenURI(newURI) {
+		const tokenId = Number(await this.contract.getTokenId(this.txService.address));
+		if (tokenId === 0) throw new Error("Agent not registered, cannot update token URI");
+		logger.info(`[registry] Updating tokenURI for token ${tokenId}: ${newURI}`);
+		const nonce = await this.txService.getFreshNonce();
+		const receipt = await (await this.contract.updateTokenURI(tokenId, newURI, { nonce })).wait();
+		logger.info(`[registry] TokenURI updated: txHash=${receipt.hash}`);
+		return receipt.hash;
+	}
+	/**
+	* Update the agent's endpoint and capabilities hash.
+	*/
+	async updateAgent(endpoint, capabilitiesHash) {
+		const capHash = capabilitiesHash || DEFAULT_CAPABILITIES_HASH;
+		logger.info(`[registry] Updating agent profile: endpoint=${endpoint}`);
+		const nonce = await this.txService.getFreshNonce();
+		const receipt = await (await this.contract.updateAgent(endpoint, capHash, { nonce })).wait();
+		logger.info(`[registry] Agent updated: txHash=${receipt.hash}`);
+		return receipt.hash;
+	}
+	/**
+	* Check if a specific address is registered.
+	*/
+	/**
+	* Sync the full agent profile on-chain: name, endpoint, capabilities, and tokenURI.
+	* Called when the character is edited and user wants to push changes to chain.
+	*/
+	async syncProfile(params) {
+		const capHash = params.capabilitiesHash || DEFAULT_CAPABILITIES_HASH;
+		logger.info(`[registry] Syncing profile: name="${params.name}" endpoint="${params.endpoint}"`);
+		const nonce = await this.txService.getFreshNonce();
+		const tx = await this.contract.updateAgentProfile(params.name, params.endpoint, capHash, params.tokenURI, { nonce });
+		logger.info(`[registry] Sync tx submitted: ${tx.hash}`);
+		const receipt = await tx.wait();
+		logger.info(`[registry] Profile synced: txHash=${receipt.hash}`);
+		return receipt.hash;
+	}
+	async isRegistered(address) {
+		return this.contract.isRegistered(address);
+	}
+	/**
+	* Build the default capabilities hash used for Milady agents.
+	*/
+	static defaultCapabilitiesHash() {
+		return DEFAULT_CAPABILITIES_HASH;
+	}
+};
+
+//#endregion
+export { RegistryService };

package/dist/restart.js

@@ -0,0 +1,40 @@
+import process from "node:process";
+
+//#region src/runtime/restart.ts
+/**
+* Restart infrastructure for Milady.
+*
+* Provides a pluggable restart handler so the restart action (and the
+* `/api/agent/restart` endpoint) work in every host environment:
+*
+*   - **CLI** (default): exits with {@link RESTART_EXIT_CODE} (75). The runner
+*     script (`scripts/run-node.mjs`) catches this, rebuilds if source files
+*     changed, and relaunches.
+*   - **Dev-server / API**: the host registers a handler via
+*     {@link setRestartHandler} that stops the current runtime, creates a new
+*     one, and hot-swaps references.
+*   - **Electron app**: the host registers a handler that calls
+*     `AgentManager.restart()`.
+*
+* @module restart
+*/
+/**
+* Special exit code that tells the CLI runner to restart the process.
+* Must stay in sync with `RESTART_EXIT_CODE` in `scripts/run-node.mjs`.
+*/
+const RESTART_EXIT_CODE = 75;
+let _handler = () => {
+	process.exit(RESTART_EXIT_CODE);
+};
+/**
+* Trigger a restart.  Delegates to whatever handler is currently registered.
+*
+* Safe to call from the restart action, the API endpoint, or any other code
+* that needs to bounce the agent.
+*/
+function requestRestart(reason) {
+	return _handler(reason);
+}
+
+//#endregion
+export { requestRestart };

package/dist/runtime/core-plugins.js

@@ -0,0 +1,37 @@
+//#region src/runtime/core-plugins.ts
+/**
+* Core plugin package lists shared by runtime startup and the API server.
+*
+* Keeping this in a standalone module avoids a circular dependency between
+* `api/server.ts` and `runtime/eliza.ts`.
+*/
+/** Core plugins that should always be loaded. */
+const CORE_PLUGINS = [
+	"@elizaos/plugin-sql",
+	"@elizaos/plugin-local-embedding",
+	"@elizaos/plugin-secrets-manager",
+	"@elizaos/plugin-form",
+	"@elizaos/plugin-knowledge",
+	"@elizaos/plugin-rolodex",
+	"@elizaos/plugin-trajectory-logger",
+	"@elizaos/plugin-agent-orchestrator",
+	"@elizaos/plugin-cron",
+	"@elizaos/plugin-shell",
+	"@elizaos/plugin-plugin-manager",
+	"@elizaos/plugin-agent-skills",
+	"@elizaos/plugin-pdf"
+];
+/**
+* Plugins that can be enabled from the admin panel.
+* Not loaded by default — kept separate due to packaging or spec issues.
+*/
+const OPTIONAL_CORE_PLUGINS = [
+	"@elizaos/plugin-cua",
+	"@elizaos/plugin-obsidian",
+	"@elizaos/plugin-code",
+	"@elizaos/plugin-repoprompt",
+	"@milaidy/plugin-claude-code-workbench"
+];
+
+//#endregion
+export { CORE_PLUGINS, OPTIONAL_CORE_PLUGINS };