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

package/elizaos/advanced_capabilities/evaluators/reflection.py

@@ -1,134 +1,5 @@
-from __future__ import annotations
+"""Compatibility wrapper for reflection evaluator."""
 
-from collections.abc import Awaitable, Callable
-from typing import TYPE_CHECKING
+from elizaos.bootstrap.evaluators.reflection import reflection_evaluator
 
-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=[],
-)
+__all__ = ["reflection_evaluator"]

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

@@ -25,11 +25,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 = {
+            "tableName": "knowledge",
+            "roomId": str(message.room_id),
+            "embedding": primary_embedding,
+            "matchThreshold": 0.75,
+            "matchCount": 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_capabilities/services/rolodex.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from dataclasses import dataclass, field
 from datetime import datetime
-from enum import Enum
+from enum import StrEnum
 from typing import TYPE_CHECKING
 from uuid import UUID
 
@@ -12,7 +12,7 @@ if TYPE_CHECKING:
     from elizaos.types import IAgentRuntime
 
 
-class ContactCategory(str, Enum):
+class ContactCategory(StrEnum):
     FRIEND = "friend"
     FAMILY = "family"
     COLLEAGUE = "colleague"

package/elizaos/advanced_memory/actions/reset_session.py

@@ -0,0 +1,143 @@
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
+
+from elizaos.types import Action, ActionExample, ActionResult, Content
+
+if TYPE_CHECKING:
+    from elizaos.types import HandlerCallback, HandlerOptions, IAgentRuntime, Memory, State
+
+
+@dataclass
+class ResetSessionAction:
+    name: str = "RESET_SESSION"
+    similes: list[str] = field(
+        default_factory=lambda: ["CLEAR_HISTORY", "NEW_SESSION", "FORGET", "START_OVER", "RESET"]
+    )
+    description: str = (
+        "Resets the conversation session by creating a compaction point. "
+        "Messages before this point will not be included in future context."
+    )
+
+    async def validate(
+        self, runtime: IAgentRuntime, message: Memory, state: State | None = None
+    ) -> bool:
+        room = None
+        if state and getattr(state, "data", None) and getattr(state.data, "room", None):
+            room = state.data.room
+        elif message.room_id:
+            room = await runtime.get_room(message.room_id)
+
+        if not room or not getattr(room, "world_id", None):
+            return True
+
+        world = await runtime.get_world(room.world_id)
+        if not world or not getattr(world, "metadata", None):
+            return False
+
+        roles = world.metadata.get("roles", {})
+        user_role = roles.get(str(message.entity_id), "NONE")
+        return user_role in ("OWNER", "ADMIN")
+
+    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:
+        del options, responses
+
+        room = None
+        if state and getattr(state, "data", None) and getattr(state.data, "room", None):
+            room = state.data.room
+        elif message.room_id:
+            room = await runtime.get_room(message.room_id)
+
+        if room is None:
+            if callback:
+                await callback(
+                    Content(
+                        text="Unable to reset session - room not found.",
+                        actions=["RESET_SESSION_FAILED"],
+                        source=getattr(message.content, "source", None),
+                    )
+                )
+            return ActionResult(
+                text="Room not found",
+                values={"error": "room_not_found"},
+                data={"actionName": "RESET_SESSION"},
+                success=False,
+            )
+
+        metadata = dict(getattr(room, "metadata", {}) or {})
+        previous_compaction = metadata.get("lastCompactionAt")
+        compaction_history = list(metadata.get("compactionHistory", []))
+        now = int(time.time() * 1000)
+
+        compaction_history.append(
+            {
+                "timestamp": now,
+                "triggeredBy": str(message.entity_id),
+                "reason": "manual_reset",
+            }
+        )
+        metadata["lastCompactionAt"] = now
+        metadata["compactionHistory"] = compaction_history[-10:]
+
+        if (
+            hasattr(room, "metadata")
+            and hasattr(room.metadata, "clear")
+            and hasattr(room.metadata, "update")
+        ):
+            room.metadata.clear()
+            room.metadata.update(metadata)
+        else:
+            room.metadata = metadata
+
+        await runtime.update_room(room)
+
+        if callback:
+            await callback(
+                Content(
+                    text="Session has been reset. I'll start fresh from here.",
+                    actions=["RESET_SESSION"],
+                    source=getattr(message.content, "source", None),
+                )
+            )
+
+        result = ActionResult(
+            text="Session reset successfully",
+            values={
+                "success": True,
+                "compactionAt": now,
+                "roomId": str(room.id),
+            },
+            data={
+                "actionName": "RESET_SESSION",
+                "compactionAt": now,
+                "roomId": str(room.id),
+            },
+            success=True,
+        )
+        if previous_compaction is not None:
+            result.values["previousCompactionAt"] = previous_compaction
+        return result
+
+    @property
+    def examples(self) -> list[list[ActionExample]]:
+        return []
+
+
+reset_session_action = Action(
+    name=ResetSessionAction.name,
+    similes=ResetSessionAction().similes,
+    description=ResetSessionAction.description,
+    validate=ResetSessionAction().validate,
+    handler=ResetSessionAction().handler,
+    examples=ResetSessionAction().examples,
+)