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

package/tests/test_advanced_planning_behavior.py

@@ -4,6 +4,7 @@ from typing import Any
 from uuid import uuid4
 
 import pytest
+from google.protobuf.json_format import MessageToDict
 
 from elizaos.advanced_planning.planning_service import ActionPlan, ActionStep
 from elizaos.runtime import AgentRuntime
@@ -15,7 +16,6 @@ from elizaos.types.model import ModelType
 from elizaos.types.primitives import Content, as_uuid
 
 
-@pytest.mark.skip(reason="State.values.extra access issue with protobuf")
 @pytest.mark.asyncio
 async def test_advanced_planning_provider_parses_model_output() -> None:
     character = Character(name="AdvPlanningProvider", bio=["Test"], advanced_planning=True)
@@ -49,7 +49,13 @@ async def test_advanced_planning_provider_parses_model_output() -> None:
     state = await runtime.compose_state(msg)
     result = await provider.get(runtime, msg, state)
     assert result.data is not None
-    assert result.data.get("planningRequired") is True
+    parsed_data = (
+        MessageToDict(result.data, preserving_proto_field_name=True)
+        if hasattr(result.data, "DESCRIPTOR")
+        else result.data
+    )
+    assert isinstance(parsed_data, dict)
+    assert parsed_data.get("planningRequired") is True
 
 
 @pytest.mark.asyncio
@@ -72,7 +78,6 @@ async def test_advanced_planning_service_creates_simple_plan() -> None:
     assert any(step.action_name == "SEND_EMAIL" for step in plan.steps)
 
 
-@pytest.mark.skip(reason="State.values.extra access issue with protobuf")
 @pytest.mark.asyncio
 async def test_advanced_planning_service_creates_comprehensive_plan_and_executes() -> None:
     character = Character(name="AdvPlanningSvcExec", bio=["Test"], advanced_planning=True)
@@ -124,7 +129,6 @@ async def test_advanced_planning_service_creates_comprehensive_plan_and_executes
     assert result.total_steps >= 1
 
 
-@pytest.mark.skip(reason="validate lambda returns bool, not coroutine")
 @pytest.mark.asyncio
 async def test_advanced_planning_dag_executes_in_dependency_order() -> None:
     character = Character(name="AdvPlanningDag", bio=["Test"], advanced_planning=True)
@@ -220,6 +224,8 @@ async def test_advanced_planning_dag_executes_in_dependency_order() -> None:
         content=Content(text="run"),
     )
     state = await runtime.compose_state(msg)
-    await planning_service.execute_plan(plan, msg, state=state, callback=None)
+    execution_result = await planning_service.execute_plan(plan, msg, state=state, callback=None)
 
+    assert execution_result.success is True
+    assert execution_result.completed_steps == 3
     assert execution_order == ["STEP_A", "STEP_B", "STEP_C"]

package/tests/test_async_embedding.py

