@elizaos/python 2.0.0-alpha.10

package/elizaos/bootstrap/actions/reply.py

@@ -0,0 +1,140 @@
+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 REPLY_TEMPLATE
+from elizaos.types import (
+    Action,
+    ActionExample,
+    ActionResult,
+    Content,
+    ModelType,
+)
+
+if TYPE_CHECKING:
+    from elizaos.types import (
+        HandlerCallback,
+        HandlerOptions,
+        IAgentRuntime,
+        Memory,
+        State,
+    )
+
+# Get text content from centralized specs
+_spec = require_action_spec("REPLY")
+
+
+def _convert_spec_examples() -> list[list[ActionExample]]:
+    """Convert spec examples to ActionExample format."""
+    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
+class ReplyAction:
+    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:
+        all_providers: list[str] = []
+        if responses:
+            for res in responses:
+                if res.content and res.content.providers:
+                    all_providers.extend(res.content.providers)
+
+        state = await runtime.compose_state(
+            message, [*all_providers, "RECENT_MESSAGES", "ACTION_STATE"]
+        )
+
+        template = REPLY_TEMPLATE
+        if runtime.character.templates and "replyTemplate" in runtime.character.templates:
+            template = runtime.character.templates["replyTemplate"]
+
+        prompt = runtime.compose_prompt_from_state(state=state, template=template)
+
+        response = await runtime.use_model(
+            ModelType.TEXT_LARGE,
+            {
+                "prompt": prompt,
+                "system": str(runtime.character.system or ""),
+            },
+        )
+
+        parsed = parse_key_value_xml(response)
+        thought = parsed.get("thought", "") if parsed else ""
+        text = parsed.get("text", "") if parsed else ""
+
+        thought = str(thought) if thought else ""
+        text = str(text) if text else ""
+
+        response_content = Content(
+            thought=thought,
+            text=text,
+            actions=["REPLY"],
+        )
+
+        if callback:
+            await callback(response_content)
+
+        return ActionResult(
+            text=f"Generated reply: {text}",
+            values={
+                "success": True,
+                "responded": True,
+                "lastReply": text,
+                "lastReplyTime": runtime.get_current_time_ms(),
+                "thoughtProcess": thought,
+            },
+            data={
+                "actionName": "REPLY",
+                "responseThought": thought,
+                "responseText": text,
+                "messageGenerated": True,
+            },
+            success=True,
+        )
+
+    @property
+    def examples(self) -> list[list[ActionExample]]:
+        return _convert_spec_examples()
+
+
+reply_action = Action(
+    name=ReplyAction.name,
+    similes=ReplyAction().similes,
+    description=ReplyAction.description,
+    validate=ReplyAction().validate,
+    handler=ReplyAction().handler,
+    examples=ReplyAction().examples,
+)

package/elizaos/bootstrap/actions/roles.py

