miladyai 2.0.0-alpha.27

package/dist/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/dist/permissions-routes.js

@@ -0,0 +1,109 @@
+//#region src/api/permissions-routes.ts
+async function handlePermissionRoutes(ctx) {
+	const { req, res, method, pathname, state, readJsonBody, json, error, saveConfig, scheduleRuntimeRestart } = ctx;
+	if (!pathname.startsWith("/api/permissions")) return false;
+	if (method === "GET" && pathname === "/api/permissions") {
+		json(res, {
+			permissions: state.permissionStates ?? {},
+			platform: process.platform,
+			shellEnabled: state.shellEnabled ?? true
+		});
+		return true;
+	}
+	if (method === "GET" && pathname === "/api/permissions/shell") {
+		const enabled = state.shellEnabled ?? true;
+		if (!state.permissionStates) state.permissionStates = {};
+		const shellState = state.permissionStates.shell;
+		const permission = {
+			id: "shell",
+			status: enabled ? "granted" : "denied",
+			lastChecked: shellState?.lastChecked ?? Date.now(),
+			canRequest: false
+		};
+		state.permissionStates.shell = permission;
+		json(res, {
+			enabled,
+			...permission,
+			permission
+		});
+		return true;
+	}
+	if (method === "GET" && pathname.startsWith("/api/permissions/")) {
+		const permId = pathname.slice(17);
+		if (!permId || permId.includes("/")) {
+			error(res, "Invalid permission ID", 400);
+			return true;
+		}
+		const permState = (state.permissionStates ?? {})[permId];
+		if (!permState) {
+			json(res, {
+				id: permId,
+				status: "not-applicable",
+				lastChecked: Date.now(),
+				canRequest: false
+			});
+			return true;
+		}
+		json(res, permState);
+		return true;
+	}
+	if (method === "POST" && pathname === "/api/permissions/refresh") {
+		json(res, {
+			message: "Permission refresh requested",
+			action: "ipc:permissions:refresh"
+		});
+		return true;
+	}
+	if (method === "POST" && pathname.match(/^\/api\/permissions\/[^/]+\/request$/)) {
+		const permId = pathname.split("/")[3];
+		json(res, {
+			message: `Permission request for ${permId}`,
+			action: `ipc:permissions:request:${permId}`
+		});
+		return true;
+	}
+	if (method === "POST" && pathname.match(/^\/api\/permissions\/[^/]+\/open-settings$/)) {
+		const permId = pathname.split("/")[3];
+		json(res, {
+			message: `Opening settings for ${permId}`,
+			action: `ipc:permissions:openSettings:${permId}`
+		});
+		return true;
+	}
+	if (method === "PUT" && pathname === "/api/permissions/shell") {
+		const body = await readJsonBody(req, res);
+		if (!body) return true;
+		const enabled = body.enabled === true;
+		state.shellEnabled = enabled;
+		if (!state.permissionStates) state.permissionStates = {};
+		state.permissionStates.shell = {
+			id: "shell",
+			status: enabled ? "granted" : "denied",
+			lastChecked: Date.now(),
+			canRequest: false
+		};
+		if (!state.config.features) state.config.features = {};
+		state.config.features.shellEnabled = enabled;
+		saveConfig(state.config);
+		if (state.runtime) scheduleRuntimeRestart(`Shell access ${enabled ? "enabled" : "disabled"}`);
+		json(res, {
+			shellEnabled: enabled,
+			permission: state.permissionStates.shell
+		});
+		return true;
+	}
+	if (method === "PUT" && pathname === "/api/permissions/state") {
+		const body = await readJsonBody(req, res);
+		if (!body) return true;
+		if (body.permissions && typeof body.permissions === "object") state.permissionStates = body.permissions;
+		json(res, {
+			updated: true,
+			permissions: state.permissionStates
+		});
+		return true;
+	}
+	return false;
+}
+
+//#endregion
+export { handlePermissionRoutes };

