@elizaos/python 2.0.0-alpha.10

package/elizaos/basic_capabilities/services/task.py

@@ -0,0 +1,178 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import UTC, datetime
+from enum import Enum
+from typing import TYPE_CHECKING
+from uuid import UUID, uuid4
+
+from elizaos.types import Service, ServiceType
+
+if TYPE_CHECKING:
+    from elizaos.types import IAgentRuntime
+
+
+class TaskStatus(str, Enum):
+    PENDING = "PENDING"
+    IN_PROGRESS = "IN_PROGRESS"
+    COMPLETED = "COMPLETED"
+    FAILED = "FAILED"
+    CANCELLED = "CANCELLED"
+
+
+class TaskPriority(str, Enum):
+    LOW = "LOW"
+    MEDIUM = "MEDIUM"
+    HIGH = "HIGH"
+    URGENT = "URGENT"
+
+
+@dataclass
+class Task:
+    id: UUID
+    name: str
+    description: str
+    status: TaskStatus
+    priority: TaskPriority
+    created_at: datetime
+    updated_at: datetime
+    completed_at: datetime | None = None
+    metadata: dict[str, str | int | float | bool | None] = field(default_factory=dict)
+    assignee_id: UUID | None = None
+    parent_id: UUID | None = None
+
+
+class TaskService(Service):
+    name = "task"
+    service_type = ServiceType.TASK
+
+    @property
+    def capability_description(self) -> str:
+        return "Task management service for creating, tracking, and completing tasks."
+
+    def __init__(self) -> None:
+        self._tasks: dict[UUID, Task] = {}
+        self._runtime: IAgentRuntime | None = None
+
+    @classmethod
+    async def start(cls, runtime: IAgentRuntime) -> TaskService:
+        service = cls()
+        service._runtime = runtime
+        runtime.logger.info(
+            "Task service started",
+            src="service:task",
+            agentId=str(runtime.agent_id),
+        )
+        return service
+
+    async def stop(self) -> None:
+        if self._runtime:
+            self._runtime.logger.info(
+                "Task service stopped",
+                src="service:task",
+                agentId=str(self._runtime.agent_id),
+            )
+        self._tasks.clear()
+        self._runtime = None
+
+    async def create_task(
+        self,
+        name: str,
+        description: str,
+        priority: TaskPriority = TaskPriority.MEDIUM,
+        assignee_id: UUID | None = None,
+        parent_id: UUID | None = None,
+        metadata: dict[str, str | int | float | bool | None] | None = None,
+    ) -> Task:
+        now = datetime.now(UTC)
+        task = Task(
+            id=uuid4(),
+            name=name,
+            description=description,
+            status=TaskStatus.PENDING,
+            priority=priority,
+            created_at=now,
+            updated_at=now,
+            assignee_id=assignee_id,
+            parent_id=parent_id,
+            metadata=metadata or {},
+        )
+        self._tasks[task.id] = task
+
+        if self._runtime:
+            self._runtime.logger.debug(
+                "Task created",
+                src="service:task",
+                taskId=str(task.id),
+                taskName=name,
+            )
+
+        return task
+
+    async def get_task(self, task_id: UUID) -> Task | None:
+        return self._tasks.get(task_id)
+
+    async def update_task_status(
+        self,
+        task_id: UUID,
+        status: TaskStatus,
+    ) -> Task | None:
+        task = self._tasks.get(task_id)
+        if task is None:
+            return None
+
+        task.status = status
+        task.updated_at = datetime.now(UTC)
+
+        if status == TaskStatus.COMPLETED:
+            task.completed_at = task.updated_at
+
+        if self._runtime:
+            self._runtime.logger.debug(
+                "Task status updated",
+                src="service:task",
+                taskId=str(task_id),
+                newStatus=status.value,
+            )
+
+        return task
+
+    async def get_tasks_by_status(
+        self,
+        status: TaskStatus,
+    ) -> list[Task]:
+        return [t for t in self._tasks.values() if t.status == status]
+
+    async def get_tasks_by_priority(
+        self,
+        priority: TaskPriority,
+    ) -> list[Task]:
+        return [t for t in self._tasks.values() if t.priority == priority]
+
+    async def get_pending_tasks(self) -> list[Task]:
+        pending = [t for t in self._tasks.values() if t.status == TaskStatus.PENDING]
+        priority_order = {
+            TaskPriority.URGENT: 0,
+            TaskPriority.HIGH: 1,
+            TaskPriority.MEDIUM: 2,
+            TaskPriority.LOW: 3,
+        }
+        return sorted(pending, key=lambda t: priority_order[t.priority])
+
+    async def complete_task(self, task_id: UUID) -> Task | None:
+        return await self.update_task_status(task_id, TaskStatus.COMPLETED)
+
+    async def cancel_task(self, task_id: UUID) -> Task | None:
+        return await self.update_task_status(task_id, TaskStatus.CANCELLED)
+
+    async def delete_task(self, task_id: UUID) -> bool:
+        if task_id in self._tasks:
+            del self._tasks[task_id]
+            if self._runtime:
+                self._runtime.logger.debug(
+                    "Task deleted",
+                    src="service:task",
+                    taskId=str(task_id),
+                )
+            return True
+        return False