@@ -0,0 +1,193 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import Enum
+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.types import Action, ActionExample, ActionResult, Content, ModelType
+
+if TYPE_CHECKING:
+    from elizaos.types import HandlerCallback, HandlerOptions, IAgentRuntime, Memory, State
+
+# Get text content from centralized specs
+_spec = require_action_spec("UPDATE_ROLE")
+
+
+def _convert_spec_examples() -> list[list[ActionExample]]:
+    """Convert spec examples to ActionExample format."""
+    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 []
+
+
+class Role(str, Enum):
+    OWNER = "OWNER"
+    ADMIN = "ADMIN"
+    MEMBER = "MEMBER"
+    GUEST = "GUEST"
+    NONE = "NONE"
+
+
+@dataclass
+class UpdateRoleAction:
+    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 or room.world_id is None:
+            return False
+
+        world = await runtime.get_world(room.world_id)
+        if world is None or world.metadata is None:
+            return False
+
+        roles = world.metadata.get("roles", {})
+        agent_role = roles.get(str(runtime.agent_id), Role.NONE.value)
+
+        return agent_role in (Role.OWNER.value, Role.ADMIN.value)
+
+    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_ROLE action")
+
+        room_id = message.room_id
+        if not room_id:
+            return ActionResult(
+                text="No room context for role update",
+                values={"success": False, "error": "no_room_id"},
+                data={"actionName": "UPDATE_ROLE"},
+                success=False,
+            )
+
+        room = await runtime.get_room(room_id)
+        if room is None or room.world_id is None:
+            return ActionResult(
+                text="Room or world not found",
+                values={"success": False, "error": "room_not_found"},
+                data={"actionName": "UPDATE_ROLE"},
+                success=False,
+            )
+
+        world = await runtime.get_world(room.world_id)
+        if world is None or world.metadata is None:
+            return ActionResult(
+                text="World not found",
+                values={"success": False, "error": "world_not_found"},
+                data={"actionName": "UPDATE_ROLE"},
+                success=False,
+            )
+
+        state = await runtime.compose_state(
+            message, ["RECENT_MESSAGES", "ACTION_STATE", "WORLD_INFO"]
+        )
+
+        current_roles = world.metadata.get("roles", {})
+        roles_context = "\n".join(
+            f"- {entity_id}: {role}" for entity_id, role in current_roles.items()
+        )
+
+        template = (
+            runtime.character.templates.get("updateRoleTemplate")
+            if runtime.character.templates and "updateRoleTemplate" in runtime.character.templates
+            else UPDATE_ROLE_TEMPLATE
+        )
+        prompt = runtime.compose_prompt(state=state, template=template)
+        prompt = prompt.replace("{{roles}}", roles_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", ""))
+        entity_id_str = str(parsed_xml.get("entity_id", ""))
+        new_role_str = str(parsed_xml.get("new_role", "")).upper()
+
+        if not entity_id_str:
+            raise ValueError("No entity ID provided")
+
+        if new_role_str not in [r.value for r in Role]:
+            raise ValueError(f"Invalid role: {new_role_str}")
+
+        entity_id = UUID(entity_id_str)
+
+        roles = dict(world.metadata.get("roles", {}))
+        old_role = roles.get(str(entity_id), Role.NONE.value)
+        roles[str(entity_id)] = new_role_str
+        world.metadata["roles"] = roles
+
+        await runtime.update_world(world)
+
+        response_content = Content(
+            text=f"Updated role for {entity_id_str}: {old_role} -> {new_role_str}",
+            actions=["UPDATE_ROLE"],
+        )
+
+        if callback:
+            await callback(response_content)
+
+        return ActionResult(
+            text=f"Role updated: {entity_id_str} is now {new_role_str}",
+            values={
+                "success": True,
+                "roleUpdated": True,
+                "entityId": str(entity_id),
+                "oldRole": old_role,
+                "newRole": new_role_str,
+            },
+            data={
+                "actionName": "UPDATE_ROLE",
+                "entityId": str(entity_id),
+                "oldRole": old_role,
+                "newRole": new_role_str,
+                "thought": thought,
+            },
+            success=True,
+        )
+
+    @property
+    def examples(self) -> list[list[ActionExample]]:
+        return _convert_spec_examples()
+
+
+update_role_action = Action(
+    name=UpdateRoleAction.name,
+    similes=UpdateRoleAction().similes,
+    description=UpdateRoleAction.description,
+    validate=UpdateRoleAction().validate,
+    handler=UpdateRoleAction().handler,
+    examples=UpdateRoleAction().examples,
+)

package/elizaos/bootstrap/actions/schedule_follow_up.py

@@ -0,0 +1,164 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime
+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 SCHEDULE_FOLLOW_UP_TEMPLATE
+from elizaos.types import (
+    Action,
+    ActionExample,
+    ActionResult,
+    Content,
+    ModelType,
+)
+
+if TYPE_CHECKING:
+    from elizaos.types import (
+        HandlerCallback,
+        HandlerOptions,
+        IAgentRuntime,
+        Memory,
+        State,
+    )
+
+# Get text content from centralized specs
+_spec = require_action_spec("SCHEDULE_FOLLOW_UP")
+
+
+def _convert_spec_examples() -> list[list[ActionExample]]:
+    """Convert spec examples to ActionExample format."""
+    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
+class ScheduleFollowUpAction:
+    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")
+        follow_up_service = runtime.get_service("follow_up")
+        return rolodex_service is not None and follow_up_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.follow_up import FollowUpService
+        from elizaos.bootstrap.services.rolodex import RolodexService
+
+        rolodex_service = runtime.get_service("rolodex")
+        follow_up_service = runtime.get_service("follow_up")
+
+        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"},
+            )
+
+        if not follow_up_service or not isinstance(follow_up_service, FollowUpService):
+            return ActionResult(
+                text="Follow-up service not available",
+                success=False,
+                values={"error": True},
+                data={"error": "FollowUpService not available"},
+            )
+
+        state = await runtime.compose_state(message, ["RECENT_MESSAGES", "ENTITIES"])
+        state.values["currentDateTime"] = datetime.utcnow().isoformat()
+
+        prompt = runtime.compose_prompt_from_state(
+            state=state,
+            template=SCHEDULE_FOLLOW_UP_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 extract follow-up information",
+                success=False,
+                values={"error": True},
+                data={"error": "Failed to parse follow-up info"},
+            )
+
+        contact_name = str(parsed.get("contactName", ""))
+        scheduled_at_str = str(parsed.get("scheduledAt", ""))
+        reason = str(parsed.get("reason", "Follow-up"))
+        priority = str(parsed.get("priority", "medium"))
+        follow_up_message = str(parsed.get("message", ""))
+
+        scheduled_at = datetime.fromisoformat(scheduled_at_str.replace("Z", "+00:00"))
+
+        entity_id = message.entity_id
+        await follow_up_service.schedule_follow_up(
+            entity_id=entity_id,
+            scheduled_at=scheduled_at,
+            reason=reason,
+            priority=priority,
+            message=follow_up_message,
+        )
+
+        response_text = f"I've scheduled a follow-up with {contact_name} for {scheduled_at.strftime('%B %d, %Y')}. Reason: {reason}"
+
+        if callback:
+            await callback(Content(text=response_text, actions=["SCHEDULE_FOLLOW_UP"]))
+
+        return ActionResult(
+            text=response_text,
+            success=True,
+            values={
+                "contactId": str(entity_id),
+                "scheduledAt": scheduled_at.isoformat(),
+            },
+            data={
+                "contactId": str(entity_id),
+                "contactName": contact_name,
+                "scheduledAt": scheduled_at.isoformat(),
+                "reason": reason,
+                "priority": priority,
+            },
+        )
+
+    @property
+    def examples(self) -> list[list[ActionExample]]:
+        return _convert_spec_examples()
+
+
+schedule_follow_up_action = Action(
+    name=ScheduleFollowUpAction.name,
+    similes=ScheduleFollowUpAction().similes,
+    description=ScheduleFollowUpAction.description,
+    validate=ScheduleFollowUpAction().validate,
+    handler=ScheduleFollowUpAction().handler,
+    examples=ScheduleFollowUpAction().examples,
+)

package/elizaos/bootstrap/actions/search_contacts.py

@@ -0,0 +1,159 @@
+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,
+)
+
+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."""
+    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
+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(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,
+)