@elizaos/python 2.0.0-alpha.10

package/tests/test_autonomy.py

@@ -0,0 +1,445 @@
+from __future__ import annotations
+
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+
+from elizaos.bootstrap.autonomy import (
+    AUTONOMY_SERVICE_TYPE,
+    AutonomyService,
+    admin_chat_provider,
+    autonomy_status_provider,
+    send_to_admin_action,
+)
+from elizaos.bootstrap.autonomy.types import AutonomyStatus
+from elizaos.types.memory import Memory
+from elizaos.types.primitives import Content, as_uuid
+
+TEST_AGENT_ID = "00000000-0000-0000-0000-000000000001"
+TEST_ROOM_ID = "00000000-0000-0000-0000-000000000002"
+TEST_ENTITY_ID = "00000000-0000-0000-0000-000000000003"
+TEST_MESSAGE_ID = "00000000-0000-0000-0000-000000000004"
+OTHER_ROOM_ID = "00000000-0000-0000-0000-000000000005"
+AUTONOMOUS_ROOM_ID = "00000000-0000-0000-0000-000000000006"
+
+
+@pytest.fixture
+def test_runtime():
+    runtime = MagicMock()
+    runtime.agent_id = as_uuid(TEST_AGENT_ID)
+    runtime.character = MagicMock()
+    runtime.character.name = "Test Agent"
+
+    runtime.ensure_world_exists = AsyncMock()
+    runtime.ensure_room_exists = AsyncMock()
+    runtime.add_participant = AsyncMock()
+    runtime.get_entity_by_id = AsyncMock(return_value=MagicMock(id=TEST_AGENT_ID))
+    runtime.get_memories = AsyncMock(return_value=[])
+    runtime.emit_event = AsyncMock()
+    runtime.create_memory = AsyncMock(return_value="memory-id")
+
+    runtime.get_setting = MagicMock(return_value=None)
+    runtime.set_setting = MagicMock()
+    runtime.enable_autonomy = False
+
+    runtime.logger = MagicMock()
+    runtime.logger.info = MagicMock()
+    runtime.logger.debug = MagicMock()
+    runtime.logger.error = MagicMock()
+    runtime.logger.warn = MagicMock()
+    runtime.logger.warning = MagicMock()
+
+    # Task system mocks (used by _create_autonomy_task / _remove_autonomy_task)
+    runtime.create_task = AsyncMock()
+    runtime.get_tasks = AsyncMock(return_value=[])
+    runtime.delete_task = AsyncMock()
+    runtime.register_task_worker = MagicMock()
+
+    return runtime
+
+
+@pytest.fixture
+def test_memory():
+    return Memory(
+        id=as_uuid(TEST_MESSAGE_ID),
+        room_id=as_uuid(TEST_ROOM_ID),
+        entity_id=as_uuid(TEST_ENTITY_ID),
+        agent_id=as_uuid(TEST_AGENT_ID),
+        content=Content(text="Test message"),
+        created_at=1234567890,
+    )
+
+
+class TestAutonomyService:
+    def test_service_type(self):
+        assert AutonomyService.service_type == AUTONOMY_SERVICE_TYPE
+        assert AutonomyService.service_type == "AUTONOMY"
+
+    @pytest.mark.asyncio
+    async def test_start_creates_service(self, test_runtime):
+        service = await AutonomyService.start(test_runtime)
+
+        assert service is not None
+        assert isinstance(service, AutonomyService)
+        assert service.is_loop_running() is False
+        assert service.get_loop_interval() == 30000
+        assert service.get_autonomous_room_id() is not None
+
+    @pytest.mark.asyncio
+    async def test_auto_start_when_enabled(self, test_runtime):
+        test_runtime.enable_autonomy = True
+
+        service = await AutonomyService.start(test_runtime)
+
+        assert service.is_loop_running() is True
+
+        await service.disable_autonomy()
+
+    @pytest.mark.asyncio
+    async def test_ensure_context_on_initialization(self, test_runtime):
+        _ = await AutonomyService.start(test_runtime)
+
+        test_runtime.ensure_world_exists.assert_called_once()
+        test_runtime.ensure_room_exists.assert_called_once()
+        test_runtime.add_participant.assert_called_once()
+
+        world_call = test_runtime.ensure_world_exists.call_args[0][0]
+        assert world_call.name == "Autonomy World"
+
+        room_call = test_runtime.ensure_room_exists.call_args[0][0]
+        assert room_call.name == "Autonomous Thoughts"
+        assert room_call.source == "autonomy-service"
+
+    @pytest.mark.asyncio
+    async def test_start_stop_loop(self, test_runtime):
+        service = await AutonomyService.start(test_runtime)
+
+        assert service.is_loop_running() is False
+
+        await service.enable_autonomy()
+        assert service.is_loop_running() is True
+        assert test_runtime.enable_autonomy is True
+
+        await service.disable_autonomy()
+        assert service.is_loop_running() is False
+        assert test_runtime.enable_autonomy is False
+
+    @pytest.mark.asyncio
+    async def test_no_double_start(self, test_runtime):
+        service = await AutonomyService.start(test_runtime)
+
+        await service.enable_autonomy()
+        call_count = test_runtime.set_setting.call_count
+
+        await service.enable_autonomy()
+        assert test_runtime.set_setting.call_count == call_count
+
+        await service.disable_autonomy()
+
+    @pytest.mark.asyncio
+    async def test_no_double_stop(self, test_runtime):
+        service = await AutonomyService.start(test_runtime)
+
+        call_count = test_runtime.set_setting.call_count
+        await service.disable_autonomy()
+        assert test_runtime.set_setting.call_count == call_count
+
+    @pytest.mark.asyncio
+    async def test_interval_configuration(self, test_runtime):
+        service = await AutonomyService.start(test_runtime)
+
+        await service.set_loop_interval(60000)
+        assert service.get_loop_interval() == 60000
+
+    @pytest.mark.asyncio
+    async def test_interval_minimum_enforced(self, test_runtime):
+        service = await AutonomyService.start(test_runtime)
+
+        await service.set_loop_interval(1000)
+        assert service.get_loop_interval() == 5000
+
+    @pytest.mark.asyncio
+    async def test_interval_maximum_enforced(self, test_runtime):
+        service = await AutonomyService.start(test_runtime)
+
+        await service.set_loop_interval(1000000)
+        assert service.get_loop_interval() == 600000
+
+    @pytest.mark.asyncio
+    async def test_target_room_context_dedupes_by_earliest_created_at(self, test_runtime):
+        service = await AutonomyService.start(test_runtime)
+        target_room_id = as_uuid(OTHER_ROOM_ID)
+        test_runtime.get_setting = MagicMock(return_value=str(target_room_id))
+
+        dup_id = as_uuid(TEST_MESSAGE_ID)
+        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,
+        )
+        newer = 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="new"),
+            created_at=20,
+        )
+
+        async def get_memories(params):
+            if params["tableName"] == "memories":
+                return [newer]
+            return [older]
+
+        test_runtime.get_memories = AsyncMock(side_effect=get_memories)
+
+        context = await service._get_target_room_context_text()
+        assert "old" in context
+        assert "new" not in context
+
+    @pytest.mark.asyncio
+    async def test_enable_autonomy(self, test_runtime):
+        service = await AutonomyService.start(test_runtime)
+
+        await service.enable_autonomy()
+
+        assert test_runtime.enable_autonomy is True
+        assert service.is_loop_running() is True
+
+        await service.disable_autonomy()
+
+    @pytest.mark.asyncio
+    async def test_disable_autonomy(self, test_runtime):
+        service = await AutonomyService.start(test_runtime)
+
+        await service.enable_autonomy()
+        await service.disable_autonomy()
+
+        assert test_runtime.enable_autonomy is False
+        assert service.is_loop_running() is False
+
+    @pytest.mark.asyncio
+    async def test_get_status(self, test_runtime):
+        test_runtime.enable_autonomy = True
+        service = await AutonomyService.start(test_runtime)
+
+        status = service.get_status()
+
+        assert isinstance(status, AutonomyStatus)
+        assert status.enabled is True
+        assert status.running is True
+        assert status.thinking is False
+        assert status.interval == 30000
+        assert status.autonomous_room_id is not None
+
+    @pytest.mark.asyncio
+    async def test_last_autonomous_thought_uses_latest_created_at(self, test_runtime):
+        service = await AutonomyService.start(test_runtime)
+        test_runtime.enable_autonomy = True
+        test_runtime.get_setting = MagicMock(return_value=None)
+
+        older = Memory(
+            id=as_uuid("12345678-1234-1234-1234-123456789010"),
+            room_id=service.get_autonomous_room_id(),
+            entity_id=as_uuid(TEST_AGENT_ID),
+            agent_id=as_uuid(TEST_AGENT_ID),
+            content=Content(text="older"),
+            created_at=10,
+        )
+        newer = Memory(
+            id=as_uuid("12345678-1234-1234-1234-123456789011"),
+            room_id=service.get_autonomous_room_id(),
+            entity_id=as_uuid(TEST_AGENT_ID),
+            agent_id=as_uuid(TEST_AGENT_ID),
+            content=Content(text="newer"),
+            created_at=20,
+        )
+
+        test_runtime.get_memories = AsyncMock(return_value=[older, newer])
+
+        await service.perform_autonomous_think()
+
+        assert test_runtime.emit_event.called is True
+        payload = test_runtime.emit_event.call_args[0][1]
+        msg = payload.get("message")
+        assert msg is not None
+        assert "newer" in (msg.content.text or "")
+
+        await service.disable_autonomy()
+
+    @pytest.mark.asyncio
+    async def test_thinking_guard_initial_state(self, test_runtime):
+        service = await AutonomyService.start(test_runtime)
+
+        assert service.is_thinking_in_progress() is False
+        assert service.get_status().thinking is False
+
+    @pytest.mark.asyncio
+    async def test_thinking_guard_prevents_overlap(self, test_runtime):
+        service = await AutonomyService.start(test_runtime)
+
+        service._is_thinking = True
+
+        assert service.is_thinking_in_progress() is True
+        assert service.get_status().thinking is True
+
+        service._is_thinking = False
+        assert service.is_thinking_in_progress() is False
+
+
+class TestSendToAdminAction:
+    def test_action_metadata(self):
+        assert send_to_admin_action.name == "SEND_TO_ADMIN"
+        assert send_to_admin_action.description is not None
+        assert send_to_admin_action.examples is not None
+        assert len(send_to_admin_action.examples) > 0
+
+    @pytest.mark.asyncio
+    async def test_validate_in_autonomous_room(self, test_runtime):
+        room_id = as_uuid(TEST_ROOM_ID)
+        mock_service = MagicMock(spec=AutonomyService)
+        mock_service.get_autonomous_room_id = MagicMock(return_value=room_id)
+        test_runtime.get_service = MagicMock(return_value=mock_service)
+        test_runtime.get_setting = MagicMock(return_value="admin-user-id")
+
+        message = Memory(
+            id=as_uuid(TEST_MESSAGE_ID),
+            room_id=room_id,
+            entity_id=as_uuid(TEST_ENTITY_ID),
+            agent_id=as_uuid(TEST_AGENT_ID),
+            content=Content(text="Tell admin about this update"),
+            created_at=1234567890,
+        )
+
+        is_valid = await send_to_admin_action.validate(test_runtime, message)
+        assert is_valid is True
+
+    @pytest.mark.asyncio
+    async def test_validate_not_in_autonomous_room(self, test_runtime, test_memory):
+        mock_service = MagicMock(spec=AutonomyService)
+        mock_service.get_autonomous_room_id = MagicMock(return_value=as_uuid(OTHER_ROOM_ID))
+        test_runtime.get_service = MagicMock(return_value=mock_service)
+        test_runtime.get_setting = MagicMock(return_value="admin-user-id")
+
+        is_valid = await send_to_admin_action.validate(test_runtime, test_memory)
+        assert is_valid is False
+
+    @pytest.mark.asyncio
+    async def test_validate_no_admin_configured(self, test_runtime, test_memory):
+        mock_service = MagicMock(spec=AutonomyService)
+        mock_service.get_autonomous_room_id = MagicMock(return_value=test_memory.room_id)
+        test_runtime.get_service = MagicMock(return_value=mock_service)
+        test_runtime.get_setting = MagicMock(return_value=None)
+
+        is_valid = await send_to_admin_action.validate(test_runtime, test_memory)
+        assert is_valid is False
+
+
+class TestAdminChatProvider:
+    def test_provider_metadata(self):
+        assert admin_chat_provider.name == "ADMIN_CHAT_HISTORY"
+        assert admin_chat_provider.description is not None
+
+    @pytest.mark.asyncio
+    async def test_returns_empty_when_no_service(self, test_runtime, test_memory):
+        test_runtime.get_service = MagicMock(return_value=None)
+
+        result = await admin_chat_provider.get(test_runtime, test_memory, {})
+
+        assert result.text == ""
+
+    @pytest.mark.asyncio
+    async def test_returns_empty_when_not_in_autonomous_room(self, test_runtime, test_memory):
+        mock_service = MagicMock(spec=AutonomyService)
+        mock_service.get_autonomous_room_id = MagicMock(return_value=as_uuid(OTHER_ROOM_ID))
+        test_runtime.get_service = MagicMock(return_value=mock_service)
+
+        result = await admin_chat_provider.get(test_runtime, test_memory, {})
+
+        assert result.text == ""
+
+    @pytest.mark.asyncio
+    async def test_indicates_no_admin_configured(self, test_runtime, test_memory):
+        mock_service = MagicMock(spec=AutonomyService)
+        mock_service.get_autonomous_room_id = MagicMock(return_value=test_memory.room_id)
+        test_runtime.get_service = MagicMock(return_value=mock_service)
+        test_runtime.get_setting = MagicMock(return_value=None)
+
+        result = await admin_chat_provider.get(test_runtime, test_memory, {})
+
+        assert "No admin user configured" in result.text
+        assert result.data == {"adminConfigured": False}
+
+
+class TestAutonomyStatusProvider:
+    def test_provider_metadata(self):
+        assert autonomy_status_provider.name == "AUTONOMY_STATUS"
+        assert autonomy_status_provider.description is not None
+
+    @pytest.mark.asyncio
+    async def test_returns_empty_when_no_service(self, test_runtime, test_memory):
+        test_runtime.get_service = MagicMock(return_value=None)
+
+        result = await autonomy_status_provider.get(test_runtime, test_memory, {})
+
+        assert result.text == ""
+
+    @pytest.mark.asyncio
+    async def test_returns_empty_in_autonomous_room(self, test_runtime, test_memory):
+        mock_service = MagicMock(spec=AutonomyService)
+        mock_service.get_autonomous_room_id = MagicMock(return_value=test_memory.room_id)
+        test_runtime.get_service = MagicMock(return_value=mock_service)
+
+        result = await autonomy_status_provider.get(test_runtime, test_memory, {})
+
+        assert result.text == ""
+
+    @pytest.mark.asyncio
+    async def test_shows_running_status(self, test_runtime, test_memory):
+        mock_service = MagicMock(spec=AutonomyService)
+        mock_service.get_autonomous_room_id = MagicMock(return_value=as_uuid(AUTONOMOUS_ROOM_ID))
+        mock_service.is_loop_running = MagicMock(return_value=True)
+        mock_service.get_loop_interval = MagicMock(return_value=30000)
+        test_runtime.get_service = MagicMock(return_value=mock_service)
+        test_runtime.get_setting = MagicMock(return_value=True)
+
+        result = await autonomy_status_provider.get(test_runtime, test_memory, {})
+
+        assert "AUTONOMY_STATUS" in result.text
+        assert "running autonomously" in result.text
+        assert result.data["serviceRunning"] is True
+        assert result.data["status"] == "running"
+
+    @pytest.mark.asyncio
+    async def test_shows_disabled_status(self, test_runtime, test_memory):
+        mock_service = MagicMock(spec=AutonomyService)
+        mock_service.get_autonomous_room_id = MagicMock(return_value=as_uuid(AUTONOMOUS_ROOM_ID))
+        mock_service.is_loop_running = MagicMock(return_value=False)
+        mock_service.get_loop_interval = MagicMock(return_value=30000)
+        test_runtime.get_service = MagicMock(return_value=mock_service)
+        test_runtime.get_setting = MagicMock(return_value=False)
+
+        result = await autonomy_status_provider.get(test_runtime, test_memory, {})
+
+        assert "autonomy disabled" in result.text
+        assert result.data["status"] == "disabled"
+
+
+class TestAutonomyIntegration:
+    def test_exports_all_components(self):
+        from elizaos.bootstrap.autonomy import (
+            AUTONOMY_SERVICE_TYPE,
+            AutonomyService,
+            admin_chat_provider,
+            autonomy_status_provider,
+            send_to_admin_action,
+        )
+
+        assert AutonomyService is not None
+        assert AUTONOMY_SERVICE_TYPE == "AUTONOMY"
+        assert send_to_admin_action is not None
+        assert admin_chat_provider is not None
+        assert autonomy_status_provider is not None