package/elizaos/bootstrap/__init__.py

@@ -0,0 +1,12 @@
+"""elizaOS Bootstrap Plugin - Python implementation."""
+
+from .plugin import bootstrap_plugin, create_bootstrap_plugin
+from .types import CapabilityConfig
+
+__version__ = "2.0.0-alpha.0"
+__all__ = [
+    "bootstrap_plugin",
+    "create_bootstrap_plugin",
+    "CapabilityConfig",
+    "__version__",
+]

package/elizaos/bootstrap/actions/__init__.py

@@ -0,0 +1,68 @@
+from .add_contact import add_contact_action
+from .choice import choose_option_action
+from .follow_room import follow_room_action
+from .ignore import ignore_action
+from .image_generation import generate_image_action
+from .mute_room import mute_room_action
+from .none import none_action
+from .remove_contact import remove_contact_action
+from .reply import reply_action
+from .roles import update_role_action
+from .schedule_follow_up import schedule_follow_up_action
+from .search_contacts import search_contacts_action
+from .send_message import send_message_action
+from .settings import update_settings_action
+from .unfollow_room import unfollow_room_action
+from .unmute_room import unmute_room_action
+from .update_contact import update_contact_action
+from .update_entity import update_entity_action
+
+__all__ = [
+    "add_contact_action",
+    "choose_option_action",
+    "follow_room_action",
+    "generate_image_action",
+    "ignore_action",
+    "mute_room_action",
+    "none_action",
+    "remove_contact_action",
+    "reply_action",
+    "schedule_follow_up_action",
+    "search_contacts_action",
+    "send_message_action",
+    "unfollow_room_action",
+    "unmute_room_action",
+    "update_contact_action",
+    "update_entity_action",
+    "update_role_action",
+    "update_settings_action",
+    "BASIC_ACTIONS",
+    "EXTENDED_ACTIONS",
+    "ALL_ACTIONS",
+]
+
+BASIC_ACTIONS = [
+    reply_action,
+    ignore_action,
+    none_action,
+]
+
+EXTENDED_ACTIONS = [
+    add_contact_action,
+    choose_option_action,
+    follow_room_action,
+    generate_image_action,
+    mute_room_action,
+    remove_contact_action,
+    schedule_follow_up_action,
+    search_contacts_action,
+    send_message_action,
+    unfollow_room_action,
+    unmute_room_action,
+    update_contact_action,
+    update_entity_action,
+    update_role_action,
+    update_settings_action,
+]
+
+ALL_ACTIONS = BASIC_ACTIONS + EXTENDED_ACTIONS

package/elizaos/bootstrap/actions/add_contact.py

@@ -0,0 +1,149 @@
+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 ADD_CONTACT_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("ADD_CONTACT")
+
+
+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 AddContactAction:
+    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 ContactPreferences, 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=ADD_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 extract contact information",
+                success=False,
+                values={"error": True},
+                data={"error": "Failed to parse contact info"},
+            )
+
+        contact_name = str(parsed.get("contactName", ""))
+        categories_str = str(parsed.get("categories", "acquaintance"))
+        categories = [c.strip() for c in categories_str.split(",") if c.strip()]
+        notes = str(parsed.get("notes", ""))
+        reason = str(parsed.get("reason", ""))
+
+        entity_id = message.entity_id
+        preferences = ContactPreferences(notes=notes) if notes else None
+
+        await rolodex_service.add_contact(
+            entity_id=entity_id,
+            categories=categories,
+            preferences=preferences,
+        )
+
+        response_text = (
+            f"I've added {contact_name} to your contacts as {', '.join(categories)}. {reason}"
+        )
+
+        if callback:
+            await callback(Content(text=response_text, actions=["ADD_CONTACT"]))
+
+        return ActionResult(
+            text=response_text,
+            success=True,
+            values={
+                "contactId": str(entity_id),
+                "contactName": contact_name,
+                "categoriesStr": ",".join(categories),
+            },
+            data={
+                "contactId": str(entity_id),
+                "contactName": contact_name,
+                "categories": ",".join(categories),
+            },
+        )
+
+    @property
+    def examples(self) -> list[list[ActionExample]]:
+        return _convert_spec_examples()
+
+
+add_contact_action = Action(
+    name=AddContactAction.name,
+    similes=AddContactAction().similes,
+    description=AddContactAction.description,
+    validate=AddContactAction().validate,
+    handler=AddContactAction().handler,
+    examples=AddContactAction().examples,
+)