@@ -0,0 +1,124 @@
+import asyncio
+import unittest
+import uuid
+from unittest.mock import AsyncMock, MagicMock
+
+from elizaos.bootstrap.services.embedding import EmbeddingService
+from elizaos.types import ModelType
+from elizaos.types.events import EventType
+from elizaos.types.memory import Memory
+from elizaos.types.primitives import Content
+
+
+class TestAsyncEmbedding(unittest.IsolatedAsyncioTestCase):
+    async def test_async_embedding_generation(self):
+        # Mock runtime
+        runtime = (
+            MagicMock()
+        )  # Don't use spec=IAgentRuntime to avoid abstract methods issues for now
+        runtime.agent_id = uuid.uuid4()
+        runtime.logger = MagicMock()
+
+        # Event handling
+        events = {}
+
+        def register_event(event, handler):
+            if event not in events:
+                events[event] = []
+            events[event].append(handler)
+
+        async def emit_event(event, payload):
+            handlers = events.get(event, [])
+            for handler in handlers:
+                if asyncio.iscoroutinefunction(handler):
+                    await handler(payload)
+                else:
+                    handler(payload)
+
+        async def use_model(model_type, **kwargs):
+            if model_type == ModelType.TEXT_SMALL:
+                return "intent"
+            if model_type == ModelType.TEXT_EMBEDDING:
+                return [0.1] * 384
+            return None
+
+        runtime.register_event = register_event
+        runtime.emit_event = AsyncMock(side_effect=emit_event)
+        runtime.use_model = AsyncMock(side_effect=use_model)
+
+        # Mock adapter
+        adapter = AsyncMock()
+        runtime.db = adapter
+        runtime._adapter = adapter
+        service = await EmbeddingService.start(runtime)
+
+        # Setup completion listener
+        completed_future = asyncio.Future()
+
+        async def on_completed(payload):
+            completed_future.set_result(payload)
+
+        runtime.register_event(
+            EventType.Name(EventType.EVENT_TYPE_EMBEDDING_GENERATION_COMPLETED), on_completed
+        )
+
+        # Create memory
+        memory_id = str(uuid.uuid4())
+        memory = Memory(
+            id=memory_id,
+            content=Content(
+                text="A very long message that should trigger intent generation and then embedding."
+            ),
+            room_id=str(uuid.uuid4()),
+            entity_id=str(uuid.uuid4()),
+            agent_id=str(runtime.agent_id),
+        )
+
+        # Emit request
+        # Construct proper EventPayload
+        # EventPayload (protobuf) expects 'extra' to be a Struct or map<string, Value>
+        # But for python test convenience, we can use a mock that has attributes
+
+        # Actually EventPayload 'extra' field is google.protobuf.Struct usually
+        # But here we just need an object with .extra attribute for our code to work
+        # Or we can use the actual proto class
+
+        # Let's use a simple Namespace
+        from types import SimpleNamespace
+
+        payload = SimpleNamespace(extra={"memory": memory})
+
+        # Manually trigger handler because emit_event in MockRuntime doesn't wait for queue processing
+        # In real runtime, emit_event calls handlers. embedding service handler writes to queue.
+        # Worker reads from queue.
+
+        event_name = EventType.Name(EventType.EVENT_TYPE_EMBEDDING_GENERATION_REQUESTED)
+        await runtime.emit_event(event_name, payload)
+
+        # Wait for completion
+        try:
+            result = await asyncio.wait_for(completed_future, timeout=5.0)
+            self.assertEqual(result["memory_id"], str(memory_id))
+        except TimeoutError:
+            print("TIMEOUT! Logging errors:")
+            for call in runtime.logger.error.call_args_list:
+                print(call)
+            for call in runtime.logger.warning.call_args_list:
+                print(call)
+            self.fail("Embedding generation timed out")
+
+        # Verify db update
+        runtime._adapter.update_memory.assert_called_once()
+        call_args = runtime._adapter.update_memory.call_args
+        updated_memory = call_args[0][0]
+        self.assertIsNotNone(updated_memory.embedding)
+        self.assertEqual(len(updated_memory.embedding), 384)
+        # Check intent (metadata update)
+        # Verify in custom metadata
+        self.assertEqual(updated_memory.metadata.custom.custom_data["intent"], "intent")
+
+        await service.stop()
+
+
+if __name__ == "__main__":
+    unittest.main()

package/tests/test_autonomy.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import time
 from unittest.mock import AsyncMock, MagicMock
 
 import pytest
@@ -11,9 +12,10 @@ from elizaos.bootstrap.autonomy import (
     autonomy_status_provider,
     send_to_admin_action,
 )
+from elizaos.bootstrap.autonomy.service import AUTONOMY_TASK_TAGS
 from elizaos.bootstrap.autonomy.types import AutonomyStatus
 from elizaos.types.memory import Memory
-from elizaos.types.primitives import Content, as_uuid
+from elizaos.types.primitives import Content, as_uuid, string_to_uuid
 
 TEST_AGENT_ID = "00000000-0000-0000-0000-000000000001"
 TEST_ROOM_ID = "00000000-0000-0000-0000-000000000002"
