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

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
 
 

package/elizaos/bootstrap/providers/actions.py

@@ -1,8 +1,14 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+import contextlib
+from typing import TYPE_CHECKING, TypeVar
 
 from elizaos.action_docs import get_canonical_action_example_calls
+from elizaos.deterministic import (
+    build_conversation_seed,
+    build_deterministic_seed,
+    deterministic_int,
+)
 from elizaos.generated.spec_helpers import require_provider_spec
 from elizaos.types import Provider, ProviderResult
 from elizaos.types.components import ActionExample
@@ -21,10 +27,6 @@ if TYPE_CHECKING:
 _spec = require_provider_spec("ACTIONS")
 
 
-def format_action_names(actions: list[Action]) -> str:
-    return ", ".join(action.name for action in actions)
-
-
 def _format_parameter_type(schema: ActionParameterSchema) -> str:
     if schema.type == "number" and (schema.minimum is not None or schema.maximum is not None):
         min_val = schema.minimum if schema.minimum is not None else "∞"
@@ -62,9 +64,23 @@ def _format_action_parameters(parameters: list[ActionParameter]) -> str:
     return "\n".join(lines)
 
 
-def format_actions(actions: list[Action]) -> str:
+T = TypeVar("T")
+
+
+def _deterministic_shuffle(items: list[T], seed: str, surface: str = "shuffle") -> list[T]:
+    shuffled = list(items)
+    for i in range(len(shuffled) - 1, 0, -1):
+        j = deterministic_int(seed, f"{surface}:{i}", i + 1)
+        shuffled[i], shuffled[j] = shuffled[j], shuffled[i]
+    return shuffled
+
+
+def format_actions(actions: list[Action], seed: str | None = None) -> str:
+    deterministic_seed = seed or build_deterministic_seed(
+        ["actions-format", ",".join(action.name for action in actions)]
+    )
     lines: list[str] = []
-    for action in actions:
+    for action in _deterministic_shuffle(actions, deterministic_seed, "actions"):
         line = f"- **{action.name}**: {action.description or 'No description'}"
         if action.parameters:
             params_text = _format_action_parameters(action.parameters)
@@ -81,7 +97,24 @@ def _replace_name_placeholders(text: str) -> str:
     return text
 
 
