@elizaos/python 2.0.0-alpha.10

package/elizaos/advanced_capabilities/actions/unmute_room.py

@@ -0,0 +1,164 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
+
+from elizaos.generated.spec_helpers import require_action_spec
+from elizaos.types import Action, ActionExample, ActionResult, Content
+
+if TYPE_CHECKING:
+    from elizaos.types import HandlerCallback, HandlerOptions, IAgentRuntime, Memory, State
+
+# Get text content from centralized specs
+_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(
+                ActionExample(
+                    name=str(msg.get("name", "")),
+                    content=Content(text=text, actions=actions),
+                )
+            )
+        if row:
+            result.append(row)
+    return result
+
+
+@dataclass
+class UnmuteRoomAction:
+    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:
+        room_id = message.room_id
+        if not room_id:
+            return False
+
+        room = await runtime.get_room(room_id)
+        if room is None:
+            return False
+
+        world_id = room.world_id
+        if world_id:
+            world = await runtime.get_world(world_id)
+            if world and world.metadata:
+                muted_rooms = world.metadata.get("mutedRooms", [])
+                if str(room_id) in muted_rooms:
+                    return True
+
+        return False
+
+    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:
+        room_id = message.room_id
+        if not room_id:
+            return ActionResult(
+                text="No room specified to unmute",
+                values={"success": False, "error": "no_room_id"},
+                data={"actionName": "UNMUTE_ROOM"},
+                success=False,
+            )
+
+        room = await runtime.get_room(room_id)
+        if room is None:
+            return ActionResult(
+                text="Room not found",
+                values={"success": False, "error": "room_not_found"},
+                data={"actionName": "UNMUTE_ROOM"},
+                success=False,
+            )
+
+        room_name = str(room.name) if room.name else "Unknown Room"
+
+        world_id = room.world_id
+        if world_id:
+            world = await runtime.get_world(world_id)
+            if world and world.metadata:
+                muted_rooms = list(world.metadata.get("mutedRooms", []))
+                room_id_str = str(room_id)
+
+                if room_id_str in muted_rooms:
+                    muted_rooms.remove(room_id_str)
+                    world.metadata["mutedRooms"] = muted_rooms
+                    await runtime.update_world(world)
+
+        await runtime.create_memory(
+            content=Content(
+                text=f"Unmuted room: {room_name}",
+                actions=["UNMUTE_ROOM"],
+            ),
+            room_id=room_id,
+            entity_id=runtime.agent_id,
+            memory_type="action",
+            metadata={"type": "UNMUTE_ROOM", "roomName": room_name},
+        )
+
+        response_content = Content(
+            text=f"I have unmuted {room_name}. I will now respond to messages there.",
+            actions=["UNMUTE_ROOM"],
+        )
+
+        if callback:
+            await callback(response_content)
+
+        return ActionResult(
+            text=f"Unmuted room: {room_name}",
+            values={
+                "success": True,
+                "unmuted": True,
+                "roomId": str(room_id),
+                "roomName": room_name,
+            },
+            data={
+                "actionName": "UNMUTE_ROOM",
+                "roomId": str(room_id),
+                "roomName": room_name,
+            },
+            success=True,
+        )
+
+    @property
+    def examples(self) -> list[list[ActionExample]]:
+        return _convert_spec_examples()
+
+
+unmute_room_action = Action(
+    name=UnmuteRoomAction.name,
+    similes=UnmuteRoomAction().similes,
+    description=UnmuteRoomAction.description,
+    validate=UnmuteRoomAction().validate,
+    handler=UnmuteRoomAction().handler,
+    examples=UnmuteRoomAction().examples,
+)

package/elizaos/advanced_capabilities/actions/update_contact.py

