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

package/elizaos/advanced_memory/evaluators/reflection.py

@@ -0,0 +1,134 @@
+from __future__ import annotations
+
+from collections.abc import Awaitable, Callable
+from typing import TYPE_CHECKING
+
+from elizaos.bootstrap.types import EvaluatorResult
+from elizaos.bootstrap.utils.xml import parse_key_value_xml
+from elizaos.generated.spec_helpers import require_evaluator_spec
+from elizaos.prompts import REFLECTION_TEMPLATE
+from elizaos.types import ActionResult, Evaluator, HandlerOptions, ModelType
+
+if TYPE_CHECKING:
+    from elizaos.types import Content, IAgentRuntime, Memory, State
+
+# Get text content from centralized specs
+_spec = require_evaluator_spec("REFLECTION")
+
+
+async def evaluate_reflection(
+    runtime: IAgentRuntime,
+    message: Memory,
+    state: State | None = None,
+) -> EvaluatorResult:
+    if state is None:
+        return EvaluatorResult(
+            score=50,
+            passed=True,
+            reason="No state for reflection",
+            details={},
+        )
+
+    recent_interactions: list[str] = []
+    room_id = message.room_id
+
+    if room_id:
+        recent_messages = await runtime.get_memories(
+            room_id=room_id,
+            limit=10,
+            order_by="created_at",
+            order_direction="desc",
+        )
+
+        for msg in recent_messages:
+            if msg.content and msg.content.text:
+                sender = "Unknown"
+                if msg.entity_id:
+                    if str(msg.entity_id) == str(runtime.agent_id):
+                        sender = runtime.character.name
+                    else:
+                        entity = await runtime.get_entity(msg.entity_id)
+                        if entity and entity.name:
+                            sender = entity.name
+                recent_interactions.append(f"{sender}: {msg.content.text}")
+
+    if not recent_interactions:
+        return EvaluatorResult(
+            score=50,
+            passed=True,
+            reason="No recent interactions to reflect on",
+            details={"noInteractions": True},
+        )
+
+    interactions_text = "\n".join(recent_interactions)
+
+    template = (
+        runtime.character.templates.get("reflectionTemplate")
+        if runtime.character.templates and "reflectionTemplate" in runtime.character.templates
+        else REFLECTION_TEMPLATE
+    )
+    prompt = runtime.compose_prompt(state=state, template=template)
+    prompt = prompt.replace("{{recentInteractions}}", interactions_text)
+
+    response_text = await runtime.use_model(ModelType.TEXT_LARGE, prompt=prompt)
+    parsed_xml = parse_key_value_xml(response_text)
+
+    if parsed_xml is None:
+        raise ValueError("Failed to parse reflection response")
+
+    quality_str = str(parsed_xml.get("quality_score", "50"))
+    quality_score = max(0, min(100, int(quality_str)))
+
+    thought = str(parsed_xml.get("thought", ""))
+    strengths = str(parsed_xml.get("strengths", ""))
+    improvements = str(parsed_xml.get("improvements", ""))
+    learnings = str(parsed_xml.get("learnings", ""))
+
+    passed = quality_score >= 50
+
+    return EvaluatorResult(
+        score=quality_score,
+        passed=passed,
+        reason=f"Strengths: {strengths}\nImprovements: {improvements}",
+        details={
+            "thought": thought,
+            "strengths": strengths,
+            "improvements": improvements,
+            "learnings": learnings,
+            "interactionCount": len(recent_interactions),
+        },
+    )
+
+
+async def validate_reflection(
+    runtime: IAgentRuntime,
+    message: Memory,
+    _state: State | None = None,
+) -> bool:
+    return True
+
+
+async def _reflection_handler(
+    runtime: IAgentRuntime,
+    message: Memory,
+    state: State | None = None,
+    options: HandlerOptions | None = None,
+    callback: Callable[[Content], Awaitable[list[Memory]]] | None = None,
+    responses: list[Memory] | None = None,
+) -> ActionResult | None:
+    """Wrapper handler that matches the expected signature."""
+    _ = options, callback, responses  # Unused parameters
+    result = await evaluate_reflection(runtime, message, state)
+    # Return ActionResult - evaluators don't typically return action results
+    return ActionResult(text=result.reason, success=result.passed, values={}, data={})
+
+
+reflection_evaluator = Evaluator(
+    name=str(_spec["name"]),
+    description=str(_spec["description"]),
+    similes=list(_spec.get("similes", [])) if _spec.get("similes") else [],
+    validate=validate_reflection,
+    handler=_reflection_handler,
+    always_run=bool(_spec.get("alwaysRun", False)),
+    examples=[],
+)

