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

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

package/elizaos/bootstrap/autonomy/service.py

@@ -446,6 +446,14 @@ class AutonomyService(Service):
             {"roomId": self._autonomous_room_id, "count": per_room_limit, "tableName": "memories"}
         )
 
+        # ── 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

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
 
 

package/elizaos/bootstrap/providers/knowledge.py

@@ -4,6 +4,7 @@ from typing import TYPE_CHECKING
 
 from elizaos.generated.spec_helpers import require_provider_spec
 from elizaos.types import Provider, ProviderResult
+from elizaos.types.database import MemorySearchOptions
 
 if TYPE_CHECKING:
     from elizaos.types import IAgentRuntime, Memory, State
@@ -29,11 +30,33 @@ async def get_knowledge_context(
             text="", values={"knowledgeCount": 0, "hasKnowledge": False}, data={"entries": []}
         )
 
-    relevant_knowledge = await runtime.search_knowledge(
-        query=query_text,
-        limit=5,
+    # 1. Fetch recent messages to get embeddings
+    recent_messages = await runtime.get_memories(
+        room_id=message.room_id, limit=5, table_name="messages"
     )
 
+    # 2. Extract valid embeddings
+    embeddings = [m.embedding for m in recent_messages if m and m.embedding]
+
+    relevant_knowledge = []
+    # 3. Search using the most recent embedding if available
+    if embeddings:
+        primary_embedding = embeddings[0]
+        params = MemorySearchOptions(
+            table_name="knowledge",
+            room_id=message.room_id,
+            embedding=primary_embedding,
+            match_threshold=0.75,
+            match_count=5,
+            unique=True,
+        )
+        relevant_knowledge = await runtime.search_memories(params)
+    elif query_text:
+        # Fallback to search_knowledge if no embeddings found?
+        # TS implementation might rely on search_memories logic handling missing embedding?
+        # No, TS skips if no embedding.
+        pass
+
     for entry in relevant_knowledge:
         if entry.content and entry.content.text:
             knowledge_text = entry.content.text

package/elizaos/bootstrap/services/embedding.py

@@ -1,8 +1,11 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+import asyncio
+import contextlib
+from typing import TYPE_CHECKING, Any
 
 from elizaos.types import ModelType, Service, ServiceType
+from elizaos.types.events import EventType
 
 if TYPE_CHECKING:
     from elizaos.types import IAgentRuntime
@@ -21,11 +24,21 @@ class EmbeddingService(Service):
         self._cache: dict[str, list[float]] = {}
         self._cache_enabled: bool = True
         self._max_cache_size: int = 1000
+        self._queue: asyncio.Queue = asyncio.Queue()
+        self._worker_task: asyncio.Task | None = None
 
     @classmethod
     async def start(cls, runtime: IAgentRuntime) -> EmbeddingService:
         service = cls()
         service._runtime = runtime
+
+        # Register event handler
+        event_name = EventType.Name(EventType.EVENT_TYPE_EMBEDDING_GENERATION_REQUESTED)
+        runtime.register_event(event_name, service._handle_embedding_request)
+
+        # Start worker
+        service._worker_task = asyncio.create_task(service._worker())
+
         runtime.logger.info(
             "Embedding service started",
             src="service:embedding",
@@ -34,6 +47,12 @@ class EmbeddingService(Service):
         return service
 
     async def stop(self) -> None:
+        if self._worker_task:
+            self._worker_task.cancel()
+            with contextlib.suppress(asyncio.CancelledError):
+                await self._worker_task
+            self._worker_task = None
+
         if self._runtime:
             self._runtime.logger.info(
                 "Embedding service stopped",
@@ -120,3 +139,139 @@ class EmbeddingService(Service):
             return 0.0
 
         return dot_product / (magnitude1 * magnitude2)
+
+    async def _handle_embedding_request(self, payload: Any) -> None:
+        """Handle embedding generation request event."""
+        await self._queue.put(payload)
+
+    async def _worker(self) -> None:
+        """Background worker for processing embedding requests."""
+        while True:
+            try:
+                payload = await self._queue.get()
+            except asyncio.CancelledError:
+                break
+
+            try:
+                await self._process_embedding_request(payload)
+            except Exception as e:
+                if self._runtime:
+                    self._runtime.logger.error(f"Error in embedding worker: {e}", exc_info=True)
+            finally:
+                self._queue.task_done()
+
+    async def _process_embedding_request(self, payload: Any) -> None:
+        from elizaos.types.events import EventType
+        from elizaos.types.memory import Memory
+
+        # Extract memory from payload
+        # Handle both protobuf object and dict/wrapper
+        memory_data = None
+        if hasattr(payload, "memory"):  # specific payload
+            memory_data = payload.memory
+        elif hasattr(payload, "extra") and hasattr(
+            payload.extra, "__getitem__"
+        ):  # generic event payload
+            try:
+                # Check if 'memory' is in extra
+                # payload.extra might be a Struct or dict
+                if "memory" in payload.extra:
+                    from elizaos.runtime import _struct_value_to_python
+
+                    mem_val = payload.extra["memory"]
+                    if hasattr(mem_val, "struct_value"):
+                        if mem_val.HasField("struct_value"):
+                            memory_data = _struct_value_to_python(mem_val)
+                        else:
+                            memory_data = mem_val
+                    else:
+                        memory_data = mem_val
+            except Exception:
+                pass
+
+        if not memory_data:
+            return
+
+        # Convert to Memory object if needed
+        if isinstance(memory_data, dict):
+            memory = Memory(
+                id=memory_data.get("id"),
+                content=memory_data.get("content"),
+                room_id=memory_data.get("roomId") or memory_data.get("room_id"),
+                entity_id=memory_data.get("entityId")
+                or memory_data.get("entity_id")
+                or memory_data.get("userId")
+                or memory_data.get("user_id"),
+                agent_id=memory_data.get("agentId") or memory_data.get("agent_id"),
+            )
+            if "embedding" in memory_data:
+                memory.embedding = memory_data["embedding"]
+            if "metadata" in memory_data:
+                memory.metadata = memory_data["metadata"]
+        else:
+            memory = memory_data
+
+        if not memory.id:
+            return
+
+        if memory.embedding and len(memory.embedding) > 0:
+            return
+
+        text = (
+            memory.content.text
+            if hasattr(memory.content, "text")
+            else getattr(memory.content, "text", "")
+        )
+        if not text:
+            return
+
+        embedding_source_text = text
+
+        # Intent generation logic
+        if len(text) > 20:
+            has_intent = False
+            if memory.metadata and isinstance(memory.metadata, dict):
+                has_intent = "intent" in memory.metadata
+
+            if not has_intent:
+                prompt = (
+                    "Analyze the following message and extract the core user intent or a summary "
+                    "of what they are asking/saying. Return ONLY the intent text.\n"
+                    f'Message:\n"{text}"\n\nIntent:'
+                )
+
+                try:
+                    output = await self._runtime.use_model(ModelType.TEXT_SMALL, prompt=prompt)
+
+                    intent = str(output).strip()
+                    if intent:
+                        embedding_source_text = intent
+                        # Update metadata
+                        # Use custom metadata for intent
+                        memory.metadata.custom.custom_data["intent"] = intent
+                except Exception as e:
+                    self._runtime.logger.warning(f"Failed to generate intent: {e}")
+
+        # Generate embedding
+        try:
+            embedding = await self.embed(embedding_source_text)
+            # Protobuf repeated field assignment must extend or use slice
+            if hasattr(memory.embedding, "extend"):  # It's a repeated field
+                del memory.embedding[:]
+                memory.embedding.extend(embedding)
+            else:
+                # If it's a list (unlikely based on error)
+                memory.embedding = embedding
+
+            # Update in DB
+            if getattr(self._runtime, "_adapter", None):
+                await self._runtime._adapter.update_memory(memory)
+
+            # Emit completion
+            await self._runtime.emit_event(
+                EventType.Name(EventType.EVENT_TYPE_EMBEDDING_GENERATION_COMPLETED),
+                {"source": "embedding_service", "memory_id": str(memory.id)},
+            )
+
+        except Exception as e:
+            self._runtime.logger.error(f"Failed to generate embedding: {e}")