package/elizaos/bootstrap/actions/choice.py

@@ -0,0 +1,147 @@
+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 CHOOSE_OPTION_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("CHOOSE_OPTION")
+
+
+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 ChooseOptionAction:
+    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.options:
+            return len(message.content.options) > 0
+        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 CHOOSE_OPTION action")
+
+        available_options: list[dict[str, str]] = []
+        if message.content and message.content.options:
+            available_options = message.content.options
+
+        if not available_options:
+            return ActionResult(
+                text="No options available to choose from",
+                values={"success": False, "error": "no_options"},
+                data={"actionName": "CHOOSE_OPTION"},
+                success=False,
+            )
+
+        state = await runtime.compose_state(message, ["RECENT_MESSAGES", "ACTION_STATE"])
+
+        options_context = "\n".join(
+            f"- [{opt.get('id', idx)}] {opt.get('label', '')}: {opt.get('description', '')}"
+            for idx, opt in enumerate(available_options)
+        )
+
+        template = (
+            runtime.character.templates.get("chooseOptionTemplate")
+            if runtime.character.templates and "chooseOptionTemplate" in runtime.character.templates
+            else CHOOSE_OPTION_TEMPLATE
+        )
+        prompt = runtime.compose_prompt(state=state, template=template)
+        prompt = prompt.replace("{{options}}", options_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", ""))
+        selected_id = str(parsed_xml.get("selected_id", ""))
+
+        if not selected_id:
+            raise ValueError("No option selected")
+
+        selected_option = next(
+            (opt for opt in available_options if str(opt.get("id", "")) == selected_id),
+            None,
+        )
+
+        if selected_option is None:
+            raise ValueError(f"Selected option ID '{selected_id}' not found")
+
+        response_content = Content(
+            thought=thought,
+            text=f"Selected option: {selected_option.get('label', selected_id)}",
+            actions=["CHOOSE_OPTION"],
+        )
+
+        if callback:
+            await callback(response_content)
+
+        return ActionResult(
+            text=f"Selected option: {selected_option.get('label', selected_id)}",
+            values={
+                "success": True,
+                "selectedId": selected_id,
+                "selectedLabel": selected_option.get("label", ""),
+                "thought": thought,
+            },
+            data={
+                "actionName": "CHOOSE_OPTION",
+                "selectedOption": selected_option,
+                "thought": thought,
+            },
+            success=True,
+        )
+
+    @property
+    def examples(self) -> list[list[ActionExample]]:
+        return _convert_spec_examples()
+
+
+choose_option_action = Action(
+    name=ChooseOptionAction.name,
+    similes=ChooseOptionAction().similes,
+    description=ChooseOptionAction.description,
+    validate=ChooseOptionAction().validate,
+    handler=ChooseOptionAction().handler,
+    examples=ChooseOptionAction().examples,
+)

package/elizaos/bootstrap/actions/follow_room.py

@@ -0,0 +1,151 @@
+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("FOLLOW_ROOM")
+
+
+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 FollowRoomAction:
+    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 False
+
+        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:
+        room_id = message.room_id
+        if not room_id:
+            return ActionResult(
+                text="No room specified to follow",
+                values={"success": False, "error": "no_room_id"},
+                data={"actionName": "FOLLOW_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": "FOLLOW_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 not in followed_rooms:
+                    followed_rooms.append(room_id_str)
+                    world.metadata["followedRooms"] = followed_rooms
+                    await runtime.update_world(world)
+
+        await runtime.create_memory(
+            content=Content(
+                text=f"Now following room: {room_name}",
+                actions=["FOLLOW_ROOM"],
+            ),
+            room_id=room_id,
+            entity_id=runtime.agent_id,
+            memory_type="action",
+            metadata={"type": "FOLLOW_ROOM", "roomName": room_name},
+        )
+
+        response_content = Content(
+            text=f"I am now following {room_name} and will monitor its messages.",
+            actions=["FOLLOW_ROOM"],
+        )
+
+        if callback:
+            await callback(response_content)
+
+        return ActionResult(
+            text=f"Now following room: {room_name}",
+            values={
+                "success": True,
+                "following": True,
+                "roomId": str(room_id),
+                "roomName": room_name,
+            },
+            data={
+                "actionName": "FOLLOW_ROOM",
+                "roomId": str(room_id),
+                "roomName": room_name,
+            },
+            success=True,
+        )
+
+    @property
+    def examples(self) -> list[list[ActionExample]]:
+        return _convert_spec_examples()
+
+
+follow_room_action = Action(
+    name=FollowRoomAction.name,
+    similes=FollowRoomAction().similes,
+    description=FollowRoomAction.description,
+    validate=FollowRoomAction().validate,
+    handler=FollowRoomAction().handler,
+    examples=FollowRoomAction().examples,
+)