@@ -75,6 +77,9 @@ class TestAutonomyService:
         assert AutonomyService.service_type == AUTONOMY_SERVICE_TYPE
         assert AutonomyService.service_type == "AUTONOMY"
 
+    def test_task_tags_match_typescript(self):
+        assert AUTONOMY_TASK_TAGS == ["queue", "repeat", "autonomy"]
+
     @pytest.mark.asyncio
     async def test_start_creates_service(self, test_runtime):
         service = await AutonomyService.start(test_runtime)
@@ -85,6 +90,12 @@ class TestAutonomyService:
         assert service.get_loop_interval() == 30000
         assert service.get_autonomous_room_id() is not None
 
+    @pytest.mark.asyncio
+    async def test_autonomous_room_id_is_deterministic(self, test_runtime):
+        service = await AutonomyService.start(test_runtime)
+        expected_room_id = as_uuid(string_to_uuid(f"autonomy-room-{test_runtime.agent_id}"))
+        assert service.get_autonomous_room_id() == expected_room_id
+
     @pytest.mark.asyncio
     async def test_auto_start_when_enabled(self, test_runtime):
         test_runtime.enable_autonomy = True
@@ -172,13 +183,14 @@ class TestAutonomyService:
         test_runtime.get_setting = MagicMock(return_value=str(target_room_id))
 
         dup_id = as_uuid(TEST_MESSAGE_ID)
+        now_ms = int(time.time() * 1000)
         older = Memory(
             id=dup_id,
             room_id=target_room_id,
             entity_id=as_uuid(TEST_ENTITY_ID),
             agent_id=as_uuid(TEST_AGENT_ID),
             content=Content(text="old"),
-            created_at=10,
+            created_at=now_ms - 60_000,  # 1 minute ago (within 1-hour window)
         )
         newer = Memory(
             id=dup_id,
@@ -186,7 +198,7 @@ class TestAutonomyService:
             entity_id=as_uuid(TEST_ENTITY_ID),
             agent_id=as_uuid(TEST_AGENT_ID),
             content=Content(text="new"),
-            created_at=20,
+            created_at=now_ms - 30_000,  # 30 seconds ago (within 1-hour window)
         )
 
         async def get_memories(params):
@@ -435,11 +447,20 @@ class TestAutonomyIntegration:
             AutonomyService,
             admin_chat_provider,
             autonomy_status_provider,
+            disable_autonomy_action,
+            enable_autonomy_action,
+            post_action_evaluator,
             send_to_admin_action,
         )
 
         assert AutonomyService is not None
         assert AUTONOMY_SERVICE_TYPE == "AUTONOMY"
         assert send_to_admin_action is not None
+        assert enable_autonomy_action is not None
+        assert enable_autonomy_action.name == "ENABLE_AUTONOMY"
+        assert disable_autonomy_action is not None
+        assert disable_autonomy_action.name == "DISABLE_AUTONOMY"
+        assert post_action_evaluator is not None
+        assert post_action_evaluator.name == "POST_ACTION_EVALUATOR"
         assert admin_chat_provider is not None
         assert autonomy_status_provider is not None

package/tests/test_history_compaction.py

