@elizaos/python 2.0.0-alpha.10

package/elizaos/bootstrap/autonomy/providers.py

@@ -0,0 +1,165 @@
+from __future__ import annotations
+
+from datetime import datetime
+from typing import TYPE_CHECKING
+
+from elizaos.types.components import Provider, ProviderResult
+from elizaos.types.primitives import as_uuid
+
+from .service import AUTONOMY_SERVICE_TYPE, AutonomyService
+
+if TYPE_CHECKING:
+    from elizaos.types.memory import Memory
+    from elizaos.types.runtime import IAgentRuntime
+    from elizaos.types.state import State
+
+
+async def _get_admin_chat_history(
+    runtime: IAgentRuntime,
+    message: Memory,
+    _state: State | None = None,
+) -> ProviderResult:
+    autonomy_service = runtime.get_service(AUTONOMY_SERVICE_TYPE)
+    if not autonomy_service or not isinstance(autonomy_service, AutonomyService):
+        return ProviderResult(text="")
+
+    autonomous_room_id = autonomy_service.get_autonomous_room_id()
+    if not autonomous_room_id or message.room_id != autonomous_room_id:
+        return ProviderResult(text="")
+
+    admin_user_id = runtime.get_setting("ADMIN_USER_ID")
+    if not admin_user_id:
+        return ProviderResult(
+            text="[ADMIN_CHAT_HISTORY]\nNo admin user configured. Set ADMIN_USER_ID in character settings.\n[/ADMIN_CHAT_HISTORY]",
+            data={"adminConfigured": False},
+        )
+
+    admin_uuid = as_uuid(str(admin_user_id))
+
+    admin_messages = await runtime.get_memories(
+        {
+            "entityId": admin_uuid,
+            "count": 15,
+            "unique": False,
+            "tableName": "memories",
+        }
+    )
+
+    if not admin_messages:
+        return ProviderResult(
+            text="[ADMIN_CHAT_HISTORY]\nNo recent messages found with admin user.\n[/ADMIN_CHAT_HISTORY]",
+            data={
+                "adminConfigured": True,
+                "messageCount": 0,
+                "adminUserId": str(admin_user_id),
+            },
+        )
+
+    sorted_messages = sorted(admin_messages, key=lambda m: m.created_at or 0)[-10:]
+
+    history_lines = []
+    for msg in sorted_messages:
+        is_from_admin = msg.entity_id == admin_uuid
+        is_from_agent = msg.entity_id == runtime.agent_id
+
+        sender = "Admin" if is_from_admin else "Agent" if is_from_agent else "Other"
+        text = msg.content.text if msg.content and msg.content.text else "[No text content]"
+        timestamp = datetime.fromtimestamp((msg.created_at or 0) / 1000).strftime("%H:%M:%S")
+
+        history_lines.append(f"{timestamp} {sender}: {text}")
+
+    conversation_history = "\n".join(history_lines)
+
+    recent_admin_messages = [msg for msg in sorted_messages if msg.entity_id == admin_uuid][-3:]
+
+    last_admin_message = recent_admin_messages[-1] if recent_admin_messages else None
+    admin_mood_context = (
+        f'Last admin message: "{last_admin_message.content.text if last_admin_message and last_admin_message.content else "N/A"}"'
+        if recent_admin_messages
+        else "No recent admin messages"
+    )
+
+    return ProviderResult(
+        text=f"[ADMIN_CHAT_HISTORY]\nRecent conversation with admin user ({len(admin_messages)} total messages):\n\n{conversation_history}\n\n{admin_mood_context}\n[/ADMIN_CHAT_HISTORY]",
+        data={
+            "adminConfigured": True,
+            "messageCount": len(admin_messages),
+            "adminUserId": str(admin_user_id),
+            "recentMessageCount": len(recent_admin_messages),
+            "lastAdminMessage": last_admin_message.content.text
+            if last_admin_message and last_admin_message.content
+            else "",
+            "conversationActive": any(
+                (datetime.now().timestamp() * 1000) - (m.created_at or 0) < 3600000
+                for m in admin_messages
+            ),
+        },
+    )
+
+
+async def _get_autonomy_status(
+    runtime: IAgentRuntime,
+    message: Memory,
+    _state: State | None = None,
+) -> ProviderResult:
+    autonomy_service = runtime.get_service(AUTONOMY_SERVICE_TYPE)
+    if not autonomy_service or not isinstance(autonomy_service, AutonomyService):
+        return ProviderResult(text="")
+
+    autonomous_room_id = autonomy_service.get_autonomous_room_id()
+    if autonomous_room_id and message.room_id == autonomous_room_id:
+        return ProviderResult(text="")
+
+    setting_value = runtime.get_setting("AUTONOMY_ENABLED")
+    autonomy_enabled = (
+        setting_value is True
+        or (isinstance(setting_value, str) and setting_value.strip().lower() == "true")
+        or runtime.enable_autonomy is True
+    )
+    service_running = autonomy_service.is_loop_running()
+    interval = autonomy_service.get_loop_interval()
+
+    if service_running:
+        status = "running autonomously"
+        status_icon = "🤖"
+    elif autonomy_enabled:
+        status = "autonomy enabled but not running"
+        status_icon = "⏸️"
+    else:
+        status = "autonomy disabled"
+        status_icon = "🔕"
+
+    interval_seconds = interval // 1000
+    interval_unit = (
+        f"{interval_seconds} seconds"
+        if interval_seconds < 60
+        else f"{interval_seconds // 60} minutes"
+    )
+
+    return ProviderResult(
+        text=f"[AUTONOMY_STATUS]\nCurrent status: {status_icon} {status}\nThinking interval: {interval_unit}\n[/AUTONOMY_STATUS]",
+        data={
+            "autonomyEnabled": bool(autonomy_enabled),
+            "serviceRunning": service_running,
+            "interval": interval,
+            "intervalSeconds": interval_seconds,
+            "status": "running"
+            if service_running
+            else "enabled"
+            if autonomy_enabled
+            else "disabled",
+        },
+    )
+
+
+admin_chat_provider = Provider(
+    name="ADMIN_CHAT_HISTORY",
+    description="Provides recent conversation history with the admin user for autonomous context",
+    get=_get_admin_chat_history,
+)
+
+autonomy_status_provider = Provider(
+    name="AUTONOMY_STATUS",
+    description="Provides current autonomy status for agent awareness in conversations",
+    get=_get_autonomy_status,
+)

