@elizaos/python 2.0.0-alpha.3 → 2.0.0-alpha.31

package/elizaos/bootstrap/autonomy/evaluators.py

@@ -0,0 +1,217 @@
+"""Post-action evaluator for the autonomous loop.
+
+After actions complete during an autonomous cycle, this evaluator asks the LLM
+whether the agent has satisfied its goal or should continue with more actions.
+If the LLM says CONTINUE, the evaluator recursively triggers another full
+message-handling cycle so the agent can pick and execute additional actions.
+This repeats until the LLM says PAUSE or the safety limit is reached.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any
+
+from elizaos.types.components import ActionResult, Evaluator, HandlerOptions
+from elizaos.types.memory import Memory
+from elizaos.types.model import ModelType
+from elizaos.types.primitives import Content
+
+from .service import AUTONOMY_SERVICE_TYPE, AutonomyService
+
+if TYPE_CHECKING:
+    from collections.abc import Awaitable, Callable
+
+    from elizaos.types.runtime import IAgentRuntime
+    from elizaos.types.state import State
+
+_logger = logging.getLogger(__name__)
+
+# Safety limit – the evaluator will stop recursing after this many
+# consecutive CONTINUE decisions within a single evaluation chain.
+MAX_CONTINUATION_DEPTH = 10
+
+POST_ACTION_EVALUATION_TEMPLATE = """\
+You are evaluating whether an autonomous agent has completed its current objective.
+
+Recent actions and their results:
+{action_results}
+
+Recent context:
+{recent_context}
+
+Based on the above, decide:
+- If the agent has completed everything it set out to do, or there is nothing \
+more it can meaningfully do right now, respond with exactly: PAUSE
+- If there are remaining steps, errors that need retrying, or follow-up actions \
+the agent should take immediately, respond with exactly: CONTINUE
+
+Respond with a single word: CONTINUE or PAUSE
+"""
+
+
+async def _validate_post_action(
+    runtime: IAgentRuntime,
+    message: Memory,
+    _state: State | None = None,
+) -> bool:
+    """Run when the message originated from the autonomy service."""
+    if not message.content:
+        return False
+
+    # Check content.data for autonomy markers
+    data = message.content.data
+    if isinstance(data, dict):
+        if data.get("isAutonomous") is True or data.get("source") == "autonomy-service":
+            return True
+
+    # Check content.source field
+    source = getattr(message.content, "source", None)
+    return bool(isinstance(source, str) and source == "autonomy-service")
+
+
+def _collect_action_results_text(runtime: IAgentRuntime, message: Memory) -> str:
+    """Build a human-readable summary of most recent action results."""
+    if not message.id:
+        return "(no action results available)"
+
+    results = runtime.get_action_results(message.id)
+    if not results:
+        return "(no action results available)"
+
+    lines: list[str] = []
+    for r in results:
+        name = ""
+        data = getattr(r, "data", None)
+        if isinstance(data, dict):
+            v = data.get("actionName")
+            if isinstance(v, str):
+                name = v
+        success = getattr(r, "success", True)
+        text = getattr(r, "text", "")
+        status = "success" if success else "failed"
+        lines.append(f"- {name} ({status}): {text}")
+
+    return "\n".join(lines) if lines else "(no action results available)"
+
+
+async def _collect_recent_context(runtime: IAgentRuntime, room_id: Any) -> str:
+    """Gather a short snippet of recent memories for the evaluation prompt."""
+    try:
+        recent_memories = await runtime.get_memories(
+            {"roomId": room_id, "count": 5, "tableName": "memories"}
+        )
+    except Exception:
+        return "(no recent context)"
+
+    if not recent_memories:
+        return "(no recent context)"
+
+    ctx_lines: list[str] = []
+    for m in recent_memories:
+        if m.content and m.content.text:
+            ctx_lines.append(m.content.text[:200])
+
+    return "\n".join(ctx_lines[-3:]) if ctx_lines else "(no recent context)"
+
+
+async def _handle_post_action(
+    runtime: IAgentRuntime,
+    message: Memory,
+    state: State | None = None,
+    options: HandlerOptions | None = None,
+    callback: Callable[[Content], Awaitable[None]] | None = None,
+    responses: list[Memory] | None = None,
+) -> ActionResult | None:
+    """Evaluate whether the agent should continue with more actions.
+
+    Runs after ``processActions`` completes during an autonomy cycle.
+    If the LLM says CONTINUE, it recursively triggers another autonomous
+    think iteration.  This repeats until the LLM says PAUSE or the
+    safety depth limit is reached.
+    """
+    autonomy_service = runtime.get_service(AUTONOMY_SERVICE_TYPE)
+    if not autonomy_service or not isinstance(autonomy_service, AutonomyService):
+        return None
+
+    # Don't evaluate if autonomy is not actually running
+    if not autonomy_service.is_loop_running():
+        return None
+
+    # Track recursion depth via an attribute on the service instance
+    depth: int = getattr(autonomy_service, "_eval_depth", 0)
+
+    action_results_text = _collect_action_results_text(runtime, message)
+
+    room_id = autonomy_service.get_autonomous_room_id() or message.room_id
+    recent_context = await _collect_recent_context(runtime, room_id)
+
+    prompt = POST_ACTION_EVALUATION_TEMPLATE.format(
+        action_results=action_results_text,
+        recent_context=recent_context,
+    )
+
+    try:
+        result = await runtime.use_model(
+            ModelType.TEXT_SMALL,
+            {"prompt": prompt, "temperature": 0.1, "maxTokens": 10},
+        )
+        decision = str(result).strip().upper()
+    except Exception as e:
+        _logger.warning(f"Post-action evaluation LLM call failed: {e}")
+        autonomy_service._eval_depth = 0  # type: ignore[attr-defined]
+        return None
+
+    if "CONTINUE" in decision:
+        depth += 1
+
+        if depth >= MAX_CONTINUATION_DEPTH:
+            runtime.logger.warning(
+                f"[post-action-evaluator] Safety limit reached ({MAX_CONTINUATION_DEPTH} "
+                "consecutive actions). Pausing."
+            )
+            autonomy_service._eval_depth = 0  # type: ignore[attr-defined]
+            return ActionResult(
+                success=True,
+                text=f"Paused after {MAX_CONTINUATION_DEPTH} consecutive actions",
+                data={"decision": "PAUSE", "reason": "depth_limit", "depth": depth},
+            )
+
+        runtime.logger.info(
+            f"[post-action-evaluator] CONTINUE (depth {depth}) – "
+            "triggering another autonomous think cycle"
+        )
+        autonomy_service._eval_depth = depth  # type: ignore[attr-defined]
+
+        # Recurse: trigger another full think → actions → evaluate cycle
+        await autonomy_service.perform_autonomous_think()
+
+        return ActionResult(
+            success=True,
+            text=f"Continued with additional actions (depth {depth})",
+            data={"decision": "CONTINUE", "depth": depth},
+        )
+
+    # PAUSE (or unrecognised → default to pause)
+    runtime.logger.info(
+        f"[post-action-evaluator] PAUSE after {depth} continuation(s) – agent is satisfied"
+    )
+    autonomy_service._eval_depth = 0  # type: ignore[attr-defined]
+
+    return ActionResult(
+        success=True,
+        text="Agent is satisfied, pausing",
+        data={"decision": "PAUSE", "depth": depth},
+    )
+
+
+post_action_evaluator = Evaluator(
+    name="POST_ACTION_EVALUATOR",
+    description=(
+        "Evaluates after autonomous actions complete to determine if the agent "
+        "should recursively continue with more actions or pause."
+    ),
+    validate=_validate_post_action,
+    handler=_handle_post_action,
+    always_run=True,
+)

package/elizaos/bootstrap/autonomy/service.py

@@ -11,6 +11,7 @@ import contextlib
 import logging
 import time
 import uuid
+from collections.abc import Iterable
 from typing import TYPE_CHECKING, Any
 
 from elizaos.bootstrap.services.task import Task
@@ -23,7 +24,7 @@ from elizaos.prompts import (
 from elizaos.types.environment import Room, World
 from elizaos.types.events import EventType
 from elizaos.types.memory import Memory
-from elizaos.types.primitives import UUID, Content, as_uuid
+from elizaos.types.primitives import UUID, Content, as_uuid, string_to_uuid
 from elizaos.types.service import Service
 
 from .types import AutonomyStatus
@@ -40,8 +41,7 @@ AUTONOMY_SERVICE_TYPE = "AUTONOMY"
 AUTONOMY_TASK_NAME = "AUTONOMY_THINK"
 
 # Tags used for autonomy tasks (parity with TypeScript).
-# Note: TypeScript uses ["repeat", "autonomy", "internal"] without "queue".
-AUTONOMY_TASK_TAGS = ["repeat", "autonomy", "internal"]
+AUTONOMY_TASK_TAGS = ["queue", "repeat", "autonomy"]
 
 # Default interval in milliseconds
 DEFAULT_INTERVAL_MS = 30_000
@@ -112,8 +112,10 @@ class AutonomyService(Service):
         self._interval_ms = DEFAULT_INTERVAL_MS
         self._task_registered = False
         self._settings_monitor_task: asyncio.Task[None] | None = None
-        self._autonomous_room_id = as_uuid(str(uuid.uuid4()))
+        # Placeholder; replaced with a deterministic ID during _initialize().
+        self._autonomous_room_id = as_uuid("00000000-0000-0000-0000-000000000000")
         self._autonomous_world_id = as_uuid("00000000-0000-0000-0000-000000000001")
+        self._autonomy_entity_id = as_uuid("00000000-0000-0000-0000-000000000002")
 
     def _log(self, level: str, msg: str) -> None:
         if self._runtime:
@@ -135,6 +137,9 @@ class AutonomyService(Service):
         if not self._runtime:
             return
 
+        self._autonomous_room_id = as_uuid(
+            string_to_uuid(f"autonomy-room-{self._runtime.agent_id}")
+        )
         self._log("info", f"Using autonomous room ID: {self._autonomous_room_id}")
 
         # Ensure autonomous context exists
@@ -289,35 +294,231 @@ class AutonomyService(Service):
         except Exception:
             return None
 
+    @staticmethod
+    def _coerce_name(entity: object) -> str | None:
+        if isinstance(entity, dict):
+            names = entity.get("names")
+            if isinstance(names, list):
+                for name in names:
+                    if isinstance(name, str) and name.strip():
+                        return name.strip()
+            name = entity.get("name")
+            if isinstance(name, str) and name.strip():
+                return name.strip()
+            return None
+
+        names = getattr(entity, "names", None)
+        if isinstance(names, list):
+            for name in names:
+                if isinstance(name, str) and name.strip():
+                    return name.strip()
+
+        name = getattr(entity, "name", None)
+        if isinstance(name, str) and name.strip():
+            return name.strip()
+
+        return None
+
+    @staticmethod
+    def _memory_text(memory: Memory) -> str:
+        if memory.content and isinstance(memory.content.text, str):
+            return memory.content.text.strip()
+        return ""
+
+    async def _build_entity_name_lookup(self, entity_ids: Iterable[UUID]) -> dict[UUID, str]:
+        if not self._runtime:
+            return {}
+
+        ids = list({entity_id for entity_id in entity_ids if entity_id})
+        if not ids:
+            return {}
+
+        getter = getattr(self._runtime, "get_entities_by_ids", None)
+        if not callable(getter):
+            return {}
+
+        try:
+            entities = await getter(ids)
+        except Exception:
+            return {}
+
+        name_by_id: dict[UUID, str] = {}
+        for entity in entities or []:
+            entity_id = None
+            if isinstance(entity, dict):
+                raw_id = entity.get("id")
+                if isinstance(raw_id, str):
+                    with contextlib.suppress(Exception):
+                        entity_id = as_uuid(raw_id)
+            else:
+                raw_id = getattr(entity, "id", None)
+                if raw_id is not None:
+                    with contextlib.suppress(Exception):
+                        entity_id = as_uuid(str(raw_id))
+
+            if not entity_id:
+                continue
+
+            entity_name = self._coerce_name(entity)
+            if entity_name:
+                name_by_id[entity_id] = entity_name
+
+        return name_by_id
+
+    @staticmethod
+    def _dedupe_memories_by_id_keep_earliest(memories: list[Memory]) -> list[Memory]:
+        by_id: dict[str, Memory] = {}
+        without_id: list[Memory] = []
+
+        for memory in memories:
+            mem_id = str(memory.id) if memory.id else ""
+            if not mem_id:
+                without_id.append(memory)
+                continue
+
+            existing = by_id.get(mem_id)
+            if existing is None or (memory.created_at or 0) < (existing.created_at or 0):
+                by_id[mem_id] = memory
+
+        return [*without_id, *by_id.values()]
+
     async def _get_target_room_context_text(self) -> str:
         if not self._runtime:
-            return "(no target room configured)"
+            return "(no rooms configured)"
+
         target_room_id = self._get_target_room_id()
-        if not target_room_id:
-            return "(no target room configured)"
-        memories_table = await self._runtime.get_memories(
-            {"roomId": target_room_id, "count": 15, "tableName": "memories"}
+
+        ordered_room_ids: list[UUID] = []
+        if target_room_id:
+            ordered_room_ids.append(target_room_id)
+
+        get_participant_rooms = getattr(self._runtime, "get_rooms_for_participant", None)
+        if callable(get_participant_rooms):
+            with contextlib.suppress(Exception):
+                participant_rooms = await get_participant_rooms(self._runtime.agent_id)
+                for room_id in participant_rooms or []:
+                    if room_id not in ordered_room_ids:
+                        ordered_room_ids.append(room_id)
+
+        if not ordered_room_ids:
+            return "(no rooms configured)"
+
+        room_name_by_id: dict[UUID, str] = {}
+        get_rooms_by_ids = getattr(self._runtime, "get_rooms_by_ids", None)
+        if callable(get_rooms_by_ids):
+            with contextlib.suppress(Exception):
+                rooms = await get_rooms_by_ids(ordered_room_ids)
+                for room in rooms or []:
+                    if room and room.id:
+                        room_name_by_id[room.id] = (
+                            room.name if isinstance(room.name, str) and room.name else str(room.id)
+                        )
+
+        message_room_ids = [rid for rid in ordered_room_ids if rid != self._autonomous_room_id]
+        per_room_limit = 10
+
+        fetched_messages: list[Memory] = []
+        if message_room_ids:
+            get_memories_by_room_ids = getattr(self._runtime, "get_memories_by_room_ids", None)
+            if callable(get_memories_by_room_ids):
+                with contextlib.suppress(Exception):
+                    fetched_messages = await get_memories_by_room_ids(
+                        {
+                            "roomIds": message_room_ids,
+                            "limit": per_room_limit * len(message_room_ids),
+                            "tableName": "messages",
+                        }
+                    )
+            if not fetched_messages:
+                for room_id in message_room_ids:
+                    with contextlib.suppress(Exception):
+                        fetched_messages.extend(
+                            await self._runtime.get_memories(
+                                {
+                                    "roomId": room_id,
+                                    "count": per_room_limit,
+                                    "tableName": "messages",
+                                }
+                            )
+                        )
+
+        autonomy_memories = await self._runtime.get_memories(
+            {"roomId": self._autonomous_room_id, "count": per_room_limit, "tableName": "memories"}
         )
-        messages_table = await self._runtime.get_memories(
-            {"roomId": target_room_id, "count": 15, "tableName": "messages"}
+
+        # ── Recent-context cutoff: ignore messages older than 1 hour ──
+        one_hour_ms = 3_600_000
+        now_ms = int(time.time() * 1000)
+        cutoff_ms = now_ms - one_hour_ms
+
+        fetched_messages = [m for m in fetched_messages if (m.created_at or 0) >= cutoff_ms]
+        autonomy_memories = [m for m in autonomy_memories if (m.created_at or 0) >= cutoff_ms]
+
+        external_messages = [
+            m
+            for m in fetched_messages
+            if m and m.entity_id and m.entity_id != self._runtime.agent_id
+        ]
+        entity_name_by_id = await self._build_entity_name_lookup(
+            memory.entity_id for memory in external_messages
         )
-        by_id: dict[str, Memory] = {}
-        for m in [*memories_table, *messages_table]:
-            mem_id = m.id or ""
-            if not mem_id:
+
+        messages_by_room: dict[UUID, list[Memory]] = {}
+        sorted_messages = sorted(
+            self._dedupe_memories_by_id_keep_earliest(external_messages),
+            key=lambda m: m.created_at or 0,
+            reverse=True,
+        )
+        for memory in sorted_messages:
+            bucket = messages_by_room.setdefault(memory.room_id, [])
+            if len(bucket) >= per_room_limit:
                 continue
-            created_at = m.created_at or 0
-            existing = by_id.get(mem_id)
-            if existing is None or created_at < (existing.created_at or 0):
-                by_id[mem_id] = m
-        ordered = sorted(by_id.values(), key=lambda m: m.created_at or 0)
-        lines: list[str] = []
-        for m in ordered:
-            role = "Agent" if m.entity_id == self._runtime.agent_id else "User"
-            text = m.content.text if m.content and isinstance(m.content.text, str) else ""
-            if text.strip():
-                lines.append(f"{role}: {text}")
-        return "\n".join(lines) if lines else "(no recent messages)"
+            bucket.append(memory)
+
+        room_sections: list[str] = []
+        for room_id in message_room_ids:
+            room_name = room_name_by_id.get(room_id, str(room_id))
+            room_messages = list(reversed(messages_by_room.get(room_id, [])))
+            if not room_messages:
+                room_sections.append(f"Room: {room_name}\n(no recent messages)")
+                continue
+
+            lines: list[str] = []
+            for memory in room_messages:
+                text = self._memory_text(memory)
+                if not text:
+                    continue
+                author = entity_name_by_id.get(memory.entity_id, str(memory.entity_id))
+                lines.append(f"{author}: {text}")
+
+            if lines:
+                room_sections.append(f"Room: {room_name}\n" + "\n".join(lines))
+            else:
+                room_sections.append(f"Room: {room_name}\n(no recent messages)")
+
+        autonomy_entries: list[str] = []
+        for memory in autonomy_memories:
+            text = self._memory_text(memory)
+            if not text:
+                continue
+
+            metadata_obj = memory.content.data if memory.content else None
+            metadata: dict[str, object] = metadata_obj if isinstance(metadata_obj, dict) else {}
+            entry_type = metadata.get("type")
+
+            if memory.entity_id == self._runtime.agent_id and entry_type == "autonomous-response":
+                autonomy_entries.append(f"Thought: {text}")
+            elif (
+                memory.entity_id == self._autonomy_entity_id and entry_type == "autonomous-trigger"
+            ):
+                autonomy_entries.append(f"Trigger: {text}")
+
+        if autonomy_entries:
+            autonomy_section = "Autonomous context:\n" + "\n".join(autonomy_entries)
+        else:
+            autonomy_section = "Autonomous context: (none)"
+
+        return "\n\n".join([*room_sections, autonomy_section])
 
     async def _settings_monitoring(self) -> None:
         while not self._is_stopped:
@@ -412,7 +613,7 @@ class AutonomyService(Service):
             else self._create_continuous_prompt(last_thought, is_first_thought, target_context)
         )
 
-        entity_id = agent_entity.id if agent_entity.id else self._runtime.agent_id
+        entity_id = self._autonomy_entity_id
         current_time_ms = int(time.time() * 1000)
         autonomous_message = Memory(
             id=as_uuid(str(uuid.uuid4())),
@@ -420,6 +621,15 @@ class AutonomyService(Service):
             content=Content(
                 text=autonomy_prompt,
                 source="autonomy-service",
+                data={
+                    "type": "autonomous-prompt",
+                    "isAutonomous": True,
+                    "isInternalThought": True,
+                    "autonomyMode": mode,
+                    "channelId": "autonomous",
+                    "timestamp": current_time_ms,
+                    "isContinuation": not is_first_thought,
+                },
             ),
             room_id=self._autonomous_room_id,
             agent_id=self._runtime.agent_id,

package/elizaos/bootstrap/plugin.py

@@ -21,6 +21,9 @@ from .autonomy import (
     AutonomyService,
     admin_chat_provider,
     autonomy_status_provider,
+    disable_autonomy_action,
+    enable_autonomy_action,
+    post_action_evaluator,
     send_to_admin_action,
 )
 from .types import CapabilityConfig
@@ -63,6 +66,8 @@ def _get_actions(config: CapabilityConfig) -> list:
         result.extend(EXTENDED_ACTIONS)
     if config.enable_autonomy:
         result.append(send_to_admin_action)
+        result.append(enable_autonomy_action)
+        result.append(disable_autonomy_action)
     return result
 
 
@@ -73,6 +78,8 @@ def _get_evaluators(config: CapabilityConfig) -> list:
         result.extend(BASIC_EVALUATORS)
     if config.enable_extended:
         result.extend(EXTENDED_EVALUATORS)
+    if config.enable_autonomy:
+        result.append(post_action_evaluator)
     return result