package/dist/plugin-validation.js

@@ -0,0 +1,107 @@
+//#region src/api/plugin-validation.ts
+const KEY_PREFIX_HINTS = {
+	ANTHROPIC_API_KEY: {
+		prefix: "sk-ant-",
+		label: "Anthropic"
+	},
+	OPENAI_API_KEY: {
+		prefix: "sk-",
+		label: "OpenAI"
+	},
+	GROQ_API_KEY: {
+		prefix: "gsk_",
+		label: "Groq"
+	},
+	XAI_API_KEY: {
+		prefix: "xai-",
+		label: "xAI"
+	},
+	OPENROUTER_API_KEY: {
+		prefix: "sk-or-",
+		label: "OpenRouter"
+	}
+};
+/**
+* Validate a plugin's configuration.
+*
+* Checks all required parameters (from the plugin's package.json metadata)
+* and applies format-specific warnings for known API key patterns.
+*
+* @param pluginId - The plugin identifier (e.g. "anthropic", "discord")
+* @param category - Plugin category
+* @param envKey - Primary environment variable key (legacy, used as fallback)
+* @param configKeys - All known config key names for this plugin
+* @param providedConfig - Config values being set (for PUT validation)
+* @param paramDefs - Full parameter definitions with required/sensitive metadata
+*/
+function validatePluginConfig(_pluginId, _category, envKey, configKeys, providedConfig, paramDefs) {
+	const errors = [];
+	const warnings = [];
+	const allowedConfigKeys = new Set(configKeys);
+	const canonicalKeyByNormalized = new Map(configKeys.map((key) => [key.trim().toUpperCase(), key]));
+	if (providedConfig) for (const key of Object.keys(providedConfig)) {
+		if (allowedConfigKeys.has(key)) continue;
+		const canonical = canonicalKeyByNormalized.get(key.trim().toUpperCase());
+		if (canonical) {
+			errors.push({
+				field: key,
+				message: `${key} does not match declared config key casing; use ${canonical}`
+			});
+			continue;
+		}
+		errors.push({
+			field: key,
+			message: `${key} is not a declared config key for this plugin`
+		});
+	}
+	if (paramDefs && paramDefs.length > 0) for (const param of paramDefs) {
+		if (!param.required) continue;
+		const value = providedConfig?.[param.key] ?? process.env[param.key];
+		if (!value || !value.trim()) {
+			if (param.default) warnings.push({
+				field: param.key,
+				message: `${param.key} is not set (will use default: ${param.default})`
+			});
+			else errors.push({
+				field: param.key,
+				message: `${param.key} is required but not set`
+			});
+			continue;
+		}
+		const hint = KEY_PREFIX_HINTS[param.key];
+		if (hint && !value.startsWith(hint.prefix)) warnings.push({
+			field: param.key,
+			message: `${hint.label} key should start with "${hint.prefix}" — the current value may be invalid`
+		});
+		if (param.sensitive && value.trim().length < 10) warnings.push({
+			field: param.key,
+			message: `${param.key} looks too short (${value.trim().length} chars)`
+		});
+	}
+	else if (envKey) {
+		const currentValue = providedConfig?.[envKey] ?? process.env[envKey];
+		if (!currentValue || !currentValue.trim()) errors.push({
+			field: envKey,
+			message: `${envKey} is required but not set`
+		});
+		else {
+			const hint = KEY_PREFIX_HINTS[envKey];
+			if (hint && !currentValue.startsWith(hint.prefix)) warnings.push({
+				field: envKey,
+				message: `${hint.label} key should start with "${hint.prefix}" — the current value may be invalid`
+			});
+			if (currentValue.trim().length < 10) warnings.push({
+				field: envKey,
+				message: `${envKey} looks too short (${currentValue.trim().length} chars)`
+			});
+		}
+	}
+	return {
+		valid: errors.length === 0,
+		errors,
+		warnings
+	};
+}
+
+//#endregion
+export { validatePluginConfig };

