@elizaos/python 2.0.0-alpha.11 → 2.0.0-alpha.27

package/elizaos/utils/validation.py

@@ -0,0 +1,76 @@
+import re
+
+from elizaos.types.memory import Memory
+
+
+def validate_action_keywords(
+    message: Memory, recent_messages: list[Memory], keywords: list[str]
+) -> bool:
+    """
+    Validates if any of the given keywords are present in the recent message history.
+
+    Checks:
+    1. The current message content
+    2. The last 5 messages in recent_messages
+    """
+    if not keywords:
+        return False
+
+    relevant_text = []
+
+    # 1. Current message content
+    if message.content and message.content.text:
+        relevant_text.append(message.content.text)
+
+    # 2. Recent messages (last 5)
+    # Take the last 5 messages
+    recent_subset = recent_messages[-5:] if recent_messages else []
+
+    for msg in recent_subset:
+        if msg.content and msg.content.text:
+            relevant_text.append(msg.content.text)
+
+    if not relevant_text:
+        return False
+
+    combined_text = "\n".join(relevant_text).lower()
+
+    return any(keyword.lower() in combined_text for keyword in keywords)
+
+
+def validate_action_regex(
+    message: Memory, recent_messages: list[Memory], regex_pattern: str
+) -> bool:
+    """
+    Validates if any of the recent message history matches the given regex pattern.
+
+    Args:
+        message: The current message memory
+        recent_messages: List of recent memories
+        regex_pattern: The regular expression pattern to check against
+
+    Returns:
+        bool: True if the regex matches any message content, False otherwise
+    """
+    if not regex_pattern:
+        return False
+
+    relevant_text = []
+
+    # 1. Current message content
+    if message.content and message.content.text:
+        relevant_text.append(message.content.text)
+
+    # 2. Recent messages (last 5)
+    recent_subset = recent_messages[-5:] if recent_messages else []
+
+    for msg in recent_subset:
+        if msg.content and msg.content.text:
+            relevant_text.append(msg.content.text)
+
+    if not relevant_text:
+        return False
+
+    combined_text = "\n".join(relevant_text)
+
+    return bool(re.search(regex_pattern, combined_text, re.MULTILINE))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elizaos/python",
-  "version": "2.0.0-alpha.11",
+  "version": "2.0.0-alpha.27",
   "description": "elizaOS Core - Python runtime and types",
   "publishConfig": {
     "access": "public"
@@ -16,5 +16,5 @@
   },
   "author": "elizaOS",
   "license": "MIT",
-  "gitHead": "33e7c7ee0c64f519085218c9f53997a6c5740808"
+  "gitHead": "645f273ed2eee2f5777193ee7d9d94c8a4444767"
 }

package/tests/test_actions_provider_examples.py

@@ -3,7 +3,26 @@ import pytest
 from elizaos.action_docs import with_canonical_action_docs
 from elizaos.bootstrap.actions import send_message_action
 from elizaos.runtime import AgentRuntime
-from elizaos.types import Character, Content, Memory, as_uuid
+from elizaos.types import Action, Character, Content, Memory, as_uuid
+
+
+async def _noop_handler(
+    runtime: AgentRuntime,
+    message: Memory,
+    state: object | None = None,
+    options: object | None = None,
+    callback: object | None = None,
+    responses: object | None = None,
+) -> None:
+    return None
+
+
+async def _always_valid(
+    runtime: AgentRuntime,
+    message: Memory,
+    state: object | None = None,
+) -> bool:
+    return True
 
 
 @pytest.mark.asyncio
@@ -37,3 +56,41 @@ async def test_actions_provider_includes_examples_and_parameter_examples() -> No
     # Canonical docs include examples for SEND_MESSAGE parameters
     assert "SEND_MESSAGE" in text
     assert "# Action Call Examples" in text
