@elizaos/ui 2.0.0-alpha.25 → 2.0.0-alpha.334

package/packages/typescript/src/features/advanced-planning/types.d.ts

@@ -0,0 +1,78 @@
+import type { ActionParameters, ActionResult, HandlerCallback, Memory, State, UUID } from "../../types/index.ts";
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export type ExecutionModel = "sequential" | "parallel" | "dag";
+export type PlanStatus = "pending" | "running" | "completed" | "failed" | "cancelled";
+export interface PlanningContext {
+    goal: string;
+    message?: Memory;
+    state?: State;
+    constraints?: Array<{
+        type: "time" | "resource" | "custom";
+        value: string | number;
+        description?: string;
+    }>;
+    availableActions?: string[];
+    preferences?: {
+        executionModel?: ExecutionModel;
+        maxSteps?: number;
+        timeoutMs?: number;
+    };
+}
+export interface RetryPolicy {
+    maxRetries: number;
+    backoffMs: number;
+    backoffMultiplier: number;
+    onError: "abort" | "continue" | "skip";
+}
+export interface ActionStepExtended {
+    id: UUID;
+    actionName: string;
+    parameters: ActionParameters;
+    dependencies: UUID[];
+    retryPolicy?: RetryPolicy;
+    onError?: "abort" | "continue" | "skip";
+}
+export interface ExtendedActionPlan {
+    id: string;
+    goal: string;
+    thought: string;
+    totalSteps: number;
+    currentStep: number;
+    steps: ActionStepExtended[];
+    executionModel: ExecutionModel;
+    createdAt: number;
+    context?: PlanningContext;
+}
+export interface PlanExecutionResult {
+    planId: string;
+    success: boolean;
+    completedSteps: number;
+    totalSteps: number;
+    results: ActionResult[];
+    error?: string;
+    duration?: number;
+}
+export interface PlanState {
+    status: PlanStatus;
+    currentStepIndex: number;
+    startTime?: number;
+    endTime?: number;
+    error?: string;
+}
+export interface IPlanningService {
+    createSimplePlan(goal: string, message?: Memory, state?: State): Promise<ExtendedActionPlan>;
+    createComprehensivePlan(context: PlanningContext): Promise<ExtendedActionPlan>;
+    executePlan(plan: ExtendedActionPlan, message: Memory, state: State, callback?: HandlerCallback): Promise<PlanExecutionResult>;
+    validatePlan(plan: ExtendedActionPlan): Promise<{
+        valid: boolean;
+        errors: string[];
+        warnings: string[];
+    }>;
+    cancelPlan(planId: string): Promise<boolean>;
+    getPlanStatus(planId: string): Promise<PlanState | null>;
+    adaptPlan(planId: string, newContext: PlanningContext, reason: string): Promise<ExtendedActionPlan | null>;
+}
+//# sourceMappingURL=types.d.ts.map

package/packages/typescript/src/features/advanced-planning/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../../typescript/src/features/advanced-planning/types.ts"],"names":[],"mappings":"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"}

package/packages/typescript/src/features/advanced-planning/types.js

@@ -0,0 +1 @@
+export {};

package/packages/typescript/src/features/autonomy/action.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Autonomy Actions for elizaOS
+ *
+ * Actions that enable autonomous agent communication.
+ */
+import type { Action } from "../../types";
+/**
+ * Send to Admin Action
+ *
+ * Allows agent to send messages to admin from autonomous context.
+ * Only available in autonomous room to prevent misuse.
+ */
+export declare const sendToAdminAction: Action;
+//# sourceMappingURL=action.d.ts.map

package/packages/typescript/src/features/autonomy/action.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"action.d.ts","sourceRoot":"","sources":["../../../../../../../typescript/src/features/autonomy/action.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAOH,OAAO,KAAK,EACX,MAAM,EAQN,MAAM,aAAa,CAAC;AAQrB;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,EAAE,MA+L/B,CAAC"}

package/packages/typescript/src/features/autonomy/action.js

