@elizaos/python 2.0.0-alpha.10

package/elizaos/bootstrap/evaluators/reflection.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from elizaos.bootstrap.types import EvaluatorResult
+from elizaos.bootstrap.utils.xml import parse_key_value_xml
+from elizaos.generated.spec_helpers import require_evaluator_spec
+from elizaos.prompts import REFLECTION_TEMPLATE
+from elizaos.types import Evaluator, ModelType
+
+if TYPE_CHECKING:
+    from elizaos.types import IAgentRuntime, Memory, State
+
+# Get text content from centralized specs
+_spec = require_evaluator_spec("REFLECTION")
+
+
+async def evaluate_reflection(
+    runtime: IAgentRuntime,
+    message: Memory,
+    state: State | None = None,
+) -> EvaluatorResult:
+    if state is None:
+        return EvaluatorResult(
+            score=50,
+            passed=True,
+            reason="No state for reflection",
+            details={},
+        )
+
+    recent_interactions: list[str] = []
+    room_id = message.room_id
+
+    if room_id:
+        recent_messages = await runtime.get_memories(
+            room_id=room_id,
+            limit=10,
+            order_by="created_at",
+            order_direction="desc",
+        )
+
+        for msg in recent_messages:
+            if msg.content and msg.content.text:
+                sender = "Unknown"
+                if msg.entity_id:
+                    if str(msg.entity_id) == str(runtime.agent_id):
+                        sender = runtime.character.name
+                    else:
+                        entity = await runtime.get_entity(msg.entity_id)
+                        if entity and entity.name:
+                            sender = entity.name
+                recent_interactions.append(f"{sender}: {msg.content.text}")
+
+    if not recent_interactions:
+        return EvaluatorResult(
+            score=50,
+            passed=True,
+            reason="No recent interactions to reflect on",
+            details={"noInteractions": True},
+        )
+
+    interactions_text = "\n".join(recent_interactions)
+
+    template = (
+        runtime.character.templates.get("reflectionTemplate")
+        if runtime.character.templates and "reflectionTemplate" in runtime.character.templates
+        else REFLECTION_TEMPLATE
+    )
+    prompt = runtime.compose_prompt(state=state, template=template)
+    prompt = prompt.replace("{{recentInteractions}}", interactions_text)
+
+    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 reflection response")
+
+    quality_str = str(parsed_xml.get("quality_score", "50"))
+    quality_score = max(0, min(100, int(quality_str)))
+
+    thought = str(parsed_xml.get("thought", ""))
+    strengths = str(parsed_xml.get("strengths", ""))
+    improvements = str(parsed_xml.get("improvements", ""))
+    learnings = str(parsed_xml.get("learnings", ""))
+
+    passed = quality_score >= 50
+
+    return EvaluatorResult(
+        score=quality_score,
+        passed=passed,
+        reason=f"Strengths: {strengths}\nImprovements: {improvements}",
+        details={
+            "thought": thought,
+            "strengths": strengths,
+            "improvements": improvements,
+            "learnings": learnings,
+            "interactionCount": len(recent_interactions),
+        },
+    )
+
+
+async def validate_reflection(
+    runtime: IAgentRuntime,
+    message: Memory,
+    _state: State | None = None,
+) -> bool:
+    return True
+
+
+reflection_evaluator = Evaluator(
+    name=_spec["name"],
+    description=_spec["description"],
+    similes=_spec.get("similes", []),
+    validate=validate_reflection,
+    handler=evaluate_reflection,
+    always_run=_spec.get("alwaysRun", False),
+    examples=_spec.get("examples", []),
+)

package/elizaos/bootstrap/evaluators/relationship_extraction.py