-def format_action_examples(actions: list[Action], max_examples: int = 10) -> str:
+def _replace_name_placeholders_seeded(text: str, seed: str, example_index: int) -> str:
+    names = ["Alex", "Jordan", "Sam", "Taylor", "Riley"]
+    output = text
+    for placeholder_index in range(1, 6):
+        name_index = deterministic_int(
+            seed,
+            f"example:{example_index}:name:{placeholder_index}",
+            len(names),
+        )
+        output = output.replace(f"{{{{name{placeholder_index}}}}}", names[name_index])
+    return output
+
+
+def format_action_examples(
+    actions: list[Action],
+    max_examples: int = 10,
+    seed: str | None = None,
+) -> str:
     """
     Format a deterministic subset of action examples for prompt context.
 
@@ -90,27 +123,60 @@ def format_action_examples(actions: list[Action], max_examples: int = 10) -> str
     if max_examples <= 0:
         return ""
 
-    examples: list[list[ActionExample]] = []
-    for action in sorted(actions, key=lambda a: a.name):
-        if not action.examples:
-            continue
-        for ex in action.examples:
-            if isinstance(ex, list) and ex:
-                examples.append(ex)
-            if len(examples) >= max_examples:
-                break
-        if len(examples) >= max_examples:
-            break
-
-    if not examples:
+    actions_with_examples = [
+        action
+        for action in actions
+        if action.examples and isinstance(action.examples, list) and len(action.examples) > 0
+    ]
+    if not actions_with_examples:
         return ""
 
+    examples_copy: list[list[list[ActionExample]]] = [
+        [example for example in (action.examples or []) if isinstance(example, list) and example]
+        for action in actions_with_examples
+    ]
+    available_action_indices = [
+        idx for idx, action_examples in enumerate(examples_copy) if action_examples
+    ]
+
+    selection_seed = seed or build_deterministic_seed(
+        [
+            "action-examples",
+            ",".join(action.name for action in actions_with_examples),
+            max_examples,
+        ]
+    )
+
+    selected_examples: list[list[ActionExample]] = []
+    iteration = 0
+    while len(selected_examples) < max_examples and available_action_indices:
+        random_index = deterministic_int(
+            selection_seed,
+            f"action-index:{iteration}",
+            len(available_action_indices),
+        )
+        action_index = available_action_indices[random_index]
+        action_examples = examples_copy[action_index]
+
+        example_index = deterministic_int(
+            selection_seed,
+            f"example-index:{iteration}",
+            len(action_examples),
+        )
+        selected_examples.append(action_examples.pop(example_index))
+        iteration += 1
+
+        if not action_examples:
+            available_action_indices.pop(random_index)
+
     blocks: list[str] = []
-    for ex in examples:
+    for example_index, ex in enumerate(selected_examples):
         lines: list[str] = []
         for msg in ex:
             msg_text = msg.content.text if msg.content and msg.content.text else ""
-            lines.append(f"{msg.name}: {_replace_name_placeholders(msg_text)}")
+            lines.append(
+                f"{msg.name}: {_replace_name_placeholders_seeded(msg_text, selection_seed, example_index)}"
+            )
         blocks.append("\n".join(lines))
 
     return "\n\n".join(blocks)
@@ -180,6 +246,17 @@ def format_action_call_examples(actions: list[Action], max_examples: int = 5) ->
     return "\n\n".join(blocks)
 
 
+def format_action_names(actions: list[Action], seed: str | None = None) -> str:
+    if not actions:
+        return ""
+
+    deterministic_seed = seed or build_deterministic_seed(
+        ["action-names", ",".join(action.name for action in actions)]
+    )
+    shuffled = _deterministic_shuffle(actions, deterministic_seed, "actions")
+    return ", ".join(action.name for action in shuffled)
+
+
 async def get_actions(
     runtime: IAgentRuntime,
     message: Memory,
@@ -189,13 +266,27 @@ async def get_actions(
 
     for action in runtime.actions:
         validate_fn = getattr(action, "validate", None) or getattr(action, "validate_fn", None)
-        is_valid = await validate_fn(runtime, message, state) if validate_fn else True
+        if not validate_fn:
+            is_valid = True
+        else:
+            try:
+                is_valid = await validate_fn(runtime, message, state)
+            except Exception:
+                if hasattr(runtime, "logger"):
+                    with contextlib.suppress(Exception):
+                        runtime.logger.warning(
+                            f"Action validation failed for {action.name}; excluding from prompt"
+                        )
+                is_valid = False
         if is_valid:
             validated_actions.append(action)
 
-    action_names = format_action_names(validated_actions)
-    actions_text = format_actions(validated_actions)
-    examples_text = format_action_examples(validated_actions, max_examples=10)
+    action_seed = build_conversation_seed(runtime, message, state, "provider:actions")
+    action_names = format_action_names(validated_actions, seed=f"{action_seed}:names")
+    actions_text = format_actions(validated_actions, seed=f"{action_seed}:descriptions")
+    examples_text = format_action_examples(
+        validated_actions, max_examples=10, seed=f"{action_seed}:examples"
+    )
     call_examples_text = format_action_call_examples(validated_actions, max_examples=5)
 
     text_parts: list[str] = [f"Possible response actions: {action_names}"]

package/elizaos/bootstrap/providers/agent_settings.py

@@ -60,4 +60,5 @@ agent_settings_provider = Provider(
     description=_spec["description"],
     get=get_agent_settings_context,
     dynamic=_spec.get("dynamic", True),
+    position=_spec.get("position"),
 )

package/elizaos/bootstrap/providers/attachments.py

@@ -73,4 +73,5 @@ attachments_provider = Provider(
     description=_spec["description"],
     get=get_attachments,
     dynamic=_spec.get("dynamic", True),
+    position=_spec.get("position"),
 )

package/elizaos/bootstrap/providers/capabilities.py

@@ -63,4 +63,5 @@ capabilities_provider = Provider(
     description=_spec["description"],
     get=get_capabilities,
     dynamic=_spec.get("dynamic", False),
+    position=_spec.get("position"),
 )

package/elizaos/bootstrap/providers/character.py

@@ -125,4 +125,5 @@ character_provider = Provider(
     description=_spec["description"],
     get=get_character_context,
     dynamic=_spec.get("dynamic", False),
+    position=_spec.get("position"),
 )

package/elizaos/bootstrap/providers/choice.py

@@ -74,4 +74,5 @@ choice_provider = Provider(
     description=_spec["description"],
     get=get_choice_options,
     dynamic=_spec.get("dynamic", True),
+    position=_spec.get("position"),
 )

package/elizaos/bootstrap/providers/contacts.py

@@ -75,4 +75,5 @@ contacts_provider = Provider(
     description=_spec["description"],
     get=get_contacts_context,
     dynamic=_spec.get("dynamic", True),
+    position=_spec.get("position"),
 )

package/elizaos/bootstrap/providers/current_time.py

@@ -1,8 +1,8 @@
 from __future__ import annotations
 
-from datetime import UTC, datetime
 from typing import TYPE_CHECKING
 
+from elizaos.deterministic import get_prompt_reference_datetime
 from elizaos.generated.spec_helpers import require_provider_spec
 from elizaos.types import Provider, ProviderResult
 
@@ -18,7 +18,12 @@ async def get_current_time_context(
     message: Memory,
     state: State | None = None,
 ) -> ProviderResult:
-    now = datetime.now(UTC)
+    now = get_prompt_reference_datetime(
+        runtime,
+        message,
+        state,
+        "provider:current_time",
+    )
 
     iso_timestamp = now.isoformat()
     human_readable = now.strftime("%A, %B %d, %Y at %H:%M:%S UTC")
@@ -53,4 +58,5 @@ current_time_provider = Provider(
     description=_spec["description"],
     get=get_current_time_context,
     dynamic=_spec.get("dynamic", True),
+    position=_spec.get("position"),
 )

package/elizaos/bootstrap/providers/entities.py

@@ -96,4 +96,5 @@ entities_provider = Provider(
     description=_spec["description"],
     get=get_entities_context,
     dynamic=_spec.get("dynamic", True),
+    position=_spec.get("position"),
 )

package/elizaos/bootstrap/providers/evaluators.py

@@ -55,4 +55,5 @@ evaluators_provider = Provider(
     description=_spec["description"],
     get=get_evaluators,
     dynamic=_spec.get("dynamic", False),
+    position=_spec.get("position"),
 )

package/elizaos/bootstrap/providers/facts.py

@@ -83,4 +83,5 @@ facts_provider = Provider(
     description=_spec["description"],
     get=get_facts_context,
     dynamic=_spec.get("dynamic", True),
+    position=_spec.get("position"),
 )

package/elizaos/bootstrap/providers/follow_ups.py

@@ -113,4 +113,5 @@ follow_ups_provider = Provider(
     description=_spec["description"],
     get=get_follow_ups_context,
     dynamic=_spec.get("dynamic", True),
+    position=_spec.get("position"),
 )