package/dist/plugins/whatsapp/actions.js

@@ -0,0 +1,91 @@
+//#region src/plugins/whatsapp/actions.ts
+const sendWhatsAppMessage = {
+	name: "SEND_WHATSAPP_MESSAGE",
+	description: "Send a text message to a phone number on WhatsApp. Use this when the user asks you to send a WhatsApp message to someone.",
+	similes: [
+		"WHATSAPP_MESSAGE",
+		"TEXT_ON_WHATSAPP",
+		"MESSAGE_ON_WHATSAPP",
+		"SEND_WHATSAPP",
+		"WA_MESSAGE"
+	],
+	parameters: [{
+		name: "phoneNumber",
+		description: "The recipient's phone number in international format (e.g. +1234567890). Include country code.",
+		required: true,
+		schema: { type: "string" }
+	}, {
+		name: "message",
+		description: "The text message to send.",
+		required: true,
+		schema: { type: "string" }
+	}],
+	validate: async (runtime, _message) => {
+		return runtime.hasService("whatsapp");
+	},
+	handler: async (runtime, message, _state, options, callback) => {
+		const params = options?.parameters;
+		const phoneNumber = params?.phoneNumber;
+		const messageText = params?.message;
+		if (!phoneNumber || !messageText) {
+			runtime.logger.warn("[whatsapp] SEND_WHATSAPP_MESSAGE missing phoneNumber or message params");
+			if (callback) await callback({
+				text: "I need both a phone number and a message to send on WhatsApp.",
+				actions: []
+			});
+			return { success: false };
+		}
+		const cleanPhone = phoneNumber.replace(/[^0-9]/g, "");
+		if (cleanPhone.length < 8) {
+			if (callback) await callback({
+				text: `The phone number "${phoneNumber}" doesn't look valid. Please include the country code (e.g. +1234567890).`,
+				actions: []
+			});
+			return { success: false };
+		}
+		const jid = `${cleanPhone}@s.whatsapp.net`;
+		try {
+			await runtime.sendMessageToTarget({
+				source: "whatsapp",
+				channelId: jid,
+				roomId: message.roomId
+			}, { text: messageText });
+			runtime.logger.info(`[whatsapp] Sent message to +${cleanPhone} via SEND_WHATSAPP_MESSAGE action`);
+			if (callback) await callback({
+				text: `Message sent to +${cleanPhone} on WhatsApp.`,
+				actions: []
+			});
+			return { success: true };
+		} catch (err) {
+			const errMsg = err instanceof Error ? err.message : String(err);
+			runtime.logger.error(`[whatsapp] Failed to send WhatsApp message: ${errMsg}`);
+			if (callback) await callback({
+				text: `Failed to send WhatsApp message: ${errMsg}`,
+				actions: []
+			});
+			return { success: false };
+		}
+	},
+	examples: [[{
+		name: "{{user1}}",
+		content: { text: "Send a WhatsApp message to +1234567890 saying hello, how are you?" }
+	}, {
+		name: "{{agent}}",
+		content: {
+			text: "I'll send that WhatsApp message now.",
+			actions: ["SEND_WHATSAPP_MESSAGE"]
+		}
+	}], [{
+		name: "{{user1}}",
+		content: { text: "Text my friend on WhatsApp at +1234567890 and tell them I'll be late" }
+	}, {
+		name: "{{agent}}",
+		content: {
+			text: "Sending the message on WhatsApp.",
+			actions: ["SEND_WHATSAPP_MESSAGE"]
+		}
+	}]]
+};
+
+//#endregion
+export { sendWhatsAppMessage };

package/dist/plugins/whatsapp/index.js

