@elizaos/python 2.0.0-alpha.10

package/elizaos/advanced_capabilities/actions/search_contacts.py

@@ -0,0 +1,145 @@
+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 SEARCH_CONTACTS_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("SEARCH_CONTACTS")
+
+
+def _convert_spec_examples() -> list[list[ActionExample]]:
+    """Convert spec examples to ActionExample format."""
+    return convert_spec_examples(_spec)
+
+
+@dataclass
+class SearchContactsAction:
+    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"])
+
+        prompt = runtime.compose_prompt_from_state(
+            state=state,
+            template=SEARCH_CONTACTS_TEMPLATE,
+        )
+
+        response = await runtime.use_model(ModelType.TEXT_SMALL, {"prompt": prompt})
+        parsed = parse_key_value_xml(response)
+
+        categories = None
+        tags = None
+        search_term = None
+
+        if parsed:
+            if parsed.get("categories"):
+                categories = [c.strip() for c in str(parsed["categories"]).split(",") if c.strip()]
+            if parsed.get("searchTerm"):
+                search_term = str(parsed["searchTerm"])
+            if parsed.get("tags"):
+                tags = [t.strip() for t in str(parsed["tags"]).split(",") if t.strip()]
+
+        contacts = await rolodex_service.search_contacts(
+            categories=categories,
+            tags=tags,
+            search_term=search_term,
+        )
+
+        contact_details: list[dict[str, str]] = []
+        for contact in contacts:
+            entity = await runtime.get_entity(str(contact.entity_id))
+            name = entity.name if entity and entity.name else "Unknown"
+            contact_details.append(
+                {
+                    "id": str(contact.entity_id),
+                    "name": name,
+                    "categories": ",".join(contact.categories),
+                    "tags": ",".join(contact.tags),
+                }
+            )
+
+        if not contact_details:
+            response_text = "No contacts found matching your criteria."
+        else:
+            response_text = f"I found {len(contact_details)} contact(s):\n"
+            for detail in contact_details:
+                response_text += f"- {detail['name']}"
+                if detail["categories"]:
+                    response_text += f" [{detail['categories']}]"
+                response_text += "\n"
+
+        if callback:
+            await callback(Content(text=response_text.strip(), actions=["SEARCH_CONTACTS"]))
+
+        return ActionResult(
+            text=response_text.strip(),
+            success=True,
+            values={
+                "count": len(contact_details),
+            },
+            data={
+                "count": len(contact_details),
+            },
+        )
+
+    @property
+    def examples(self) -> list[list[ActionExample]]:
+        return _convert_spec_examples()
+
+
+search_contacts_action = Action(
+    name=SearchContactsAction.name,
+    similes=SearchContactsAction().similes,
+    description=SearchContactsAction.description,
+    validate=SearchContactsAction().validate,
+    handler=SearchContactsAction().handler,
+    examples=SearchContactsAction().examples,
+)

package/elizaos/advanced_capabilities/actions/send_message.py

