@elizaos/python 2.0.0-alpha.10

package/tests/test_plugin.py

@@ -0,0 +1,117 @@
+import pytest
+
+from elizaos.plugin import (
+    PluginLoadError,
+    resolve_plugin_dependencies,
+)
+from elizaos.types import Plugin
+
+
+class TestResolveDependencies:
+    def test_no_dependencies(self) -> None:
+        plugins = [
+            Plugin(name="plugin-a", description="Plugin A"),
+            Plugin(name="plugin-b", description="Plugin B"),
+        ]
+        result = resolve_plugin_dependencies(plugins)
+        assert len(result) == 2
+
+    def test_simple_dependency(self) -> None:
+        plugins = [
+            Plugin(
+                name="plugin-b",
+                description="Plugin B",
+                dependencies=["plugin-a"],
+            ),
+            Plugin(name="plugin-a", description="Plugin A"),
+        ]
+        result = resolve_plugin_dependencies(plugins)
+        assert result[0].name == "plugin-a"
+        assert result[1].name == "plugin-b"
+
+    def test_chain_dependency(self) -> None:
+        plugins = [
+            Plugin(
+                name="plugin-c",
+                description="Plugin C",
+                dependencies=["plugin-b"],
+            ),
+            Plugin(
+                name="plugin-b",
+                description="Plugin B",
+                dependencies=["plugin-a"],
+            ),
+            Plugin(name="plugin-a", description="Plugin A"),
+        ]
+        result = resolve_plugin_dependencies(plugins)
+        names = [p.name for p in result]
+        assert names.index("plugin-a") < names.index("plugin-b")
+        assert names.index("plugin-b") < names.index("plugin-c")
+
+    def test_circular_dependency(self) -> None:
+        plugins = [
+            Plugin(
+                name="plugin-a",
+                description="Plugin A",
+                dependencies=["plugin-b"],
+            ),
+            Plugin(
+                name="plugin-b",
+                description="Plugin B",
+                dependencies=["plugin-a"],
+            ),
+        ]
+        with pytest.raises(PluginLoadError, match="Circular dependency"):
+            resolve_plugin_dependencies(plugins)
+
+    def test_missing_dependency_handled(self) -> None:
+        plugins = [
+            Plugin(
+                name="plugin-a",
+                description="Plugin A",
+                dependencies=["external-plugin"],
+            ),
+        ]
+        result = resolve_plugin_dependencies(plugins)
+        assert len(result) == 1
+
+    def test_multiple_dependencies(self) -> None:
+        plugins = [
+            Plugin(
+                name="plugin-c",
+                description="Plugin C",
+                dependencies=["plugin-a", "plugin-b"],
+            ),
+            Plugin(name="plugin-a", description="Plugin A"),
+            Plugin(name="plugin-b", description="Plugin B"),
+        ]
+        result = resolve_plugin_dependencies(plugins)
+        names = [p.name for p in result]
+        assert names.index("plugin-a") < names.index("plugin-c")
+        assert names.index("plugin-b") < names.index("plugin-c")
+
+    def test_diamond_dependency(self) -> None:
+        plugins = [
+            Plugin(name="plugin-a", description="Plugin A"),
+            Plugin(
+                name="plugin-b",
+                description="Plugin B",
+                dependencies=["plugin-a"],
+            ),
+            Plugin(
+                name="plugin-c",
+                description="Plugin C",
+                dependencies=["plugin-a"],
+            ),
+            Plugin(
+                name="plugin-d",
+                description="Plugin D",
+                dependencies=["plugin-b", "plugin-c"],
+            ),
+        ]
+        result = resolve_plugin_dependencies(plugins)
+        names = [p.name for p in result]
+        assert names.index("plugin-a") < names.index("plugin-b")
+        assert names.index("plugin-a") < names.index("plugin-c")
+        assert names.index("plugin-b") < names.index("plugin-d")
+        assert names.index("plugin-c") < names.index("plugin-d")

package/tests/test_runtime.py