@@ -0,0 +1,192 @@
+from __future__ import annotations
+
+import re
+from typing import TYPE_CHECKING
+
+from elizaos.bootstrap.types import EvaluatorResult
+from elizaos.generated.spec_helpers import require_evaluator_spec
+from elizaos.types import Evaluator
+
+if TYPE_CHECKING:
+    from elizaos.types import IAgentRuntime, Memory, State
+
+# Get text content from centralized specs
+_spec = require_evaluator_spec("RELATIONSHIP_EXTRACTION")
+
+X_HANDLE_PATTERN = re.compile(r"@[\w]+")
+EMAIL_PATTERN = re.compile(r"[\w.+-]+@[\w.-]+\.\w+")
+PHONE_PATTERN = re.compile(r"\+?[\d\s\-()]{10,}")
+DISCORD_PATTERN = re.compile(r"[\w]+#\d{4}")
+
+
+def extract_platform_identities(text: str) -> list[dict[str, str | bool | float]]:
+    identities: list[dict[str, str | bool | float]] = []
+
+    for match in X_HANDLE_PATTERN.finditer(text):
+        handle = match.group()
+        if handle.lower() not in ("@here", "@everyone", "@channel"):
+            identities.append(
+                {
+                    "platform": "x",
+                    "handle": handle,
+                    "verified": False,
+                    "confidence": 0.7,
+                }
+            )
+
+    for match in EMAIL_PATTERN.finditer(text):
+        identities.append(
+            {
+                "platform": "email",
+                "handle": match.group(),
+                "verified": False,
+                "confidence": 0.9,
+            }
+        )
+
+    for match in DISCORD_PATTERN.finditer(text):
+        identities.append(
+            {
+                "platform": "discord",
+                "handle": match.group(),
+                "verified": False,
+                "confidence": 0.8,
+            }
+        )
+
+    return identities
+
+
+def detect_relationship_indicators(text: str) -> list[dict[str, str | float]]:
+    indicators: list[dict[str, str | float]] = []
+
+    friend_patterns = [
+        r"my friend",
+        r"good friend",
+        r"best friend",
+        r"close friend",
+        r"we're friends",
+    ]
+    for pattern in friend_patterns:
+        if re.search(pattern, text, re.IGNORECASE):
+            indicators.append(
+                {
+                    "type": "friend",
+                    "sentiment": "positive",
+                    "confidence": 0.8,
+                }
+            )
+            break
+
+    colleague_patterns = [
+        r"my colleague",
+        r"coworker",
+        r"co-worker",
+        r"work together",
+        r"at work",
+    ]
+    for pattern in colleague_patterns:
+        if re.search(pattern, text, re.IGNORECASE):
+            indicators.append(
+                {
+                    "type": "colleague",
+                    "sentiment": "neutral",
+                    "confidence": 0.8,
+                }
+            )
+            break
+
+    family_patterns = [
+        r"my (brother|sister|mom|dad|mother|father|parent|son|daughter|child)",
+        r"my family",
+        r"family member",
+    ]
+    for pattern in family_patterns:
+        if re.search(pattern, text, re.IGNORECASE):
+            indicators.append(
+                {
+                    "type": "family",
+                    "sentiment": "positive",
+                    "confidence": 0.9,
+                }
+            )
+            break
+
+    return indicators
+
+
+async def evaluate_relationship_extraction(
+    runtime: IAgentRuntime,
+    message: Memory,
+    state: State | None = None,
+) -> EvaluatorResult:
+    text = message.content.text if message.content else ""
+
+    if not text:
+        return EvaluatorResult(
+            score=50,
+            passed=True,
+            reason="No text to analyze",
+            details={"noText": True},
+        )
+
+    identities = extract_platform_identities(text)
+
+    indicators = detect_relationship_indicators(text)
+
+    if identities and message.entity_id:
+        entity = await runtime.get_entity(message.entity_id)
+        if entity:
+            metadata = entity.metadata or {}
+            existing_identities = metadata.get("platformIdentities", [])
+            if isinstance(existing_identities, list):
+                for identity in identities:
+                    exists = any(
+                        i.get("platform") == identity["platform"]
+                        and i.get("handle") == identity["handle"]
+                        for i in existing_identities
+                    )
+                    if not exists:
+                        existing_identities.append(identity)
+                metadata["platformIdentities"] = existing_identities
+                entity.metadata = metadata
+                await runtime.update_entity(entity)
+
+    runtime.logger.info(
+        {
+            "src": "evaluator:relationship_extraction",
+            "agentId": str(runtime.agent_id),
+            "identitiesFound": len(identities),
+            "indicatorsFound": len(indicators),
+        },
+        "Completed extraction",
+    )
+
+    return EvaluatorResult(
+        score=70,
+        passed=True,
+        reason=f"Found {len(identities)} identities and {len(indicators)} relationship indicators",
+        details={
+            "identitiesCount": len(identities),
+            "indicatorsCount": len(indicators),
+        },
+    )
+
+
+async def validate_relationship_extraction(
+    runtime: IAgentRuntime,
+    message: Memory,
+    _state: State | None = None,
+) -> bool:
+    return message.content is not None and bool(message.content.text)
+
+
+relationship_extraction_evaluator = Evaluator(
+    name=_spec["name"],
+    description=_spec["description"],
+    similes=_spec.get("similes", []),
+    validate=validate_relationship_extraction,
+    handler=evaluate_relationship_extraction,
+    always_run=_spec.get("alwaysRun", False),
+    examples=_spec.get("examples", []),
+)