@@ -0,0 +1,164 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
+
+from elizaos.bootstrap.utils.xml import parse_key_value_xml
+from elizaos.generated.spec_helpers import require_action_spec
+from elizaos.prompts import UPDATE_CONTACT_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,
+    )
+
+# Get text content from centralized specs
+_spec = require_action_spec("UPDATE_CONTACT")
+
+
+def _convert_spec_examples() -> list[list[ActionExample]]:
+    """Convert spec examples to ActionExample format."""
+    return convert_spec_examples(_spec)
+
+
+@dataclass
+class UpdateContactAction:
+    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")
+        return rolodex_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.rolodex import RolodexService
+
+        rolodex_service = runtime.get_service("rolodex")
+        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"},
+            )
+
+        state = await runtime.compose_state(message, ["RECENT_MESSAGES", "ENTITIES"])
+
+        prompt = runtime.compose_prompt_from_state(
+            state=state,
+            template=UPDATE_CONTACT_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 determine which contact to update",
+                success=False,
+                values={"error": True},
+                data={"error": "No contact name provided"},
+            )
+
+        contact_name = str(parsed.get("contactName", ""))
+        operation = str(parsed.get("operation", "replace"))
+
+        contacts = await rolodex_service.search_contacts(search_term=contact_name)
+
+        if not contacts:
+            return ActionResult(
+                text=f"Could not find a contact named '{contact_name}'",
+                success=False,
+                values={"error": True},
+                data={"error": "Contact not found"},
+            )
+
+        contact = contacts[0]
+
+        categories = None
+        tags = None
+
+        if parsed.get("categories"):
+            new_categories = [c.strip() for c in str(parsed["categories"]).split(",") if c.strip()]
+            if operation == "add_to" and contact.categories:
+                categories = list(set(contact.categories + new_categories))
+            else:
+                categories = new_categories
+
+        if parsed.get("tags"):
+            new_tags = [t.strip() for t in str(parsed["tags"]).split(",") if t.strip()]
+            if operation == "add_to" and contact.tags:
+                tags = list(set(contact.tags + new_tags))
+            else:
+                tags = new_tags
+
+        updated = await rolodex_service.update_contact(
+            entity_id=contact.entity_id,
+            categories=categories,
+            tags=tags,
+        )
+
+        if updated:
+            response_text = f"I've updated {contact_name}'s contact information."
+            if categories:
+                response_text += f" Categories: {', '.join(categories)}."
+            if tags:
+                response_text += f" Tags: {', '.join(tags)}."
+
+            if callback:
+                await callback(Content(text=response_text, actions=["UPDATE_CONTACT"]))
+
+            return ActionResult(
+                text=response_text,
+                success=True,
+                values={
+                    "contactId": str(contact.entity_id),
+                    "categoriesStr": ",".join(categories) if categories else "",
+                    "tagsStr": ",".join(tags) if tags else "",
+                },
+                data={"success": True},
+            )
+        else:
+            return ActionResult(
+                text="Failed to update contact",
+                success=False,
+                values={"error": True},
+                data={"error": "Update operation failed"},
+            )
+
+    @property
+    def examples(self) -> list[list[ActionExample]]:
+        return _convert_spec_examples()
+
+
+update_contact_action = Action(
+    name=UpdateContactAction.name,
+    similes=UpdateContactAction().similes,
+    description=UpdateContactAction.description,
+    validate=UpdateContactAction().validate,
+    handler=UpdateContactAction().handler,
+    examples=UpdateContactAction().examples,
+)

package/elizaos/advanced_capabilities/actions/update_entity.py

