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

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

@@ -0,0 +1,11 @@
+/**
+ * Autonomy Routes for elizaOS
+ *
+ * API routes for controlling autonomy via REST.
+ */
+import type { Route } from "../../types";
+/**
+ * Autonomy API routes
+ */
+export declare const autonomyRoutes: Route[];
+//# sourceMappingURL=routes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../../../../../../../typescript/src/features/autonomy/routes.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAczC;;GAEG;AACH,eAAO,MAAM,cAAc,EAAE,KAAK,EAuKjC,CAAC"}

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

@@ -0,0 +1,158 @@
+/**
+ * Autonomy Routes for elizaOS
+ *
+ * API routes for controlling autonomy via REST.
+ */
+import { AUTONOMY_SERVICE_TYPE } from "./service";
+/**
+ * Get autonomy service from runtime with fallback
+ */
+function getAutonomyService(runtime) {
+    return (runtime.getService(AUTONOMY_SERVICE_TYPE) || runtime.getService("autonomy"));
+}
+/**
+ * Autonomy API routes
+ */
+export const autonomyRoutes = [
+    {
+        path: "/autonomy/status",
+        type: "GET",
+        handler: async (_req, res, runtime) => {
+            const autonomyService = getAutonomyService(runtime);
+            if (!autonomyService) {
+                res.status(503).json({
+                    error: "Autonomy service not available",
+                });
+                return;
+            }
+            const status = autonomyService.getStatus();
+            res.json({
+                success: true,
+                data: {
+                    enabled: status.enabled,
+                    running: status.running,
+                    interval: status.interval,
+                    intervalSeconds: Math.round(status.interval / 1000),
+                    autonomousRoomId: status.autonomousRoomId,
+                    agentId: runtime.agentId,
+                    characterName: runtime.character?.name || "Agent",
+                },
+            });
+        },
+    },
+    {
+        path: "/autonomy/enable",
+        type: "POST",
+        handler: async (_req, res, runtime) => {
+            const autonomyService = getAutonomyService(runtime);
+            if (!autonomyService) {
+                res.status(503).json({
+                    success: false,
+                    error: "Autonomy service not available",
+                });
+                return;
+            }
+            await autonomyService.enableAutonomy();
+            const status = autonomyService.getStatus();
+            res.json({
+                success: true,
+                message: "Autonomy enabled",
+                data: {
+                    enabled: status.enabled,
+                    running: status.running,
+                    interval: status.interval,
+                },
+            });
+        },
+    },
+    {
+        path: "/autonomy/disable",
+        type: "POST",
+        handler: async (_req, res, runtime) => {
+            const autonomyService = getAutonomyService(runtime);
+            if (!autonomyService) {
+                res.status(503).json({
+                    success: false,
+                    error: "Autonomy service not available",
+                });
+                return;
+            }
+            await autonomyService.disableAutonomy();
+            const status = autonomyService.getStatus();
+            res.json({
+                success: true,
+                message: "Autonomy disabled",
+                data: {
+                    enabled: status.enabled,
+                    running: status.running,
+                    interval: status.interval,
+                },
+            });
+        },
+    },
+    {
+        path: "/autonomy/toggle",
+        type: "POST",
+        handler: async (_req, res, runtime) => {
+            const autonomyService = getAutonomyService(runtime);
+            if (!autonomyService) {
+                res.status(503).json({
+                    success: false,
+                    error: "Autonomy service not available",
+                });
+                return;
+            }
+            const currentStatus = autonomyService.getStatus();
+            if (currentStatus.enabled) {
+                await autonomyService.disableAutonomy();
+            }
+            else {
+                await autonomyService.enableAutonomy();
+            }
+            const newStatus = autonomyService.getStatus();
+            res.json({
+                success: true,
+                message: newStatus.enabled ? "Autonomy enabled" : "Autonomy disabled",
+                data: {
+                    enabled: newStatus.enabled,
+                    running: newStatus.running,
+                    interval: newStatus.interval,
+                },
+            });
+        },
+    },
+    {
+        path: "/autonomy/interval",
+        type: "POST",
+        handler: async (req, res, runtime) => {
+            const autonomyService = getAutonomyService(runtime);
+            if (!autonomyService) {
+                res.status(503).json({
+                    success: false,
+                    error: "Autonomy service not available",
+                });
+                return;
+            }
+            const { interval } = req.body;
+            if (typeof interval !== "number" ||
+                interval < 5000 ||
+                interval > 600000) {
+                res.status(400).json({
+                    success: false,
+                    error: "Interval must be a number between 5000ms (5s) and 600000ms (10m)",
+                });
+                return;
+            }
+            autonomyService.setLoopInterval(interval);
+            const status = autonomyService.getStatus();
+            res.json({
+                success: true,
+                message: "Interval updated",
+                data: {
+                    interval: status.interval,
+                    intervalSeconds: Math.round(status.interval / 1000),
+                },
+            });
+        },
+    },
+];

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

