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

package/elizaos/advanced_capabilities/actions/send_message.py

@@ -2,11 +2,12 @@ from __future__ import annotations
 
 import contextlib
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 from elizaos.generated.spec_helpers import require_action_spec
 from elizaos.types import Action, ActionExample, ActionResult, Content
 from elizaos.types.memory import Memory as MemoryType
+from elizaos.types.primitives import UUID, as_uuid
 
 if TYPE_CHECKING:
     from elizaos.types import HandlerCallback, HandlerOptions, IAgentRuntime, Memory, State
@@ -18,34 +19,69 @@ _spec = require_action_spec("SEND_MESSAGE")
 def _convert_spec_examples() -> list[list[ActionExample]]:
     """Convert spec examples to ActionExample format."""
     spec_examples = _spec.get("examples", [])
-    if not isinstance(spec_examples, list):
-        return []
-    result: list[list[ActionExample]] = []
-    for example in spec_examples:
-        if not isinstance(example, list):
-            continue
-        row: list[ActionExample] = []
-        for msg in example:
-            if not isinstance(msg, dict):
-                continue
-            content = msg.get("content", {})
-            text = ""
-            actions: list[str] | None = None
-            if isinstance(content, dict):
-                text_val = content.get("text", "")
-                text = str(text_val) if text_val else ""
-                actions_val = content.get("actions")
-                if isinstance(actions_val, list) and all(isinstance(a, str) for a in actions_val):
-                    actions = list(actions_val)
-            row.append(
+    if spec_examples:
+        return [
+            [
                 ActionExample(
-                    name=str(msg.get("name", "")),
-                    content=Content(text=text, actions=actions),
+                    name=msg.get("name", ""),
+                    content=Content(
+                        text=msg.get("content", {}).get("text", ""),
+                        actions=msg.get("content", {}).get("actions"),
+                    ),
                 )
-            )
-        if row:
-            result.append(row)
-    return result
+                for msg in example
+            ]
+            for example in spec_examples
+        ]
+    return []
+
+
+def _parse_uuid(value: object) -> UUID | None:
+    if not isinstance(value, str) or not value.strip():
+        return None
+    with contextlib.suppress(Exception):
+        return as_uuid(value.strip())
+    return None
+
+
+def _normalize_parameters(options: HandlerOptions | None) -> dict[str, Any]:
+    raw = getattr(options, "parameters", None)
+    if isinstance(raw, dict):
+        return raw
+
+    if raw is None:
+        return {}
+
+    if hasattr(raw, "items"):
+        try:
+            return {str(k): v for k, v in raw.items()}
+        except Exception:
+            return {}
+
+    return {}
+
+
+def _coerce_entity_name(entity: object) -> list[str]:
+    if isinstance(entity, dict):
+        names = entity.get("names")
+        if isinstance(names, list):
+            return [str(n).strip() for n in names if isinstance(n, str) and n.strip()]
+        name = entity.get("name")
+        if isinstance(name, str) and name.strip():
+            return [name.strip()]
+        return []
+
+    names = getattr(entity, "names", None)
+    if isinstance(names, list):
+        clean = [str(n).strip() for n in names if isinstance(n, str) and str(n).strip()]
+        if clean:
+            return clean
+
+    name = getattr(entity, "name", None)
+    if isinstance(name, str) and name.strip():
+        return [name.strip()]
+
+    return []
 
 
 @dataclass
@@ -70,9 +106,14 @@ class SendMessageAction:
         callback: HandlerCallback | None = None,
         responses: list[Memory] | None = None,
     ) -> ActionResult:
-        message_text = ""
-        if responses and responses[0].content:
-            message_text = str(responses[0].content.text or "")
+        params = _normalize_parameters(options)
+
+        text_param = params.get("text")
+        message_text = str(text_param).strip() if isinstance(text_param, str) else ""
+        if not message_text and responses and responses[0].content:
+            message_text = str(responses[0].content.text or "").strip()
+        if not message_text and message.content and isinstance(message.content.text, str):
+            message_text = message.content.text.strip()
 
         if not message_text:
             return ActionResult(
@@ -82,24 +123,95 @@ class SendMessageAction:
                 success=False,
             )
 