package/tests/test_bootstrap_initialize.py

@@ -0,0 +1,37 @@
+import pytest
+
+from elizaos.runtime import AgentRuntime
+from elizaos.types import Character
+from elizaos.types.service import ServiceType
+
+
+@pytest.mark.asyncio
+async def test_runtime_initialize_registers_bootstrap_services() -> None:
+    """
+    Ensure AgentRuntime.initialize() loads the bootstrap plugin and registers services.
+
+    This guards against regressions where bootstrap service registration silently
+    stores None or fails to start services properly.
+    """
+    runtime = AgentRuntime(
+        character=Character(name="BootstrapTest", bio="bootstrap init test"),
+        log_level="ERROR",
+    )
+
+    await runtime.initialize()
+
+    assert any(p.name == "bootstrap" for p in runtime.plugins)
+
+    # Bootstrap should register at least one service of type TASK.
+    assert runtime.has_service(ServiceType.TASK)
+
+    task_service = runtime.get_service(ServiceType.TASK)
+    assert task_service is not None
+
+    task_services = runtime.get_services_by_type(ServiceType.TASK)
+    assert task_services
+    assert all(s is not None for s in task_services)
+
+    # Bootstrap should also register some core actions/providers/evaluators.
+    assert runtime.actions
+    assert runtime.providers