@@ -0,0 +1,104 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from types import SimpleNamespace
+from unittest.mock import AsyncMock
+
+import pytest
+
+from elizaos.advanced_memory.actions.reset_session import (
+    reset_session_action as advanced_reset_session_action,
+)
+from elizaos.basic_capabilities.providers.recent_messages import (
+    recent_messages_provider as basic_recent_messages_provider,
+)
+from elizaos.bootstrap.actions.reset_session import (
+    reset_session_action as bootstrap_reset_session_action,
+)
+from elizaos.bootstrap.providers.recent_messages import (
+    recent_messages_provider as bootstrap_recent_messages_provider,
+)
+from elizaos.types import Content, Memory, as_uuid
+
+
+@dataclass
+class FakeRoom:
+    id: object
+    world_id: object | None
+    metadata: dict[str, object]
+
+
+class FakeRuntime:
+    def __init__(self, room: FakeRoom, *, role: str = "OWNER") -> None:
+        self.room = room
+        self.updated_room: FakeRoom | None = None
+        self.get_room = AsyncMock(return_value=room)
+        self.update_room = AsyncMock(side_effect=self._update_room)
+        self.get_memories = AsyncMock(return_value=[])
+        self.get_entity = AsyncMock(return_value=SimpleNamespace(name="User"))
+        self.agent_id = as_uuid("91000000-0000-0000-0000-000000000001")
+        self.character = SimpleNamespace(name="CompactionAgent")
+        self.get_world = AsyncMock(
+            return_value=SimpleNamespace(
+                metadata={"roles": {"91000000-0000-0000-0000-000000000002": role}}
+            )
+        )
+
+    async def _update_room(self, room: FakeRoom) -> None:
+        self.updated_room = room
+        self.room = room
+
+
+def _message() -> Memory:
+    return Memory(
+        id=as_uuid("91000000-0000-0000-0000-000000000010"),
+        entity_id=as_uuid("91000000-0000-0000-0000-000000000002"),
+        room_id=as_uuid("91000000-0000-0000-0000-000000000003"),
+        content=Content(text="start over", source="test"),
+    )
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "action_under_test",
+    [bootstrap_reset_session_action, advanced_reset_session_action],
+)
+async def test_reset_session_action_updates_room_metadata(action_under_test: object) -> None:
+    room = FakeRoom(
+        id=as_uuid("91000000-0000-0000-0000-000000000003"),
+        world_id=as_uuid("91000000-0000-0000-0000-000000000004"),
+        metadata={
+            "lastCompactionAt": 1000,
+            "compactionHistory": [{"timestamp": 1000, "triggeredBy": "old", "reason": "manual"}],
+        },
+    )
+    runtime = FakeRuntime(room)
+
+    result = await action_under_test.handler(runtime, _message(), None, None, None, None)
+
+    assert result.success is True
+    assert runtime.updated_room is not None
+    assert runtime.updated_room.metadata["lastCompactionAt"] >= 1000
+    assert len(runtime.updated_room.metadata["compactionHistory"]) == 2
+    assert result.values["previousCompactionAt"] == 1000
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "provider_under_test",
+    [bootstrap_recent_messages_provider, basic_recent_messages_provider],
+)
+async def test_recent_messages_provider_uses_last_compaction_boundary(
+    provider_under_test: object,
+) -> None:
+    room = FakeRoom(
+        id=as_uuid("91000000-0000-0000-0000-000000000003"),
+        world_id=None,
+        metadata={"lastCompactionAt": 4242},
+    )
+    runtime = FakeRuntime(room)
+
+    result = await provider_under_test.get(runtime, _message(), None)
+
+    assert result.values["roomId"] == str(_message().room_id)
+    assert runtime.get_memories.await_args.kwargs["start"] == 4242

package/tests/test_memory_bounds.py

