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

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_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

package/tests/test_schedule_follow_up_action.py

@@ -0,0 +1,260 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from types import SimpleNamespace
+from typing import Protocol
+
+import pytest
+
+from elizaos.advanced_capabilities.actions.schedule_follow_up import (
+    schedule_follow_up_action as advanced_schedule_follow_up_action,
+)
+from elizaos.bootstrap.actions.schedule_follow_up import (
+    schedule_follow_up_action as bootstrap_schedule_follow_up_action,
+)
+from elizaos.bootstrap.services.follow_up import FollowUpService
+from elizaos.bootstrap.services.rolodex import RolodexService
+from elizaos.types import Content, Memory, as_uuid
+
+
+class RolodexLike(Protocol):
+    async def search_contacts(
+        self,
+        categories: list[str] | None = None,
+        tags: list[str] | None = None,
+        search_term: str | None = None,
+    ) -> list[SimpleNamespace]: ...
+
+    async def get_contact(self, entity_id: object) -> SimpleNamespace | None: ...
+
+
+class ActionLike(Protocol):
+    async def handler(
+        self,
+        runtime: object,
+        message: Memory,
+        state: object | None,
+        options: object | None,
+        callback: object | None,
+        responses: list[Memory] | None,
+    ) -> object: ...
+
+
+@dataclass
+class FakeFollowUpCall:
+    entity_id: object
+    priority: str
+
+
+class FakeFollowUpService(FollowUpService):
+    def __init__(self) -> None:
+        self.calls: list[FakeFollowUpCall] = []
+
+    async def schedule_follow_up(
+        self,
+        entity_id: object,
+        scheduled_at: object,
+        reason: str,
+        priority: str = "medium",
+        message: str | None = None,
+    ) -> SimpleNamespace:
+        self.calls.append(FakeFollowUpCall(entity_id=entity_id, priority=priority))
+        return SimpleNamespace(
+            entity_id=entity_id,
+            scheduled_at=str(scheduled_at),
+            reason=reason,
+            priority=priority,
+            message=message,
+        )
+
+
+class FakeRolodexService(RolodexService):
+    def __init__(self, contacts: list[SimpleNamespace]) -> None:
+        self._contacts = contacts
+
+    async def search_contacts(
+        self,
+        categories: list[str] | None = None,
+        tags: list[str] | None = None,
+        search_term: str | None = None,
+    ) -> list[SimpleNamespace]:
+        if not search_term:
+            return self._contacts
+        lowered = search_term.lower()
+        return [
+            contact
+            for contact in self._contacts
+            if lowered in str(contact.entity_id).lower()
+            or lowered in str(getattr(contact, "name", "")).lower()
+        ]
+
+    async def get_contact(self, entity_id: object) -> SimpleNamespace | None:
+        for contact in self._contacts:
+            if contact.entity_id == entity_id:
+                return contact
+        return None
+
+
+class FakeRuntime:
+    def __init__(self, rolodex: RolodexLike, follow_up: FakeFollowUpService, response: str) -> None:
+        self._rolodex = rolodex
+        self._follow_up = follow_up
+        self._response = response
+
+    def get_service(self, name: str) -> object | None:
+        if name == "rolodex":
+            return self._rolodex
+        if name == "follow_up":
+            return self._follow_up
+        return None
+
+    async def compose_state(self, _message: Memory, _providers: list[str]) -> SimpleNamespace:
+        return SimpleNamespace(values={}, data={}, text="")
+
+    def get_setting(self, _key: str) -> object | None:
+        return None
+
+    def compose_prompt_from_state(self, state: object, template: str) -> str:
+        return f"{template}\n{state}"
+
+    async def use_model(self, _model_type: object, _params: dict[str, object]) -> str:
+        return self._response
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "action_under_test",
+    [bootstrap_schedule_follow_up_action, advanced_schedule_follow_up_action],
+)
+async def test_schedule_follow_up_fails_when_contact_unresolved(
+    action_under_test: ActionLike,
+) -> None:
+    follow_up_service = FakeFollowUpService()
+    rolodex_service = FakeRolodexService(contacts=[])
+    runtime = FakeRuntime(
+        rolodex=rolodex_service,
+        follow_up=follow_up_service,
+        response=(
+            "<response>"
+            "<contactName>missing-contact</contactName>"
+            "<scheduledAt>2026-01-02T12:00:00Z</scheduledAt>"
+            "<reason>Check-in</reason>"
+            "<priority>high</priority>"
+            "</response>"
+        ),
+    )
+
+    message = Memory(
+        id=as_uuid("70000000-0000-0000-0000-000000000001"),
+        room_id=as_uuid("70000000-0000-0000-0000-000000000002"),
+        entity_id=None,
+        content=Content(text="follow up with missing-contact next week"),
+    )
+
+    result = await action_under_test.handler(
+        runtime,
+        message,
+        None,
+        None,
+        None,
+        None,
+    )
+
+    assert result is not None
+    assert result.success is False
+    assert len(follow_up_service.calls) == 0
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "action_under_test",
+    [bootstrap_schedule_follow_up_action, advanced_schedule_follow_up_action],
+)
+async def test_schedule_follow_up_normalizes_priority_and_schedules(
+    action_under_test: ActionLike,
+) -> None:
+    follow_up_service = FakeFollowUpService()
+    contact_id = as_uuid("80000000-0000-0000-0000-000000000001")
+    rolodex_service = FakeRolodexService(
+        contacts=[SimpleNamespace(entity_id=contact_id, name="known-contact")]
+    )
+    runtime = FakeRuntime(
+        rolodex=rolodex_service,
+        follow_up=follow_up_service,
+        response=(
+            "<response>"
+            "<contactName>known-contact</contactName>"
+            "<scheduledAt>2026-01-03T09:30:00Z</scheduledAt>"
+            "<reason>Status update</reason>"
+            "<priority>urgent</priority>"
+            "</response>"
+        ),
+    )
+
+    message = Memory(
+        id=as_uuid("80000000-0000-0000-0000-000000000002"),
+        room_id=as_uuid("80000000-0000-0000-0000-000000000003"),
+        entity_id=None,
+        content=Content(text="schedule follow-up with known-contact"),
+    )
+
+    result = await action_under_test.handler(
+        runtime,
+        message,
+        None,
+        None,
+        None,
+        None,
+    )
+
+    assert result is not None
+    assert result.success is True
+    assert len(follow_up_service.calls) == 1
+    assert follow_up_service.calls[0].priority == "medium"
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "action_under_test",
+    [bootstrap_schedule_follow_up_action, advanced_schedule_follow_up_action],
+)
+async def test_schedule_follow_up_rejects_invalid_scheduled_at(
+    action_under_test: ActionLike,
+) -> None:
+    follow_up_service = FakeFollowUpService()
+    contact_id = as_uuid("90000000-0000-0000-0000-000000000001")
+    rolodex_service = FakeRolodexService(
+        contacts=[SimpleNamespace(entity_id=contact_id, name="known-contact")]
+    )
+    runtime = FakeRuntime(
+        rolodex=rolodex_service,
+        follow_up=follow_up_service,
+        response=(
+            "<response>"
+            "<contactName>known-contact</contactName>"
+            "<scheduledAt>not-a-date</scheduledAt>"
+            "<reason>Status update</reason>"
+            "<priority>high</priority>"
+            "</response>"
+        ),
+    )
+
+    message = Memory(
+        id=as_uuid("90000000-0000-0000-0000-000000000002"),
+        room_id=as_uuid("90000000-0000-0000-0000-000000000003"),
+        entity_id=None,
+        content=Content(text="schedule follow-up with known-contact"),
+    )
+
+    result = await action_under_test.handler(
+        runtime,
+        message,
+        None,
+        None,
+        None,
+        None,
+    )
+
+    assert result is not None
+    assert result.success is False
+    assert len(follow_up_service.calls) == 0

