@elizaos/python 2.0.0-alpha.10

package/elizaos/advanced_capabilities/providers/relationships.py

@@ -0,0 +1,112 @@
+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
+
+
+def format_relationship(
+    relationship: dict[str, str | int | list[str] | dict[str, str]],
+    target_name: str,
+) -> str:
+    tags = relationship.get("tags", [])
+    tags_str = (", ".join(tags) if tags else "none") if isinstance(tags, list) else str(tags)
+
+    interactions = relationship.get("metadata", {})
+    interaction_count = interactions.get("interactions", 0) if isinstance(interactions, dict) else 0
+
+    return f"- {target_name}: tags=[{tags_str}], interactions={interaction_count}"
+
+
+async def get_relationships(
+    runtime: IAgentRuntime,
+    message: Memory,
+    state: State | None = None,
+) -> ProviderResult:
+    entity_id = message.entity_id
+    if not entity_id:
+        return ProviderResult(
+            text="No relationships found.",
+            values={"relationshipCount": 0},
+            data={"relationships": []},
+        )
+
+    try:
+        relationships = await runtime.get_relationships({"entityId": str(entity_id)})
+    except Exception as e:
+        runtime.logger.debug(
+            f"Failed to get relationships: src=provider:relationships agentId={runtime.agent_id} error={e}"
+        )
+        relationships = []
+
+    if not relationships:
+        return ProviderResult(
+            text="No relationships found.",
+            values={"relationshipCount": 0},
+            data={"relationships": []},
+        )
+
+    def _get_interactions(r: object) -> int:
+        if isinstance(r, dict):
+            meta = r.get("metadata", {})
+            if isinstance(meta, dict):
+                val = meta.get("interactions", 0)
+                return int(val) if isinstance(val, (int, float)) else 0
+        return 0
+
+    sorted_relationships = sorted(
+        relationships,
+        key=_get_interactions,
+        reverse=True,
+    )[:30]
+
+    formatted_relationships: list[str] = []
+    entity_cache: dict[str, str] = {}
+    for rel in sorted_relationships:
+        if not isinstance(rel, dict):
+            continue
+        target_id = rel.get("targetEntityId")
+        if not target_id:
+            continue
+
+        target_id_str = str(target_id)
+        target_name = entity_cache.get(target_id_str)
+        if target_name is None:
+            target_entity = await runtime.get_entity(target_id_str)
+            target_name = target_entity.name if target_entity else target_id_str[:8]
+            entity_cache[target_id_str] = target_name
+
+        formatted_relationships.append(format_relationship(rel, target_name))
+
+    if not formatted_relationships:
+        return ProviderResult(
+            text="No relationships found.",
+            values={"relationshipCount": 0},
+            data={"relationships": []},
+        )
+
+    sender_name = message.content.sender_name if message.content else "Unknown"
+    text = f"# {runtime.character.name} has observed {sender_name} interacting with:\n" + "\n".join(
+        formatted_relationships
+    )
+
+    return ProviderResult(
+        text=text,
+        values={
+            "relationshipCount": len(sorted_relationships),
+        },
+        data={
+            "relationships": sorted_relationships,
+        },
+    )
+
+
+relationships_provider = Provider(
+    name="RELATIONSHIPS",
+    description="Relationships between entities observed by the agent",
+    get=get_relationships,
+    dynamic=True,
+)