@@ -0,0 +1,177 @@
+/**
+ * Autonomy Actions for elizaOS
+ *
+ * Actions that enable autonomous agent communication.
+ */
+import { v4 as uuidv4 } from "uuid";
+import { findKeywordTermMatch, getValidationKeywordTerms, } from "../../i18n/validation-keywords.js";
+import { stringToUuid } from "../../utils";
+import { AUTONOMY_SERVICE_TYPE } from "./service";
+const ADMIN_KEYWORDS = getValidationKeywordTerms("action.sendToAdmin.request", {
+    includeAllLocales: true,
+});
+/**
+ * Send to Admin Action
+ *
+ * Allows agent to send messages to admin from autonomous context.
+ * Only available in autonomous room to prevent misuse.
+ */
+export const sendToAdminAction = {
+    name: "SEND_TO_ADMIN",
+    description: "Send a message directly to the admin user from autonomous context",
+    examples: [
+        [
+            {
+                name: "Agent",
+                content: {
+                    text: "I need to update the admin about my progress on the task.",
+                    action: "SEND_TO_ADMIN",
+                },
+            },
+            {
+                name: "Agent",
+                content: {
+                    text: "Message sent to admin successfully.",
+                },
+            },
+        ],
+        [
+            {
+                name: "Agent",
+                content: {
+                    text: "I should let the admin know I completed the analysis.",
+                    action: "SEND_TO_ADMIN",
+                },
+            },
+            {
+                name: "Agent",
+                content: {
+                    text: "Admin has been notified of the analysis completion.",
+                },
+            },
+        ],
+    ],
+    validate: async (runtime, message) => {
+        // Only allow this action in autonomous context
+        const autonomyService = runtime.getService(AUTONOMY_SERVICE_TYPE);
+        if (!autonomyService) {
+            return false;
+        }
+        const autonomousRoomId = autonomyService.getAutonomousRoomId?.();
+        if (!autonomousRoomId || message.roomId !== autonomousRoomId) {
+            return false;
+        }
+        // Check if admin is configured
+        const adminUserId = runtime.getSetting("ADMIN_USER_ID");
+        if (typeof adminUserId !== "string" || adminUserId.length === 0) {
+            return false;
+        }
+        // Check if message contains intention to communicate with admin
+        const text = message.content.text ?? "";
+        if (text.length === 0) {
+            return false;
+        }
+        return findKeywordTermMatch(text, ADMIN_KEYWORDS) !== undefined;
+    },
+    handler: async (runtime, message, _state, _options, callback) => {
+        // Double-check we're in autonomous context
+        const autonomyService = runtime.getService(AUTONOMY_SERVICE_TYPE);
+        if (!autonomyService) {
+            return {
+                success: false,
+                text: "Autonomy service not available",
+                data: { error: "Service unavailable" },
+            };
+        }
+        const autonomousRoomId = autonomyService.getAutonomousRoomId?.();
+        if (!autonomousRoomId || message.roomId !== autonomousRoomId) {
+            return {
+                success: false,
+                text: "Send to admin only available in autonomous context",
+                data: { error: "Invalid context" },
+            };
+        }
+        // Get admin user ID
+        const adminUserId = runtime.getSetting("ADMIN_USER_ID");
+        if (typeof adminUserId !== "string" || adminUserId.length === 0) {
+            return {
+                success: false,
+                text: "No admin user configured. Set ADMIN_USER_ID in settings.",
+                data: { error: "No admin configured" },
+            };
+        }
+        // Find target room
+        const adminMessages = await runtime.getMemories({
+            roomId: runtime.agentId,
+            limit: 10,
+            tableName: "memories",
+        });
+        let targetRoomId;
+        if (adminMessages && adminMessages.length > 0) {
+            const lastMessage = adminMessages[adminMessages.length - 1];
+            targetRoomId = lastMessage.roomId ?? runtime.agentId;
+        }
+        else {
+            targetRoomId = runtime.agentId;
+        }
+        // Extract message content
+        const autonomousThought = message.content.text || "";
+        // Generate message to admin
+        let messageToAdmin;
+        if (autonomousThought.includes("completed") ||
+            autonomousThought.includes("finished")) {
+            messageToAdmin = `I've completed a task and wanted to update you. My thoughts: ${autonomousThought}`;
+        }
+        else if (autonomousThought.includes("problem") ||
+            autonomousThought.includes("issue") ||
+            autonomousThought.includes("error")) {
+            messageToAdmin = `I encountered something that might need your attention: ${autonomousThought}`;
+        }
+        else if (autonomousThought.includes("question") ||
+            autonomousThought.includes("unsure")) {
+            messageToAdmin = `I have a question and would appreciate your guidance: ${autonomousThought}`;
+        }
+        else {
+            messageToAdmin = `Autonomous update: ${autonomousThought}`;
+        }
+        // Create and store message
+        const now = Date.now();
+        const adminMessage = {
+            id: stringToUuid(uuidv4()),
+            entityId: runtime.agentId,
+            roomId: targetRoomId,
+            content: {
+                text: messageToAdmin,
+                source: "autonomy-to-admin",
+                metadata: {
+                    type: "autonomous-to-admin-message",
+                    originalThought: autonomousThought,
+                    timestamp: now,
+                },
+            },
+            createdAt: now,
+        };
+        await runtime.createMemory(adminMessage, "memories");
+        const successMessage = `Message sent to admin in room ${targetRoomId.slice(0, 8)}...`;
+        if (callback) {
+            await callback({
+                text: successMessage,
+                data: {
+                    adminUserId,
+                    targetRoomId,
+                    messageContent: messageToAdmin,
+                },
+            });
+        }
+        return {
+            success: true,
+            text: successMessage,
+            data: {
+                adminUserId,
+                targetRoomId,
+                messageContent: messageToAdmin,
+                sent: true,
+            },
+        };
+    },
+};

