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

package/elizaos/advanced_capabilities/evaluators/relationship_extraction.py

@@ -1,203 +1,7 @@
-from __future__ import annotations
+"""Compatibility wrapper for relationship extraction evaluator."""
 
-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=[],
+from elizaos.bootstrap.evaluators.relationship_extraction import (
+    relationship_extraction_evaluator,
 )
+
+__all__ = ["relationship_extraction_evaluator"]

package/elizaos/advanced_capabilities/providers/__init__.py

@@ -4,32 +4,21 @@ Extended providers that can be enabled with `advanced_capabilities=True`.
 """
 
 from .agent_settings import agent_settings_provider
-from .contacts import contacts_provider
-from .facts import facts_provider
-from .follow_ups import follow_ups_provider
 from .knowledge import knowledge_provider
-from .relationships import relationships_provider
 from .roles import roles_provider
 from .settings import settings_provider
 
 __all__ = [
     "agent_settings_provider",
-    "contacts_provider",
-    "facts_provider",
-    "follow_ups_provider",
     "knowledge_provider",
-    "relationships_provider",
     "roles_provider",
     "settings_provider",
     "advanced_providers",
 ]
 
+# Rolodex/contact providers are provided by plugin-rolodex.
 advanced_providers = [
-    contacts_provider,
-    facts_provider,
-    follow_ups_provider,
     knowledge_provider,
-    relationships_provider,
     roles_provider,
     agent_settings_provider,
     settings_provider,

package/elizaos/advanced_capabilities/providers/knowledge.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 from typing import TYPE_CHECKING
 
 from elizaos.types import Provider, ProviderResult
+from elizaos.types.database import MemorySearchOptions
 
 if TYPE_CHECKING:
     from elizaos.types import IAgentRuntime, Memory, State
@@ -25,11 +26,31 @@ async def get_knowledge_context(
             text="", values={"knowledgeCount": 0, "hasKnowledge": False}, data={"entries": []}
         )
 
-    relevant_knowledge = await runtime.search_knowledge(
-        query=query_text,
-        limit=5,
+    # 1. Fetch recent messages to get embeddings
+    recent_messages = await runtime.get_memories(
+        room_id=message.room_id, limit=5, table_name="messages"
     )
 
+    # 2. Extract valid embeddings
+    embeddings = [m.embedding for m in recent_messages if m and m.embedding]
+
+    relevant_knowledge = []
+    # 3. Search using the most recent embedding if available
+    if embeddings:
+        primary_embedding = embeddings[0]
+        params = MemorySearchOptions(
+            table_name="knowledge",
+            room_id=message.room_id,
+            embedding=primary_embedding,
+            match_threshold=0.75,
+            match_count=5,
+            unique=True,
+        )
+        relevant_knowledge = await runtime.search_memories(params)
+    elif query_text:
+        # Fallback skipped for parity with TS/Bootstrap
+        pass
+
     for entry in relevant_knowledge:
         # Handle both dict and object entries
         if isinstance(entry, dict):

package/elizaos/advanced_capabilities/services/__init__.py

@@ -3,16 +3,9 @@
 Services that can be enabled with `advanced_capabilities=True`.
 """
 
-from .follow_up import FollowUpService
-from .rolodex import RolodexService
-
 __all__ = [
-    "FollowUpService",
-    "RolodexService",
     "advanced_services",
 ]
 
-advanced_services: list[type] = [
-    RolodexService,
-    FollowUpService,
-]
+# Rolodex/follow-up services are owned by plugin-rolodex.
+advanced_services: list[type] = []

package/elizaos/advanced_memory/actions/reset_session.py

@@ -0,0 +1,11 @@
+from ...types import Action
+
+# TODO: Implement reset_session action
+reset_session_action: Action = {
+    "name": "RESET_SESSION",
+    "similes": [],
+    "description": "Reset the session (Implementation TODO)",
+    "handler": None,
+    "validate": None,
+    "examples": [],
+}

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=[],
+)