package/elizaos/advanced_memory/evaluators/relationship_extraction.py

@@ -0,0 +1,203 @@
+from __future__ import annotations
+
+import re
+from collections.abc import Awaitable, Callable
+from typing import TYPE_CHECKING
+
+from elizaos.bootstrap.types import EvaluatorResult
+from elizaos.generated.spec_helpers import require_evaluator_spec
+from elizaos.types import ActionResult, Evaluator, HandlerOptions
+
+if TYPE_CHECKING:
+    from elizaos.types import Content, IAgentRuntime, Memory, State
+
+# Get text content from centralized specs
+_spec = require_evaluator_spec("RELATIONSHIP_EXTRACTION")
+
+X_HANDLE_PATTERN = re.compile(r"@[\w]+")
+EMAIL_PATTERN = re.compile(r"[\w.+-]+@[\w.-]+\.\w+")
+PHONE_PATTERN = re.compile(r"\+?[\d\s\-()]{10,}")
+DISCORD_PATTERN = re.compile(r"[\w]+#\d{4}")
+
+
+def extract_platform_identities(text: str) -> list[dict[str, str | bool | float]]:
+    identities: list[dict[str, str | bool | float]] = []
+
+    for match in X_HANDLE_PATTERN.finditer(text):
+        handle = match.group()
+        if handle.lower() not in ("@here", "@everyone", "@channel"):
+            identities.append(
+                {
+                    "platform": "x",
+                    "handle": handle,
+                    "verified": False,
+                    "confidence": 0.7,
+                }
+            )
+
+    for match in EMAIL_PATTERN.finditer(text):
+        identities.append(
+            {
+                "platform": "email",
+                "handle": match.group(),
+                "verified": False,
+                "confidence": 0.9,
+            }
+        )
+
+    for match in DISCORD_PATTERN.finditer(text):
+        identities.append(
+            {
+                "platform": "discord",
+                "handle": match.group(),
+                "verified": False,
+                "confidence": 0.8,
+            }
+        )
+
+    return identities
+
+
+def detect_relationship_indicators(text: str) -> list[dict[str, str | float]]:
+    indicators: list[dict[str, str | float]] = []
+
+    friend_patterns = [
+        r"my friend",
+        r"good friend",
+        r"best friend",
+        r"close friend",
+        r"we're friends",
+    ]
+    for pattern in friend_patterns:
+        if re.search(pattern, text, re.IGNORECASE):
+            indicators.append(
+                {
+                    "type": "friend",
+                    "sentiment": "positive",
+                    "confidence": 0.8,
+                }
+            )
+            break
+
+    colleague_patterns = [
+        r"my colleague",
+        r"coworker",
+        r"co-worker",
+        r"work together",
+        r"at work",
+    ]
+    for pattern in colleague_patterns:
+        if re.search(pattern, text, re.IGNORECASE):
+            indicators.append(
+                {
+                    "type": "colleague",
+                    "sentiment": "neutral",
+                    "confidence": 0.8,
+                }
+            )
+            break
+
+    family_patterns = [
+        r"my (brother|sister|mom|dad|mother|father|parent|son|daughter|child)",
+        r"my family",
+        r"family member",
+    ]
+    for pattern in family_patterns:
+        if re.search(pattern, text, re.IGNORECASE):
+            indicators.append(
+                {
+                    "type": "family",
+                    "sentiment": "positive",
+                    "confidence": 0.9,
+                }
+            )
+            break
+
+    return indicators
+
+
+async def evaluate_relationship_extraction(
+    runtime: IAgentRuntime,
+    message: Memory,
+    state: State | None = None,
+) -> EvaluatorResult:
+    text = message.content.text if message.content else ""
+
+    if not text:
+        return EvaluatorResult(
+            score=50,
+            passed=True,
+            reason="No text to analyze",
+            details={"noText": True},
+        )
+
+    identities = extract_platform_identities(text)
+
+    indicators = detect_relationship_indicators(text)
+
+    if identities and message.entity_id:
+        entity = await runtime.get_entity(str(message.entity_id))
+        if entity:
+            metadata = entity.metadata or {}
+            existing_identities = metadata.get("platformIdentities", [])
+            if isinstance(existing_identities, list):
+                for identity in identities:
+                    exists = any(
+                        i.get("platform") == identity["platform"]
+                        and i.get("handle") == identity["handle"]
+                        for i in existing_identities
+                        if isinstance(i, dict)
+                    )
+                    if not exists:
+                        existing_identities.append(identity)
+                metadata["platformIdentities"] = existing_identities
+                entity.metadata = metadata
+                await runtime.update_entity(entity)
+
+    runtime.logger.info(
+        f"Completed extraction: src=evaluator:relationship_extraction agentId={runtime.agent_id} identitiesFound={len(identities)} indicatorsFound={len(indicators)}"
+    )
+
+    return EvaluatorResult(
+        score=70,
+        passed=True,
+        reason=f"Found {len(identities)} identities and {len(indicators)} relationship indicators",
+        details={
+            "identitiesCount": len(identities),
+            "indicatorsCount": len(indicators),
+        },
+    )
+
+
+async def validate_relationship_extraction(
+    runtime: IAgentRuntime,
+    message: Memory,
+    _state: State | None = None,
+) -> bool:
+    return message.content is not None and bool(message.content.text)
+
+
+async def _relationship_extraction_handler(
+    runtime: IAgentRuntime,
+    message: Memory,
+    state: State | None = None,
+    options: HandlerOptions | None = None,
+    callback: Callable[[Content], Awaitable[list[Memory]]] | None = None,
+    responses: list[Memory] | None = None,
+) -> ActionResult | None:
+    """Wrapper handler that matches the expected signature."""
+    _ = options, callback, responses  # Unused parameters
+    result = await evaluate_relationship_extraction(runtime, message, state)
+    # Return None as ActionResult - evaluators don't typically return action results
+    return ActionResult(text=result.reason, success=result.passed, values={}, data={})
+
+
+relationship_extraction_evaluator = Evaluator(
+    name=str(_spec["name"]),
+    description=str(_spec["description"]),
+    similes=list(_spec.get("similes", [])) if _spec.get("similes") else [],
+    validate=validate_relationship_extraction,
+    handler=_relationship_extraction_handler,
+    always_run=bool(_spec.get("alwaysRun", False)),
+    examples=[],
+)