-        from uuid import UUID as StdUUID
+        target_room_id = message.room_id
+        target_entity_id: UUID | None = None
+        target_type = "room"
+
+        target_type_param = params.get("targetType") or params.get("target_type")
+        target_param = params.get("target")
+        source_param = params.get("source")
+
+        source = (
+            source_param.strip()
+            if isinstance(source_param, str) and source_param.strip()
+            else (
+                message.content.source
+                if message.content and isinstance(message.content.source, str)
+                else "agent"
+            )
+        )
+
+        if isinstance(target_type_param, str):
+            normalized_target_type = target_type_param.strip().lower()
+            if normalized_target_type in {"user", "entity"}:
+                target_type = "user"
+            elif normalized_target_type == "room":
+                target_type = "room"
 
-        target_room_id_val: str | None = str(message.room_id) if message.room_id else None
-        target_entity_id: str | None = None
+        if isinstance(target_param, str) and target_param.strip():
+            target_value = target_param.strip()
+            if target_type == "room":
+                parsed_room = _parse_uuid(target_value)
+                if parsed_room:
+                    target_room_id = parsed_room
+                else:
+                    world_id = None
+                    room_data = (
+                        getattr(getattr(state, "data", None), "room", None) if state else None
+                    )
+                    if room_data is not None:
+                        world_id = getattr(room_data, "world_id", None) or getattr(
+                            room_data, "worldId", None
+                        )
+                    if world_id is None:
+                        with contextlib.suppress(Exception):
+                            current_room = await runtime.get_room(message.room_id)
+                            if current_room:
+                                world_id = getattr(current_room, "world_id", None) or getattr(
+                                    current_room, "worldId", None
+                                )
+
+                    if world_id is not None:
+                        with contextlib.suppress(Exception):
+                            rooms = await runtime.get_rooms(world_id)
+                            for room in rooms:
+                                room_name = getattr(room, "name", None)
+                                if (
+                                    isinstance(room_name, str)
+                                    and room_name.strip().lower() == target_value.lower()
+                                ):
+                                    room_id = getattr(room, "id", None)
+                                    if room_id is not None:
+                                        target_room_id = as_uuid(str(room_id))
+                                        break
+            else:
+                parsed_entity = _parse_uuid(target_value)
+                if parsed_entity:
+                    target_entity_id = parsed_entity
+                else:
+                    with contextlib.suppress(Exception):
+                        entities = await runtime.get_entities_for_room(message.room_id)
+                        for entity in entities:
+                            names = _coerce_entity_name(entity)
+                            if any(name.lower() == target_value.lower() for name in names):
+                                entity_id = getattr(entity, "id", None)
+                                if entity_id is not None:
+                                    target_entity_id = as_uuid(str(entity_id))
+                                    break
 
         if message.content and message.content.target:
             target = message.content.target
             if isinstance(target, dict):
                 room_str = target.get("roomId")
                 entity_str = target.get("entityId")