package/packages/typescript/src/features/autonomy/execution-facade.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Execution facade for autonomy: runs the same post-LLM steps as the message
+ * pipeline (processActions, memory creation, evaluators) given batcher result
+ * fields and a synthetic autonomy message.
+ *
+ * WHY: The batcher delivers the Reason phase output; we must run Run actions +
+ * Evaluate without duplicating message.ts. One facade keeps schema and semantics
+ * aligned and gives a single place to change post-LLM behavior.
+ */
+import type { HandlerCallback, IAgentRuntime, Memory } from "../../types/index.ts";
+/**
+ * Run the same post-LLM steps as the message pipeline for an autonomy response:
+ * build response content and messages, save to memory, process actions, run
+ * evaluators. Call this from the autonomy batcher section's onResult.
+ *
+ * @param runtime - Agent runtime
+ * @param autonomousMessage - Synthetic message representing the autonomy prompt (entityId = autonomy entity, roomId = autonomous room, content.metadata isAutonomous etc.)
+ * @param fields - Batcher result fields (thought, actions, text, simple, etc.; namespace already stripped)
+ * @param callback - Optional handler callback (e.g. for logging or downstream consumers)
+ */
+export declare function runAutonomyPostResponse(runtime: IAgentRuntime, autonomousMessage: Memory, fields: Record<string, unknown>, callback?: HandlerCallback): Promise<void>;
+//# sourceMappingURL=execution-facade.d.ts.map

package/packages/typescript/src/features/autonomy/execution-facade.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execution-facade.d.ts","sourceRoot":"","sources":["../../../../../../../typescript/src/features/autonomy/execution-facade.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,OAAO,KAAK,EAEX,eAAe,EACf,aAAa,EACb,MAAM,EAEN,MAAM,sBAAsB,CAAC;AAmD9B;;;;;;;;;GASG;AACH,wBAAsB,uBAAuB,CAC5C,OAAO,EAAE,aAAa,EACtB,iBAAiB,EAAE,MAAM,EACzB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,QAAQ,CAAC,EAAE,eAAe,GACxB,OAAO,CAAC,IAAI,CAAC,CA6Hf"}