@@ -0,0 +1,138 @@
+/**
+ * Autonomy Service for elizaOS
+ *
+ * Provides autonomous operation for agents using the prompt batcher (Option A).
+ * One register only: the batcher. When enableAutonomy is true, a recurring
+ * section is registered; the batcher's background tick and minCycleMs drive
+ * when the autonomy section drains. No Task DB or worker.
+ */
+import { type IAgentRuntime, type UUID } from "../../types";
+import { Service } from "../../types/service";
+import type { AutonomyStatus } from "./types";
+/**
+ * Service type constant for autonomy
+ */
+export declare const AUTONOMY_SERVICE_TYPE: "AUTONOMY";
+/**
+ * Task name for autonomy thinking
+ */
+export declare const AUTONOMY_TASK_NAME: "AUTONOMY_THINK";
+/**
+ * Tags used for autonomy tasks
+ */
+export declare const AUTONOMY_TASK_TAGS: readonly ["repeat", "autonomy", "internal"];
+/**
+ * AutonomyService - Manages autonomous agent operation.
+ *
+ * Uses the prompt batcher only (Option A): one register, no Task.
+ * When enableAutonomy is true, a recurring section is registered;
+ * the batcher's background tick and minCycleMs drive when it drains.
+ */
+export declare class AutonomyService extends Service {
+    static serviceType: "AUTONOMY";
+    static serviceName: string;
+    protected isRunning: boolean;
+    protected intervalMs: number;
+    protected autonomousRoomId: UUID;
+    protected autonomousWorldId: UUID;
+    private isThinking;
+    protected autonomyEntityId: UUID;
+    private getAutonomyMode;
+    private getTargetRoomId;
+    private getTargetRoomContextText;
+    constructor();
+    /**
+     * Start the autonomy service
+     */
+    static start(runtime: IAgentRuntime): Promise<AutonomyService>;
+    /**
+     * Initialize the service. Option A: autonomy is driven only by the prompt batcher; no Task.
+     * WHY: We only register the batcher section when enableAutonomy is true; no task worker or createTask.
+     */
+    private initialize;
+    /**
+     * Ensure autonomous world and room exist
+     */
+    private ensureAutonomyEntity;
+    private ensureAutonomousContext;
+    private buildEntityNameLookup;
+    private readEntityName;
+    /**
+     * Perform one iteration of autonomous thinking using the full Eliza agent pipeline.
+     * This processes the message through:
+     * - All registered providers (context gathering)
+     * - The LLM generation pipeline (response creation)
+     * - Action processing (executing decided actions)
+     * - Evaluators (post-response analysis)
+     */
+    performAutonomousThink(): Promise<void>;
+    /**
+     * Create a continuous autonomous operation prompt
+     */
+    private createContinuousPrompt;
+    private createTaskPrompt;
+    private fillAutonomyTemplate;
+    /**
+     * Build the autonomy context string for the prompt batcher (Reason phase).
+     * Used by the batcher section's contextBuilder; does not assume messages exist.
+     * WHY: Recurring autonomy drains with an empty message buffer; context must come
+     * from runtime (room context, last thought from memories) and the same templates
+     * as the old performAutonomousThink path so model behavior stays consistent.
+     */
+    buildAutonomyContextForBatcher(): Promise<string>;
+    /**
+     * Register the autonomy section with the prompt batcher (recurring, contextBuilder-driven).
+     * Idempotent by section id "autonomy". Called when autonomy is enabled.
+     * WHY: One register only (Option A). Batcher owns "when" via minCycleMs and background
+     * tick; we supply "what" (contextBuilder, preamble, schema). Same schema as message
+     * pipeline so the execution facade consumes batcher output without a separate contract.
+     */
+    private registerAutonomyBatcherSection;
+    /**
+     * Check if autonomy is currently running
+     */
+    isLoopRunning(): boolean;
+    /**
+     * Get current loop interval in milliseconds
+     */
+    getLoopInterval(): number;
+    /**
+     * Set loop interval (recreates the task with new interval)
+     */
+    setLoopInterval(ms: number): Promise<void>;
+    /**
+     * Get the autonomous room ID
+     */
+    getAutonomousRoomId(): UUID;
+    /**
+     * Enable autonomy — registers the section with the prompt batcher (Option A; no Task).
+     * WHY: No Task creation; one register only. Batcher background tick + minCycleMs drive when the section drains.
+     */
+    enableAutonomy(): Promise<void>;
+    /**
+     * Disable autonomy — removes the section from the prompt batcher.
+     * WHY: removeSection("autonomy") stops future drains; no Task to delete.
+     */
+    disableAutonomy(): Promise<void>;
+    /**
+     * Legacy method names for backwards compatibility
+     */
+    startLoop(): Promise<void>;
+    stopLoop(): Promise<void>;
+    /**
+     * Trigger an autonomous thinking cycle immediately.
+     * Useful for testing or manual intervention without waiting for the interval.
+     * @returns true if thinking was triggered, false if already thinking or an error occurred
+     */
+    triggerThinkNow(): Promise<boolean>;
+    /**
+     * Get current autonomy status
+     */
+    getStatus(): AutonomyStatus;
+    /**
+     * Stop the service
+     */
+    stop(): Promise<void>;
+    get capabilityDescription(): string;
+}
+//# sourceMappingURL=service.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../../../../../../typescript/src/features/autonomy/service.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAUH,OAAO,EAMN,KAAK,aAAa,EAElB,KAAK,IAAI,EACT,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAG9C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAE9C;;GAEG;AACH,eAAO,MAAM,qBAAqB,EAAG,UAAmB,CAAC;AAEzD;;GAEG;AACH,eAAO,MAAM,kBAAkB,EAAG,gBAAyB,CAAC;AAE5D;;GAEG;AACH,eAAO,MAAM,kBAAkB,6CAA8C,CAAC;AAG9E;;;;;;GAMG;AACH,qBAAa,eAAgB,SAAQ,OAAO;IAC3C,MAAM,CAAC,WAAW,aAAyB;IAC3C,MAAM,CAAC,WAAW,SAAc;IAEhC,SAAS,CAAC,SAAS,UAAS;IAC5B,SAAS,CAAC,UAAU,EAAE,MAAM,CAAC;IAC7B,SAAS,CAAC,gBAAgB,EAAE,IAAI,CAAC;IACjC,SAAS,CAAC,iBAAiB,EAAE,IAAI,CAAC;IAClC,OAAO,CAAC,UAAU,CAAS;IAC3B,SAAS,CAAC,gBAAgB,EAAE,IAAI,CAAC;IAEjC,OAAO,CAAC,eAAe;IAMvB,OAAO,CAAC,eAAe;YAUT,wBAAwB;;IA0HtC;;OAEG;WACU,KAAK,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,eAAe,CAAC;IAOpE;;;OAGG;YACW,UAAU;IAoDxB;;OAEG;YACW,oBAAoB;YAyCpB,uBAAuB;YA8DvB,qBAAqB;IAenC,OAAO,CAAC,cAAc;IAUtB;;;;;;;OAOG;IACG,sBAAsB,IAAI,OAAO,CAAC,IAAI,CAAC;IAoN7C;;OAEG;IACH,OAAO,CAAC,sBAAsB;IAc9B,OAAO,CAAC,gBAAgB;IAcxB,OAAO,CAAC,oBAAoB;IAY5B;;;;;;OAMG;IACG,8BAA8B,IAAI,OAAO,CAAC,MAAM,CAAC;IA4DvD;;;;;;OAMG;IACH,OAAO,CAAC,8BAA8B;IA6JtC;;OAEG;IACH,aAAa,IAAI,OAAO;IAIxB;;OAEG;IACH,eAAe,IAAI,MAAM;IAIzB;;OAEG;IACG,eAAe,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAgChD;;OAEG;IACH,mBAAmB,IAAI,IAAI;IAI3B;;;OAGG;IACG,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC;IAQrC;;;OAGG;IACG,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC;IAQtC;;OAEG;IACG,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;IAI1B,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAI/B;;;;OAIG;IACG,eAAe,IAAI,OAAO,CAAC,OAAO,CAAC;IA6BzC;;OAEG;IACH,SAAS,IAAI,cAAc;IAW3B;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAS3B,IAAI,qBAAqB,IAAI,MAAM,CAElC;CACD"}