@@ -0,0 +1,422 @@
+from typing import Any
+
+import pytest
+
+from elizaos.runtime import AgentRuntime
+from elizaos.types import (
+    Action,
+    ActionResult,
+    Character,
+    Evaluator,
+    HandlerOptions,
+    IAgentRuntime,
+    LLMMode,
+    Memory,
+    ModelType,
+    Plugin,
+    Provider,
+    ProviderResult,
+    State,
+    as_uuid,
+)
+
+
+@pytest.fixture
+def character() -> Character:
+    return Character(
+        name="TestAgent",
+        bio=["A test agent for unit testing."],
+        system="You are a helpful test agent.",
+    )
+
+
+@pytest.fixture
+def runtime(character: Character) -> AgentRuntime:
+    return AgentRuntime(character=character)
+
+
+class TestAgentRuntimeInit:
+    def test_runtime_creation(self, character: Character) -> None:
+        runtime = AgentRuntime(character=character)
+        assert runtime.character.name == "TestAgent"
+        assert runtime.agent_id is not None
+
+    def test_runtime_with_agent_id(self, character: Character) -> None:
+        agent_id = as_uuid("12345678-1234-1234-1234-123456789012")
+        runtime = AgentRuntime(character=character, agent_id=agent_id)
+        assert runtime.agent_id == agent_id
+
+    def test_runtime_with_settings(self, character: Character) -> None:
+        runtime = AgentRuntime(
+            character=character,
+            settings={"custom_setting": "value"},
+        )
+        assert runtime.get_setting("custom_setting") == "value"
+
+
+class TestAgentRuntimeSettings:
+    def test_get_setting_from_runtime(self, runtime: AgentRuntime) -> None:
+        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"},
+        )
+        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",
+            bio=["Test"],
+            secrets={"API_KEY": "secret_key"},
+        )
+        runtime = AgentRuntime(character=character)
+        assert runtime.get_setting("API_KEY") == "secret_key"
+
+    def test_get_nonexistent_setting(self, runtime: AgentRuntime) -> None:
+        assert runtime.get_setting("nonexistent") is None
+
+
+class TestAgentRuntimeProviders:
+    @pytest.mark.asyncio
+    async def test_register_provider(self, runtime: AgentRuntime) -> None:
+        async def get_data(rt: IAgentRuntime, msg: Memory, state: State) -> ProviderResult:
+            return ProviderResult(text="Provider data")
+
+        provider = Provider(
+            name="test-provider",
+            description="A test provider",
+            get=get_data,
+        )
+        runtime.register_provider(provider)
+        assert len(runtime.providers) == 1
+        assert runtime.providers[0].name == "test-provider"
+
+
+class TestAgentRuntimeActions:
+    @pytest.mark.asyncio
+    async def test_register_action(self, runtime: AgentRuntime) -> None:
+        async def validate(rt: IAgentRuntime, msg: Memory, state: State | None) -> bool:
+            return True
+
+        async def handler(
+            rt: IAgentRuntime,
+            msg: Memory,
+            state: State | None,
+            options: HandlerOptions | None,
+            callback: Any,
+            responses: list[Memory] | None,
+        ) -> ActionResult | None:
+            return ActionResult(success=True)
+
+        action = Action(
+            name="TEST_ACTION",
+            description="A test action",
+            validate=validate,
+            handler=handler,
+        )
+        runtime.register_action(action)
+        assert len(runtime.actions) == 1
+        assert runtime.actions[0].name == "TEST_ACTION"
+
+
+class TestAgentRuntimeEvaluators:
+    @pytest.mark.asyncio
+    async def test_register_evaluator(self, runtime: AgentRuntime) -> None:
+        async def validate(rt: IAgentRuntime, msg: Memory, state: State | None) -> bool:
+            return True
+
+        async def handler(
+            rt: IAgentRuntime,
+            msg: Memory,
+            state: State | None,
+            options: HandlerOptions | None,
+            callback: Any,
+            responses: list[Memory] | None,
+        ) -> ActionResult | None:
+            return ActionResult(success=True)
+
+        evaluator = Evaluator(
+            name="test-evaluator",
+            description="A test evaluator",
+            examples=[],
+            validate=validate,
+            handler=handler,
+        )
+        runtime.register_evaluator(evaluator)
+        assert len(runtime.evaluators) == 1
+        assert runtime.evaluators[0].name == "test-evaluator"
+
+
+class TestAgentRuntimePlugins:
+    @pytest.mark.asyncio
+    async def test_register_plugin(self, runtime: AgentRuntime) -> None:
+        async def get_data(rt: IAgentRuntime, msg: Memory, state: State) -> ProviderResult:
+            return ProviderResult(text="Plugin provider data")
+
+        plugin = Plugin(
+            name="test-plugin",
+            description="A test plugin",
+            providers=[
+                Provider(
+                    name="plugin-provider",
+                    get=get_data,
+                )
+            ],
+        )
+        await runtime.register_plugin(plugin)
+        assert len(runtime.plugins) == 1
+        assert runtime.plugins[0].name == "test-plugin"
+        assert len(runtime.providers) == 1
+
+
+class TestAgentRuntimeEvents:
+    @pytest.mark.asyncio
+    async def test_register_event_handler(self, runtime: AgentRuntime) -> None:
+        events_received: list[str] = []
+
+        async def handler(params: dict[str, object]) -> None:
+            events_received.append("event_received")
+
+        runtime.register_event("TEST_EVENT", handler)
+        await runtime.emit_event("TEST_EVENT", {"data": "test"})
+
+        assert len(events_received) == 1
+        assert events_received[0] == "event_received"
+
+    @pytest.mark.asyncio
+    async def test_multiple_event_handlers(self, runtime: AgentRuntime) -> None:
+        count = [0]
+
+        async def handler1(params: dict[str, object]) -> None:
+            count[0] += 1
+
+        async def handler2(params: dict[str, object]) -> None:
+            count[0] += 1
+
+        runtime.register_event("MULTI_EVENT", handler1)
+        runtime.register_event("MULTI_EVENT", handler2)
+        await runtime.emit_event("MULTI_EVENT", {})
+
+        assert count[0] == 2
+
+
+class TestAgentRuntimeModels:
+    @pytest.mark.asyncio
+    async def test_register_model(self, runtime: AgentRuntime) -> None:
+        async def model_handler(rt: IAgentRuntime, params: dict[str, Any]) -> Any:
+            return f"Generated: {params.get('prompt', '')}"
+
+        runtime.register_model(
+            model_type="TEXT_LARGE",
+            handler=model_handler,
+            provider="test-provider",
+        )
+
+        result = await runtime.use_model("TEXT_LARGE", {"prompt": "Hello"})
+        assert result == "Generated: Hello"
+
+    @pytest.mark.asyncio
+    async def test_model_priority(self, runtime: AgentRuntime) -> None:
+        async def low_priority_handler(rt: IAgentRuntime, params: dict[str, Any]) -> Any:
+            return "low"
+
+        async def high_priority_handler(rt: IAgentRuntime, params: dict[str, Any]) -> Any:
+            return "high"
+
+        runtime.register_model(
+            model_type="TEXT_LARGE",
+            handler=low_priority_handler,
+            provider="low",
+            priority=0,
+        )
+        runtime.register_model(
+            model_type="TEXT_LARGE",
+            handler=high_priority_handler,
+            provider="high",
+            priority=10,
+        )
+
+        result = await runtime.use_model("TEXT_LARGE", {})
+        assert result == "high"
+
+
+class TestAgentRuntimeRunTracking:
+    def test_create_run_id(self, runtime: AgentRuntime) -> None:
+        run_id = runtime.create_run_id()
+        assert run_id is not None
+        assert len(run_id) == 36
+
+    def test_start_and_end_run(self, runtime: AgentRuntime) -> None:
+        room_id = as_uuid("12345678-1234-1234-1234-123456789012")
+        run_id = runtime.start_run(room_id)
+        assert run_id == runtime.get_current_run_id()
+
+        runtime.end_run()
+        new_run_id = runtime.get_current_run_id()
+        assert new_run_id != run_id
+
+
+class TestAgentRuntimeServices:
+    def test_has_service_empty(self, runtime: AgentRuntime) -> None:
+        assert runtime.has_service("test-service") is False
+
+    def test_get_service_empty(self, runtime: AgentRuntime) -> None:
+        assert runtime.get_service("test-service") is None
+
+    def test_get_registered_service_types_empty(self, runtime: AgentRuntime) -> None:
+        assert runtime.get_registered_service_types() == []
+
+
+class TestAgentRuntimeLogLevel:
+    def test_default_log_level_is_error(self, character: Character) -> None:
+        runtime = AgentRuntime(character=character)
+        assert runtime.logger is not None
+
+    def test_custom_log_level_info(self, character: Character) -> None:
+        runtime = AgentRuntime(character=character, log_level="INFO")
+        assert runtime.logger is not None
+
+    def test_custom_log_level_debug(self, character: Character) -> None:
+        runtime = AgentRuntime(character=character, log_level="DEBUG")
+        assert runtime.logger is not None
+
+    def test_custom_log_level_warning(self, character: Character) -> None:
+        runtime = AgentRuntime(character=character, log_level="WARNING")
+        assert runtime.logger is not None
+
+
+class TestAgentRuntimeLLMMode:
+    def test_default_llm_mode_is_default(self, character: Character) -> None:
+        runtime = AgentRuntime(character=character)
+        assert runtime.get_llm_mode() == LLMMode.DEFAULT
+
+    def test_constructor_option_small(self, character: Character) -> None:
+        runtime = AgentRuntime(character=character, llm_mode=LLMMode.SMALL)
+        assert runtime.get_llm_mode() == LLMMode.SMALL
+
+    def test_constructor_option_large(self, character: Character) -> None:
+        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"},
+        )
+        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"},
+        )
+        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"},
+        )
+        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"},
+        )
+        runtime = AgentRuntime(character=character)
+        assert runtime.get_llm_mode() == LLMMode.DEFAULT
+
+    @pytest.mark.asyncio
+    async def test_use_model_override_small(self, character: Character) -> None:
+        runtime = AgentRuntime(character=character, llm_mode=LLMMode.SMALL)
+
+        async def small_handler(rt: IAgentRuntime, params: dict[str, Any]) -> Any:
+            return "small response"
+
+        async def large_handler(rt: IAgentRuntime, params: dict[str, Any]) -> Any:
+            return "large response"
+
+        runtime.register_model(ModelType.TEXT_SMALL, small_handler, "test")
+        runtime.register_model(ModelType.TEXT_LARGE, large_handler, "test")
+
+        result = await runtime.use_model(ModelType.TEXT_LARGE, {"prompt": "test"})
+        assert result == "small response"
+
+    @pytest.mark.asyncio
+    async def test_use_model_override_large(self, character: Character) -> None:
+        runtime = AgentRuntime(character=character, llm_mode=LLMMode.LARGE)
+
+        async def small_handler(rt: IAgentRuntime, params: dict[str, Any]) -> Any:
+            return "small response"
+
+        async def large_handler(rt: IAgentRuntime, params: dict[str, Any]) -> Any:
+            return "large response"
+
+        runtime.register_model(ModelType.TEXT_SMALL, small_handler, "test")
+        runtime.register_model(ModelType.TEXT_LARGE, large_handler, "test")
+
+        result = await runtime.use_model(ModelType.TEXT_SMALL, {"prompt": "test"})
+        assert result == "large response"
+
+
+class TestAgentRuntimeCheckShouldRespond:
+    def test_default_is_true(self, character: Character) -> None:
+        runtime = AgentRuntime(character=character)
+        assert runtime.is_check_should_respond_enabled() is True
+
+    def test_constructor_option_false(self, character: Character) -> None:
+        runtime = AgentRuntime(character=character, check_should_respond=False)
+        assert runtime.is_check_should_respond_enabled() is False
+
+    def test_constructor_option_true(self, character: Character) -> None:
+        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"},
+        )
+        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"},
+        )
+        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"},
+        )
+        runtime = AgentRuntime(character=character)
+        assert runtime.is_check_should_respond_enabled() is True

