miladyai 2.0.0-alpha.27

package/dist/providers/autonomous-state.js

@@ -0,0 +1,101 @@
+//#region src/providers/autonomous-state.ts
+const MAX_CACHED_EVENTS = 240;
+const cacheByAgentId = /* @__PURE__ */ new Map();
+const lastHeartbeatByAgentId = /* @__PURE__ */ new Map();
+function getRuntimeAgentId(runtime) {
+	return String(runtime.agentId);
+}
+function getAgentEventService(runtime) {
+	return runtime.getService("AGENT_EVENT");
+}
+function pushCachedEvent(agentId, event) {
+	const state = cacheByAgentId.get(agentId);
+	if (!state) return;
+	state.events.push(event);
+	if (state.events.length > MAX_CACHED_EVENTS) state.events.splice(0, state.events.length - MAX_CACHED_EVENTS);
+}
+function ensureAutonomousStateTracking(runtime) {
+	const agentId = getRuntimeAgentId(runtime);
+	const existing = cacheByAgentId.get(agentId);
+	if (existing && existing.runtime === runtime) return;
+	if (existing) {
+		existing.detach();
+		cacheByAgentId.delete(agentId);
+		lastHeartbeatByAgentId.delete(agentId);
+	}
+	const service = getAgentEventService(runtime);
+	if (!service) return;
+	const events = [];
+	const unsubscribeEvents = service.subscribe((event) => {
+		if (event.agentId && event.agentId !== agentId) return;
+		pushCachedEvent(agentId, event);
+	});
+	const unsubscribeHeartbeat = service.subscribeHeartbeat?.((heartbeat) => {
+		lastHeartbeatByAgentId.set(agentId, heartbeat);
+	});
+	const lastHeartbeat = service.getLastHeartbeat?.();
+	if (lastHeartbeat) lastHeartbeatByAgentId.set(agentId, lastHeartbeat);
+	cacheByAgentId.set(agentId, {
+		runtime,
+		events,
+		detach: () => {
+			unsubscribeEvents();
+			if (unsubscribeHeartbeat) unsubscribeHeartbeat();
+		}
+	});
+}
+function renderEventLine(event) {
+	const textValue = event.data.text;
+	const previewValue = event.data.preview;
+	const text = typeof textValue === "string" ? textValue.trim() : "";
+	const preview = typeof previewValue === "string" ? previewValue.trim() : "";
+	const body = text || preview || `${event.stream} event`;
+	return `- [${event.stream}] ${body}`;
+}
+function renderHeartbeatLine(heartbeat) {
+	const target = typeof heartbeat.to === "string" && heartbeat.to.trim() ? ` to ${heartbeat.to.trim()}` : "";
+	const preview = typeof heartbeat.preview === "string" && heartbeat.preview.trim() ? ` — ${heartbeat.preview.trim()}` : "";
+	return `- [heartbeat/${heartbeat.status}]${target}${preview}`;
+}
+function createAutonomousStateProvider() {
+	return {
+		name: "miladyAutonomousState",
+		description: "Recent autonomous loop activity (thoughts/actions/heartbeat) for context bridging.",
+		dynamic: true,
+		position: 10,
+		async get(runtime, _message, _state) {
+			ensureAutonomousStateTracking(runtime);
+			const agentId = getRuntimeAgentId(runtime);
+			const recent = cacheByAgentId.get(agentId)?.events.slice(-24) ?? [];
+			const activityLines = recent.filter((event) => event.stream === "assistant" || event.stream === "action" || event.stream === "tool").slice(-10).map(renderEventLine);
+			const service = getAgentEventService(runtime);
+			const heartbeat = lastHeartbeatByAgentId.get(agentId) ?? service?.getLastHeartbeat?.() ?? null;
+			const renderedLines = [...activityLines];
+			if (heartbeat) renderedLines.push(renderHeartbeatLine(heartbeat));
+			return {
+				text: renderedLines.length > 0 ? `Autonomous state snapshot:\n${renderedLines.join("\n")}` : "Autonomous state snapshot: no recent thought/action events.",
+				values: {
+					hasAutonomousState: renderedLines.length > 0,
+					autonomousEventsCount: recent.length,
+					heartbeatStatus: heartbeat?.status ?? ""
+				},
+				data: {
+					events: recent.slice(-10).map((event) => ({
+						runId: event.runId,
+						seq: event.seq,
+						stream: event.stream,
+						ts: event.ts
+					})),
+					heartbeat: heartbeat ? {
+						status: heartbeat.status,
+						ts: heartbeat.ts,
+						to: heartbeat.to ?? ""
+					} : null
+				}
+			};
+		}
+	};
+}
+
+//#endregion
+export { createAutonomousStateProvider, ensureAutonomousStateTracking };