+
+
+@pytest.mark.asyncio
+async def test_actions_provider_does_not_trim_available_actions_to_top_10() -> None:
+    runtime = AgentRuntime(
+        character=Character(name="NoTrimTest", bio=["no trim test"], system="test"),
+        log_level="ERROR",
+    )
+    await runtime.initialize()
+
+    custom_action_names: list[str] = []
+    for index in range(12):
+        action_name = f"CUSTOM_ACTION_{index:02d}"
+        custom_action_names.append(action_name)
+        runtime.register_action(
+            Action(
+                name=action_name,
+                description=f"Custom action {index}",
+                handler=_noop_handler,
+                validate=_always_valid,
+            )
+        )
+
+    actions_provider = next(p for p in runtime.providers if p.name == "ACTIONS")
+
+    message = Memory(
+        id=as_uuid("42345678-1234-1234-1234-123456789012"),
+        entity_id=as_uuid("42345678-1234-1234-1234-123456789013"),
+        room_id=as_uuid("42345678-1234-1234-1234-123456789014"),
+        content=Content(text="show me every action"),
+    )
+
+    state = await runtime.compose_state(message)
+    result = await actions_provider.get(runtime, message, state)
+
+    text = result.text or ""
+    for action_name in custom_action_names:
+        assert action_name in text

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
@@ -182,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,
@@ -196,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):
@@ -445,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_validation.py

@@ -0,0 +1,141 @@
+import time
+
+from elizaos.types.memory import Memory
+from elizaos.types.primitives import Content
+from elizaos.utils.validation import validate_action_keywords, validate_action_regex
+
+
+def create_mock_memory(text: str, id: str = "1") -> Memory:
+    return Memory(
+        id=id,
+        entity_id="user1",
+        room_id="room1",
+        agent_id="agent1",
+        content=Content(text=text),
+        created_at=int(time.time() * 1000),
+    )
+
+
+def test_validate_action_keywords():
+    mock_message = Memory(
+        id="123",
+        entity_id="user1",
+        room_id="room1",
+        agent_id="agent1",
+        content=Content(text="Hello world"),
+        created_at=int(time.time() * 1000),
+    )
+
+    mock_recent_messages = [
+        Memory(
+            id="1",
+            entity_id="user1",
+            room_id="room1",
+            agent_id="agent1",
+            content=Content(text="Previous message 1"),
+            created_at=0,
+        ),
+        Memory(
+            id="2",
+            entity_id="user1",
+            room_id="room1",
+            agent_id="agent1",
+            content=Content(text="Previous message 2"),
+            created_at=0,
+        ),
+        Memory(
+            id="3",
+            entity_id="user1",
+            room_id="room1",
+            agent_id="agent1",
+            content=Content(text="Crypto is cool"),
+            created_at=0,
+        ),
+        Memory(
+            id="4",
+            entity_id="user1",
+            room_id="room1",
+            agent_id="agent1",
+            content=Content(text="Another message"),
+            created_at=0,
+        ),
+        Memory(
+            id="5",
+            entity_id="user1",
+            room_id="room1",
+            agent_id="agent1",
+            content=Content(text="Last one"),
+            created_at=0,
+        ),
+    ]
+
+    # 1. Keyword in current message
+    msg = create_mock_memory("I want to transfer sol", "124")
+    assert validate_action_keywords(msg, [], ["transfer"])
+
+    # 2. Keyword in recent messages
+    assert validate_action_keywords(mock_message, mock_recent_messages, ["crypto"])
+
+    # 3. Keyword not found
+    assert not validate_action_keywords(mock_message, mock_recent_messages, ["banana"])
+
+    # 4. Case insensitive
+    msg_upper = create_mock_memory("I want to TRANSFER sol", "125")
+    assert validate_action_keywords(msg_upper, [], ["transfer"])
+
+    # 5. Empty keywords list
+    assert not validate_action_keywords(mock_message, mock_recent_messages, [])
+
+    # 6. Partial match
+    msg_partial = Memory(
+        id="126",
+        entity_id="user1",
+        room_id="room1",
+        agent_id="agent1",
+        content=Content(text="cryptography"),
+        created_at=0,
+    )
+    assert validate_action_keywords(msg_partial, [], ["crypto"])
+
+
+def test_validate_action_regex():
+    mock_message = create_mock_memory("Hello world", "123")
+    mock_recent_messages = [
+        create_mock_memory("Previous message 1", "1"),
+        create_mock_memory("Previous message 2", "2"),
+        create_mock_memory("Crypto is cool", "3"),
+        create_mock_memory("Another message", "4"),
+        create_mock_memory("Last one", "5"),
+    ]
+
+    # Regex in current message
+    msg = create_mock_memory("Transfer 100 SOL")
+    # Default re.search is case-sensitive
+    assert not validate_action_regex(msg, [], r"transfer \d+ sol")
+    # Use inline flag for case-insensitive
+    assert validate_action_regex(msg, [], r"(?i)transfer \d+ sol")
+
+    # Regex in recent messages
+    assert validate_action_regex(mock_message, mock_recent_messages, r"(?i)crypto")
+
+    # No match
+    assert not validate_action_regex(mock_message, mock_recent_messages, r"banana")
+
+    # Complex regex
+    msg = create_mock_memory("user@example.com")
+    assert validate_action_regex(msg, [], r"^[\w\.-]+@([\w-]+\.)+[\w-]{2,4}$")  # Empty pattern
+    assert not validate_action_regex(mock_message, mock_recent_messages, "")
+
+    # Unicode characters
+    msg = create_mock_memory("Transfer 100 €")
+    assert not validate_action_regex(msg, [], r"transfer \d+ €") # case sensitive
+    assert validate_action_regex(msg, [], r"(?i)transfer \d+ €")
+
+    # Special characters
+    msg = create_mock_memory("Hello (world) [ok]")
+    assert validate_action_regex(msg, [], r"\(world\)")
+
+    # Long inputs (basic DoS check)
+    long_text = "a" * 10000 + "transfer"
+    msg = create_mock_memory(long_text)
+    assert validate_action_regex(msg, [], r"transfer")