package/tests/test_character.py

@@ -0,0 +1,163 @@
+import json
+import os
+import tempfile
+
+import pytest
+
+from elizaos.character import (
+    CharacterLoadError,
+    CharacterValidationError,
+    build_character_plugins,
+    load_character_from_file,
+    merge_character_defaults,
+    parse_character,
+    validate_character_config,
+)
+from elizaos.types import Character
+
+
+class TestParseCharacter:
+    def test_parse_character_object(self) -> None:
+        character = Character(name="Test", bio=["A test agent"])
+        result = parse_character(character)
+        assert result.name == "Test"
+        assert list(result.bio) == ["A test agent"]
+
+    def test_parse_character_dict(self) -> None:
+        data = {"name": "Test", "bio": ["A test agent"]}
+        result = parse_character(data)
+        assert result.name == "Test"
+        assert list(result.bio) == ["A test agent"]
+
+    def test_parse_character_invalid_dict(self) -> None:
+        data = {"bio": "Missing name"}
+        with pytest.raises(CharacterValidationError):
+            parse_character(data)
+
+    def test_parse_character_file_path(self) -> None:
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as f:
+            json.dump({"name": "FileAgent", "bio": ["From file"]}, f)
+            f.flush()
+
+            try:
+                result = parse_character(f.name)
+                assert result.name == "FileAgent"
+            finally:
+                os.unlink(f.name)
+
+
+class TestLoadCharacterFromFile:
+    def test_load_valid_file(self) -> None:
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as f:
+            json.dump(
+                {
+                    "name": "FileAgent",
+                    "bio": ["A file-based agent"],
+                    "topics": ["testing"],
+                },
+                f,
+            )
+            f.flush()
+
+            try:
+                result = load_character_from_file(f.name)
+                assert result.name == "FileAgent"
+                assert list(result.topics) == ["testing"]
+            finally:
+                os.unlink(f.name)
+
+    def test_load_nonexistent_file(self) -> None:
+        with pytest.raises(CharacterLoadError, match="not found"):
+            load_character_from_file("/nonexistent/path/character.json")
+
+    def test_load_invalid_json(self) -> None:
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as f:
+            f.write("not valid json {")
+            f.flush()
+
+            try:
+                with pytest.raises(CharacterLoadError, match="Invalid JSON"):
+                    load_character_from_file(f.name)
+            finally:
+                os.unlink(f.name)
+
+
+class TestValidateCharacterConfig:
+    def test_valid_character(self) -> None:
+        character = Character(name="Test", bio=["A test agent"])
+        result = validate_character_config(character)
+        assert result["isValid"] is True
+        assert result["errors"] == []
+
+    def test_character_with_all_fields(self) -> None:
+        character = Character(
+            name="CompleteAgent",
+            username="complete",
+            bio=["Line 1", "Line 2"],
+            system="You are a complete agent.",
+            topics=["all", "topics"],
+            adjectives=["thorough", "complete"],
+            plugins=["@elizaos/plugin-sql"],
+        )
+        result = validate_character_config(character)
+        assert result["isValid"] is True
+
+
+class TestMergeCharacterDefaults:
+    def test_merge_empty(self) -> None:
+        result = merge_character_defaults({})
+        assert result.name == "Unnamed Character"
+        assert list(result.plugins) == []
+
+    def test_merge_partial(self) -> None:
+        result = merge_character_defaults({"name": "CustomAgent", "bio": ["Custom bio"]})
+        assert result.name == "CustomAgent"
+        assert list(result.bio) == ["Custom bio"]
+
+    def test_merge_preserves_values(self) -> None:
+        result = merge_character_defaults(
+            {
+                "name": "Agent",
+                "bio": ["Bio"],
+                "plugins": ["plugin-1"],
+            }
+        )
+        assert list(result.plugins) == ["plugin-1"]
+
+
+class TestBuildCharacterPlugins:
+    def test_default_plugins(self) -> None:
+        plugins = build_character_plugins({})
+        assert "@elizaos/plugin-sql" in plugins
+        assert "@elizaos/plugin-ollama" in plugins
+
+    def test_with_openai(self) -> None:
+        plugins = build_character_plugins({"OPENAI_API_KEY": "test-key"})
+        assert "@elizaos/plugin-openai" in plugins
+        assert "@elizaos/plugin-ollama" not in plugins
+
+    def test_with_anthropic(self) -> None:
+        plugins = build_character_plugins({"ANTHROPIC_API_KEY": "test-key"})
+        assert "@elizaos/plugin-anthropic" in plugins
+        assert "@elizaos/plugin-ollama" not in plugins
+
+    def test_with_discord(self) -> None:
+        plugins = build_character_plugins(
+            {
+                "DISCORD_API_TOKEN": "test-token",
+                "OPENAI_API_KEY": "test-key",
+            }
+        )
+        assert "@elizaos/plugin-discord" in plugins
+
+    def test_plugin_order(self) -> None:
+        plugins = build_character_plugins(
+            {
+                "OPENAI_API_KEY": "key1",
+                "ANTHROPIC_API_KEY": "key2",
+                "DISCORD_API_TOKEN": "token",
+            }
+        )
+        assert plugins.index("@elizaos/plugin-sql") == 0
+        assert plugins.index("@elizaos/plugin-anthropic") < plugins.index("@elizaos/plugin-openai")
+        assert plugins.index("@elizaos/plugin-discord") > plugins.index("@elizaos/plugin-openai")