@elizaos/python 2.0.0-alpha.3 → 2.0.0-alpha.31

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_memory/types.py

@@ -1,11 +1,11 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field
-from enum import Enum
+from enum import StrEnum
 from uuid import UUID
 
 
-class LongTermMemoryCategory(str, Enum):
+class LongTermMemoryCategory(StrEnum):
     EPISODIC = "episodic"
     SEMANTIC = "semantic"
     PROCEDURAL = "procedural"

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, Any, cast
+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 = cast(list[list[dict[str, Any]]], _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,
+)

package/elizaos/advanced_planning/planning_service.py

@@ -10,7 +10,7 @@ from uuid import UUID, uuid4
 from google.protobuf.json_format import MessageToDict
 
 from elizaos.logger import Logger
-from elizaos.types.components import ActionContext, ActionResult, HandlerCallback, HandlerOptions
+from elizaos.types.components import ActionContext, ActionResult, HandlerCallback
 from elizaos.types.memory import Memory
 from elizaos.types.primitives import Content
 from elizaos.types.service import Service
@@ -538,6 +538,8 @@ Focus on:
         ]
         results = await asyncio.gather(*tasks, return_exceptions=True)
         for r in results:
+            if isinstance(r, Exception):
+                raise RuntimeError(f"Plan step failed during parallel execution: {r}") from r
             if isinstance(r, ActionResult):
                 execution.results.append(r)
 
@@ -586,6 +588,10 @@ Focus on:
 
             for step, r in zip(ready_batch, results, strict=False):
                 completed_count += 1
+                if isinstance(r, Exception):
+                    raise RuntimeError(
+                        f"Plan step '{step.action_name}' failed during DAG execution: {r}"
+                    ) from r
                 if isinstance(r, ActionResult):
                     execution.results.append(r)
 
@@ -622,13 +628,16 @@ Focus on:
             if execution.abort_event.is_set():
                 raise RuntimeError("Plan execution aborted")
             try:
-                options = HandlerOptions(
-                    action_context=action_context,
-                    parameters=step.parameters,
-                )
-                # Attach extra execution context (allowed by extra="allow")
-                options.previous_results = previous_results  # type: ignore[attr-defined]
-                options.context = {"workingMemory": execution.working_memory}  # type: ignore[attr-defined]
+                options = type(
+                    "_PlanningHandlerOptions",
+                    (),
+                    {
+                        "action_context": action_context,
+                        "parameters": step.parameters,
+                        "previous_results": previous_results,
+                        "context": {"workingMemory": execution.working_memory},
+                    },
+                )()
 
                 validate_fn = getattr(action, "validate", None) or getattr(
                     action, "validate_fn", None
@@ -641,12 +650,15 @@ Focus on:
                 if result is None:
                     return None
 
-                if result.data is None:
-                    result.data = {}
-                if isinstance(result.data, dict):
-                    result.data["stepId"] = str(step.id)
-                    result.data["actionName"] = step.action_name
-                    result.data["executedAt"] = int(time.time() * 1000)
+                step_metadata = {
+                    "stepId": str(step.id),
+                    "actionName": step.action_name,
+                    "executedAt": int(time.time() * 1000),
+                }
+                if isinstance(result.data, dict) or hasattr(result.data, "update"):
+                    result.data.update(step_metadata)
+                else:
+                    result.data = step_metadata
                 return result
             except Exception as e:
                 retries += 1

package/elizaos/basic_capabilities/__init__.py

@@ -18,7 +18,6 @@ from .providers import (
     actions_provider,
     attachments_provider,
     basic_providers,
-    capabilities_provider,
     character_provider,
     choice_provider,
     context_bench_provider,
@@ -48,7 +47,6 @@ __all__ = [
     "action_state_provider",
     "actions_provider",
     "attachments_provider",
-    "capabilities_provider",
     "character_provider",
     "choice_provider",
     "context_bench_provider",