package/elizaos/advanced_capabilities/providers/roles.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+import asyncio
+from typing import TYPE_CHECKING
+
+from elizaos.types import Provider, ProviderResult
+
+if TYPE_CHECKING:
+    from elizaos.types import IAgentRuntime, Memory, State
+
+
+def format_role_info(entity_name: str, role: str) -> str:
+    return f"- {entity_name}: {role}"
+
+
+async def get_roles(
+    runtime: IAgentRuntime,
+    message: Memory,
+    state: State | None = None,
+) -> ProviderResult:
+    role_info: list[dict[str, str]] = []
+
+    world_id = None
+    if state and hasattr(state, "world"):
+        world = state.world
+        if world and hasattr(world, "id"):
+            world_id = world.id
+
+    if not world_id and message.room_id:
+        room = await runtime.get_room(message.room_id)
+        if room and hasattr(room, "world_id"):
+            world_id = room.world_id
+
+    if world_id:
+        world = await runtime.get_world(world_id)
+        if world and hasattr(world, "metadata"):
+            roles = world.metadata.get("roles", {})
+            if isinstance(roles, dict):
+                entity_ids = list(roles.keys())
+                entities = await asyncio.gather(
+                    *(runtime.get_entity(entity_id) for entity_id in entity_ids)
+                )
+                for entity_id, entity, role in zip(
+                    entity_ids, entities, roles.values(), strict=False
+                ):
+                    entity_name = entity.name if entity else str(entity_id)[:8]
+
+                    role_info.append(
+                        {
+                            "entityId": str(entity_id),
+                            "entityName": entity_name,
+                            "role": str(role),
+                        }
+                    )
+
+    if message.entity_id:
+        entity = await runtime.get_entity(message.entity_id)
+        if entity and hasattr(entity, "metadata"):
+            sender_role = entity.metadata.get("role")
+            if sender_role:
+                existing = next(
+                    (r for r in role_info if r["entityId"] == str(message.entity_id)), None
+                )
+                if not existing:
+                    role_info.append(
+                        {
+                            "entityId": str(message.entity_id),
+                            "entityName": entity.name or "Unknown",
+                            "role": str(sender_role),
+                        }
+                    )
+
+    if not role_info:
+        return ProviderResult(text="", values={"roleCount": 0}, data={"roles": []})
+
+    formatted_roles = "\n".join(format_role_info(r["entityName"], r["role"]) for r in role_info)
+
+    text = f"# Entity Roles\n{formatted_roles}"
+
+    return ProviderResult(
+        text=text,
+        values={
+            "roleCount": len(role_info),
+            "roles": {r["entityName"]: r["role"] for r in role_info},
+        },
+        data={
+            "roles": role_info,
+        },
+    )
+
+
+roles_provider = Provider(
+    name="ROLES",
+    description="Roles assigned to entities in the current context",
+    get=get_roles,
+    dynamic=True,
+)

package/elizaos/advanced_capabilities/providers/settings.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from elizaos.bootstrap.providers.agent_settings import SENSITIVE_KEY_PATTERNS
+from elizaos.types import Provider, ProviderResult
+
+if TYPE_CHECKING:
+    from elizaos.types import IAgentRuntime, Memory, State
+
+
+async def get_settings_context(
+    runtime: IAgentRuntime,
+    message: Memory,
+    state: State | None = None,
+) -> ProviderResult:
+    _ = message, state
+
+    all_settings = runtime.get_all_settings()
+
+    safe_settings: dict[str, str] = {}
+    for key, value in all_settings.items():
+        if not any(pattern in key.lower() for pattern in SENSITIVE_KEY_PATTERNS):
+            safe_settings[key] = str(value)
+
+    lines: list[str] = []
+    if safe_settings:
+        lines.append("## Current Configuration")
+        for key, value in safe_settings.items():
+            display_value = value if len(value) <= 50 else value[:50] + "..."
+            lines.append(f"- {key}: {display_value}")
+
+    context_text = "\n".join(lines) if lines else ""
+
+    return ProviderResult(
+        text=context_text,
+        values={
+            "settings": context_text,
+            "settingsCount": len(safe_settings),
+            "hasSettings": len(safe_settings) > 0,
+        },
+        data={"settings": safe_settings},
+    )
+
+
+settings_provider = Provider(
+    name="SETTINGS",
+    description="Current settings for the agent/server (filtered for security)",
+    get=get_settings_context,
+    dynamic=True,
+)

package/elizaos/advanced_capabilities/services/__init__.py