package/tests/test_salt_production_enforcement.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+import pytest
+
+from elizaos.settings import get_salt
+
+
+def test_get_salt_throws_in_production_when_default(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setenv("NODE_ENV", "production")
+    monkeypatch.delenv("SECRET_SALT", raising=False)
+    monkeypatch.delenv("ELIZA_ALLOW_DEFAULT_SECRET_SALT", raising=False)
+
+    with pytest.raises(RuntimeError, match="SECRET_SALT must be set"):
+        get_salt()
+
+
+def test_get_salt_allows_override_in_production(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setenv("NODE_ENV", "production")
+    monkeypatch.delenv("SECRET_SALT", raising=False)
+    monkeypatch.setenv("ELIZA_ALLOW_DEFAULT_SECRET_SALT", "true")
+
+    assert get_salt() == "secretsalt"

package/tests/test_settings_crypto.py

@@ -0,0 +1,118 @@
+import secrets
+
+import pytest
+from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
+from cryptography.hazmat.primitives.padding import PKCS7
+
+from elizaos import AgentRuntime, Character
+from elizaos.settings import (
+    _derive_key,
+    decrypt_string_value,
+    encrypt_string_value,
+    get_salt,
+    migrate_encrypted_string_value,
+)
+
+
+class TestSettingsCrypto:
+    def test_get_salt_default(self, monkeypatch: pytest.MonkeyPatch) -> None:
+        monkeypatch.delenv("SECRET_SALT", raising=False)
+        assert get_salt() == "secretsalt"
+
+    def test_encrypt_decrypt_roundtrip(self) -> None:
+        salt = "test-salt-value"
+        plaintext = "sensitive-data"
+
+        encrypted = encrypt_string_value(plaintext, salt)
+        assert isinstance(encrypted, str)
+        assert encrypted != plaintext
+        assert ":" in encrypted
+
+        decrypted = decrypt_string_value(encrypted, salt)
+        assert decrypted == plaintext
+
+    def test_encrypt_is_idempotent_for_encrypted_values(self) -> None:
+        salt = "test-salt-value"
+        plaintext = "hello"
+        encrypted = encrypt_string_value(plaintext, salt)
+        assert isinstance(encrypted, str)
+        encrypted2 = encrypt_string_value(encrypted, salt)
+        assert encrypted2 == encrypted
+
+    def test_decrypt_non_encrypted_returns_original(self) -> None:
+        salt = "test-salt-value"
+        assert decrypt_string_value("not-encrypted", salt) == "not-encrypted"
+
+    def test_decrypt_legacy_v1_aes_cbc_value(self) -> None:
+        salt = "test-salt-value"
+        plaintext = "legacy-secret"
+
+        key = _derive_key(salt)
+        iv = secrets.token_bytes(16)
+
+        padder = PKCS7(128).padder()
+        padded = padder.update(plaintext.encode("utf-8")) + padder.finalize()
+
+        cipher = Cipher(algorithms.AES(key), modes.CBC(iv))
+        encryptor = cipher.encryptor()
+        ciphertext = encryptor.update(padded) + encryptor.finalize()
+
+        legacy = f"{iv.hex()}:{ciphertext.hex()}"
+        assert decrypt_string_value(legacy, salt) == plaintext
+
+    def test_migrate_legacy_v1_to_v2(self) -> None:
+        salt = "test-salt-value"
+        plaintext = "legacy-migrate"
+
+        key = _derive_key(salt)
+        iv = secrets.token_bytes(16)
+        padder = PKCS7(128).padder()
+        padded = padder.update(plaintext.encode("utf-8")) + padder.finalize()
+        cipher = Cipher(algorithms.AES(key), modes.CBC(iv))
+        encryptor = cipher.encryptor()
+        ciphertext = encryptor.update(padded) + encryptor.finalize()
+        legacy = f"{iv.hex()}:{ciphertext.hex()}"
+
+        migrated = migrate_encrypted_string_value(legacy, salt)
+        assert isinstance(migrated, str)
+        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:
+        salt = "test-salt-value"
+        monkeypatch.setenv("SECRET_SALT", salt)
+
+        encrypted_api_key = encrypt_string_value("super-secret", salt)
+        assert isinstance(encrypted_api_key, str)
+
+        character = Character(
+            name="TestAgent",
+            bio=["Test"],
+            secrets={"API_KEY": encrypted_api_key},
+        )
+        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:
+        salt = "test-salt-value"
+        monkeypatch.setenv("SECRET_SALT", salt)
+
+        encrypted_true = encrypt_string_value("true", salt)
+        encrypted_false = encrypt_string_value("false", salt)
+        assert isinstance(encrypted_true, str)
+        assert isinstance(encrypted_false, str)
+
+        character = Character(
+            name="TestAgent",
+            bio=["Test"],
+            secrets={"FLAG_TRUE": encrypted_true, "FLAG_FALSE": encrypted_false},
+        )
+        runtime = AgentRuntime(character=character)
+        assert runtime.get_setting("FLAG_TRUE") is True
+        assert runtime.get_setting("FLAG_FALSE") is False