package/elizaos/advanced_memory/memory_service.py

@@ -3,7 +3,8 @@ from __future__ import annotations
 import heapq
 import re
 import time
-from typing import cast
+from collections import OrderedDict
+from typing import TypeVar, cast
 from uuid import UUID, uuid4
 
 from elizaos.types.model import ModelType
@@ -27,6 +28,7 @@ from .types import (
 _TABLE_SESSION_SUMMARY = "session_summary"
 _TABLE_LONG_TERM_MEMORY = "long_term_memory"
 _GLOBAL_LONG_TERM_ROOM_ID = string_to_uuid("advanced-memory:long-term")
+_OrderedValueT = TypeVar("_OrderedValueT")
 
 
 def _parse_summary_xml(xml: str) -> SummaryResult:
@@ -79,14 +81,28 @@ def _top_k_by_confidence(items: list[LongTermMemory], limit: int) -> list[LongTe
 
 class MemoryService(Service):
     service_type = "memory"
+    _MAX_LOCAL_SESSION_SUMMARIES = 500
+    _MAX_LOCAL_EXTRACTION_CHECKPOINTS = 500
+    _MAX_LOCAL_LONG_TERM_ENTITIES = 500
+    _MAX_LOCAL_LONG_TERM_PER_ENTITY = 200
 
     def __init__(self, runtime=None) -> None:
         super().__init__(runtime=runtime)
         self._config: MemoryConfig = MemoryConfig()
         # Fallback storage for runtimes without a DB adapter (tests/benchmarks).
-        self._session_summaries: dict[str, SessionSummary] = {}
-        self._long_term: dict[str, list[LongTermMemory]] = {}
-        self._extraction_checkpoints: dict[str, int] = {}
+        self._session_summaries: OrderedDict[str, SessionSummary] = OrderedDict()
+        self._long_term: OrderedDict[str, list[LongTermMemory]] = OrderedDict()
+        self._extraction_checkpoints: OrderedDict[str, int] = OrderedDict()
+
+    @staticmethod
+    def _touch_ordered(mapping: OrderedDict[str, _OrderedValueT], key: str) -> None:
+        if key in mapping:
+            mapping.move_to_end(key)
+
+    @staticmethod
+    def _prune_ordered(mapping: OrderedDict[str, _OrderedValueT], max_entries: int) -> None:
+        while len(mapping) > max_entries:
+            mapping.popitem(last=False)
 
     @property
     def capability_description(self) -> str:
@@ -95,38 +111,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 +160,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)
@@ -158,17 +172,23 @@ class MemoryService(Service):
                 return 0
             except Exception:
                 return 0
-        return int(self._extraction_checkpoints.get(key, 0))
+        checkpoint = self._extraction_checkpoints.get(key)
+        if checkpoint is None:
+            return 0
+        self._touch_ordered(self._extraction_checkpoints, key)
+        return int(checkpoint)
 
     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))
             return
         self._extraction_checkpoints[key] = int(message_count)