@@ -0,0 +1,18 @@
+"""Advanced Services - Extended services for agent operation.
+
+Services that can be enabled with `advanced_capabilities=True`.
+"""
+
+from .follow_up import FollowUpService
+from .rolodex import RolodexService
+
+__all__ = [
+    "FollowUpService",
+    "RolodexService",
+    "advanced_services",
+]
+
+advanced_services: list[type] = [
+    RolodexService,
+    FollowUpService,
+]

package/elizaos/advanced_capabilities/services/follow_up.py

@@ -0,0 +1,138 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import UTC, datetime
+from typing import TYPE_CHECKING
+from uuid import UUID
+
+from elizaos.types import Service, ServiceType
+
+if TYPE_CHECKING:
+    from elizaos.types import IAgentRuntime
+
+
+@dataclass
+class FollowUpTask:
+    entity_id: UUID
+    reason: str
+    message: str | None = None
+    priority: str = "medium"
+    scheduled_at: str = ""
+    metadata: dict[str, str | int | float | bool] = field(default_factory=dict)
+
+
+@dataclass
+class FollowUpSuggestion:
+    entity_id: UUID
+    entity_name: str
+    days_since_last_contact: int
+    relationship_strength: float
+    suggested_reason: str
+
+
+class FollowUpService(Service):
+    name = "follow_up"
+    service_type = ServiceType.TASK
+
+    @property
+    def capability_description(self) -> str:
+        return "Follow-up scheduling and reminder management service"
+
+    def __init__(self) -> None:
+        self._follow_ups: dict[UUID, FollowUpTask] = {}
+        self._runtime: IAgentRuntime | None = None
+
+    @classmethod
+    async def start(cls, runtime: IAgentRuntime) -> FollowUpService:
+        service = cls()
+        service._runtime = runtime
+        runtime.logger.info(
+            "Follow-up service started",
+            src="service:follow_up",
+            agentId=str(runtime.agent_id),
+        )
+        return service
+
+    async def stop(self) -> None:
+        if self._runtime:
+            self._runtime.logger.info(
+                "Follow-up service stopped",
+                src="service:follow_up",
+                agentId=str(self._runtime.agent_id),
+            )
+        self._follow_ups.clear()
+        self._runtime = None
+
+    async def schedule_follow_up(
+        self,
+        entity_id: UUID,
+        scheduled_at: datetime,
+        reason: str,
+        priority: str = "medium",
+        message: str | None = None,
+    ) -> FollowUpTask:
+        task = FollowUpTask(
+            entity_id=entity_id,
+            reason=reason,
+            message=message,
+            priority=priority,
+            scheduled_at=scheduled_at.isoformat(),
+        )
+
+        self._follow_ups[entity_id] = task
+
+        if self._runtime:
+            self._runtime.logger.info(
+                f"Scheduled follow-up with {entity_id}",
+                src="service:follow_up",
+                scheduled_at=task.scheduled_at,
+            )
+
+        return task
+
+    async def get_follow_up(self, entity_id: UUID) -> FollowUpTask | None:
+        return self._follow_ups.get(entity_id)
+
+    async def cancel_follow_up(self, entity_id: UUID) -> bool:
+        if entity_id in self._follow_ups:
+            del self._follow_ups[entity_id]
+            return True
+        return False
+
+    async def get_upcoming_follow_ups(
+        self,
+        days_ahead: int = 7,
+        include_overdue: bool = True,
+    ) -> list[FollowUpTask]:
+        now = datetime.now(UTC)
+        results: list[FollowUpTask] = []
+
+        for task in self._follow_ups.values():
+            scheduled = datetime.fromisoformat(task.scheduled_at.replace("Z", "+00:00"))
+            days_until = (scheduled - now).days
+
+            if include_overdue and days_until < 0 or 0 <= days_until <= days_ahead:
+                results.append(task)
+
+        results.sort(key=lambda t: t.scheduled_at)
+        return results
+
+    async def get_overdue_follow_ups(self) -> list[FollowUpTask]:
+        now = datetime.now(UTC)
+        results: list[FollowUpTask] = []
+
+        for task in self._follow_ups.values():
+            scheduled = datetime.fromisoformat(task.scheduled_at.replace("Z", "+00:00"))
+            if scheduled < now:
+                results.append(task)
+
+        return results
+
+    async def get_follow_up_suggestions(
+        self,
+        max_suggestions: int = 5,
+    ) -> list[FollowUpSuggestion]:
+        return []
+
+    async def complete_follow_up(self, entity_id: UUID) -> bool:
+        return await self.cancel_follow_up(entity_id)