@@ -0,0 +1,187 @@
+from __future__ import annotations
+
+import contextlib
+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
+from elizaos.types.memory import Memory as MemoryType
+
+if TYPE_CHECKING:
+    from elizaos.types import HandlerCallback, HandlerOptions, IAgentRuntime, Memory, State
+
+# Get text content from centralized specs
+_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(
+                ActionExample(
+                    name=str(msg.get("name", "")),
+                    content=Content(text=text, actions=actions),
+                )
+            )
+        if row:
+            result.append(row)
+    return result
+
+
+@dataclass
+class SendMessageAction:
+    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:
+        if message.content and message.content.target:
+            return True
+        return True
+
+    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:
+        message_text = ""
+        if responses and responses[0].content:
+            message_text = str(responses[0].content.text or "")
+
+        if not message_text:
+            return ActionResult(
+                text="No message content to send",
+                values={"success": False, "error": "no_content"},
+                data={"actionName": "SEND_MESSAGE"},
+                success=False,
+            )
+
+        from uuid import UUID as StdUUID
+
+        target_room_id_val: str | None = str(message.room_id) if message.room_id else None
+        target_entity_id: str | None = None
+
+        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:
+            return ActionResult(
+                text="No target room specified",
+                values={"success": False, "error": "no_target"},
+                data={"actionName": "SEND_MESSAGE"},
+                success=False,
+            )
+
+        message_content = Content(
+            text=message_text,
+            source="agent",
+            actions=["SEND_MESSAGE"],
+        )
+
+        # Create the message memory for event emission
+        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,
+            content=message_content,
+            created_at=int(time.time() * 1000),
+        )
+
+        await runtime.create_memory(
+            content=message_content,
+            room_id=target_room_id_val,
+            entity_id=runtime.agent_id,
+            memory_type="message",
+            metadata={
+                "type": "SEND_MESSAGE",
+                "targetEntityId": str(target_entity_id) if target_entity_id else None,
+            },
+        )
+
+        # Emit MESSAGE_SENT event
+        await runtime.emit_event(
+            "MESSAGE_SENT",
+            {
+                "runtime": runtime,
+                "source": "send-message-action",
+                "message": message_memory,
+            },
+        )
+
+        response_content = Content(
+            text=f"Message sent: {message_text[:50]}...",
+            actions=["SEND_MESSAGE"],
+        )
+
+        if callback:
+            await callback(response_content)
+
+        return ActionResult(
+            text="Message sent to room",
+            values={
+                "success": True,
+                "messageSent": True,
+                "targetRoomId": str(target_room_id_val),
+                "targetEntityId": str(target_entity_id) if target_entity_id else None,
+            },
+            data={
+                "actionName": "SEND_MESSAGE",
+                "targetRoomId": str(target_room_id_val),
+                "messagePreview": message_text[:100],
+            },
+            success=True,
+        )
+
+    @property
+    def examples(self) -> list[list[ActionExample]]:
+        return _convert_spec_examples()
+
+
+send_message_action = Action(
+    name=SendMessageAction.name,
+    similes=SendMessageAction().similes,
+    description=SendMessageAction.description,
+    validate=SendMessageAction().validate,
+    handler=SendMessageAction().handler,
+    examples=SendMessageAction().examples,
+)

package/elizaos/advanced_capabilities/actions/settings.py

@@ -0,0 +1,151 @@
+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_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
+
+# Get text content from centralized specs
+_spec = require_action_spec("UPDATE_SETTINGS")
+
+
+def _convert_spec_examples() -> list[list[ActionExample]]:
+    """Convert spec examples to ActionExample format."""
+    return convert_spec_examples(_spec)
+
+
+@dataclass
+class SettingUpdate:
+    key: str
+    value: str
+
+
+@dataclass
+class UpdateSettingsAction:
+    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 True
+
+    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_SETTINGS action")
+
+        state = await runtime.compose_state(
+            message, ["RECENT_MESSAGES", "ACTION_STATE", "AGENT_SETTINGS"]
+        )
+
+        current_settings = runtime.get_all_settings()
+        settings_context = "\n".join(
+            f"- {key}: {value}"
+            for key, value in current_settings.items()
+            if not key.lower().endswith(("key", "secret", "password", "token"))
+        )
+
+        template = (
+            runtime.character.templates.get("updateSettingsTemplate")
+            if runtime.character.templates
+            and "updateSettingsTemplate" in runtime.character.templates
+            else UPDATE_SETTINGS_TEMPLATE
+        )
+        prompt = runtime.compose_prompt(state=state, template=template)
+        prompt = prompt.replace("{{settings}}", settings_context)
+
+        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", ""))
+        updates_raw = parsed_xml.get("updates", [])
+
+        updated_settings: list[SettingUpdate] = []
+
+        if isinstance(updates_raw, list):
+            for update in updates_raw:
+                if isinstance(update, dict):
+                    key = str(update.get("key", ""))
+                    value = str(update.get("value", ""))
+                    if key and value:
+                        updated_settings.append(SettingUpdate(key=key, value=value))
+        elif isinstance(updates_raw, dict):
+            update_list = updates_raw.get("update", [])
+            if isinstance(update_list, dict):
+                update_list = [update_list]
+            for update in update_list:
+                if isinstance(update, dict):
+                    key = str(update.get("key", ""))
+                    value = str(update.get("value", ""))
+                    if key and value:
+                        updated_settings.append(SettingUpdate(key=key, value=value))
+
+        if not updated_settings:
+            return ActionResult(
+                text="No settings to update",
+                values={"success": True, "noChanges": True},
+                data={"actionName": "UPDATE_SETTINGS", "thought": thought},
+                success=True,
+            )
+
+        for setting in updated_settings:
+            runtime.set_setting(setting.key, setting.value)
+
+        updated_keys = [s.key for s in updated_settings]
+
+        response_content = Content(
+            text=f"Updated {len(updated_settings)} setting(s): {', '.join(updated_keys)}",
+            actions=["UPDATE_SETTINGS"],
+        )
+
+        if callback:
+            await callback(response_content)
+
+        return ActionResult(
+            text=f"Updated settings: {', '.join(updated_keys)}",
+            values={
+                "success": True,
+                "settingsUpdated": True,
+                "updatedCount": len(updated_settings),
+                "updatedKeys": ", ".join(updated_keys),
+            },
+            data={
+                "actionName": "UPDATE_SETTINGS",
+                "updatedSettings": updated_keys,
+                "thought": thought,
+            },
+            success=True,
+        )
+
+    @property
+    def examples(self) -> list[list[ActionExample]]:
+        return _convert_spec_examples()
+
+
+update_settings_action = Action(
+    name=UpdateSettingsAction.name,
+    similes=UpdateSettingsAction().similes,
+    description=UpdateSettingsAction.description,
+    validate=UpdateSettingsAction().validate,
+    handler=UpdateSettingsAction().handler,
+    examples=UpdateSettingsAction().examples,
+)