+        self._touch_ordered(self._extraction_checkpoints, key)
+        self._prune_ordered(self._extraction_checkpoints, self._MAX_LOCAL_EXTRACTION_CHECKPOINTS)
 
     async def should_run_extraction(
         self, entity_id: UUID, room_id: UUID, current_message_count: int
@@ -182,7 +202,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
 
@@ -221,7 +241,11 @@ class MemoryService(Service):
                     # Best-effort; ignore corrupt rows.
                     continue
 
-        return self._session_summaries.get(str(room_id))
+        summary = self._session_summaries.get(str(room_id))
+        if summary is None:
+            return None
+        self._touch_ordered(self._session_summaries, str(room_id))
+        return summary
 
     async def store_session_summary(
         self,
@@ -234,7 +258,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,
@@ -273,13 +297,16 @@ class MemoryService(Service):
             )
             return s
 
-        self._session_summaries[str(room_id)] = s
+        room_key = str(room_id)
+        self._session_summaries[room_key] = s
+        self._touch_ordered(self._session_summaries, room_key)
+        self._prune_ordered(self._session_summaries, self._MAX_LOCAL_SESSION_SUMMARIES)
         return s
 
     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:
@@ -324,9 +351,11 @@ class MemoryService(Service):
             )
             return
 
-        existing = self._session_summaries.get(str(room_id))
+        room_key = str(room_id)
+        existing = self._session_summaries.get(room_key)
         if not existing or existing.id != summary_id:
             return
+        self._touch_ordered(self._session_summaries, room_key)
         if "summary" in updates and isinstance(updates["summary"], str):
             existing.summary = updates["summary"]
         if "message_count" in updates and isinstance(updates["message_count"], (int, float, str)):
@@ -350,7 +379,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,
@@ -383,7 +412,17 @@ class MemoryService(Service):
             )
             return m
 
-        self._long_term.setdefault(str(entity_id), []).append(m)
+        entity_key = str(entity_id)
+        bucket = self._long_term.get(entity_key)
+        if bucket is None:
+            bucket = []
+            self._long_term[entity_key] = bucket
+        else:
+            self._touch_ordered(self._long_term, entity_key)
+        bucket.append(m)
+        if len(bucket) > self._MAX_LOCAL_LONG_TERM_PER_ENTITY:
+            del bucket[: len(bucket) - self._MAX_LOCAL_LONG_TERM_PER_ENTITY]
+        self._prune_ordered(self._long_term, self._MAX_LOCAL_LONG_TERM_ENTITIES)
         return m
 
     async def get_long_term_memories(
@@ -394,7 +433,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(
                 {
@@ -439,7 +478,10 @@ class MemoryService(Service):
                     continue
             return _top_k_by_confidence(out, limit)
 
-        local_mems = self._long_term.get(str(entity_id), [])
+        entity_key = str(entity_id)
+        local_mems = self._long_term.get(entity_key, [])
+        if entity_key in self._long_term:
+            self._touch_ordered(self._long_term, entity_key)
         if category is not None:
             local_mems = [m for m in local_mems if m.category == category]
         return _top_k_by_confidence(local_mems, limit)

package/elizaos/advanced_memory/plugin.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from elizaos.types import Plugin
 
+from .actions.reset_session import reset_session_action
 from .evaluators import long_term_extraction_evaluator, summarization_evaluator
 from .memory_service import MemoryService
 from .providers import context_summary_provider, long_term_memory_provider
@@ -21,7 +22,7 @@ def create_advanced_memory_plugin() -> Plugin:
         init=init_plugin,
         config={},
         services=[MemoryService],
-        actions=[],
+        actions=[reset_session_action],
         providers=[long_term_memory_provider, context_summary_provider],
         evaluators=[summarization_evaluator, long_term_extraction_evaluator],
     )