package/elizaos/bootstrap/autonomy/routes.py

@@ -0,0 +1,171 @@
+"""
+Autonomy Routes for elizaOS Python runtime.
+
+API routes for controlling autonomy via REST.
+"""
+
+from __future__ import annotations
+
+from elizaos.types.plugin import Route, RouteRequest, RouteResponse
+from elizaos.types.runtime import IAgentRuntime
+
+from .service import AUTONOMY_SERVICE_TYPE, AutonomyService
+
+Route.model_rebuild()
+
+
+def _get_autonomy_service(runtime: IAgentRuntime) -> AutonomyService | None:
+    """Get autonomy service from runtime with fallback."""
+    service = runtime.get_service(AUTONOMY_SERVICE_TYPE)
+    if service is None:
+        service = runtime.get_service("autonomy")
+    return service  # type: ignore[return-value]
+
+
+async def _status_handler(_req: RouteRequest, res: RouteResponse, runtime: IAgentRuntime) -> None:
+    """GET /autonomy/status - Get current autonomy status."""
+    autonomy_service = _get_autonomy_service(runtime)
+
+    if not autonomy_service:
+        res.status(503).json({"error": "Autonomy service not available"})
+        return
+
+    status = autonomy_service.get_status()
+
+    res.json(
+        {
+            "success": True,
+            "data": {
+                "enabled": status.enabled,
+                "running": status.running,
+                "interval": status.interval,
+                "intervalSeconds": round(status.interval / 1000),
+                "autonomousRoomId": status.autonomous_room_id,
+                "agentId": str(runtime.agent_id),
+                "characterName": runtime.character.name if runtime.character else "Agent",
+            },
+        }
+    )
+
+
+async def _enable_handler(_req: RouteRequest, res: RouteResponse, runtime: IAgentRuntime) -> None:
+    """POST /autonomy/enable - Enable autonomy."""
+    autonomy_service = _get_autonomy_service(runtime)
+
+    if not autonomy_service:
+        res.status(503).json({"success": False, "error": "Autonomy service not available"})
+        return
+
+    await autonomy_service.enable_autonomy()
+    status = autonomy_service.get_status()
+
+    res.json(
+        {
+            "success": True,
+            "message": "Autonomy enabled",
+            "data": {
+                "enabled": status.enabled,
+                "running": status.running,
+                "interval": status.interval,
+            },
+        }
+    )
+
+
+async def _disable_handler(_req: RouteRequest, res: RouteResponse, runtime: IAgentRuntime) -> None:
+    """POST /autonomy/disable - Disable autonomy."""
+    autonomy_service = _get_autonomy_service(runtime)
+
+    if not autonomy_service:
+        res.status(503).json({"success": False, "error": "Autonomy service not available"})
+        return
+
+    await autonomy_service.disable_autonomy()
+    status = autonomy_service.get_status()
+
+    res.json(
+        {
+            "success": True,
+            "message": "Autonomy disabled",
+            "data": {
+                "enabled": status.enabled,
+                "running": status.running,
+                "interval": status.interval,
+            },
+        }
+    )
+
+
+async def _toggle_handler(_req: RouteRequest, res: RouteResponse, runtime: IAgentRuntime) -> None:
+    """POST /autonomy/toggle - Toggle autonomy state."""
+    autonomy_service = _get_autonomy_service(runtime)
+
+    if not autonomy_service:
+        res.status(503).json({"success": False, "error": "Autonomy service not available"})
+        return
+
+    current_status = autonomy_service.get_status()
+
+    if current_status.enabled:
+        await autonomy_service.disable_autonomy()
+    else:
+        await autonomy_service.enable_autonomy()
+
+    new_status = autonomy_service.get_status()
+
+    res.json(
+        {
+            "success": True,
+            "message": "Autonomy enabled" if new_status.enabled else "Autonomy disabled",
+            "data": {
+                "enabled": new_status.enabled,
+                "running": new_status.running,
+                "interval": new_status.interval,
+            },
+        }
+    )
+
+
+async def _interval_handler(req: RouteRequest, res: RouteResponse, runtime: IAgentRuntime) -> None:
+    """POST /autonomy/interval - Set loop interval."""
+    autonomy_service = _get_autonomy_service(runtime)
+
+    if not autonomy_service:
+        res.status(503).json({"success": False, "error": "Autonomy service not available"})
+        return
+
+    body = req.body or {}
+    interval = body.get("interval") if isinstance(body, dict) else None
+
+    if not isinstance(interval, (int, float)) or interval < 5000 or interval > 600000:
+        res.status(400).json(
+            {
+                "success": False,
+                "error": "Interval must be a number between 5000ms (5s) and 600000ms (10m)",
+            }
+        )
+        return
+
+    autonomy_service.set_loop_interval(int(interval))
+    status = autonomy_service.get_status()
+
+    res.json(
+        {
+            "success": True,
+            "message": "Interval updated",
+            "data": {
+                "interval": status.interval,
+                "intervalSeconds": round(status.interval / 1000),
+            },
+        }
+    )
+
+
+# Autonomy API routes
+autonomy_routes: list[Route] = [
+    Route(type="GET", path="/autonomy/status", handler=_status_handler),
+    Route(type="POST", path="/autonomy/enable", handler=_enable_handler),
+    Route(type="POST", path="/autonomy/disable", handler=_disable_handler),
+    Route(type="POST", path="/autonomy/toggle", handler=_toggle_handler),
+    Route(type="POST", path="/autonomy/interval", handler=_interval_handler),
+]