package/tests/verify_memory_architecture.py

@@ -0,0 +1,192 @@
+import asyncio
+import math
+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
+
+# Mock vector for "hello world" - simple 384 dim vector
+MOCK_VECTOR_HELLO = [0.1] * 384
+# Mock vector for something else - orthogonal or different
+MOCK_VECTOR_OTHER = [-0.1] * 384
+
+
+class MockRuntime(MagicMock):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.agent_id = uuid.uuid4()
+        self.logger = MagicMock()
+        self.events = {}
+        self._adapter = AsyncMock()
+        self._models = {}
+
+        # Setup model mock
+        async def use_model_side_effect(model_type, **kwargs):
+            if model_type == ModelType.TEXT_EMBEDDING:
+                text = kwargs.get("text", "")
+                if "hello" in text.lower():
+                    return MOCK_VECTOR_HELLO
+                return MOCK_VECTOR_OTHER
+            if model_type == ModelType.TEXT_SMALL:
+                return "intent"
+            return None
+
+        self.use_model = AsyncMock(side_effect=use_model_side_effect)
+
+    def register_event(self, event, handler):
+        if event not in self.events:
+            self.events[event] = []
+        self.events[event].append(handler)
+
+    async def emit_event(self, event, payload):
+        handlers = self.events.get(event, [])
+        for handler in handlers:
+            if asyncio.iscoroutinefunction(handler):
+                await handler(payload)
+            else:
+                handler(payload)
+
+
+def dot_product(v1: list[float], v2: list[float]) -> float:
+    return sum(x * y for x, y in zip(v1, v2, strict=False))
+
+
+def magnitude(v: list[float]) -> float:
+    return math.sqrt(sum(x * x for x in v))
+
+
+def cosine_similarity(v1: list[float], v2: list[float]) -> float:
+    m1 = magnitude(v1)
+    m2 = magnitude(v2)
+    if m1 == 0 or m2 == 0:
+        return 0.0
+    return dot_product(v1, v2) / (m1 * m2)
+
+
+class VerifyMemoryArchitecture(unittest.IsolatedAsyncioTestCase):
+    async def test_end_to_end_memory_flow(self):
+        print("\n=== Starting Architectural Verification ===")
+
+        # 1. Setup
+        runtime = MockRuntime()
+        service = await EmbeddingService.start(runtime)
+
+        # --- TEST CASE 1: Short Message (Direct Embedding) ---
+        print("\n[Test 1] Short Message (< 20 chars) -> Direct Embedding")
+
+        short_id = str(uuid.uuid4())
+        short_memory = Memory(
+            id=short_id,
+            content=Content(text="Hello World"),  # < 20 chars
+            room_id=str(uuid.uuid4()),
+            entity_id=str(uuid.uuid4()),
+            agent_id=str(runtime.agent_id),
+        )
+
+        # Reset Update Memory Mock
+        runtime._adapter.update_memory.reset_mock()
+
+        # Trigger
+        from types import SimpleNamespace
+
+        payload = SimpleNamespace(extra={"memory": short_memory})
+        await self._run_pipeline(runtime, payload)
+
+        # Verify
+        runtime._adapter.update_memory.assert_called_once()
+        stored_short = runtime._adapter.update_memory.call_args[0][0]
+
+        # "Hello World" contains "hello" -> MOCK_VECTOR_HELLO
+        sim = cosine_similarity(list(stored_short.embedding), MOCK_VECTOR_HELLO)
+        self.assertAlmostEqual(
+            sim, 1.0, places=4, msg="Short message should use direct embedding (Hello)"
+        )
+        print(f"    -> Verified: Short message embedding matches content (sim={sim:.4f})")
+
+        # --- TEST CASE 2: Long Message (Intent Embedding) ---
+        print("\n[Test 2] Long Message (> 20 chars) -> Intent Embedding")
+
+        long_id = str(uuid.uuid4())
+        # "Hello World" repeated to be long, but also contains "hello"
+        # However, the logic generates INTENT.
+        # Mock returns "intent" as intent text.
+        # "intent" does NOT contain "hello", so mock returns MOCK_VECTOR_OTHER.
+        long_memory = Memory(
+            id=long_id,
+            content=Content(text="Hello World " * 5),
+            room_id=str(uuid.uuid4()),
+            entity_id=str(uuid.uuid4()),
+            agent_id=str(runtime.agent_id),
+        )
+
+        runtime._adapter.update_memory.reset_mock()
+
+        payload_long = SimpleNamespace(extra={"memory": long_memory})
+        await self._run_pipeline(runtime, payload_long)
+
+        runtime._adapter.update_memory.assert_called_once()
+        stored_long = runtime._adapter.update_memory.call_args[0][0]
+
+        # Expect MOCK_VECTOR_OTHER because embedding was on "intent"
+        sim_intent = cosine_similarity(list(stored_long.embedding), MOCK_VECTOR_OTHER)
+        self.assertAlmostEqual(
+            sim_intent, 1.0, places=4, msg="Long message should use intent embedding"
+        )
+
+        # Verify metadata
+        self.assertEqual(stored_long.metadata.custom.custom_data["intent"], "intent")
+        print(f"    -> Verified: Long message uses intent embedding (sim={sim_intent:.4f})")
+        print("    -> Verified: Intent metadata stored")
+
+        # 4. Verify Retrieval & Similarity
+        print("\n[3] Verifying Retrieval & Similarity logic...")
+        # "Hello there" -> MOCK_VECTOR_HELLO
+        # "General Kenobi" -> MOCK_VECTOR_OTHER
+        score = await service.similarity("Hello there", "General Kenobi")
+
+        # Expected: dot(HELLO, OTHER)
+        # 384 * (0.1 * -0.1) = 384 * -0.01 = -3.84
+        # Mag(HELLO) = sqrt(384 * 0.01) = sqrt(3.84) ~= 1.9596
+        # Mag(OTHER) = sqrt(384 * 0.01) = sqrt(3.84) ~= 1.9596
+        # Cos = -3.84 / (1.9596 * 1.9596) = -3.84 / 3.84 = -1.0
+        expected_sim = cosine_similarity(MOCK_VECTOR_HELLO, MOCK_VECTOR_OTHER)
+        self.assertAlmostEqual(score, expected_sim, places=4)
+        print(f"    -> Similarity calculation verified: {score:.4f} (expected {expected_sim:.4f})")
+
+        await service.stop()
+        print("=== Verification Complete ===")
+
+    async def _run_pipeline(self, runtime, payload):
+        event_name = EventType.Name(EventType.EVENT_TYPE_EMBEDDING_GENERATION_REQUESTED)
+        completion_future = asyncio.Future()
+
+        async def on_complete(p):
+            if not completion_future.done():
+                completion_future.set_result(p)
+
+        # We need to register/unregister to avoid duplicate calls if running multiple times
+        # But MockRuntime implementation appends.
+        # For simplicity, just append and ensure we trigger the right future?
+        # A new future is needed for each run.
+        # Let's clear mocks events for clean slate or just handle it.
+        # We can just register a new one.
+
+        runtime.register_event(
+            EventType.Name(EventType.EVENT_TYPE_EMBEDDING_GENERATION_COMPLETED), on_complete
+        )
+
+        await runtime.emit_event(event_name, payload)
+
+        try:
+            await asyncio.wait_for(completion_future, timeout=2.0)
+        except TimeoutError:
+            self.fail("Async pipeline timed out")
+
+
+if __name__ == "__main__":
+    unittest.main()