package/packages/typescript/src/features/autonomy/execution-facade.js

@@ -0,0 +1,150 @@
+/**
+ * Execution facade for autonomy: runs the same post-LLM steps as the message
+ * pipeline (processActions, memory creation, evaluators) given batcher result
+ * fields and a synthetic autonomy message.
+ *
+ * WHY: The batcher delivers the Reason phase output; we must run Run actions +
+ * Evaluate without duplicating message.ts. One facade keeps schema and semantics
+ * aligned and gives a single place to change post-LLM behavior.
+ */
+import { v4 as uuidv4 } from "uuid";
+import { createUniqueUuid } from "../../entities.js";
+import { outgoingPipelineHookContext } from "../../types/pipeline-hooks.js";
+import { stringToUuid } from "../../utils.js";
+/**
+ * Normalize batcher result fields into Content shape expected by processActions
+ * and the message pipeline. WHY: The dispatcher returns namespace-stripped
+ * fields; processActions expects Content (thought, actions array, text, simple,
+ * providers). We accept array or comma-separated string for actions/providers
+ * so we tolerate both schema encodings.
+ */
+function fieldsToContent(fields) {
+    const actionsRaw = fields.actions;
+    const normalizedActions = (() => {
+        if (Array.isArray(actionsRaw)) {
+            return actionsRaw
+                .map((a) => String(a).trim())
+                .filter((a) => a.length > 0);
+        }
+        if (typeof actionsRaw === "string") {
+            return actionsRaw
+                .split(",")
+                .map((a) => String(a).trim())
+                .filter((a) => a.length > 0);
+        }
+        return [];
+    })();
+    // WHY: Empty actions would break processActions expectations; IGNORE is the safe no-op.
+    const finalActions = normalizedActions.length > 0 ? normalizedActions : ["IGNORE"];
+    const providers = Array.isArray(fields.providers)
+        ? fields.providers.filter((p) => typeof p === "string")
+        : typeof fields.providers === "string"
+            ? fields.providers
+                .split(",")
+                .map((p) => String(p).trim())
+                .filter((p) => p.length > 0)
+            : [];
+    return {
+        thought: String(fields.thought ?? ""),
+        actions: finalActions,
+        text: String(fields.text ?? ""),
+        simple: fields.simple === true || fields.simple === "true",
+        providers,
+    };
+}
+/**
+ * Run the same post-LLM steps as the message pipeline for an autonomy response:
+ * build response content and messages, save to memory, process actions, run
+ * evaluators. Call this from the autonomy batcher section's onResult.
+ *
+ * @param runtime - Agent runtime
+ * @param autonomousMessage - Synthetic message representing the autonomy prompt (entityId = autonomy entity, roomId = autonomous room, content.metadata isAutonomous etc.)
+ * @param fields - Batcher result fields (thought, actions, text, simple, etc.; namespace already stripped)
+ * @param callback - Optional handler callback (e.g. for logging or downstream consumers)
+ */
+export async function runAutonomyPostResponse(runtime, autonomousMessage, fields, callback) {
+    const responseContent = fieldsToContent(fields);
+    // WHY: inReplyTo links the response to the autonomy "prompt" message so threading and callbacks are consistent.
+    if (autonomousMessage.id) {
+        responseContent.inReplyTo = createUniqueUuid(runtime, autonomousMessage.id);
+    }
+    const responseId = stringToUuid(uuidv4());
+    // WHY: processActions expects Memory[] with content; one item matches the message pipeline's single-shot response shape.
+    const responseMessages = [
+        {
+            id: responseId,
+            entityId: runtime.agentId,
+            agentId: runtime.agentId,
+            content: responseContent,
+            roomId: autonomousMessage.roomId,
+            createdAt: Date.now(),
+        },
+    ];
+    // WHY: Same provider list as message pipeline before processActions/evaluate so action names and evaluator context are available.
+    const state = await runtime.composeState(autonomousMessage, [
+        "ACTIONS",
+        "RECENT_MESSAGES",
+        "EVALUATORS",
+    ]);
+    // WHY: Mirror message pipeline logic so we take the same branch (simple = callback only, actions = processActions).
+    const isSimple = responseContent.actions?.length === 1 &&
+        String(responseContent.actions[0]).toUpperCase() === "REPLY";
+    const isStop = responseContent.actions?.length === 1 &&
+        String(responseContent.actions[0]).toUpperCase() === "STOP";
+    const mode = isStop
+        ? "none"
+        : isSimple && responseContent.text
+            ? "simple"
+            : "actions";
+    if (mode === "simple") {
+        await runtime.applyPipelineHooks("outgoing_before_deliver", outgoingPipelineHookContext(responseContent, {
+            source: "autonomy_simple",
+            roomId: autonomousMessage.roomId,
+            message: autonomousMessage,
+            responseId: responseContent.responseId ?? responseMessages[0]?.id,
+        }));
+    }
+    else if (isStop) {
+        await runtime.applyPipelineHooks("outgoing_before_deliver", outgoingPipelineHookContext(responseContent, {
+            source: "excluded",
+            roomId: autonomousMessage.roomId,
+            message: autonomousMessage,
+        }));
+    }
+    for (const responseMemory of responseMessages) {
+        runtime.logger.debug({ src: "autonomy:facade", memoryId: responseMemory.id }, "Saving autonomy response to memory");
+        await runtime.createMemory(responseMemory, "messages");
+    }
+    if (mode === "simple" && callback) {
+        await callback(responseContent);
+    }
+    else if (mode === "actions") {
+        await runtime.processActions(autonomousMessage, responseMessages, state, async (content) => {
+            runtime.logger.debug({ src: "autonomy:facade", content }, "Autonomy action callback");
+            if (callback) {
+                return callback(content);
+            }
+            return [];
+        }, {});
+    }
+    // WHY: didRespond gates some evaluators; autonomy "responded" when there is text or non-IGNORE actions.
+    const didRespond = (typeof responseContent.text === "string" &&
+        responseContent.text.trim().length > 0) ||
+        (responseContent.actions &&
+            responseContent.actions.length > 0 &&
+            responseContent.actions[0]?.toUpperCase() !== "IGNORE" &&
+            responseContent.actions[0]?.toUpperCase() !== "STOP");
+    await runtime.evaluate(autonomousMessage, state, didRespond, async (content) => {
+        runtime.logger.debug({ src: "autonomy:facade", content }, "Autonomy evaluate callback");
+        if (callback) {
+            await runtime.applyPipelineHooks("outgoing_before_deliver", outgoingPipelineHookContext(content, {
+                source: "autonomy_evaluate",
+                roomId: autonomousMessage.roomId,
+                message: autonomousMessage,
+                responseId: content.responseId,
+            }));
+            return callback(content);
+        }
+        return [];
+    }, responseMessages);
+}