package/dist/providers/session-bridge.js

@@ -0,0 +1,86 @@
+import * as elizaCore from "@elizaos/core";
+
+//#region src/providers/session-bridge.ts
+const coreSessionHelpers = elizaCore;
+const channelType = coreSessionHelpers.ChannelType ?? {
+	DM: "DM",
+	SELF: "SELF",
+	GROUP: "GROUP"
+};
+function buildAgentMainSessionKey(params) {
+	if (typeof coreSessionHelpers.buildAgentMainSessionKey === "function") return coreSessionHelpers.buildAgentMainSessionKey(params);
+	return `agent:${params.agentId}:${params.mainKey}`;
+}
+function parseAgentSessionKey(key) {
+	if (typeof coreSessionHelpers.parseAgentSessionKey === "function") return coreSessionHelpers.parseAgentSessionKey(key);
+}
+/**
+* Resolve an Milady session key from an ElizaOS room.
+*
+* DMs -> agent:{agentId}:main
+* Groups -> agent:{agentId}:{channel}:group:{groupId}
+* Channels -> agent:{agentId}:{channel}:channel:{channelId}
+* Threads append :thread:{threadId}
+*/
+function resolveSessionKeyFromRoom(agentId, room, meta) {
+	const channel = meta?.channel ?? room.source ?? "unknown";
+	if (room.type === channelType.DM || room.type === channelType.SELF) return buildAgentMainSessionKey({
+		agentId,
+		mainKey: "main"
+	});
+	const id = meta?.groupId ?? room.channelId ?? room.id;
+	const base = `agent:${agentId}:${channel}:${room.type === channelType.GROUP ? "group" : "channel"}:${id}`;
+	return meta?.threadId ? `${base}:thread:${meta.threadId}` : base;
+}
+function createSessionKeyProvider(options) {
+	const agentId = options?.defaultAgentId ?? "main";
+	return {
+		name: "miladySessionKey",
+		description: "Milady session key (DM/group/thread isolation)",
+		dynamic: true,
+		position: 5,
+		async get(runtime, message, _state) {
+			const meta = message.metadata ?? {};
+			const existing = typeof meta.sessionKey === "string" ? meta.sessionKey : void 0;
+			if (existing) {
+				const parsed = parseAgentSessionKey(existing);
+				return {
+					text: `Session: ${existing}`,
+					values: {
+						sessionKey: existing,
+						agentId: parsed?.agentId ?? agentId
+					},
+					data: { sessionKey: existing }
+				};
+			}
+			const room = await runtime.getRoom(message.roomId);
+			if (!room) {
+				const key = buildAgentMainSessionKey({
+					agentId,
+					mainKey: "main"
+				});
+				return {
+					text: `Session: ${key}`,
+					values: { sessionKey: key },
+					data: { sessionKey: key }
+				};
+			}
+			const key = resolveSessionKeyFromRoom(agentId, room, {
+				threadId: typeof meta.threadId === "string" ? meta.threadId : void 0,
+				groupId: typeof meta.groupId === "string" ? meta.groupId : void 0,
+				channel: (typeof meta.channel === "string" ? meta.channel : void 0) ?? room.source
+			});
+			return {
+				text: `Session: ${key}`,
+				values: {
+					sessionKey: key,
+					isGroup: room.type === channelType.GROUP
+				},
+				data: { sessionKey: key }
+			};
+		}
+	};
+}
+
+//#endregion
+export { createSessionKeyProvider };