package/elizaos/advanced_capabilities/actions/unfollow_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("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(
+                ActionExample(
+                    name=str(msg.get("name", "")),
+                    content=Content(text=text, actions=actions),
+                )
+            )
+        if row:
+            result.append(row)
+    return result
+
+
+@dataclass
+class UnfollowRoomAction:
+    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:
+                followed_rooms = world.metadata.get("followedRooms", [])
+                if str(room_id) in followed_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 unfollow",
+                values={"success": False, "error": "no_room_id"},
+                data={"actionName": "UNFOLLOW_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": "UNFOLLOW_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:
+                followed_rooms = list(world.metadata.get("followedRooms", []))
+                room_id_str = str(room_id)
+
+                if room_id_str in followed_rooms:
+                    followed_rooms.remove(room_id_str)
+                    world.metadata["followedRooms"] = followed_rooms
+                    await runtime.update_world(world)
+
+        await runtime.create_memory(
+            content=Content(
+                text=f"Stopped following room: {room_name}",
+                actions=["UNFOLLOW_ROOM"],
+            ),
+            room_id=room_id,
+            entity_id=runtime.agent_id,
+            memory_type="action",
+            metadata={"type": "UNFOLLOW_ROOM", "roomName": room_name},
+        )
+
+        response_content = Content(
+            text=f"I am no longer following {room_name}.",
+            actions=["UNFOLLOW_ROOM"],
+        )
+
+        if callback:
+            await callback(response_content)
+
+        return ActionResult(
+            text=f"Stopped following room: {room_name}",
+            values={
+                "success": True,
+                "unfollowed": True,
+                "roomId": str(room_id),
+                "roomName": room_name,
+            },
+            data={
+                "actionName": "UNFOLLOW_ROOM",
+                "roomId": str(room_id),
+                "roomName": room_name,
+            },
+            success=True,
+        )
+
+    @property
+    def examples(self) -> list[list[ActionExample]]:
+        return _convert_spec_examples()
+
+
+unfollow_room_action = Action(
+    name=UnfollowRoomAction.name,
+    similes=UnfollowRoomAction().similes,
+    description=UnfollowRoomAction.description,
+    validate=UnfollowRoomAction().validate,
+    handler=UnfollowRoomAction().handler,
+    examples=UnfollowRoomAction().examples,
+)