package/packages/typescript/src/features/autonomy/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Autonomy module for elizaOS
+ *
+ * Provides autonomous operation capabilities for agents.
+ */
+export { sendToAdminAction } from "./action";
+export { adminChatProvider, autonomyStatusProvider } from "./providers";
+export { autonomyRoutes } from "./routes";
+export { AUTONOMY_SERVICE_TYPE, AUTONOMY_TASK_NAME, AUTONOMY_TASK_TAGS, AutonomyService, } from "./service";
+export type { AutonomyConfig, AutonomyStatus } from "./types";
+//# sourceMappingURL=index.d.ts.map

package/packages/typescript/src/features/autonomy/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../typescript/src/features/autonomy/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAE7C,OAAO,EAAE,iBAAiB,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAExE,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAE1C,OAAO,EACN,qBAAqB,EACrB,kBAAkB,EAClB,kBAAkB,EAClB,eAAe,GACf,MAAM,WAAW,CAAC;AAEnB,YAAY,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC"}

package/packages/typescript/src/features/autonomy/index.js

@@ -0,0 +1,13 @@
+/**
+ * Autonomy module for elizaOS
+ *
+ * Provides autonomous operation capabilities for agents.
+ */
+// Action
+export { sendToAdminAction } from "./action";
+// Providers
+export { adminChatProvider, autonomyStatusProvider } from "./providers";
+// Routes
+export { autonomyRoutes } from "./routes";
+// Service
+export { AUTONOMY_SERVICE_TYPE, AUTONOMY_TASK_NAME, AUTONOMY_TASK_TAGS, AutonomyService, } from "./service";

