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

package/elizaos/advanced_memory/memory_service.py

@@ -95,38 +95,36 @@ class MemoryService(Service):
     @classmethod
     async def start(cls, runtime):
         svc = cls(runtime=runtime)
-        # read settings
-        settings = runtime.character.settings or {}
-        if (v := settings.get("MEMORY_SUMMARIZATION_THRESHOLD")) is not None and isinstance(
+        if (v := runtime.get_setting("MEMORY_SUMMARIZATION_THRESHOLD")) is not None and isinstance(
             v, (int, float, str)
         ):
             svc._config.short_term_summarization_threshold = int(v)
-        if (v := settings.get("MEMORY_RETAIN_RECENT")) is not None and isinstance(
+        if (v := runtime.get_setting("MEMORY_RETAIN_RECENT")) is not None and isinstance(
             v, (int, float, str)
         ):
             svc._config.short_term_retain_recent = int(v)
-        if (v := settings.get("MEMORY_SUMMARIZATION_INTERVAL")) is not None and isinstance(
+        if (v := runtime.get_setting("MEMORY_SUMMARIZATION_INTERVAL")) is not None and isinstance(
             v, (int, float, str)
         ):
             svc._config.short_term_summarization_interval = int(v)
-        if (v := settings.get("MEMORY_MAX_NEW_MESSAGES")) is not None and isinstance(
+        if (v := runtime.get_setting("MEMORY_MAX_NEW_MESSAGES")) is not None and isinstance(
             v, (int, float, str)
         ):
             svc._config.summary_max_new_messages = int(v)
-        if (v := settings.get("MEMORY_LONG_TERM_ENABLED")) is not None:
+        if (v := runtime.get_setting("MEMORY_LONG_TERM_ENABLED")) is not None:
             if str(v).lower() == "false":
                 svc._config.long_term_extraction_enabled = False
             elif str(v).lower() == "true":
                 svc._config.long_term_extraction_enabled = True
-        if (v := settings.get("MEMORY_CONFIDENCE_THRESHOLD")) is not None and isinstance(
+        if (v := runtime.get_setting("MEMORY_CONFIDENCE_THRESHOLD")) is not None and isinstance(
             v, (int, float, str)
         ):
             svc._config.long_term_confidence_threshold = float(v)
-        if (v := settings.get("MEMORY_EXTRACTION_THRESHOLD")) is not None and isinstance(
+        if (v := runtime.get_setting("MEMORY_EXTRACTION_THRESHOLD")) is not None and isinstance(
             v, (int, float, str)
         ):
             svc._config.long_term_extraction_threshold = int(v)
-        if (v := settings.get("MEMORY_EXTRACTION_INTERVAL")) is not None and isinstance(
+        if (v := runtime.get_setting("MEMORY_EXTRACTION_INTERVAL")) is not None and isinstance(
             v, (int, float, str)
         ):
             svc._config.long_term_extraction_interval = int(v)
@@ -146,7 +144,7 @@ class MemoryService(Service):
         return f"memory:extraction:{entity_id}:{room_id}"
 
     async def get_last_extraction_checkpoint(self, entity_id: UUID, room_id: UUID) -> int:
-        runtime = self.runtime
+        runtime = self._runtime
         key = self._checkpoint_key(entity_id, room_id)
         if runtime is not None and getattr(runtime, "_adapter", None) is not None:
             cached = await runtime.get_cache(key)
@@ -163,7 +161,7 @@ class MemoryService(Service):
     async def set_last_extraction_checkpoint(
         self, entity_id: UUID, room_id: UUID, message_count: int
     ) -> None:
-        runtime = self.runtime
+        runtime = self._runtime
         key = self._checkpoint_key(entity_id, room_id)
         if runtime is not None and getattr(runtime, "_adapter", None) is not None:
             _ = await runtime.set_cache(key, int(message_count))
@@ -182,7 +180,7 @@ class MemoryService(Service):
         return current_cp > last_cp
 
     async def get_current_session_summary(self, room_id: UUID) -> SessionSummary | None:
-        runtime = self.runtime
+        runtime = self._runtime
         if runtime is None:
             return None
 
@@ -234,7 +232,7 @@ class MemoryService(Service):
         topics: list[str] | None = None,
         metadata: dict[str, object] | None = None,
     ) -> SessionSummary:
-        runtime = self.runtime
+        runtime = self._runtime
         s = SessionSummary(
             id=uuid4(),
             agent_id=agent_id,
@@ -279,7 +277,7 @@ class MemoryService(Service):
     async def update_session_summary(
         self, summary_id: UUID, room_id: UUID, **updates: object
     ) -> None:
-        runtime = self.runtime
+        runtime = self._runtime
         if runtime is not None and getattr(runtime, "_adapter", None) is not None:
             existing = await self.get_current_session_summary(room_id)
             if not existing or existing.id != summary_id:
@@ -350,7 +348,7 @@ class MemoryService(Service):
         source: str | None = None,
         metadata: dict[str, object] | None = None,
     ) -> LongTermMemory:
-        runtime = self.runtime
+        runtime = self._runtime
         m = LongTermMemory(
             id=uuid4(),
             agent_id=agent_id,
@@ -394,7 +392,7 @@ class MemoryService(Service):
     ) -> list[LongTermMemory]:
         if limit <= 0:
             return []
-        runtime = self.runtime
+        runtime = self._runtime
         if runtime is not None and getattr(runtime, "_adapter", None) is not None:
             db_mems = await runtime.get_memories(
                 {

package/elizaos/advanced_memory/test_advanced_memory.py

@@ -0,0 +1,357 @@
+"""Tests for the advanced memory module.
+
+Covers XML parsing, extraction checkpointing, config management,
+confidence sorting, and formatted memory output.
+"""
+
+from __future__ import annotations
+
+from uuid import uuid4
+
+import pytest
+
+from .memory_service import (
+    MemoryService,
+    _parse_memory_extraction_xml,
+    _parse_summary_xml,
+    _top_k_by_confidence,
+)
+from .types import (
+    LongTermMemory,
+    LongTermMemoryCategory,
+)
+
+# ============================================================================
+# XML Parsing: Summary
+# ============================================================================
+
+
+class TestParseSummaryXml:
+    def test_valid_xml(self):
+        xml = """
+<summary>
+  <text>The user discussed their favorite coffee.</text>
+  <topics>coffee, preferences, beverages</topics>
+  <key_points>
+    <point>User prefers dark roast</point>
+    <point>User drinks 3 cups daily</point>
+  </key_points>
+</summary>"""
+        result = _parse_summary_xml(xml)
+        assert result.summary == "The user discussed their favorite coffee."
+        assert result.topics == ["coffee", "preferences", "beverages"]
+        assert len(result.key_points) == 2
+        assert result.key_points[0] == "User prefers dark roast"
+        assert result.key_points[1] == "User drinks 3 cups daily"
+
+    def test_malformed_xml(self):
+        result = _parse_summary_xml("This is not XML at all")
+        assert result.summary == "Summary not available"
+        assert result.topics == []
+        assert result.key_points == []
+
+    def test_partial_tags(self):
+        result = _parse_summary_xml("<text>Just a summary</text>")
+        assert result.summary == "Just a summary"
+        assert result.topics == []
+        assert result.key_points == []
+
+    def test_empty_topics(self):
+        result = _parse_summary_xml("<text>Summary here</text><topics></topics>")
+        assert result.summary == "Summary here"
+        assert result.topics == []
+
+
+# ============================================================================
+# XML Parsing: Memory Extraction
+# ============================================================================
+
+
+class TestParseMemoryExtractionXml:
+    def test_valid_multiple(self):
+        xml = """
+<memories>
+  <memory>
+    <category>semantic</category>
+    <content>User works as a software engineer</content>
+    <confidence>0.95</confidence>
+  </memory>
+  <memory>
+    <category>episodic</category>
+    <content>User had a meeting yesterday</content>
+    <confidence>0.8</confidence>
+  </memory>
+  <memory>
+    <category>procedural</category>
+    <content>User prefers TypeScript for backend</content>
+    <confidence>0.9</confidence>
+  </memory>
+</memories>"""
+        extractions = _parse_memory_extraction_xml(xml)
+        assert len(extractions) == 3
+        assert extractions[0].category == LongTermMemoryCategory.SEMANTIC
+        assert extractions[0].content == "User works as a software engineer"
+        assert abs(extractions[0].confidence - 0.95) < 0.001
+        assert extractions[1].category == LongTermMemoryCategory.EPISODIC
+        assert extractions[2].category == LongTermMemoryCategory.PROCEDURAL
+
+    def test_invalid_category_skipped(self):
+        xml = """
+<memories>
+  <memory>
+    <category>invalid_type</category>
+    <content>This should be skipped</content>
+    <confidence>0.9</confidence>
+  </memory>
+  <memory>
+    <category>semantic</category>
+    <content>This should be kept</content>
+    <confidence>0.85</confidence>
+  </memory>
+</memories>"""
+        extractions = _parse_memory_extraction_xml(xml)
+        assert len(extractions) == 1
+        assert extractions[0].content == "This should be kept"
+
+    def test_bad_confidence_skipped(self):
+        xml = """
+<memory>
+  <category>semantic</category>
+  <content>Bad confidence</content>
+  <confidence>not_a_number</confidence>
+</memory>"""
+        extractions = _parse_memory_extraction_xml(xml)
+        assert len(extractions) == 0
+
+    def test_empty_input(self):
+        assert _parse_memory_extraction_xml("") == []
+
+    def test_no_memories(self):
+        assert _parse_memory_extraction_xml("The model didn't return structured data.") == []
+
+
+# ============================================================================
+# top_k_by_confidence
+# ============================================================================
+
+
+class TestTopKByConfidence:
+    def test_sorts_by_confidence(self):
+        entity_id = uuid4()
+        agent_id = uuid4()
+        memories = [
+            LongTermMemory(
+                id=uuid4(),
+                agent_id=agent_id,
+                entity_id=entity_id,
+                category=LongTermMemoryCategory.SEMANTIC,
+                content="low",
+                confidence=0.5,
+            ),
+            LongTermMemory(
+                id=uuid4(),
+                agent_id=agent_id,
+                entity_id=entity_id,
+                category=LongTermMemoryCategory.SEMANTIC,
+                content="high",
+                confidence=0.95,
+            ),
+            LongTermMemory(
+                id=uuid4(),
+                agent_id=agent_id,
+                entity_id=entity_id,
+                category=LongTermMemoryCategory.SEMANTIC,
+                content="mid",
+                confidence=0.8,
+            ),
+        ]
+        result = _top_k_by_confidence(memories, 2)
+        assert len(result) == 2
+        assert result[0].content == "high"
+        assert result[1].content == "mid"
+
+    def test_zero_limit(self):
+        entity_id = uuid4()
+        agent_id = uuid4()
+        memories = [
+            LongTermMemory(
+                id=uuid4(),
+                agent_id=agent_id,
+                entity_id=entity_id,
+                category=LongTermMemoryCategory.SEMANTIC,
+                content="x",
+                confidence=0.9,
+            ),
+        ]
+        assert _top_k_by_confidence(memories, 0) == []
+
+    def test_empty_list(self):
+        assert _top_k_by_confidence([], 5) == []
+
+
+# ============================================================================
+# Config Management
+# ============================================================================
+
+
+class TestConfigManagement:
+    def test_defaults_are_sensible(self):
+        svc = MemoryService()
+        config = svc.get_config()
+        assert config.short_term_summarization_threshold > 0
+        assert config.long_term_extraction_threshold > 0
+        assert config.long_term_extraction_interval > 0
+        assert config.long_term_confidence_threshold > 0.0
+
+    def test_get_config_returns_copy(self):
+        svc = MemoryService()
+        c1 = svc.get_config()
+        c1.short_term_summarization_threshold = 99999
+        c2 = svc.get_config()
+        assert c2.short_term_summarization_threshold != 99999
+
+    def test_update_config_partial(self):
+        svc = MemoryService()
+        original = svc.get_config()
+        svc._config.short_term_summarization_threshold = 999
+        updated = svc.get_config()
+        assert updated.short_term_summarization_threshold == 999
+        # Other fields preserved
+        assert updated.long_term_extraction_threshold == original.long_term_extraction_threshold
+        assert updated.long_term_extraction_interval == original.long_term_extraction_interval
+
+
+# ============================================================================
+# Extraction Checkpointing
+# ============================================================================
+
+
+class TestExtractionCheckpointing:
+    @pytest.mark.asyncio
+    async def test_below_threshold_does_not_run(self):
+        svc = MemoryService()
+        entity = uuid4()
+        room = uuid4()
+        assert not await svc.should_run_extraction(entity, room, 1)
+
+    @pytest.mark.asyncio
+    async def test_at_threshold_runs_first_time(self):
+        svc = MemoryService()
+        config = svc.get_config()
+        entity = uuid4()
+        room = uuid4()
+        assert await svc.should_run_extraction(entity, room, config.long_term_extraction_threshold)
+
+    @pytest.mark.asyncio
+    async def test_checkpoint_prevents_rerun(self):
+        svc = MemoryService()
+        config = svc.get_config()
+        threshold = config.long_term_extraction_threshold
+        entity = uuid4()
+        room = uuid4()
+        await svc.set_last_extraction_checkpoint(entity, room, threshold)
+        assert not await svc.should_run_extraction(entity, room, threshold)
+
+    @pytest.mark.asyncio
+    async def test_next_interval_runs(self):
+        svc = MemoryService()
+        config = svc.get_config()
+        threshold = config.long_term_extraction_threshold
+        interval = config.long_term_extraction_interval
+        entity = uuid4()
+        room = uuid4()
+        await svc.set_last_extraction_checkpoint(entity, room, threshold)
+        assert await svc.should_run_extraction(entity, room, threshold + interval)
+
+    @pytest.mark.asyncio
+    async def test_independent_entity_room_pairs(self):
+        svc = MemoryService()
+        config = svc.get_config()
+        threshold = config.long_term_extraction_threshold
+        entity_a = uuid4()
+        entity_b = uuid4()
+        room = uuid4()
+        await svc.set_last_extraction_checkpoint(entity_a, room, threshold)
+        # entity_b should still be eligible
+        assert await svc.should_run_extraction(entity_b, room, threshold)
+        # entity_a should not
+        assert not await svc.should_run_extraction(entity_a, room, threshold)
+
+
+# ============================================================================
+# Formatted Memory Output
+# ============================================================================
+
+
+class TestFormattedLongTermMemories:
+    @pytest.mark.asyncio
+    async def test_groups_by_category(self):
+        svc = MemoryService()
+        entity_id = uuid4()
+        agent_id = uuid4()
+
+        # Manually inject memories into fallback storage
+        key = str(entity_id)
+        svc._long_term[key] = [
+            LongTermMemory(
+                id=uuid4(),
+                agent_id=agent_id,
+                entity_id=entity_id,
+                category=LongTermMemoryCategory.SEMANTIC,
+                content="Likes coffee",
+                confidence=0.9,
+            ),
+            LongTermMemory(
+                id=uuid4(),
+                agent_id=agent_id,
+                entity_id=entity_id,
+                category=LongTermMemoryCategory.EPISODIC,
+                content="Had meeting",
+                confidence=0.85,
+            ),
+            LongTermMemory(
+                id=uuid4(),
+                agent_id=agent_id,
+                entity_id=entity_id,
+                category=LongTermMemoryCategory.SEMANTIC,
+                content="Prefers dark mode",
+                confidence=0.88,
+            ),
+        ]
+
+        result = await svc.get_formatted_long_term_memories(entity_id)
+        assert "**Semantic**:" in result
+        assert "**Episodic**:" in result
+        assert "- Likes coffee" in result
+        assert "- Prefers dark mode" in result
+        assert "- Had meeting" in result
+
+    @pytest.mark.asyncio
+    async def test_empty_returns_empty_string(self):
+        svc = MemoryService()
+        entity_id = uuid4()
+        result = await svc.get_formatted_long_term_memories(entity_id)
+        assert result == ""
+
+    @pytest.mark.asyncio
+    async def test_single_category(self):
+        svc = MemoryService()
+        entity_id = uuid4()
+        agent_id = uuid4()
+
+        svc._long_term[str(entity_id)] = [
+            LongTermMemory(
+                id=uuid4(),
+                agent_id=agent_id,
+                entity_id=entity_id,
+                category=LongTermMemoryCategory.PROCEDURAL,
+                content="Knows how to ride a bike",
+                confidence=0.95,
+            ),
+        ]
+
+        result = await svc.get_formatted_long_term_memories(entity_id)
+        assert "**Procedural**:" in result
+        assert "- Knows how to ride a bike" in result
+        assert "**Semantic**:" not in result
+        assert "**Episodic**:" not in result

package/elizaos/advanced_planning/actions/schedule_follow_up.py

@@ -0,0 +1,222 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import TYPE_CHECKING
+from uuid import UUID as StdUUID
+
+from elizaos.bootstrap.utils.xml import parse_key_value_xml
+from elizaos.deterministic import get_prompt_reference_datetime
+from elizaos.generated.spec_helpers import require_action_spec
+from elizaos.prompts import SCHEDULE_FOLLOW_UP_TEMPLATE
+from elizaos.types import (
+    Action,
+    ActionExample,
+    ActionResult,
+    Content,
+    ModelType,
+)
+
+if TYPE_CHECKING:
+    from elizaos.types import (
+        HandlerCallback,
+        HandlerOptions,
+        IAgentRuntime,
+        Memory,
+        State,
+    )
+
+# Get text content from centralized specs
+_spec = require_action_spec("SCHEDULE_FOLLOW_UP")
+
+
+def _convert_spec_examples() -> list[list[ActionExample]]:
+    """Convert spec examples to ActionExample format."""
+    spec_examples = _spec.get("examples", [])
+    if spec_examples:
+        return [
+            [
+                ActionExample(
+                    name=msg.get("name", ""),
+                    content=Content(
+                        text=msg.get("content", {}).get("text", ""),
+                        actions=msg.get("content", {}).get("actions"),
+                    ),
+                )
+                for msg in example
+            ]
+            for example in spec_examples
+        ]
+    return []
+
+
+def _normalize_priority(raw_priority: str) -> str:
+    normalized = raw_priority.strip().lower()
+    if normalized in {"high", "medium", "low"}:
+        return normalized
+    return "medium"
+
+
+def _coerce_uuid(value: object | None) -> StdUUID | None:
+    if value is None:
+        return None
+    text = str(value).strip()
+    if not text:
+        return None
+    try:
+        return StdUUID(text)
+    except ValueError:
+        return None
+
+
+@dataclass
+class ScheduleFollowUpAction:
+    name: str = _spec["name"]
+    similes: list[str] = field(default_factory=lambda: list(_spec.get("similes", [])))
+    description: str = _spec["description"]
+
+    async def validate(
+        self, runtime: IAgentRuntime, _message: Memory, _state: State | None = None
+    ) -> bool:
+        rolodex_service = runtime.get_service("rolodex")
+        follow_up_service = runtime.get_service("follow_up")
+        return rolodex_service is not None and follow_up_service is not None
+
+    async def handler(
+        self,
+        runtime: IAgentRuntime,
+        message: Memory,
+        state: State | None = None,
+        options: HandlerOptions | None = None,
+        callback: HandlerCallback | None = None,
+        responses: list[Memory] | None = None,
+    ) -> ActionResult:
+        from elizaos.bootstrap.services.follow_up import FollowUpService
+        from elizaos.bootstrap.services.rolodex import RolodexService
+
+        rolodex_service = runtime.get_service("rolodex")
+        follow_up_service = runtime.get_service("follow_up")
+
+        if not rolodex_service or not isinstance(rolodex_service, RolodexService):
+            return ActionResult(
+                text="Rolodex service not available",
+                success=False,
+                values={"error": True},
+                data={"error": "RolodexService not available"},
+            )
+
+        if not follow_up_service or not isinstance(follow_up_service, FollowUpService):
+            return ActionResult(
+                text="Follow-up service not available",
+                success=False,
+                values={"error": True},
+                data={"error": "FollowUpService not available"},
+            )
+
+        state = await runtime.compose_state(message, ["RECENT_MESSAGES", "ENTITIES"])
+        state.values["currentDateTime"] = get_prompt_reference_datetime(
+            runtime,
+            message,
+            state,
+            "action:schedule_follow_up",
+        ).isoformat()
+
+        prompt = runtime.compose_prompt_from_state(
+            state=state,
+            template=SCHEDULE_FOLLOW_UP_TEMPLATE,
+        )
+
+        response = await runtime.use_model(ModelType.TEXT_SMALL, {"prompt": prompt})
+        parsed = parse_key_value_xml(response)
+
+        if not parsed or not parsed.get("contactName"):
+            return ActionResult(
+                text="Could not extract follow-up information",
+                success=False,
+                values={"error": True},
+                data={"error": "Failed to parse follow-up info"},
+            )
+
+        contact_name = str(parsed.get("contactName", ""))
+        scheduled_at_str = str(parsed.get("scheduledAt", ""))
+        reason = str(parsed.get("reason", "Follow-up"))
+        priority = _normalize_priority(str(parsed.get("priority", "medium")))
+        follow_up_message = str(parsed.get("message", ""))
+        parsed_entity_id = _coerce_uuid(parsed.get("entityId"))
+        message_entity_id = _coerce_uuid(message.entity_id)
+
+        try:
+            scheduled_at = datetime.fromisoformat(scheduled_at_str.replace("Z", "+00:00"))
+        except ValueError:
+            return ActionResult(
+                text="Could not parse the follow-up date/time",
+                success=False,
+                values={"error": True},
+                data={"error": "Invalid follow-up datetime"},
+            )
+
+        entity_id_uuid = parsed_entity_id or message_entity_id
+        if entity_id_uuid is None and contact_name:
+            contacts = await rolodex_service.search_contacts(search_term=contact_name)
+            if contacts:
+                entity_id_uuid = contacts[0].entity_id
+
+        if entity_id_uuid is None:
+            return ActionResult(
+                text=f"Could not determine which contact to schedule for ({contact_name}).",
+                success=False,
+                values={"error": True},
+                data={"error": "Missing contact entity id"},
+            )
+
+        contact = await rolodex_service.get_contact(entity_id_uuid)
+        if contact is None:
+            return ActionResult(
+                text=f"Contact '{contact_name}' was not found in the rolodex.",
+                success=False,
+                values={"error": True},
+                data={"error": "Contact not found"},
+            )
+
+        await follow_up_service.schedule_follow_up(
+            entity_id=entity_id_uuid,
+            scheduled_at=scheduled_at,
+            reason=reason,
+            priority=priority,
+            message=follow_up_message,
+        )
+
+        response_text = f"I've scheduled a follow-up with {contact_name} for {scheduled_at.strftime('%B %d, %Y')}. Reason: {reason}"
+
+        if callback:
+            await callback(Content(text=response_text, actions=["SCHEDULE_FOLLOW_UP"]))
+
+        return ActionResult(
+            text=response_text,
+            success=True,
+            values={
+                "contactId": str(entity_id_uuid),
+                "scheduledAt": scheduled_at.isoformat(),
+            },
+            data={
+                "contactId": str(entity_id_uuid),
+                "contactName": contact_name,
+                "scheduledAt": scheduled_at.isoformat(),
+                "reason": reason,
+                "priority": priority,
+            },
+        )
+
+    @property
+    def examples(self) -> list[list[ActionExample]]:
+        return _convert_spec_examples()
+
+
+schedule_follow_up_action = Action(
+    name=ScheduleFollowUpAction.name,
+    similes=ScheduleFollowUpAction().similes,
+    description=ScheduleFollowUpAction.description,
+    validate=ScheduleFollowUpAction().validate,
+    handler=ScheduleFollowUpAction().handler,
+    examples=ScheduleFollowUpAction().examples,
+)