@elizaos/python 2.0.0-alpha.10 → 2.0.0-alpha.26

package/elizaos/bootstrap/actions/send_message.py

@@ -2,12 +2,12 @@ from __future__ import annotations
 
 import contextlib
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING
-from uuid import UUID
+from typing import TYPE_CHECKING, Any
 
 from elizaos.generated.spec_helpers import require_action_spec
 from elizaos.types import Action, ActionExample, ActionResult, Content
 from elizaos.types.memory import Memory as MemoryType
+from elizaos.types.primitives import UUID, as_uuid
 
 if TYPE_CHECKING:
     from elizaos.types import HandlerCallback, HandlerOptions, IAgentRuntime, Memory, State
@@ -36,6 +36,54 @@ def _convert_spec_examples() -> list[list[ActionExample]]:
     return []
 
 
+def _parse_uuid(value: object) -> UUID | None:
+    if not isinstance(value, str) or not value.strip():
+        return None
+    with contextlib.suppress(Exception):
+        return as_uuid(value.strip())
+    return None
+
+
+def _normalize_parameters(options: HandlerOptions | None) -> dict[str, Any]:
+    raw = getattr(options, "parameters", None)
+    if isinstance(raw, dict):
+        return raw
+
+    if raw is None:
+        return {}
+
+    if hasattr(raw, "items"):
+        try:
+            return {str(k): v for k, v in raw.items()}
+        except Exception:
+            return {}
+
+    return {}
+
+
+def _coerce_entity_name(entity: object) -> list[str]:
+    if isinstance(entity, dict):
+        names = entity.get("names")
+        if isinstance(names, list):
+            return [str(n).strip() for n in names if isinstance(n, str) and n.strip()]
+        name = entity.get("name")
+        if isinstance(name, str) and name.strip():
+            return [name.strip()]
+        return []
+
+    names = getattr(entity, "names", None)
+    if isinstance(names, list):
+        clean = [str(n).strip() for n in names if isinstance(n, str) and str(n).strip()]
+        if clean:
+            return clean
+
+    name = getattr(entity, "name", None)
+    if isinstance(name, str) and name.strip():
+        return [name.strip()]
+
+    return []
+
+
 @dataclass
 class SendMessageAction:
     name: str = _spec["name"]
@@ -58,9 +106,14 @@ class SendMessageAction:
         callback: HandlerCallback | None = None,
         responses: list[Memory] | None = None,
     ) -> ActionResult:
-        message_text = ""
-        if responses and responses[0].content:
-            message_text = str(responses[0].content.text or "")
+        params = _normalize_parameters(options)
+
+        text_param = params.get("text")
+        message_text = str(text_param).strip() if isinstance(text_param, str) else ""
+        if not message_text and responses and responses[0].content:
+            message_text = str(responses[0].content.text or "").strip()
+        if not message_text and message.content and isinstance(message.content.text, str):
+            message_text = message.content.text.strip()
 
         if not message_text:
             return ActionResult(
@@ -72,18 +125,91 @@ class SendMessageAction:
 
         target_room_id = message.room_id
         target_entity_id: UUID | None = None
+        target_type = "room"
+
+        target_type_param = params.get("targetType") or params.get("target_type")
+        target_param = params.get("target")
+        source_param = params.get("source")
+
+        source = (
+            source_param.strip()
+            if isinstance(source_param, str) and source_param.strip()
+            else (
+                message.content.source
+                if message.content and isinstance(message.content.source, str)
+                else "agent"
+            )
+        )
+
+        if isinstance(target_type_param, str):
+            normalized_target_type = target_type_param.strip().lower()
+            if normalized_target_type in {"user", "entity"}:
+                target_type = "user"
+            elif normalized_target_type == "room":
+                target_type = "room"
+
+        if isinstance(target_param, str) and target_param.strip():
+            target_value = target_param.strip()
+            if target_type == "room":
+                parsed_room = _parse_uuid(target_value)
+                if parsed_room:
+                    target_room_id = parsed_room
+                else:
+                    world_id = None
+                    room_data = (
+                        getattr(getattr(state, "data", None), "room", None) if state else None
+                    )
+                    if room_data is not None:
+                        world_id = getattr(room_data, "world_id", None) or getattr(
+                            room_data, "worldId", None
+                        )
+                    if world_id is None:
+                        with contextlib.suppress(Exception):
+                            current_room = await runtime.get_room(message.room_id)
+                            if current_room:
+                                world_id = getattr(current_room, "world_id", None) or getattr(
+                                    current_room, "worldId", None
+                                )
+
+                    if world_id is not None:
+                        with contextlib.suppress(Exception):
+                            rooms = await runtime.get_rooms(world_id)
+                            for room in rooms:
+                                room_name = getattr(room, "name", None)
+                                if (
+                                    isinstance(room_name, str)
+                                    and room_name.strip().lower() == target_value.lower()
+                                ):
+                                    room_id = getattr(room, "id", None)
+                                    if room_id is not None:
+                                        target_room_id = as_uuid(str(room_id))
+                                        break
+            else:
+                parsed_entity = _parse_uuid(target_value)
+                if parsed_entity:
+                    target_entity_id = parsed_entity
+                else:
+                    with contextlib.suppress(Exception):
+                        entities = await runtime.get_entities_for_room(message.room_id)
+                        for entity in entities:
+                            names = _coerce_entity_name(entity)
+                            if any(name.lower() == target_value.lower() for name in names):
+                                entity_id = getattr(entity, "id", None)
+                                if entity_id is not None:
+                                    target_entity_id = as_uuid(str(entity_id))
+                                    break
 
         if message.content and message.content.target:
             target = message.content.target
             if isinstance(target, dict):
                 room_str = target.get("roomId")
                 entity_str = target.get("entityId")
-                if room_str:
-                    with contextlib.suppress(ValueError):
-                        target_room_id = UUID(room_str)
-                if entity_str:
-                    with contextlib.suppress(ValueError):
-                        target_entity_id = UUID(entity_str)
+                if room_str and target_type == "room":
+                    with contextlib.suppress(Exception):
+                        target_room_id = as_uuid(room_str)
+                if entity_str and target_type == "user":
+                    with contextlib.suppress(Exception):
+                        target_entity_id = as_uuid(entity_str)
 
         if not target_room_id:
             return ActionResult(
@@ -95,16 +221,28 @@ class SendMessageAction:
 
         message_content = Content(
             text=message_text,
-            source="agent",
+            source=source,
             actions=["SEND_MESSAGE"],
         )
 
+        send_message_to_target = getattr(runtime, "send_message_to_target", None)
+        if callable(send_message_to_target):
+            with contextlib.suppress(Exception):
+                from elizaos.types.runtime import TargetInfo
+
+                await send_message_to_target(
+                    TargetInfo(
+                        roomId=str(target_room_id),
+                        entityId=str(target_entity_id) if target_entity_id else None,
+                        source=source,
+                    ),
+                    message_content,
+                )
+
         # Create the message memory
         import time
         import uuid as uuid_module
 
-        from elizaos.types.primitives import as_uuid
-
         message_memory = MemoryType(
             id=as_uuid(str(uuid_module.uuid4())),
             entity_id=runtime.agent_id,
@@ -142,16 +280,25 @@ class SendMessageAction:
         if callback:
             await callback(response_content)
 
+        target_id = (
+            target_entity_id if target_type == "user" and target_entity_id else target_room_id
+        )
         return ActionResult(
-            text="Message sent to room",
+            text="Message sent",
             values={
                 "success": True,
                 "messageSent": True,
+                "targetType": target_type,
+                "target": str(target_id),
+                "source": source,
                 "targetRoomId": str(target_room_id),
                 "targetEntityId": str(target_entity_id) if target_entity_id else None,
             },
             data={
                 "actionName": "SEND_MESSAGE",
+                "targetType": target_type,
+                "target": str(target_id),
+                "source": source,
                 "targetRoomId": str(target_room_id),
                 "messagePreview": message_text[:100],
             },

package/elizaos/bootstrap/autonomy/__init__.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
-from .action import send_to_admin_action
+from .action import disable_autonomy_action, enable_autonomy_action, send_to_admin_action
+from .evaluators import post_action_evaluator
 from .providers import admin_chat_provider, autonomy_status_provider
 from .routes import autonomy_routes
 from .service import AUTONOMY_SERVICE_TYPE, AutonomyService
@@ -12,6 +13,9 @@ __all__ = [
     "AutonomyService",
     "AUTONOMY_SERVICE_TYPE",
     "send_to_admin_action",
+    "enable_autonomy_action",
+    "disable_autonomy_action",
+    "post_action_evaluator",
     "admin_chat_provider",
     "autonomy_status_provider",
     "autonomy_routes",

package/elizaos/bootstrap/autonomy/action.py

@@ -195,3 +195,164 @@ send_to_admin_action = Action(
     validate=_validate_send_to_admin,
     handler=_handle_send_to_admin,
 )
+
+
+# ── ENABLE_AUTONOMY / DISABLE_AUTONOMY actions ─────────────────────────
+
+
+def _is_autonomy_running(runtime: IAgentRuntime) -> bool:
+    """Return True if the autonomy loop is currently active."""
+    svc = runtime.get_service(AUTONOMY_SERVICE_TYPE)
+    if svc and isinstance(svc, AutonomyService):
+        return svc.is_loop_running()
+    return getattr(runtime, "enable_autonomy", False)
+
+
+async def _validate_enable_autonomy(
+    runtime: IAgentRuntime,
+    message: Memory,
+    _state: State | None = None,
+) -> bool:
+    """Valid only when autonomy is currently paused / disabled."""
+    return not _is_autonomy_running(runtime)
+
+
+async def _validate_disable_autonomy(
+    runtime: IAgentRuntime,
+    message: Memory,
+    _state: State | None = None,
+) -> bool:
+    """Valid only when autonomy is currently running / enabled."""
+    return _is_autonomy_running(runtime)
+
+
+async def _handle_enable_autonomy(
+    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:
+    """Enable the autonomous loop."""
+    autonomy_service = runtime.get_service(AUTONOMY_SERVICE_TYPE)
+
+    if not autonomy_service or not isinstance(autonomy_service, AutonomyService):
+        runtime.enable_autonomy = True
+        result_text = "Autonomy enabled (runtime flag). The autonomy service is not running."
+        if callback:
+            await callback(Content(text=result_text))
+        return ActionResult(success=True, text=result_text, data={"enabled": True})
+
+    await autonomy_service.enable_autonomy()
+    result_text = "Autonomy has been enabled."
+    if callback:
+        await callback(Content(text=result_text))
+    return ActionResult(success=True, text=result_text, data={"enabled": True})
+
+
+async def _handle_disable_autonomy(
+    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:
+    """Disable the autonomous loop."""
+    autonomy_service = runtime.get_service(AUTONOMY_SERVICE_TYPE)
+
+    if not autonomy_service or not isinstance(autonomy_service, AutonomyService):
+        runtime.enable_autonomy = False
+        result_text = "Autonomy disabled (runtime flag)."
+        if callback:
+            await callback(Content(text=result_text))
+        return ActionResult(success=True, text=result_text, data={"enabled": False})
+
+    await autonomy_service.disable_autonomy()
+    result_text = "Autonomy has been disabled."
+    if callback:
+        await callback(Content(text=result_text))
+    return ActionResult(success=True, text=result_text, data={"enabled": False})
+
+
+enable_autonomy_action = Action(
+    name="ENABLE_AUTONOMY",
+    description=(
+        "Enable the agent's autonomous operation. "
+        "Use this when asked to start autonomy, go autonomous, or activate autonomous behavior. "
+        "Only available when autonomy is currently paused."
+    ),
+    similes=["START_AUTONOMY", "ACTIVATE_AUTONOMY", "GO_AUTONOMOUS"],
+    examples=[
+        [
+            {
+                "name": "User",
+                "content": {"text": "Enable autonomy"},
+            },
+            {
+                "name": "Agent",
+                "content": {
+                    "text": "Autonomy has been enabled.",
+                    "action": "ENABLE_AUTONOMY",
+                },
+            },
+        ],
+        [
+            {
+                "name": "User",
+                "content": {"text": "Go autonomous"},
+            },
+            {
+                "name": "Agent",
+                "content": {
+                    "text": "Autonomy has been enabled.",
+                    "action": "ENABLE_AUTONOMY",
+                },
+            },
+        ],
+    ],
+    validate=_validate_enable_autonomy,
+    handler=_handle_enable_autonomy,
+)
+
+
+disable_autonomy_action = Action(
+    name="DISABLE_AUTONOMY",
+    description=(
+        "Disable the agent's autonomous operation. "
+        "Use this when asked to stop, pause, or deactivate autonomous behavior. "
+        "Only available when autonomy is currently running."
+    ),
+    similes=["STOP_AUTONOMY", "PAUSE_AUTONOMY", "DEACTIVATE_AUTONOMY"],
+    examples=[
+        [
+            {
+                "name": "User",
+                "content": {"text": "Disable autonomy"},
+            },
+            {
+                "name": "Agent",
+                "content": {
+                    "text": "Autonomy has been disabled.",
+                    "action": "DISABLE_AUTONOMY",
+                },
+            },
+        ],
+        [
+            {
+                "name": "User",
+                "content": {"text": "Stop being autonomous"},
+            },
+            {
+                "name": "Agent",
+                "content": {
+                    "text": "Autonomy has been disabled.",
+                    "action": "DISABLE_AUTONOMY",
+                },
+            },
+        ],
+    ],
+    validate=_validate_disable_autonomy,
+    handler=_handle_disable_autonomy,
+)

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,
+)