@@ -0,0 +1,161 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
+from uuid import UUID
+
+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
+
+# Get text content from centralized specs
+_spec = require_action_spec("UPDATE_ENTITY")
+
+
+def _convert_spec_examples() -> list[list[ActionExample]]:
+    """Convert spec examples to ActionExample format."""
+    return convert_spec_examples(_spec)
+
+
+@dataclass
+class UpdateEntityAction:
+    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:
+        return message.entity_id 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:
+        if state is None:
+            raise ValueError("State is required for UPDATE_ENTITY action")
+
+        entity_id = message.entity_id
+        if not entity_id:
+            return ActionResult(
+                text="No entity specified to update",
+                values={"success": False, "error": "no_entity_id"},
+                data={"actionName": "UPDATE_ENTITY"},
+                success=False,
+            )
+
+        entity = await runtime.get_entity(entity_id)
+        if entity is None:
+            return ActionResult(
+                text="Entity not found",
+                values={"success": False, "error": "entity_not_found"},
+                data={"actionName": "UPDATE_ENTITY"},
+                success=False,
+            )
+
+        state = await runtime.compose_state(
+            message, ["RECENT_MESSAGES", "ACTION_STATE", "ENTITY_INFO"]
+        )
+
+        entity_info = f"""
+Entity ID: {entity.id}
+Name: {entity.name or "Unknown"}
+Type: {entity.entity_type or "Unknown"}
+"""
+        if entity.metadata:
+            entity_info += f"Metadata: {entity.metadata}"
+
+        template = (
+            runtime.character.templates.get("updateEntityTemplate")
+            if runtime.character.templates and "updateEntityTemplate" in runtime.character.templates
+            else UPDATE_ENTITY_TEMPLATE
+        )
+        prompt = runtime.compose_prompt(state=state, template=template)
+        prompt = prompt.replace("{{entityInfo}}", entity_info)
+
+        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 XML response")
+
+        thought = str(parsed_xml.get("thought", ""))
+        target_entity_id_str = str(parsed_xml.get("entity_id", str(entity_id)))
+
+        target_entity_id = UUID(target_entity_id_str)
+
+        updates_raw = parsed_xml.get("updates", {})
+        updated_fields: list[str] = []
+
+        if isinstance(updates_raw, dict):
+            field_list = updates_raw.get("field", [])
+            if isinstance(field_list, dict):
+                field_list = [field_list]
+            for field_update in field_list:
+                if isinstance(field_update, dict):
+                    field_name = str(field_update.get("name", ""))
+                    field_value = str(field_update.get("value", ""))
+                    if field_name and field_value:
+                        if entity.metadata is None:
+                            entity.metadata = {}
+                        entity.metadata[field_name] = field_value
+                        updated_fields.append(field_name)
+
+        if not updated_fields:
+            return ActionResult(
+                text="No fields to update",
+                values={"success": True, "noChanges": True},
+                data={"actionName": "UPDATE_ENTITY", "thought": thought},
+                success=True,
+            )
+
+        await runtime.update_entity(entity)
+
+        response_content = Content(
+            text=f"Updated entity fields: {', '.join(updated_fields)}",
+            actions=["UPDATE_ENTITY"],
+        )
+
+        if callback:
+            await callback(response_content)
+
+        return ActionResult(
+            text=f"Updated entity: {', '.join(updated_fields)}",
+            values={
+                "success": True,
+                "entityUpdated": True,
+                "entityId": str(target_entity_id),
+                "updatedFields": ", ".join(updated_fields),
+            },
+            data={
+                "actionName": "UPDATE_ENTITY",
+                "entityId": str(target_entity_id),
+                "updatedFields": updated_fields,
+                "thought": thought,
+            },
+            success=True,
+        )
+
+    @property
+    def examples(self) -> list[list[ActionExample]]:
+        return _convert_spec_examples()
+
+
+update_entity_action = Action(
+    name=UpdateEntityAction.name,
+    similes=UpdateEntityAction().similes,
+    description=UpdateEntityAction.description,
+    validate=UpdateEntityAction().validate,
+    handler=UpdateEntityAction().handler,
+    examples=UpdateEntityAction().examples,
+)

package/elizaos/advanced_capabilities/evaluators/__init__.py

@@ -0,0 +1,18 @@
+"""Advanced Evaluators - Extended evaluators for agent operation.
+
+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,
+]

package/elizaos/advanced_capabilities/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=[],
+)