@elizaos/python 2.0.0-alpha.10

package/elizaos/advanced_planning/plugin.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from elizaos.types import Plugin
+
+from .actions import (
+    analyze_input_action,
+    create_plan_action,
+    execute_final_action,
+    process_analysis_action,
+)
+from .message_classifier import message_classifier_provider
+from .planning_service import PlanningService
+
+
+def create_advanced_planning_plugin() -> Plugin:
+    async def init_plugin(_config, runtime) -> None:
+        runtime.logger.info(
+            "Advanced planning enabled",
+            src="plugin:advanced-planning",
+            agentId=str(runtime.agent_id),
+        )
+
+    return Plugin(
+        name="advanced-planning",
+        description="Built-in advanced planning and execution capabilities",
+        init=init_plugin,
+        config={},
+        services=[PlanningService],
+        actions=[
+            analyze_input_action,
+            process_analysis_action,
+            execute_final_action,
+            create_plan_action,
+        ],
+        providers=[message_classifier_provider],
+        evaluators=[],
+    )
+
+
+advanced_planning_plugin = create_advanced_planning_plugin()

package/elizaos/advanced_planning/prompts.py

@@ -0,0 +1,4 @@
+# Re-export from centralized prompts
+from elizaos.prompts import MESSAGE_CLASSIFIER_TEMPLATE
+
+__all__ = ["MESSAGE_CLASSIFIER_TEMPLATE"]

package/elizaos/basic_capabilities/__init__.py

@@ -0,0 +1,66 @@
+"""Basic Capabilities - Core functionality for agent operation.
+
+This module provides the fundamental capabilities needed for basic agent operation:
+- Core actions (reply, ignore, none, choice)
+- Core providers (actions, character, entities, messages, etc.)
+- Essential services (task management, embeddings)
+"""
+
+from .actions import (
+    basic_actions,
+    choice_action,
+    ignore_action,
+    none_action,
+    reply_action,
+)
+from .providers import (
+    action_state_provider,
+    actions_provider,
+    attachments_provider,
+    basic_providers,
+    capabilities_provider,
+    character_provider,
+    choice_provider,
+    context_bench_provider,
+    current_time_provider,
+    entities_provider,
+    evaluators_provider,
+    providers_list_provider,
+    recent_messages_provider,
+    time_provider,
+    world_provider,
+)
+from .services import (
+    EmbeddingService,
+    TaskService,
+    basic_services,
+)
+
+__all__ = [
+    # Actions
+    "basic_actions",
+    "choice_action",
+    "ignore_action",
+    "none_action",
+    "reply_action",
+    # Providers
+    "basic_providers",
+    "action_state_provider",
+    "actions_provider",
+    "attachments_provider",
+    "capabilities_provider",
+    "character_provider",
+    "choice_provider",
+    "context_bench_provider",
+    "current_time_provider",
+    "entities_provider",
+    "evaluators_provider",
+    "providers_list_provider",
+    "recent_messages_provider",
+    "time_provider",
+    "world_provider",
+    # Services
+    "basic_services",
+    "EmbeddingService",
+    "TaskService",
+]

package/elizaos/basic_capabilities/actions/__init__.py

@@ -0,0 +1,24 @@
+"""Basic Actions - Core response actions.
+
+Fundamental actions included by default in the bootstrap plugin.
+"""
+
+from .choice import choose_option_action as choice_action
+from .ignore import ignore_action
+from .none import none_action
+from .reply import reply_action
+
+__all__ = [
+    "choice_action",
+    "ignore_action",
+    "none_action",
+    "reply_action",
+    "basic_actions",
+]
+
+basic_actions = [
+    choice_action,
+    reply_action,
+    ignore_action,
+    none_action,
+]