package/elizaos/bootstrap/plugin.py

@@ -0,0 +1,140 @@
+"""elizaOS Bootstrap Plugin - Python implementation."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from elizaos.action_docs import with_canonical_action_docs, with_canonical_evaluator_docs
+from elizaos.advanced_capabilities import (
+    advanced_actions,
+    advanced_evaluators,
+    advanced_providers,
+    advanced_services,
+)
+
+# Import from new capability modules
+from elizaos.basic_capabilities import basic_actions, basic_providers, basic_services
+from elizaos.types import Plugin
+
+# Autonomy capabilities remain in bootstrap
+from .autonomy import (
+    AutonomyService,
+    admin_chat_provider,
+    autonomy_status_provider,
+    send_to_admin_action,
+)
+from .types import CapabilityConfig
+
+# Re-export for backward compatibility
+BASIC_ACTIONS = basic_actions
+EXTENDED_ACTIONS = advanced_actions
+BASIC_PROVIDERS = basic_providers
+EXTENDED_PROVIDERS = advanced_providers
+BASIC_EVALUATORS: list = []  # No basic evaluators
+EXTENDED_EVALUATORS = advanced_evaluators
+BASIC_SERVICES = basic_services
+EXTENDED_SERVICES = advanced_services
+
+if TYPE_CHECKING:
+    from elizaos.types import IAgentRuntime
+
+
+def _get_providers(config: CapabilityConfig) -> list:
+    """Get providers based on capability config."""
+    result = []
+    if not config.disable_basic:
+        providers_to_add = BASIC_PROVIDERS
+        if config.skip_character_provider:
+            providers_to_add = [p for p in providers_to_add if p.name != "CHARACTER"]
+        result.extend(providers_to_add)
+    if config.enable_extended:
+        result.extend(EXTENDED_PROVIDERS)
+    if config.enable_autonomy:
+        result.extend([admin_chat_provider, autonomy_status_provider])
+    return result
+
+
+def _get_actions(config: CapabilityConfig) -> list:
+    """Get actions based on capability config."""
+    result = []
+    if not config.disable_basic:
+        result.extend(BASIC_ACTIONS)
+    if config.enable_extended:
+        result.extend(EXTENDED_ACTIONS)
+    if config.enable_autonomy:
+        result.append(send_to_admin_action)
+    return result
+
+
+def _get_evaluators(config: CapabilityConfig) -> list:
+    """Get evaluators based on capability config."""
+    result = []
+    if not config.disable_basic:
+        result.extend(BASIC_EVALUATORS)
+    if config.enable_extended:
+        result.extend(EXTENDED_EVALUATORS)
+    return result
+
+
+def _get_services(config: CapabilityConfig) -> list[type]:
+    """Get services based on capability config."""
+    result = []
+    if not config.disable_basic:
+        result.extend(BASIC_SERVICES)
+    if config.enable_extended:
+        result.extend(EXTENDED_SERVICES)
+    if config.enable_autonomy:
+        result.append(AutonomyService)
+    return result
+
+
+def create_bootstrap_plugin(config: CapabilityConfig | None = None) -> Plugin:
+    """Create a bootstrap plugin with the specified capability configuration."""
+    if config is None:
+        config = CapabilityConfig()
+
+    providers = _get_providers(config)
+    actions = [with_canonical_action_docs(a) for a in _get_actions(config)]
+    evaluators = [with_canonical_evaluator_docs(e) for e in _get_evaluators(config)]
+    services = _get_services(config)
+
+    async def init_plugin(
+        plugin_config: dict[str, str | int | float | bool | None],
+        runtime: IAgentRuntime,
+    ) -> None:
+        """Initialize the Bootstrap plugin."""
+        _ = plugin_config
+        runtime.logger.info(
+            "Initializing Bootstrap plugin",
+            src="plugin:bootstrap",
+            agentId=str(runtime.agent_id),
+        )
+
+        runtime.logger.info(
+            "Bootstrap plugin initialized",
+            src="plugin:bootstrap",
+            agentId=str(runtime.agent_id),
+            actionCount=len(actions),
+            providerCount=len(providers),
+            evaluatorCount=len(evaluators),
+            serviceCount=len(services),
+        )
+
+    return Plugin(
+        name="bootstrap",
+        description=(
+            "elizaOS Bootstrap Plugin - Python implementation of core agent "
+            "actions, providers, evaluators, and services"
+        ),
+        init=init_plugin,
+        config={},
+        services=services,
+        actions=actions,
+        providers=providers,
+        evaluators=evaluators,
+    )
+
+
+bootstrap_plugin = create_bootstrap_plugin()
+
+__all__ = ["bootstrap_plugin", "create_bootstrap_plugin", "CapabilityConfig"]

package/elizaos/bootstrap/providers/__init__.py

@@ -0,0 +1,80 @@
+from .action_state import action_state_provider
+from .actions import actions_provider
+from .agent_settings import agent_settings_provider
+from .attachments import attachments_provider
+from .capabilities import capabilities_provider
+from .character import character_provider
+from .choice import choice_provider
+from .contacts import contacts_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 .facts import facts_provider
+from .follow_ups import follow_ups_provider
+from .knowledge import knowledge_provider
+from .providers_list import providers_list_provider
+from .recent_messages import recent_messages_provider
+from .relationships import relationships_provider
+from .roles import roles_provider
+from .settings import settings_provider
+from .time import time_provider
+from .world import world_provider
+
+__all__ = [
+    "action_state_provider",
+    "actions_provider",
+    "agent_settings_provider",
+    "attachments_provider",
+    "capabilities_provider",
+    "character_provider",
+    "context_bench_provider",
+    "choice_provider",
+    "contacts_provider",
+    "current_time_provider",
+    "entities_provider",
+    "evaluators_provider",
+    "facts_provider",
+    "follow_ups_provider",
+    "knowledge_provider",
+    "providers_list_provider",
+    "recent_messages_provider",
+    "relationships_provider",
+    "roles_provider",
+    "settings_provider",
+    "time_provider",
+    "world_provider",
+    "BASIC_PROVIDERS",
+    "EXTENDED_PROVIDERS",
+    "ALL_PROVIDERS",
+]
+
+BASIC_PROVIDERS = [
+    actions_provider,
+    action_state_provider,
+    attachments_provider,
+    capabilities_provider,
+    character_provider,
+    context_bench_provider,
+    entities_provider,
+    evaluators_provider,
+    providers_list_provider,
+    recent_messages_provider,
+    current_time_provider,
+    time_provider,
+    world_provider,
+]
+
+EXTENDED_PROVIDERS = [
+    choice_provider,
+    contacts_provider,
+    facts_provider,
+    follow_ups_provider,
+    knowledge_provider,
+    relationships_provider,
+    roles_provider,
+    agent_settings_provider,
+    settings_provider,
+]
+
+ALL_PROVIDERS = BASIC_PROVIDERS + EXTENDED_PROVIDERS

package/elizaos/bootstrap/providers/action_state.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from elizaos.generated.spec_helpers import require_provider_spec
+from elizaos.types import Provider, ProviderResult
+
+if TYPE_CHECKING:
+    from elizaos.types import IAgentRuntime, Memory, State
+
+# Get text content from centralized specs
+_spec = require_provider_spec("ACTION_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:
+        pending = state.values.get("pendingActions", [])
+        if isinstance(pending, list):
+            action_data["pending"] = [str(a) for a in pending]
+
+        completed = state.values.get("completedActions", [])
+        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=_spec["name"],
+    description=_spec["description"],
+    get=get_action_state_context,
+    position=_spec.get("position"),
+    dynamic=_spec.get("dynamic", True),
+)