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

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,
+)

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",

package/elizaos/basic_capabilities/providers/__init__.py

@@ -6,7 +6,6 @@ Fundamental providers included by default in the bootstrap plugin.
 from .action_state import action_state_provider
 from .actions import actions_provider
 from .attachments import attachments_provider
-from .capabilities import capabilities_provider
 from .character import character_provider
 from .choice import choice_provider
 from .context_bench import context_bench_provider
@@ -22,7 +21,6 @@ __all__ = [
     "action_state_provider",
     "actions_provider",
     "attachments_provider",
-    "capabilities_provider",
     "character_provider",
     "choice_provider",
     "context_bench_provider",
@@ -40,7 +38,6 @@ basic_providers = [
     actions_provider,
     action_state_provider,
     attachments_provider,
-    capabilities_provider,
     character_provider,
     choice_provider,
     context_bench_provider,

package/elizaos/basic_capabilities/providers/agent_settings.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from elizaos.generated.spec_helpers import require_provider_spec
+from elizaos.types import Provider, ProviderResult
+
+if TYPE_CHECKING:
+    from elizaos.types import IAgentRuntime, Memory, State
+
+# Get text content from centralized specs
+_spec = require_provider_spec("AGENT_SETTINGS")
+
+SENSITIVE_KEY_PATTERNS = (
+    "key",
+    "secret",
+    "password",
+    "token",
+    "credential",
+    "auth",
+    "private",
+)
+
+
+async def get_agent_settings_context(
+    runtime: IAgentRuntime,
+    message: Memory,
+    state: State | None = None,
+) -> ProviderResult:
+    all_settings = runtime.get_all_settings()
+
+    safe_settings: dict[str, str] = {}
+    for key, value in all_settings.items():
+        if not any(pattern in key.lower() for pattern in SENSITIVE_KEY_PATTERNS):
+            safe_settings[key] = str(value)
+
+    sections: list[str] = []
+    if safe_settings:
+        sections.append("# Agent Settings")
+        for key, value in safe_settings.items():
+            display_value = value if len(value) <= 50 else value[:50] + "..."
+            sections.append(f"- {key}: {display_value}")
+
+    context_text = "\n".join(sections) if sections else ""
+
+    return ProviderResult(
+        text=context_text,
+        values={
+            "settingsCount": len(safe_settings),
+            "hasSettings": len(safe_settings) > 0,
+        },
+        data={
+            "settings": safe_settings,
+        },
+    )
+
+
+agent_settings_provider = Provider(
+    name=_spec["name"],
+    description=_spec["description"],
+    get=get_agent_settings_context,
+    dynamic=_spec.get("dynamic", True),
+    position=_spec.get("position"),
+)