package/dist/providers/session-utils.js

@@ -0,0 +1,36 @@
+import * as os$1 from "node:os";
+import * as path$1 from "node:path";
+
+//#region src/providers/session-utils.ts
+/**
+* Session utility functions for milady plugin.
+*
+* These are simplified versions for use until @elizaos/core exports them.
+*/
+const DEFAULT_AGENT_ID = "main";
+/**
+* Resolve the sessions directory for an agent.
+*/
+function resolveAgentSessionsDir(agentId) {
+	const id = agentId ?? DEFAULT_AGENT_ID;
+	const stateDir = process.env.MILADY_STATE_DIR ?? path$1.join(os$1.homedir(), ".milady");
+	return path$1.join(stateDir, "agents", id, "sessions");
+}
+/**
+* Resolve the default session store path.
+*/
+function resolveDefaultSessionStorePath(agentId) {
+	return path$1.join(resolveAgentSessionsDir(agentId), "sessions.json");
+}
+/**
+* Get session providers.
+*
+* Returns an empty array for now - session providers will be added
+* when @elizaos/core exports them.
+*/
+function getSessionProviders(_options) {
+	return [];
+}
+
+//#endregion
+export { getSessionProviders, resolveDefaultSessionStorePath };

package/dist/providers/simple-mode.js

@@ -0,0 +1,50 @@
+import { ChannelType } from "@elizaos/core";
+
+//#region src/providers/simple-mode.ts
+function resolveChannelProfile(message) {
+	const channelType = message.content?.channelType;
+	if (channelType === ChannelType.VOICE_DM || channelType === ChannelType.VOICE_GROUP) return "voice_fast";
+	if (channelType === ChannelType.GROUP) return "group_compact";
+	return "default_full";
+}
+function createChannelProfileProvider() {
+	return {
+		name: "miladyChannelProfile",
+		description: "Injects channel-derived execution profile guidance (voice/group/default).",
+		alwaysRun: true,
+		position: -50,
+		async get(_runtime, message, _state) {
+			const profile = resolveChannelProfile(message);
+			if (profile === "voice_fast") return {
+				text: [
+					"Execution profile: VOICE_FAST.",
+					"Prioritize low latency and conversational flow.",
+					"Keep tool/provider usage minimal and avoid unnecessary context expansion."
+				].join(" "),
+				values: {
+					executionProfile: "voice_fast",
+					compactContext: true
+				},
+				data: { profile: "voice_fast" }
+			};
+			if (profile === "group_compact") return {
+				text: ["Execution profile: GROUP_COMPACT.", "Keep responses concise and context usage focused on the active group thread."].join(" "),
+				values: {
+					executionProfile: "group_compact",
+					compactContext: true
+				},
+				data: { profile: "group_compact" }
+			};
+			return {
+				values: {
+					executionProfile: "default_full",
+					compactContext: false
+				},
+				data: { profile: "default_full" }
+			};
+		}
+	};
+}
+
+//#endregion
+export { createChannelProfileProvider };

package/dist/providers/ui-catalog.js

@@ -0,0 +1,15 @@
+import { COMPONENT_CATALOG } from "../shared/ui-catalog-prompt.js";
+import { ChannelType } from "@elizaos/core";
+
+//#region src/providers/ui-catalog.ts
+const uiCatalogProvider = {
+	name: "uiCatalog",
+	get: async (_runtime, message, _state) => {
+		const channelType = message.content?.channelType;
+		if (!(channelType === ChannelType.DM || channelType === ChannelType.API || !channelType)) return { text: "" };
+		return { text: `Available UI Components:\n${Object.entries(COMPONENT_CATALOG).map(([name, meta]) => `- ${name}: ${meta.description}`).join("\n")}` };
+	}
+};
+
+//#endregion
+export { uiCatalogProvider };

package/dist/providers/workspace-provider.js