package/tests/test_send_message_action_targets.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+from types import SimpleNamespace
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+
+from elizaos.advanced_capabilities.actions.send_message import (
+    send_message_action as advanced_send_message_action,
+)
+from elizaos.bootstrap.actions.send_message import (
+    send_message_action as bootstrap_send_message_action,
+)
+from elizaos.types.memory import Memory
+from elizaos.types.primitives import Content, as_uuid
+
+
+def _make_runtime() -> MagicMock:
+    runtime = MagicMock()
+    runtime.agent_id = as_uuid("42345678-1234-1234-1234-123456789001")
+    runtime.create_memory = AsyncMock()
+    runtime.emit_event = AsyncMock()
+    runtime.send_message_to_target = AsyncMock()
+    runtime.get_room = AsyncMock(return_value=None)
+    runtime.get_rooms = AsyncMock(return_value=[])
+    runtime.get_entities_for_room = AsyncMock(return_value=[])
+    return runtime
+
+
+def _make_message() -> Memory:
+    return Memory(
+        id=as_uuid("42345678-1234-1234-1234-123456789010"),
+        entity_id=as_uuid("42345678-1234-1234-1234-123456789011"),
+        room_id=as_uuid("42345678-1234-1234-1234-123456789012"),
+        content=Content(text="fallback", source="telegram"),
+    )
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "action_under_test",
+    [bootstrap_send_message_action, advanced_send_message_action],
+)
+async def test_send_message_uses_room_target_parameters(action_under_test: object) -> None:
+    runtime = _make_runtime()
+    message = _make_message()
+    target_room_id = "42345678-1234-1234-1234-123456789099"
+
+    result = await action_under_test.handler(
+        runtime,
+        message,
+        None,
+        SimpleNamespace(
+            parameters={
+                "targetType": "room",
+                "target": target_room_id,
+                "source": "discord",
+                "text": "ship it",
+            }
+        ),
+        None,
+        None,
+    )
+
+    assert result.success is True
+    assert result.values["targetType"] == "room"
+    assert result.values["targetRoomId"] == target_room_id
+    runtime.create_memory.assert_awaited_once()
+    create_kwargs = runtime.create_memory.await_args.kwargs
+    assert create_kwargs["room_id"] == as_uuid(target_room_id)
+
+    runtime.send_message_to_target.assert_awaited_once()
+    send_target = runtime.send_message_to_target.await_args.args[0]
+    assert str(send_target.room_id) == target_room_id
+    assert send_target.source == "discord"
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize(
+    "action_under_test",
+    [bootstrap_send_message_action, advanced_send_message_action],
+)
+async def test_send_message_resolves_user_target_from_room_entities(
+    action_under_test: object,
+) -> None:
+    runtime = _make_runtime()
+    message = _make_message()
+    target_entity_id = as_uuid("42345678-1234-1234-1234-123456789088")
+    runtime.get_entities_for_room = AsyncMock(
+        return_value=[SimpleNamespace(id=target_entity_id, names=["Alice"])]
+    )
+
+    result = await action_under_test.handler(
+        runtime,
+        message,
+        None,
+        SimpleNamespace(
+            parameters={
+                "targetType": "user",
+                "target": "alice",
+                "source": "discord",
+                "text": "hello",
+            }
+        ),
+        None,
+        None,
+    )
+
+    assert result.success is True
+    assert result.values["targetType"] == "user"
+    assert result.values["targetEntityId"] == target_entity_id
+    runtime.send_message_to_target.assert_awaited_once()
+    send_target = runtime.send_message_to_target.await_args.args[0]
+    assert str(send_target.entity_id) == target_entity_id

package/tests/test_settings_crypto.py

@@ -78,7 +78,6 @@ class TestSettingsCrypto:
         assert migrated.startswith("v2:")
         assert decrypt_string_value(migrated, salt) == plaintext
 
-    @pytest.mark.skip(reason="Runtime get_setting from secrets not yet implemented")
     def test_runtime_get_setting_decrypts_secret_strings(
         self, monkeypatch: pytest.MonkeyPatch
     ) -> None:
@@ -96,7 +95,6 @@ class TestSettingsCrypto:
         runtime = AgentRuntime(character=character)
         assert runtime.get_setting("API_KEY") == "super-secret"
 
-    @pytest.mark.skip(reason="Runtime get_setting from secrets not yet implemented")
     def test_runtime_get_setting_coerces_true_false_strings(
         self, monkeypatch: pytest.MonkeyPatch
     ) -> None: