@elizaos/python 2.0.0-alpha.10

package/elizaos/advanced_capabilities/__init__.py

@@ -0,0 +1,85 @@
+"""Advanced Capabilities - Extended features for agent operation.
+
+This module provides advanced capabilities that can be enabled with
+`advanced_capabilities=True` or `enable_extended=True`:
+- Extended actions (contacts, room management, image generation, etc.)
+- Extended providers (facts, knowledge, relationships, etc.)
+- Evaluators (reflection, relationship extraction)
+- Extended services (rolodex, follow-up scheduling)
+"""
+
+from .actions import (
+    add_contact_action,
+    advanced_actions,
+    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,
+)
+from .evaluators import (
+    advanced_evaluators,
+    reflection_evaluator,
+    relationship_extraction_evaluator,
+)
+from .providers import (
+    advanced_providers,
+    agent_settings_provider,
+    contacts_provider,
+    facts_provider,
+    follow_ups_provider,
+    knowledge_provider,
+    relationships_provider,
+    roles_provider,
+    settings_provider,
+)
+from .services import (
+    FollowUpService,
+    RolodexService,
+    advanced_services,
+)
+
+__all__ = [
+    # Actions
+    "advanced_actions",
+    "add_contact_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",
+    # Providers
+    "advanced_providers",
+    "agent_settings_provider",
+    "contacts_provider",
+    "facts_provider",
+    "follow_ups_provider",
+    "knowledge_provider",
+    "relationships_provider",
+    "roles_provider",
+    "settings_provider",
+    # Evaluators
+    "advanced_evaluators",
+    "reflection_evaluator",
+    "relationship_extraction_evaluator",
+    # Services
+    "advanced_services",
+    "FollowUpService",
+    "RolodexService",
+]

package/elizaos/advanced_capabilities/actions/__init__.py

@@ -0,0 +1,54 @@
+"""Advanced Actions - Extended actions for agent operation.
+
+Extended actions that can be enabled with `advanced_capabilities=True`.
+"""
+
+from .add_contact import add_contact_action
+from .follow_room import follow_room_action
+from .image_generation import generate_image_action
+from .mute_room import mute_room_action
+from .remove_contact import remove_contact_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",
+    "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",
+    "advanced_actions",
+]
+
+advanced_actions = [
+    add_contact_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,
+]

package/elizaos/advanced_capabilities/actions/add_contact.py

@@ -0,0 +1,139 @@
+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,
+)
+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("ADD_CONTACT")
+
+
+def _convert_spec_examples() -> list[list[ActionExample]]:
+    """Convert spec examples to ActionExample format."""
+    return convert_spec_examples(_spec)
+
+
+@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", ""))
+
+        from uuid import UUID as StdUUID
+
+        entity_id = message.entity_id
+        entity_id_uuid = StdUUID(str(entity_id)) if entity_id else None
+        preferences = ContactPreferences(notes=notes) if notes else None
+
+        if entity_id_uuid:
+            await rolodex_service.add_contact(
+                entity_id=entity_id_uuid,
+                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/advanced_capabilities/actions/follow_room.py

@@ -0,0 +1,151 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING
+
+from elizaos.types import Action, ActionExample, ActionResult, Content
+
+if TYPE_CHECKING:
+    from elizaos.types import HandlerCallback, HandlerOptions, IAgentRuntime, Memory, State
+
+
+@dataclass
+class FollowRoomAction:
+    name: str = "FOLLOW_ROOM"
+    similes: list[str] = field(
+        default_factory=lambda: [
+            "JOIN_ROOM",
+            "SUBSCRIBE_ROOM",
+            "WATCH_ROOM",
+            "ENTER_ROOM",
+        ]
+    )
+    description: str = (
+        "Follow a room to receive updates and monitor messages. "
+        "Use this when you want to actively engage with a room's content."
+    )
+
+    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 [
+            [
+                ActionExample(
+                    name="{{name1}}",
+                    content=Content(text="Can you keep an eye on this channel?"),
+                ),
+                ActionExample(
+                    name="{{name2}}",
+                    content=Content(
+                        text="I'll follow this room and monitor its activity.",
+                        actions=["FOLLOW_ROOM"],
+                    ),
+                ),
+            ],
+        ]
+
+
+follow_room_action = Action(
+    name=FollowRoomAction.name,
+    similes=FollowRoomAction().similes,
+    description=FollowRoomAction.description,
+    validate=FollowRoomAction().validate,
+    handler=FollowRoomAction().handler,
+    examples=FollowRoomAction().examples,
+)

package/elizaos/advanced_capabilities/actions/image_generation.py

@@ -0,0 +1,148 @@
+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 IMAGE_GENERATION_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("GENERATE_IMAGE")
+
+
+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 GenerateImageAction:
+    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 runtime.has_model(ModelType.IMAGE)
+
+    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 GENERATE_IMAGE action")
+
+        state = await runtime.compose_state(message, ["RECENT_MESSAGES", "ACTION_STATE"])
+
+        template = (
+            runtime.character.templates.get("imageGenerationTemplate")
+            if runtime.character.templates
+            and "imageGenerationTemplate" in runtime.character.templates
+            else IMAGE_GENERATION_TEMPLATE
+        )
+        prompt = runtime.compose_prompt(state=state, template=template)
+
+        prompt_response = await runtime.use_model(ModelType.TEXT_LARGE, prompt=prompt)
+        parsed_xml = parse_key_value_xml(prompt_response)
+
+        if parsed_xml is None:
+            raise ValueError("Failed to parse XML response for image prompt")
+
+        thought = str(parsed_xml.get("thought", ""))
+        image_prompt = str(parsed_xml.get("prompt", ""))
+
+        if not image_prompt:
+            raise ValueError("No image prompt generated")
+
+        image_result = await runtime.use_model(
+            ModelType.IMAGE,
+            prompt=image_prompt,
+        )
+
+        image_url: str | None = None
+        if isinstance(image_result, str):
+            image_url = image_result
+        elif isinstance(image_result, dict):
+            image_url = image_result.get("url") or image_result.get("data")
+
+        if not image_url:
+            raise ValueError("No image URL returned from generation")
+
+        response_content = Content(
+            text=f"Generated image with prompt: {image_prompt}",
+            attachments=[{"type": "image", "url": image_url}],
+            actions=["GENERATE_IMAGE"],
+        )
+
+        if callback:
+            await callback(response_content)
+
+        return ActionResult(
+            text=f"Generated image: {image_prompt}",
+            values={
+                "success": True,
+                "imageGenerated": True,
+                "imageUrl": image_url,
+                "imagePrompt": image_prompt,
+            },
+            data={
+                "actionName": "GENERATE_IMAGE",
+                "prompt": image_prompt,
+                "thought": thought,
+                "imageUrl": image_url,
+            },
+            success=True,
+        )
+
+    @property
+    def examples(self) -> list[list[ActionExample]]:
+        return _convert_spec_examples()
+
+
+generate_image_action = Action(
+    name=GenerateImageAction.name,
+    similes=GenerateImageAction().similes,
+    description=GenerateImageAction.description,
+    validate=GenerateImageAction().validate,
+    handler=GenerateImageAction().handler,
+    examples=GenerateImageAction().examples,
+)