package/packages/typescript/src/features/autonomy/providers.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Autonomy Providers for elizaOS
+ *
+ * Providers that supply autonomous context information.
+ */
+import type { Provider } from "../../types";
+/**
+ * Admin Chat Provider
+ *
+ * Provides conversation history with admin user for autonomous context.
+ * Only active in autonomous room to give agent memory of admin interactions.
+ */
+export declare const adminChatProvider: Provider;
+/**
+ * Autonomy Status Provider
+ *
+ * Shows autonomy status in regular conversations.
+ * Does NOT show in autonomous room to avoid unnecessary context.
+ */
+export declare const autonomyStatusProvider: Provider;
+//# sourceMappingURL=providers.d.ts.map

package/packages/typescript/src/features/autonomy/providers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"providers.d.ts","sourceRoot":"","sources":["../../../../../../../typescript/src/features/autonomy/providers.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAGX,QAAQ,EAGR,MAAM,aAAa,CAAC;AAIrB;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,EAAE,QAwG/B,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,EAAE,QAiEpC,CAAC"}

package/packages/typescript/src/features/autonomy/providers.js

@@ -0,0 +1,154 @@
+/**
+ * Autonomy Providers for elizaOS
+ *
+ * Providers that supply autonomous context information.
+ */
+import { stringToUuid } from "../../utils";
+import { AUTONOMY_SERVICE_TYPE } from "./service";
+/**
+ * Admin Chat Provider
+ *
+ * Provides conversation history with admin user for autonomous context.
+ * Only active in autonomous room to give agent memory of admin interactions.
+ */
+export const adminChatProvider = {
+    name: "ADMIN_CHAT_HISTORY",
+    description: "Provides recent conversation history with the admin user for autonomous context",
+    get: async (runtime, message, _state) => {
+        // Only provide admin chat context in autonomous room
+        const autonomyService = runtime.getService(AUTONOMY_SERVICE_TYPE);
+        if (!autonomyService) {
+            return { text: "", data: {} };
+        }
+        const autonomousRoomId = autonomyService.getAutonomousRoomId?.();
+        if (!autonomousRoomId || message.roomId !== autonomousRoomId) {
+            return { text: "", data: {} };
+        }
+        // Get admin user ID
+        const adminUserId = runtime.getSetting("ADMIN_USER_ID");
+        if (!adminUserId) {
+            return {
+                text: "[ADMIN_CHAT_HISTORY]\nNo admin user configured. Set ADMIN_USER_ID in character settings.\n[/ADMIN_CHAT_HISTORY]",
+                data: { adminConfigured: false },
+            };
+        }
+        const adminUUID = stringToUuid(adminUserId);
+        // Get recent messages from/to admin user
+        const adminMessages = await runtime.getMemories({
+            entityId: adminUUID,
+            limit: 15,
+            unique: false,
+            tableName: "memories",
+        });
+        if (!adminMessages || adminMessages.length === 0) {
+            return {
+                text: "[ADMIN_CHAT_HISTORY]\nNo recent messages found with admin user.\n[/ADMIN_CHAT_HISTORY]",
+                data: {
+                    adminConfigured: true,
+                    messageCount: 0,
+                    adminUserId,
+                },
+            };
+        }
+        // Format conversation history
+        const sortedMessages = adminMessages.sort((a, b) => (a.createdAt || 0) - (b.createdAt || 0));
+        const historyStart = sortedMessages.length > 10 ? sortedMessages.length - 10 : 0;
+        const conversationHistory = sortedMessages
+            .slice(historyStart)
+            .map((msg) => {
+            const isFromAdmin = msg.entityId === adminUUID;
+            const isFromAgent = msg.entityId === runtime.agentId;
+            const sender = isFromAdmin ? "Admin" : isFromAgent ? "Agent" : "Other";
+            const text = msg.content.text || "[No text content]";
+            const timestamp = new Date(msg.createdAt || 0).toLocaleTimeString();
+            return `${timestamp} ${sender}: ${text}`;
+        })
+            .join("\n");
+        // Get recent admin messages
+        const recentAdminMessages = [];
+        for (let i = sortedMessages.length - 1; i >= 0; i -= 1) {
+            const msg = sortedMessages[i];
+            if (msg.entityId !== adminUUID)
+                continue;
+            recentAdminMessages.push(msg);
+            if (recentAdminMessages.length === 3)
+                break;
+        }
+        recentAdminMessages.reverse();
+        const lastAdminMessage = recentAdminMessages[recentAdminMessages.length - 1];
+        const adminMoodContext = recentAdminMessages.length > 0
+            ? `Last admin message: "${lastAdminMessage?.content.text || "N/A"}"`
+            : "No recent admin messages";
+        const now = Date.now();
+        return {
+            text: `[ADMIN_CHAT_HISTORY]\nRecent conversation with admin user (${adminMessages.length} total messages):\n\n${conversationHistory}\n\n${adminMoodContext}\n[/ADMIN_CHAT_HISTORY]`,
+            data: {
+                adminConfigured: true,
+                messageCount: adminMessages.length,
+                adminUserId,
+                recentMessageCount: recentAdminMessages.length,
+                lastAdminMessage: lastAdminMessage?.content.text || "",
+                conversationActive: adminMessages.some((m) => now - (m.createdAt || 0) < 3600000),
+            },
+        };
+    },
+};
+/**
+ * Autonomy Status Provider
+ *
+ * Shows autonomy status in regular conversations.
+ * Does NOT show in autonomous room to avoid unnecessary context.
+ */
+export const autonomyStatusProvider = {
+    name: "AUTONOMY_STATUS",
+    description: "Provides current autonomy status for agent awareness in conversations",
+    get: async (runtime, message, _state) => {
+        // Get autonomy service
+        const autonomyService = runtime.getService(AUTONOMY_SERVICE_TYPE);
+        if (!autonomyService) {
+            return { text: "", data: {} };
+        }
+        // Don't show in autonomous room (avoid noise)
+        const autonomousRoomId = autonomyService.getAutonomousRoomId?.();
+        if (autonomousRoomId && message.roomId === autonomousRoomId) {
+            return { text: "", data: {} };
+        }
+        // Get status
+        const autonomyEnabled = runtime.enableAutonomy;
+        const serviceRunning = autonomyService.isLoopRunning?.() || false;
+        const interval = autonomyService.getLoopInterval?.() || 30000;
+        // Determine status display
+        let status;
+        let statusIcon;
+        if (serviceRunning) {
+            status = "running autonomously";
+            statusIcon = "🤖";
+        }
+        else if (autonomyEnabled) {
+            status = "autonomy enabled but not running";
+            statusIcon = "⏸️";
+        }
+        else {
+            status = "autonomy disabled";
+            statusIcon = "🔕";
+        }
+        const intervalSeconds = Math.round(interval / 1000);
+        const intervalUnit = intervalSeconds < 60
+            ? `${intervalSeconds} seconds`
+            : `${Math.round(intervalSeconds / 60)} minutes`;
+        return {
+            text: `[AUTONOMY_STATUS]\nCurrent status: ${statusIcon} ${status}\nThinking interval: ${intervalUnit}\n[/AUTONOMY_STATUS]`,
+            data: {
+                autonomyEnabled,
+                serviceRunning,
+                interval,
+                intervalSeconds,
+                status: serviceRunning
+                    ? "running"
+                    : autonomyEnabled
+                        ? "enabled"
+                        : "disabled",
+            },
+        };
+    },
+};