package/elizaos/basic_capabilities/actions/choice.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 CHOOSE_OPTION_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("CHOOSE_OPTION")
+
+
+def _convert_spec_examples() -> list[list[ActionExample]]:
+    """Convert spec examples to ActionExample format."""
+    return convert_spec_examples(_spec)
+
+
+@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:
+        # Check for options in content.data (protobuf) or content.options (legacy)
+        if message.content:
+            options = getattr(message.content, "options", None)
+            if options is None and hasattr(message.content, "data"):
+                data = message.content.data
+                if hasattr(data, "get"):
+                    options = data.get("options", [])
+            if options:
+                return len(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/basic_capabilities/actions/ignore.py

@@ -0,0 +1,66 @@
+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
+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("IGNORE")
+
+
+def _convert_spec_examples() -> list[list[ActionExample]]:
+    """Convert spec examples to ActionExample format."""
+    return convert_spec_examples(_spec)
+
+
+@dataclass
+class IgnoreAction:
+    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 callback and responses and len(responses) > 0:
+            first_response = responses[0]
+            if first_response.content:
+                await callback(first_response.content)
+
+        return ActionResult(
+            text="Ignoring message",
+            values={"success": True, "ignored": True},
+            data={"actionName": "IGNORE"},
+            success=True,
+        )
+
+    @property
+    def examples(self) -> list[list[ActionExample]]:
+        return _convert_spec_examples()
+
+
+ignore_action = Action(
+    name=IgnoreAction.name,
+    similes=IgnoreAction().similes,
+    description=IgnoreAction.description,
+    validate=IgnoreAction().validate,
+    handler=IgnoreAction().handler,
+    examples=IgnoreAction().examples,
+)

package/elizaos/basic_capabilities/actions/none.py

@@ -0,0 +1,56 @@
+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
+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("NONE")
+
+
+@dataclass
+class NoneAction:
+    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:
+        return ActionResult(
+            text="No action taken",
+            values={"success": True, "noAction": True},
+            data={"actionName": "NONE"},
+            success=True,
+        )
+
+    @property
+    def examples(self) -> list[list[ActionExample]]:
+        return convert_spec_examples(_spec)
+
+
+none_action = Action(
+    name=NoneAction.name,
+    similes=NoneAction().similes,
+    description=NoneAction.description,
+    validate=NoneAction().validate,
+    handler=NoneAction().handler,
+    examples=NoneAction().examples,
+)

package/elizaos/basic_capabilities/actions/reply.py

@@ -0,0 +1,120 @@
+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
+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("REPLY")
+
+
+def _convert_spec_examples() -> list[list[ActionExample]]:
+    """Convert spec examples to ActionExample format."""
+    return convert_spec_examples(_spec)
+
+
+@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/basic_capabilities/providers/__init__.py

@@ -0,0 +1,54 @@
+"""Basic Providers - Core providers for agent operation.
+
+Fundamental providers included by default in the bootstrap plugin.
+"""
+
+from .action_state import action_state_provider
+from .actions import actions_provider
+from .attachments import attachments_provider
+from .capabilities import capabilities_provider
+from .character import character_provider
+from .choice import choice_provider
+from .context_bench import context_bench_provider
+from .current_time import current_time_provider
+from .entities import entities_provider
+from .evaluators import evaluators_provider
+from .providers_list import providers_list_provider
+from .recent_messages import recent_messages_provider
+from .time import time_provider
+from .world import world_provider
+
+__all__ = [
+    "action_state_provider",
+    "actions_provider",
+    "attachments_provider",
+    "capabilities_provider",
+    "character_provider",
+    "choice_provider",
+    "context_bench_provider",
+    "current_time_provider",
+    "entities_provider",
+    "evaluators_provider",
+    "providers_list_provider",
+    "recent_messages_provider",
+    "time_provider",
+    "world_provider",
+    "basic_providers",
+]
+
+basic_providers = [
+    actions_provider,
+    action_state_provider,
+    attachments_provider,
+    capabilities_provider,
+    character_provider,
+    choice_provider,
+    context_bench_provider,
+    current_time_provider,
+    entities_provider,
+    evaluators_provider,
+    providers_list_provider,
+    recent_messages_provider,
+    time_provider,
+    world_provider,
+]

package/elizaos/basic_capabilities/providers/action_state.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from elizaos.types import Provider, ProviderResult
+
+if TYPE_CHECKING:
+    from elizaos.types import IAgentRuntime, Memory, State
+
+
+async def get_action_state_context(
+    runtime: IAgentRuntime,
+    message: Memory,
+    state: State | None = None,
+) -> ProviderResult:
+    sections: list[str] = []
+    action_data: dict[str, list[str]] = {
+        "pending": [],
+        "completed": [],
+        "available": [],
+    }
+
+    # Use the actions property instead of get_available_actions()
+    available_actions = runtime.actions
+    action_data["available"] = [a.name for a in available_actions]
+
+    if action_data["available"]:
+        sections.append("## Available Actions")
+        sections.append(", ".join(action_data["available"]))
+
+    if state and state.values:
+        # Handle both dict-like and protobuf state.values
+        values = state.values
+        pending = []
+        completed = []
+
+        if hasattr(values, "get") and callable(values.get):
+            # Dict-like access
+            pending = values.get("pendingActions", [])
+            completed = values.get("completedActions", [])
+        elif hasattr(values, "extra"):
+            # Protobuf - extra might be a MapField or a message
+            extra = values.extra
+            if hasattr(extra, "get") and callable(extra.get):
+                pending_raw = extra.get("pendingActions", "")
+                completed_raw = extra.get("completedActions", "")
+            elif hasattr(extra, "__getitem__"):
+                try:
+                    pending_raw = extra["pendingActions"]
+                except (KeyError, TypeError, ValueError):
+                    pending_raw = ""
+                try:
+                    completed_raw = extra["completedActions"]
+                except (KeyError, TypeError, ValueError):
+                    completed_raw = ""
+            else:
+                pending_raw = ""
+                completed_raw = ""
+
+            # Parse if stored as string
+            if isinstance(pending_raw, str) and pending_raw:
+                import json
+
+                try:
+                    pending = json.loads(pending_raw)
+                except json.JSONDecodeError:
+                    pending = []
+            elif isinstance(pending_raw, list):
+                pending = pending_raw
+
+            if isinstance(completed_raw, str) and completed_raw:
+                import json
+
+                try:
+                    completed = json.loads(completed_raw)
+                except json.JSONDecodeError:
+                    completed = []
+            elif isinstance(completed_raw, list):
+                completed = completed_raw
+
+        if isinstance(pending, list):
+            action_data["pending"] = [str(a) for a in pending]
+
+        if isinstance(completed, list):
+            action_data["completed"] = [str(a) for a in completed]
+
+    if action_data["pending"]:
+        sections.append("\n## Pending Actions")
+        sections.append("\n".join(f"- {a}" for a in action_data["pending"]))
+
+    if action_data["completed"]:
+        sections.append("\n## Recently Completed")
+        sections.append("\n".join(f"- {a}" for a in action_data["completed"][-5:]))
+
+    context_text = "# Action State\n" + "\n".join(sections) if sections else ""
+
+    return ProviderResult(
+        text=context_text,
+        values={
+            "availableActionCount": len(action_data["available"]),
+            "pendingActionCount": len(action_data["pending"]),
+            "completedActionCount": len(action_data["completed"]),
+        },
+        data=action_data,
+    )
+
+
+action_state_provider = Provider(
+    name="ACTION_STATE",
+    description="Provides information about the current action state and available actions",
+    get=get_action_state_context,
+    dynamic=True,
+)