@@ -0,0 +1,16 @@
+import { WhatsAppBaileysService } from "./service.js";
+import { sendWhatsAppMessage } from "./actions.js";
+
+//#region src/plugins/whatsapp/index.ts
+const whatsappPlugin = {
+	name: "whatsapp",
+	description: "WhatsApp messaging via Baileys (QR code auth)",
+	services: [WhatsAppBaileysService],
+	actions: [sendWhatsAppMessage],
+	init: async (_config, runtime) => {
+		runtime.logger.info("[whatsapp] Plugin initialized");
+	}
+};
+
+//#endregion
+export { whatsappPlugin as default, whatsappPlugin };

package/dist/plugins/whatsapp/service.js

@@ -0,0 +1,270 @@
+import path from "node:path";
+import fs from "node:fs";
+import os from "node:os";
+import { Service, createUniqueUuid } from "@elizaos/core";
+
+//#region src/plugins/whatsapp/service.ts
+/**
+* WhatsApp Baileys service for ElizaOS runtime.
+*
+* Manages a persistent Baileys socket using QR-auth credentials saved to disk
+* by the pairing service (`src/services/whatsapp-pairing.ts`).
+*
+* Handles:
+* - Outbound messages via `registerSendHandler("whatsapp", ...)`
+* - Inbound messages via `messages.upsert` → `emitEvent(MESSAGE_RECEIVED)`
+* - Auto-reconnect on transient disconnects
+*/
+function resolveAuthDir(runtime) {
+	const customDir = runtime.getSetting("WHATSAPP_AUTH_DIR");
+	if (customDir && typeof customDir === "string" && customDir.trim()) return customDir.trim();
+	const workspaceDir = process.env.MILADY_WORKSPACE_DIR ?? path.join(os.homedir(), ".milady", "workspace");
+	return path.join(workspaceDir, "whatsapp-auth", "default");
+}
+function extractMessageText(msg) {
+	const m = msg.message;
+	if (!m) return void 0;
+	if (typeof m.conversation === "string") return m.conversation;
+	const ext = m.extendedTextMessage;
+	if (ext && typeof ext.text === "string") return ext.text;
+	for (const key of [
+		"imageMessage",
+		"videoMessage",
+		"documentMessage"
+	]) {
+		const media = m[key];
+		if (media && typeof media.caption === "string") return media.caption;
+	}
+}
+function jidToPhoneNumber(jid) {
+	return jid.split("@")[0].split(":")[0];
+}
+var WhatsAppBaileysService = class WhatsAppBaileysService extends Service {
+	constructor(..._args) {
+		super(..._args);
+		this.capabilityDescription = "The agent can send and receive WhatsApp messages via Baileys";
+		this.sock = null;
+		this.phoneNumber = null;
+		this.connected = false;
+		this.reconnectDelay = 3e3;
+		this.reconnectTimer = null;
+	}
+	static {
+		this.serviceType = "whatsapp";
+	}
+	static async start(runtime) {
+		const service = new WhatsAppBaileysService(runtime);
+		await service.initialize();
+		return service;
+	}
+	static registerSendHandlers(runtime, service) {
+		const svc = service;
+		runtime.registerSendHandler("whatsapp", svc.handleSendMessage.bind(svc));
+		runtime.logger.info("[whatsapp] Registered send handler");
+	}
+	static async stopRuntime(runtime) {
+		const svc = runtime.getService("whatsapp");
+		if (svc) await svc.stop();
+	}
+	async initialize() {
+		const authDir = resolveAuthDir(this.runtime);
+		const credsPath = path.join(authDir, "creds.json");
+		if (!fs.existsSync(credsPath)) {
+			this.runtime.logger.warn("[whatsapp] No QR auth credentials found at " + credsPath + " — skipping Baileys connection. Pair via the WhatsApp connector settings first.");
+			return;
+		}
+		this.runtime.logger.info("[whatsapp] Auth credentials found, connecting to WhatsApp...");
+		const baileys = await import("@whiskeysockets/baileys");
+		const makeWASocket = baileys.default;
+		const { useMultiFileAuthState, fetchLatestBaileysVersion, DisconnectReason } = baileys;
+		const { Boom } = await import("@hapi/boom");
+		const pino = (await import("pino")).default;
+		const logger = pino({ level: "silent" });
+		const { state, saveCreds } = await useMultiFileAuthState(authDir);
+		const { version } = await fetchLatestBaileysVersion();
+		const connect = async () => {
+			this.sock = makeWASocket({
+				version,
+				auth: state,
+				logger,
+				printQRInTerminal: false,
+				browser: [
+					"Milady AI",
+					"Desktop",
+					"1.0.0"
+				]
+			});
+			this.sock.ev.on("creds.update", saveCreds);
+			this.sock.ev.on("connection.update", async (update) => {
+				const { connection, lastDisconnect } = update;
+				if (connection === "open") {
+					this.connected = true;
+					this.reconnectDelay = 3e3;
+					this.phoneNumber = this.sock?.user?.id?.split(":")[0] ?? null;
+					this.runtime.logger.info(`[whatsapp] Connected as +${this.phoneNumber ?? "unknown"}`);
+				}
+				if (connection === "close") {
+					this.connected = false;
+					const statusCode = (lastDisconnect?.error)?.output?.statusCode;
+					this.runtime.logger.info(`[whatsapp] Connection closed (code=${statusCode})`);
+					if (statusCode === DisconnectReason.loggedOut) {
+						this.runtime.logger.warn("[whatsapp] Logged out — device was removed from WhatsApp. Re-pair via QR to reconnect.");
+						this.sock = null;
+						return;
+					}
+					if (statusCode === DisconnectReason.restartRequired || statusCode === DisconnectReason.timedOut || statusCode === DisconnectReason.connectionClosed || statusCode === DisconnectReason.connectionReplaced) {
+						this.runtime.logger.info(`[whatsapp] Reconnecting after transient disconnect in ${this.reconnectDelay}ms...`);
+						const delay = this.reconnectDelay;
+						this.reconnectDelay = Math.min(this.reconnectDelay * 2, 6e4);
+						this.sock = null;
+						this.reconnectTimer = setTimeout(() => {
+							this.reconnectTimer = null;
+							connect().catch((err) => {
+								this.runtime.logger.error(`[whatsapp] Reconnect failed: ${err instanceof Error ? err.message : String(err)}`);
+							});
+						}, delay);
+					}
+				}
+			});
+			this.sock.ev.on("messages.upsert", async ({ messages, type }) => {
+				if (type !== "notify") return;
+				for (const msg of messages) try {
+					await this.handleIncomingMessage(msg);
+				} catch (err) {
+					this.runtime.logger.error(`[whatsapp] Error handling incoming message: ${err instanceof Error ? err.message : String(err)}`);
+				}
+			});
+		};
+		await connect();
+	}
+	async stop() {
+		this.runtime?.logger?.info("[whatsapp] Stopping service...");
+		if (this.reconnectTimer) {
+			clearTimeout(this.reconnectTimer);
+			this.reconnectTimer = null;
+		}
+		try {
+			this.sock?.end(void 0);
+		} catch {}
+		this.sock = null;
+		this.connected = false;
+	}
+	async handleSendMessage(runtime, target, content) {
+		if (!this.sock || !this.connected) throw new Error("WhatsApp is not connected. Pair via QR code first.");
+		let jid;
+		if (target.channelId) jid = target.channelId.includes("@") ? target.channelId : `${target.channelId}@s.whatsapp.net`;
+		else if (target.entityId) {
+			const cleaned = target.entityId.replace(/[^0-9]/g, "");
+			if (cleaned.length >= 8) jid = `${cleaned}@s.whatsapp.net`;
+			else throw new Error("Cannot determine WhatsApp recipient from target: " + JSON.stringify(target));
+		} else throw new Error("WhatsApp SendHandler requires channelId or entityId. Got: " + JSON.stringify(target));
+		const text = content.text ?? "";
+		if (!text.trim()) {
+			runtime.logger.warn("[whatsapp] Skipping empty message send");
+			return;
+		}
+		runtime.logger.info(`[whatsapp] Sending message to ${jidToPhoneNumber(jid)}`);
+		await this.sock.sendMessage(jid, { text });
+	}
+	async handleIncomingMessage(msg) {
+		const key = msg.key;
+		if (!key) return;
+		if (key.fromMe) return;
+		const remoteJid = key.remoteJid;
+		if (!remoteJid || remoteJid === "status@broadcast") return;
+		if (remoteJid.endsWith("@g.us")) return;
+		const text = extractMessageText(msg);
+		if (!text || !text.trim()) return;
+		const senderPhone = jidToPhoneNumber(remoteJid);
+		this.runtime.logger.info(`[whatsapp] Incoming message from +${senderPhone}: "${text.slice(0, 50)}${text.length > 50 ? "..." : ""}"`);
+		const entityId = createUniqueUuid(this.runtime, remoteJid);
+		const roomId = createUniqueUuid(this.runtime, remoteJid);
+		const messageId = createUniqueUuid(this.runtime, key.id ?? `wa-${Date.now()}`);
+		const worldId = createUniqueUuid(this.runtime, "whatsapp-world");
+		await this.runtime.ensureConnection({
+			entityId,
+			roomId,
+			userName: senderPhone,
+			name: senderPhone,
+			source: "whatsapp",
+			channelId: remoteJid,
+			type: "DM",
+			worldId,
+			worldName: "WhatsApp"
+		});
+		const memory = {
+			id: messageId,
+			entityId,
+			agentId: this.runtime.agentId,
+			roomId,
+			content: {
+				text,
+				source: "whatsapp",
+				channelType: "DM"
+			},
+			metadata: {
+				type: "custom",
+				entityName: senderPhone,
+				fromId: remoteJid
+			},
+			createdAt: Date.now()
+		};
+		const callback = async (responseContent) => {
+			try {
+				if (responseContent.target && typeof responseContent.target === "string" && responseContent.target.toLowerCase() !== "whatsapp") return [];
+				const replyText = responseContent.text ?? "";
+				if (!replyText.trim()) return [];
+				await this.sock?.sendMessage(remoteJid, { text: replyText });
+				const replyMemory = {
+					id: createUniqueUuid(this.runtime, `wa-reply-${Date.now()}`),
+					entityId: this.runtime.agentId,
+					agentId: this.runtime.agentId,
+					roomId,
+					content: {
+						...responseContent,
+						text: replyText,
+						source: "whatsapp",
+						channelType: "DM",
+						inReplyTo: messageId
+					},
+					createdAt: Date.now()
+				};
+				await this.runtime.createMemory(replyMemory, "messages");
+				return [replyMemory];
+			} catch (err) {
+				this.runtime.logger.error(`[whatsapp] Error sending reply: ${err instanceof Error ? err.message : String(err)}`);
+				return [];
+			}
+		};
+		const messagingAPI = this.getMessagingAPI();
+		const messageService = this.getMessageService();
+		if (messagingAPI) {
+			this.runtime.logger.debug("[whatsapp] Using messaging API for inbound message");
+			await messagingAPI.sendMessage(this.runtime.agentId, memory, { onResponse: callback });
+		} else if (messageService) {
+			this.runtime.logger.debug("[whatsapp] Using messageService for inbound message");
+			await messageService.handleMessage(this.runtime, memory, callback);
+		} else {
+			this.runtime.logger.debug("[whatsapp] Using event-based handling for inbound message");
+			await this.runtime.emitEvent(["MESSAGE_RECEIVED"], {
+				runtime: this.runtime,
+				message: memory,
+				callback,
+				source: "whatsapp"
+			});
+		}
+	}
+	getMessagingAPI() {
+		const rt = this.runtime;
+		if ("elizaOS" in rt && typeof rt.elizaOS === "object" && rt.elizaOS !== null && typeof rt.elizaOS.sendMessage === "function") return rt.elizaOS;
+		return null;
+	}
+	getMessageService() {
+		const svc = this.runtime.messageService;
+		if (svc && typeof svc.handleMessage === "function") return svc;
+		return null;
+	}
+};
+
+//#endregion
+export { WhatsAppBaileysService };