-                if room_str:
-                    with contextlib.suppress(ValueError):
-                        target_room_id_val = str(StdUUID(str(room_str)))
-                if entity_str:
-                    with contextlib.suppress(ValueError):
-                        target_entity_id = str(StdUUID(str(entity_str)))
-
-        if not target_room_id_val:
+                if room_str and target_type == "room":
+                    with contextlib.suppress(Exception):
+                        target_room_id = as_uuid(room_str)
+                if entity_str and target_type == "user":
+                    with contextlib.suppress(Exception):
+                        target_entity_id = as_uuid(entity_str)
+
+        if not target_room_id:
             return ActionResult(
                 text="No target room specified",
                 values={"success": False, "error": "no_target"},
@@ -109,27 +221,39 @@ class SendMessageAction:
 
         message_content = Content(
             text=message_text,
-            source="agent",
+            source=source,
             actions=["SEND_MESSAGE"],
         )
 
-        # Create the message memory for event emission
+        send_message_to_target = getattr(runtime, "send_message_to_target", None)
+        if callable(send_message_to_target):
+            with contextlib.suppress(Exception):
+                from elizaos.types.runtime import TargetInfo
+
+                await send_message_to_target(
+                    TargetInfo(
+                        roomId=str(target_room_id),
+                        entityId=str(target_entity_id) if target_entity_id else None,
+                        source=source,
+                    ),
+                    message_content,
+                )
+
+        # Create the message memory
         import time
         import uuid as uuid_module
 
-        from elizaos.types.primitives import as_uuid
-
         message_memory = MemoryType(
             id=as_uuid(str(uuid_module.uuid4())),
             entity_id=runtime.agent_id,
-            room_id=as_uuid(target_room_id_val) if target_room_id_val else None,
+            room_id=target_room_id,
             content=message_content,
             created_at=int(time.time() * 1000),
         )
 
         await runtime.create_memory(
             content=message_content,
-            room_id=target_room_id_val,
+            room_id=target_room_id,
             entity_id=runtime.agent_id,
             memory_type="message",
             metadata={
@@ -156,17 +280,26 @@ class SendMessageAction:
         if callback:
             await callback(response_content)
 
+        target_id = (
+            target_entity_id if target_type == "user" and target_entity_id else target_room_id
+        )
         return ActionResult(
-            text="Message sent to room",
+            text="Message sent",
             values={
                 "success": True,
                 "messageSent": True,
-                "targetRoomId": str(target_room_id_val),
+                "targetType": target_type,
+                "target": str(target_id),
+                "source": source,
+                "targetRoomId": str(target_room_id),
                 "targetEntityId": str(target_entity_id) if target_entity_id else None,
             },
             data={
                 "actionName": "SEND_MESSAGE",
-                "targetRoomId": str(target_room_id_val),
+                "targetType": target_type,
+                "target": str(target_id),
+                "source": source,
+                "targetRoomId": str(target_room_id),
                 "messagePreview": message_text[:100],
             },
             success=True,

package/elizaos/advanced_capabilities/actions/settings.py

@@ -7,7 +7,6 @@ from elizaos.bootstrap.utils.xml import parse_key_value_xml
 from elizaos.generated.spec_helpers import require_action_spec
 from elizaos.prompts import UPDATE_SETTINGS_TEMPLATE
 from elizaos.types import Action, ActionExample, ActionResult, Content, ModelType
-from elizaos.utils.spec_examples import convert_spec_examples
 
 if TYPE_CHECKING:
     from elizaos.types import HandlerCallback, HandlerOptions, IAgentRuntime, Memory, State
@@ -18,7 +17,22 @@ _spec = require_action_spec("UPDATE_SETTINGS")
 
 def _convert_spec_examples() -> list[list[ActionExample]]:
     """Convert spec examples to ActionExample format."""
-    return convert_spec_examples(_spec)
+    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 []
 
 
 @dataclass

package/elizaos/advanced_capabilities/actions/unfollow_room.py

@@ -16,34 +16,21 @@ _spec = require_action_spec("UNFOLLOW_ROOM")
 def _convert_spec_examples() -> list[list[ActionExample]]:
     """Convert spec examples to ActionExample format."""
     spec_examples = _spec.get("examples", [])
-    if not isinstance(spec_examples, list):
-        return []
-    result: list[list[ActionExample]] = []
-    for example in spec_examples:
-        if not isinstance(example, list):
-            continue
-        row: list[ActionExample] = []
-        for msg in example:
-            if not isinstance(msg, dict):
-                continue
-            content = msg.get("content", {})
-            text = ""
-            actions: list[str] | None = None
-            if isinstance(content, dict):
-                text_val = content.get("text", "")
-                text = str(text_val) if text_val else ""
-                actions_val = content.get("actions")
-                if isinstance(actions_val, list) and all(isinstance(a, str) for a in actions_val):
-                    actions = list(actions_val)
-            row.append(
+    if spec_examples:
+        return [
+            [
                 ActionExample(
-                    name=str(msg.get("name", "")),
-                    content=Content(text=text, actions=actions),
+                    name=msg.get("name", ""),
+                    content=Content(
+                        text=msg.get("content", {}).get("text", ""),
+                        actions=msg.get("content", {}).get("actions"),
+                    ),
                 )
-            )
-        if row:
-            result.append(row)
-    return result
+                for msg in example
+            ]
+            for example in spec_examples
+        ]
+    return []
 
 
 @dataclass

package/elizaos/advanced_capabilities/actions/unmute_room.py

@@ -16,34 +16,21 @@ _spec = require_action_spec("UNMUTE_ROOM")
 def _convert_spec_examples() -> list[list[ActionExample]]:
     """Convert spec examples to ActionExample format."""
     spec_examples = _spec.get("examples", [])
-    if not isinstance(spec_examples, list):
-        return []
-    result: list[list[ActionExample]] = []
-    for example in spec_examples:
-        if not isinstance(example, list):
-            continue
-        row: list[ActionExample] = []
-        for msg in example:
-            if not isinstance(msg, dict):
-                continue
-            content = msg.get("content", {})
-            text = ""
-            actions: list[str] | None = None
-            if isinstance(content, dict):
-                text_val = content.get("text", "")
-                text = str(text_val) if text_val else ""
-                actions_val = content.get("actions")
-                if isinstance(actions_val, list) and all(isinstance(a, str) for a in actions_val):
-                    actions = list(actions_val)
-            row.append(
+    if spec_examples:
+        return [
+            [
                 ActionExample(
-                    name=str(msg.get("name", "")),
-                    content=Content(text=text, actions=actions),
+                    name=msg.get("name", ""),
+                    content=Content(
+                        text=msg.get("content", {}).get("text", ""),
+                        actions=msg.get("content", {}).get("actions"),
+                    ),
                 )
-            )
-        if row:
-            result.append(row)
-    return result
+                for msg in example
+            ]
+            for example in spec_examples
+        ]
+    return []
 
 
 @dataclass

package/elizaos/advanced_capabilities/actions/update_contact.py

@@ -13,7 +13,6 @@ from elizaos.types import (
     Content,
     ModelType,
 )
-from elizaos.utils.spec_examples import convert_spec_examples
 
 if TYPE_CHECKING:
     from elizaos.types import (
@@ -30,7 +29,22 @@ _spec = require_action_spec("UPDATE_CONTACT")
 
 def _convert_spec_examples() -> list[list[ActionExample]]:
     """Convert spec examples to ActionExample format."""
-    return convert_spec_examples(_spec)
+    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 []
 
 
 @dataclass

package/elizaos/advanced_capabilities/actions/update_entity.py

@@ -8,7 +8,6 @@ from elizaos.bootstrap.utils.xml import parse_key_value_xml
 from elizaos.generated.spec_helpers import require_action_spec
 from elizaos.prompts import UPDATE_ENTITY_TEMPLATE
 from elizaos.types import Action, ActionExample, ActionResult, Content, ModelType
-from elizaos.utils.spec_examples import convert_spec_examples
 
 if TYPE_CHECKING:
     from elizaos.types import HandlerCallback, HandlerOptions, IAgentRuntime, Memory, State
@@ -19,7 +18,22 @@ _spec = require_action_spec("UPDATE_ENTITY")
 
 def _convert_spec_examples() -> list[list[ActionExample]]:
     """Convert spec examples to ActionExample format."""
-    return convert_spec_examples(_spec)
+    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 []
 
 
 @dataclass

package/elizaos/advanced_capabilities/evaluators/__init__.py

@@ -3,16 +3,9 @@
 Evaluators that can be enabled with `advanced_capabilities=True`.
 """
 
-from .reflection import reflection_evaluator
-from .relationship_extraction import relationship_extraction_evaluator
-
 __all__ = [
-    "reflection_evaluator",
-    "relationship_extraction_evaluator",
     "advanced_evaluators",
 ]
 
-advanced_evaluators = [
-    reflection_evaluator,
-    relationship_extraction_evaluator,
-]
+# Relationship evaluators are owned by the plugin-rolodex package.
+advanced_evaluators: list = []

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