package/elizaos/advanced_capabilities/services/rolodex.py

@@ -0,0 +1,244 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from enum import Enum
+from typing import TYPE_CHECKING
+from uuid import UUID
+
+from elizaos.types import Service, ServiceType
+
+if TYPE_CHECKING:
+    from elizaos.types import IAgentRuntime
+
+
+class ContactCategory(str, Enum):
+    FRIEND = "friend"
+    FAMILY = "family"
+    COLLEAGUE = "colleague"
+    ACQUAINTANCE = "acquaintance"
+    VIP = "vip"
+    BUSINESS = "business"
+
+
+@dataclass
+class ContactPreferences:
+    preferred_channel: str | None = None
+    timezone: str | None = None
+    language: str | None = None
+    contact_frequency: str | None = None
+    do_not_disturb: bool = False
+    notes: str | None = None
+
+
+@dataclass
+class ContactInfo:
+    entity_id: UUID
+    categories: list[str] = field(default_factory=list)
+    tags: list[str] = field(default_factory=list)
+    preferences: ContactPreferences = field(default_factory=ContactPreferences)
+    custom_fields: dict[str, str | int | float | bool] = field(default_factory=dict)
+    privacy_level: str = "private"
+    last_modified: str = ""
+
+
+@dataclass
+class RelationshipAnalytics:
+    strength: float = 0.0
+    interaction_count: int = 0
+    last_interaction_at: str | None = None
+    average_response_time: float | None = None
+    sentiment_score: float | None = None
+    topics_discussed: list[str] = field(default_factory=list)
+
+
+def calculate_relationship_strength(
+    interaction_count: int,
+    last_interaction_at: str | None = None,
+    message_quality: float = 5.0,
+    relationship_type: str = "acquaintance",
+) -> float:
+    interaction_score = min(interaction_count * 2, 40)
+
+    recency_score = 0.0
+    if last_interaction_at:
+        last_dt = datetime.fromisoformat(last_interaction_at.replace("Z", "+00:00"))
+        days_since = (datetime.now(last_dt.tzinfo) - last_dt).days
+        if days_since < 1:
+            recency_score = 30
+        elif days_since < 7:
+            recency_score = 25
+        elif days_since < 30:
+            recency_score = 15
+        elif days_since < 90:
+            recency_score = 5
+
+    quality_score = min(message_quality * 2, 20)
+
+    relationship_bonus = {
+        "family": 10,
+        "friend": 8,
+        "colleague": 6,
+        "acquaintance": 4,
+        "unknown": 0,
+    }
+
+    total = (
+        interaction_score
+        + recency_score
+        + quality_score
+        + relationship_bonus.get(relationship_type, 0)
+    )
+    return max(0.0, min(100.0, round(total, 1)))
+
+
+class RolodexService(Service):
+    name = "rolodex"
+    service_type = ServiceType.UNKNOWN
+
+    @property
+    def capability_description(self) -> str:
+        return "Comprehensive contact and relationship management service"
+
+    def __init__(self) -> None:
+        self._contacts: dict[UUID, ContactInfo] = {}
+        self._analytics: dict[str, RelationshipAnalytics] = {}
+        self._runtime: IAgentRuntime | None = None
+
+    @classmethod
+    async def start(cls, runtime: IAgentRuntime) -> RolodexService:
+        service = cls()
+        service._runtime = runtime
+        runtime.logger.info(
+            "Rolodex service started",
+            src="service:rolodex",
+            agentId=str(runtime.agent_id),
+        )
+        return service
+
+    async def stop(self) -> None:
+        if self._runtime:
+            self._runtime.logger.info(
+                "Rolodex service stopped",
+                src="service:rolodex",
+                agentId=str(self._runtime.agent_id),
+            )
+        self._contacts.clear()
+        self._analytics.clear()
+        self._runtime = None
+
+    async def add_contact(
+        self,
+        entity_id: UUID,
+        categories: list[str] | None = None,
+        preferences: ContactPreferences | None = None,
+        custom_fields: dict[str, str | int | float | bool] | None = None,
+    ) -> ContactInfo:
+        contact = ContactInfo(
+            entity_id=entity_id,
+            categories=categories or ["acquaintance"],
+            tags=[],
+            preferences=preferences or ContactPreferences(),
+            custom_fields=custom_fields or {},
+            privacy_level="private",
+            last_modified=datetime.utcnow().isoformat(),
+        )
+
+        self._contacts[entity_id] = contact
+
+        if self._runtime:
+            self._runtime.logger.info(
+                f"Added contact {entity_id}",
+                src="service:rolodex",
+                categories=contact.categories,
+            )
+
+        return contact
+
+    async def get_contact(self, entity_id: UUID) -> ContactInfo | None:
+        return self._contacts.get(entity_id)
+
+    async def update_contact(
+        self,
+        entity_id: UUID,
+        categories: list[str] | None = None,
+        tags: list[str] | None = None,
+        preferences: ContactPreferences | None = None,
+        custom_fields: dict[str, str | int | float | bool] | None = None,
+    ) -> ContactInfo | None:
+        contact = self._contacts.get(entity_id)
+        if not contact:
+            return None
+
+        if categories is not None:
+            contact.categories = categories
+        if tags is not None:
+            contact.tags = tags
+        if preferences is not None:
+            contact.preferences = preferences
+        if custom_fields is not None:
+            contact.custom_fields = custom_fields
+
+        contact.last_modified = datetime.utcnow().isoformat()
+
+        return contact
+
+    async def remove_contact(self, entity_id: UUID) -> bool:
+        if entity_id in self._contacts:
+            del self._contacts[entity_id]
+            return True
+        return False
+
+    async def search_contacts(
+        self,
+        categories: list[str] | None = None,
+        tags: list[str] | None = None,
+        search_term: str | None = None,
+    ) -> list[ContactInfo]:
+        results = list(self._contacts.values())
+
+        if categories:
+            results = [c for c in results if any(cat in c.categories for cat in categories)]
+
+        if tags:
+            results = [c for c in results if any(tag in c.tags for tag in tags)]
+
+        return results
+
+    async def get_all_contacts(self) -> list[ContactInfo]:
+        return list(self._contacts.values())
+
+    async def get_relationship_analytics(
+        self,
+        entity_id: UUID,
+    ) -> RelationshipAnalytics | None:
+        key = str(entity_id)
+        return self._analytics.get(key)
+
+    async def update_relationship_analytics(
+        self,
+        entity_id: UUID,
+        interaction_count: int | None = None,
+        last_interaction_at: str | None = None,
+    ) -> RelationshipAnalytics:
+        key = str(entity_id)
+        analytics = self._analytics.get(key) or RelationshipAnalytics()
+
+        if interaction_count is not None:
+            analytics.interaction_count = interaction_count
+        if last_interaction_at is not None:
+            analytics.last_interaction_at = last_interaction_at
+
+        contact = self._contacts.get(entity_id)
+        relationship_type = "acquaintance"
+        if contact and contact.categories:
+            relationship_type = contact.categories[0]
+
+        analytics.strength = calculate_relationship_strength(
+            analytics.interaction_count,
+            analytics.last_interaction_at,
+            relationship_type=relationship_type,
+        )
+
+        self._analytics[key] = analytics
+        return analytics

package/elizaos/advanced_memory/__init__.py

@@ -0,0 +1,3 @@
+from .plugin import advanced_memory_plugin, create_advanced_memory_plugin
+
+__all__ = ["advanced_memory_plugin", "create_advanced_memory_plugin"]