package/dist/provider-switch-config.js

@@ -0,0 +1,41 @@
+import { SUBSCRIPTION_PROVIDER_MAP } from "./auth/types.js";
+
+//#region src/api/provider-switch-config.ts
+/**
+* Apply subscription provider configuration to the config object.
+*
+* Sets `agents.defaults.subscriptionProvider` and `agents.defaults.model.primary`
+* so the runtime auto-detects the correct provider on restart.
+*
+* Mutates `config` in place.
+*/
+function applySubscriptionProviderConfig(config, provider) {
+	config.agents ??= {};
+	config.agents.defaults ??= {};
+	const defaults = config.agents.defaults;
+	const subscriptionKey = provider === "openai-subscription" ? "openai-codex" : provider;
+	const modelProvider = SUBSCRIPTION_PROVIDER_MAP[subscriptionKey];
+	if (modelProvider) {
+		defaults.subscriptionProvider = subscriptionKey;
+		defaults.model = {
+			...defaults.model,
+			primary: modelProvider
+		};
+	}
+}
+/**
+* Clear subscription provider configuration from the config object.
+*
+* Removes `agents.defaults.subscriptionProvider` so the runtime
+* doesn't try to auto-detect a subscription provider on restart.
+*
+* Mutates `config` in place.
+*/
+function clearSubscriptionProviderConfig(config) {
+	config.agents ??= {};
+	config.agents.defaults ??= {};
+	delete config.agents.defaults.subscriptionProvider;
+}
+
+//#endregion
+export { applySubscriptionProviderConfig, clearSubscriptionProviderConfig };