@@ -0,0 +1,115 @@
+from __future__ import annotations
+
+import uuid
+from types import SimpleNamespace
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+
+from elizaos.advanced_memory.memory_service import MemoryService
+from elizaos.advanced_memory.types import LongTermMemoryCategory
+from elizaos.basic_capabilities.services.embedding import (
+    EmbeddingService as BasicEmbeddingService,
+)
+from elizaos.bootstrap.services.embedding import (
+    EmbeddingService as BootstrapEmbeddingService,
+)
+from elizaos.types import ModelType
+
+
+def _mock_runtime() -> MagicMock:
+    runtime = MagicMock()
+    runtime.agent_id = uuid.uuid4()
+    runtime.logger = MagicMock()
+
+    async def use_model(model_type, **_kwargs):
+        if model_type == ModelType.TEXT_EMBEDDING:
+            return [0.1, 0.2, 0.3]
+        return "ok"
+
+    runtime.use_model = AsyncMock(side_effect=use_model)
+    return runtime
+
+
+@pytest.mark.asyncio
+async def test_embedding_services_use_lru_eviction() -> None:
+    for service_cls in (BasicEmbeddingService, BootstrapEmbeddingService):
+        runtime = _mock_runtime()
+        service = service_cls()
+        service._runtime = runtime
+        service.set_max_cache_size(2)
+
+        await service.embed("a")
+        await service.embed("b")
+        await service.embed("a")
+        await service.embed("c")
+
+        assert list(service._cache.keys()) == ["a", "c"]
+
+
+@pytest.mark.asyncio
+async def test_bootstrap_embedding_queue_deduplicates_and_clears_on_stop() -> None:
+    service = BootstrapEmbeddingService()
+    service._runtime = _mock_runtime()
+
+    payload = SimpleNamespace(extra={"memory": {"id": "memory-1"}})
+
+    await service._handle_embedding_request(payload)
+    await service._handle_embedding_request(payload)
+
+    assert service._queue.qsize() == 1
+    assert service._pending_payload_keys == {"memory-1"}
+
+    await service.stop()
+
+    assert service._queue.qsize() == 0
+    assert service._pending_payload_keys == set()
+
+
+@pytest.mark.asyncio
+async def test_advanced_memory_fallback_storage_is_bounded() -> None:
+    service = MemoryService(runtime=None)
+    agent_id = uuid.uuid4()
+
+    for index in range(service._MAX_LOCAL_SESSION_SUMMARIES + 25):
+        await service.store_session_summary(
+            agent_id=agent_id,
+            room_id=uuid.uuid4(),
+            summary=f"summary-{index}",
+            message_count=index,
+            last_message_offset=index,
+        )
+
+    assert len(service._session_summaries) == service._MAX_LOCAL_SESSION_SUMMARIES
+
+    for index in range(service._MAX_LOCAL_EXTRACTION_CHECKPOINTS + 25):
+        await service.set_last_extraction_checkpoint(uuid.uuid4(), uuid.uuid4(), index)
+
+    assert len(service._extraction_checkpoints) == service._MAX_LOCAL_EXTRACTION_CHECKPOINTS
+
+    for _ in range(service._MAX_LOCAL_LONG_TERM_ENTITIES + 25):
+        entity_id = uuid.uuid4()
+        await service.store_long_term_memory(
+            agent_id=agent_id,
+            entity_id=entity_id,
+            category=LongTermMemoryCategory.SEMANTIC,
+            content=f"entity-{entity_id}",
+            confidence=0.9,
+        )
+
+    assert len(service._long_term) == service._MAX_LOCAL_LONG_TERM_ENTITIES
+
+    hot_entity_id = uuid.uuid4()
+    for index in range(service._MAX_LOCAL_LONG_TERM_PER_ENTITY + 25):
+        await service.store_long_term_memory(
+            agent_id=agent_id,
+            entity_id=hot_entity_id,
+            category=LongTermMemoryCategory.SEMANTIC,
+            content=f"fact-{index}",
+            confidence=float(index),
+        )
+
+    retained = service._long_term[str(hot_entity_id)]
+    assert len(retained) == service._MAX_LOCAL_LONG_TERM_PER_ENTITY
+    assert retained[0].content == "fact-25"
+    assert retained[-1].content == f"fact-{service._MAX_LOCAL_LONG_TERM_PER_ENTITY + 24}"

package/tests/test_runtime.py

@@ -59,17 +59,15 @@ class TestAgentRuntimeSettings:
         runtime.set_setting("test_key", "test_value")
         assert runtime.get_setting("test_key") == "test_value"
 
-    @pytest.mark.skip(reason="CharacterSettings proto doesn't support arbitrary fields")
     def test_get_setting_from_character(self) -> None:
         character = Character(
             name="Test",
             bio=["Test"],
-            settings={"char_setting": "char_value"},
+            settings={"extra": {"char_setting": "char_value"}},
         )
         runtime = AgentRuntime(character=character)
         assert runtime.get_setting("char_setting") == "char_value"
 