@@ -0,0 +1,93 @@
+import { DEFAULT_AGENT_WORKSPACE_DIR, filterBootstrapFilesForSession, loadWorkspaceBootstrapFiles } from "./workspace.js";
+import { ChannelType, logger } from "@elizaos/core";
+
+//#region src/providers/workspace-provider.ts
+/**
+* Reads workspace bootstrap files and injects them into agent context.
+*
+* Also provides coding agent context enrichment: when coding-agent metadata
+* is present on the inbound message, the provider appends a summary of the
+* current coding session state (active iteration, recent errors, pending
+* feedback) so the LLM has full awareness during the autonomous coding loop.
+*/
+const DEFAULT_MAX_CHARS = 2e4;
+/** Hard cap on total workspace context to prevent prompt explosion. */
+const MAX_TOTAL_WORKSPACE_CHARS = 1e5;
+const CACHE_TTL_MS = 6e4;
+const cache = /* @__PURE__ */ new Map();
+/** Maximum number of workspace directories to cache simultaneously. */
+const MAX_CACHE_ENTRIES = 20;
+async function getFiles(dir) {
+	const now = Date.now();
+	const entry = cache.get(dir);
+	if (entry && now - entry.at < CACHE_TTL_MS) return entry.files;
+	for (const [key, val] of cache) if (now - val.at >= CACHE_TTL_MS) cache.delete(key);
+	if (cache.size >= MAX_CACHE_ENTRIES) {
+		const oldest = cache.keys().next().value;
+		if (oldest) cache.delete(oldest);
+	}
+	const files = await loadWorkspaceBootstrapFiles(dir);
+	cache.set(dir, {
+		files,
+		at: now
+	});
+	return files;
+}
+/** @internal Exported for testing. */
+function truncate(content, max) {
+	if (content.length <= max) return content;
+	return `${content.slice(0, max)}\n\n[... truncated at ${max.toLocaleString()} chars]`;
+}
+/** @internal Exported for testing. */
+function buildContext(files, maxChars) {
+	const sections = [];
+	let totalChars = 0;
+	for (const f of files) {
+		if (f.missing || !f.content?.trim()) continue;
+		const trimmed = f.content.trim();
+		const text = truncate(trimmed, maxChars);
+		const tag = text.length > trimmed.length ? " [TRUNCATED]" : "";
+		const section = `### ${f.name}${tag}\n\n${text}`;
+		if (totalChars + section.length > MAX_TOTAL_WORKSPACE_CHARS && sections.length > 0) break;
+		sections.push(section);
+		totalChars += section.length;
+	}
+	if (sections.length === 0) return "";
+	return `## Project Context (Workspace)\n\n${sections.join("\n\n---\n\n")}`;
+}
+function createWorkspaceProvider(options) {
+	const dir = options?.workspaceDir ?? DEFAULT_AGENT_WORKSPACE_DIR;
+	const maxChars = options?.maxCharsPerFile ?? DEFAULT_MAX_CHARS;
+	return {
+		name: "workspaceContext",
+		description: "Workspace bootstrap files (AGENTS.md, TOOLS.md, IDENTITY.md, etc.) and coding agent context",
+		position: 10,
+		async get(_runtime, message, _state) {
+			const channelType = message.content?.channelType;
+			if (channelType === ChannelType.VOICE_DM || channelType === ChannelType.VOICE_GROUP) return {
+				text: "",
+				data: {
+					workspaceDir: dir,
+					skipped: "voice_channel"
+				}
+			};
+			try {
+				const allFiles = await getFiles(dir);
+				const meta = message.metadata;
+				return {
+					text: buildContext(filterBootstrapFilesForSession(allFiles, typeof meta?.sessionKey === "string" ? meta.sessionKey : void 0), maxChars),
+					data: { workspaceDir: dir }
+				};
+			} catch (err) {
+				logger.warn(`[workspace-provider] Failed to load workspace context: ${err instanceof Error ? err.message : err}`);
+				return {
+					text: `[Workspace context unavailable: ${err instanceof Error ? err.message : err}]`,
+					data: {}
+				};
+			}
+		}
+	};
+}
+
+//#endregion
+export { createWorkspaceProvider };