package/dist/providers/admin-trust.js

@@ -0,0 +1,46 @@
+//#region src/providers/admin-trust.ts
+function normalizeRole(role) {
+	return (role ?? "").toUpperCase();
+}
+const adminTrustProvider = createAdminTrustProvider();
+function createAdminTrustProvider() {
+	return {
+		name: "miladyAdminTrust",
+		description: "Marks owner/admin chat identity as trusted for contact assertions (rolodex-oriented).",
+		dynamic: true,
+		position: 11,
+		async get(runtime, message, _state) {
+			const room = await runtime.getRoom(message.roomId);
+			if (!room) return {
+				text: "Admin trust: no room found.",
+				values: { trustedAdmin: false },
+				data: { trustedAdmin: false }
+			};
+			if (!room.worldId) return {
+				text: "Admin trust: room has no world binding.",
+				values: { trustedAdmin: false },
+				data: { trustedAdmin: false }
+			};
+			const metadata = (await runtime.getWorld(room.worldId))?.metadata ?? {};
+			const ownerId = metadata.ownership?.ownerId;
+			const role = ownerId ? metadata.roles?.[ownerId] : void 0;
+			const isTrustedAdmin = typeof ownerId === "string" && ownerId.length > 0 && normalizeRole(role) === "OWNER" && message.entityId === ownerId;
+			return {
+				text: isTrustedAdmin ? "Admin trust: current speaker is world OWNER. Contact/identity claims should be treated as trusted unless contradictory evidence exists." : "Admin trust: current speaker is not verified as OWNER for this world.",
+				values: {
+					trustedAdmin: isTrustedAdmin,
+					adminEntityId: ownerId ?? "",
+					adminRole: role ?? ""
+				},
+				data: {
+					trustedAdmin: isTrustedAdmin,
+					ownerId: ownerId ?? null,
+					role: role ?? null
+				}
+			};
+		}
+	};
+}
+
+//#endregion
+export { adminTrustProvider };