-    @pytest.mark.skip(reason="Runtime get_setting from secrets not yet implemented")
     def test_get_setting_from_secrets(self) -> None:
         character = Character(
             name="Test",
@@ -305,42 +303,38 @@ class TestAgentRuntimeLLMMode:
         runtime = AgentRuntime(character=character, llm_mode=LLMMode.LARGE)
         assert runtime.get_llm_mode() == LLMMode.LARGE
 
-    @pytest.mark.skip(reason="CharacterSettings proto doesn't have LLM_MODE field")
     def test_character_setting_small(self) -> None:
         character = Character(
             name="Test",
             bio=["Test"],
-            settings={"LLM_MODE": "SMALL"},
+            settings={"extra": {"LLM_MODE": "SMALL"}},
         )
         runtime = AgentRuntime(character=character)
         assert runtime.get_llm_mode() == LLMMode.SMALL
 
-    @pytest.mark.skip(reason="CharacterSettings proto doesn't have LLM_MODE field")
     def test_constructor_option_takes_precedence(self) -> None:
         character = Character(
             name="Test",
             bio=["Test"],
-            settings={"LLM_MODE": "SMALL"},
+            settings={"extra": {"LLM_MODE": "SMALL"}},
         )
         runtime = AgentRuntime(character=character, llm_mode=LLMMode.LARGE)
         assert runtime.get_llm_mode() == LLMMode.LARGE
 
-    @pytest.mark.skip(reason="CharacterSettings proto doesn't have LLM_MODE field")
     def test_case_insensitive_character_setting(self) -> None:
         character = Character(
             name="Test",
             bio=["Test"],
-            settings={"LLM_MODE": "small"},
+            settings={"extra": {"LLM_MODE": "small"}},
         )
         runtime = AgentRuntime(character=character)
         assert runtime.get_llm_mode() == LLMMode.SMALL
 
-    @pytest.mark.skip(reason="CharacterSettings proto doesn't have LLM_MODE field")
     def test_invalid_setting_defaults_to_default(self) -> None:
         character = Character(
             name="Test",
             bio=["Test"],
-            settings={"LLM_MODE": "invalid"},
+            settings={"extra": {"LLM_MODE": "invalid"}},
         )
         runtime = AgentRuntime(character=character)
         assert runtime.get_llm_mode() == LLMMode.DEFAULT
@@ -391,32 +385,29 @@ class TestAgentRuntimeCheckShouldRespond:
         runtime = AgentRuntime(character=character, check_should_respond=True)
         assert runtime.is_check_should_respond_enabled() is True
 
-    @pytest.mark.skip(reason="CharacterSettings proto doesn't have CHECK_SHOULD_RESPOND field")
     def test_character_setting_false(self) -> None:
         character = Character(
             name="Test",
             bio=["Test"],
-            settings={"CHECK_SHOULD_RESPOND": "false"},
+            settings={"extra": {"CHECK_SHOULD_RESPOND": "false"}},
         )
         runtime = AgentRuntime(character=character)
         assert runtime.is_check_should_respond_enabled() is False
 
-    @pytest.mark.skip(reason="CharacterSettings proto doesn't have CHECK_SHOULD_RESPOND field")
     def test_constructor_option_takes_precedence(self) -> None:
         character = Character(
             name="Test",
             bio=["Test"],
-            settings={"CHECK_SHOULD_RESPOND": "false"},
+            settings={"extra": {"CHECK_SHOULD_RESPOND": "false"}},
         )
         runtime = AgentRuntime(character=character, check_should_respond=True)
         assert runtime.is_check_should_respond_enabled() is True
 
-    @pytest.mark.skip(reason="CharacterSettings proto doesn't have CHECK_SHOULD_RESPOND field")
     def test_non_false_string_defaults_to_true(self) -> None:
         character = Character(
             name="Test",
             bio=["Test"],
-            settings={"CHECK_SHOULD_RESPOND": "yes"},
+            settings={"extra": {"CHECK_SHOULD_RESPOND": "yes"}},
         )
         runtime = AgentRuntime(character=character)
         assert runtime.is_check_should_respond_enabled() is True