@elizaos/python 2.0.0-alpha.10

package/elizaos/advanced_capabilities/evaluators/relationship_extraction.py

@@ -0,0 +1,203 @@
+from __future__ import annotations
+
+import re
+from collections.abc import Awaitable, Callable
+from typing import TYPE_CHECKING
+
+from elizaos.bootstrap.types import EvaluatorResult
+from elizaos.generated.spec_helpers import require_evaluator_spec
+from elizaos.types import ActionResult, Evaluator, HandlerOptions
+
+if TYPE_CHECKING:
+    from elizaos.types import Content, 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(str(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 isinstance(i, dict)
+                    )
+                    if not exists:
+                        existing_identities.append(identity)
+                metadata["platformIdentities"] = existing_identities
+                entity.metadata = metadata
+                await runtime.update_entity(entity)
+
+    runtime.logger.info(
+        f"Completed extraction: src=evaluator:relationship_extraction agentId={runtime.agent_id} identitiesFound={len(identities)} indicatorsFound={len(indicators)}"
+    )
+
+    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)
+
+
+async def _relationship_extraction_handler(
+    runtime: IAgentRuntime,
+    message: Memory,
+    state: State | None = None,
+    options: HandlerOptions | None = None,
+    callback: Callable[[Content], Awaitable[list[Memory]]] | None = None,
+    responses: list[Memory] | None = None,
+) -> ActionResult | None:
+    """Wrapper handler that matches the expected signature."""
+    _ = options, callback, responses  # Unused parameters
+    result = await evaluate_relationship_extraction(runtime, message, state)
+    # Return None as ActionResult - evaluators don't typically return action results
+    return ActionResult(text=result.reason, success=result.passed, values={}, data={})
+
+
+relationship_extraction_evaluator = Evaluator(
+    name=str(_spec["name"]),
+    description=str(_spec["description"]),
+    similes=list(_spec.get("similes", [])) if _spec.get("similes") else [],
+    validate=validate_relationship_extraction,
+    handler=_relationship_extraction_handler,
+    always_run=bool(_spec.get("alwaysRun", False)),
+    examples=[],
+)

package/elizaos/advanced_capabilities/providers/__init__.py

@@ -0,0 +1,36 @@
+"""Advanced Providers - Extended providers for agent operation.
+
+Extended providers that can be enabled with `advanced_capabilities=True`.
+"""
+
+from .agent_settings import agent_settings_provider
+from .contacts import contacts_provider
+from .facts import facts_provider
+from .follow_ups import follow_ups_provider
+from .knowledge import knowledge_provider
+from .relationships import relationships_provider
+from .roles import roles_provider
+from .settings import settings_provider
+
+__all__ = [
+    "agent_settings_provider",
+    "contacts_provider",
+    "facts_provider",
+    "follow_ups_provider",
+    "knowledge_provider",
+    "relationships_provider",
+    "roles_provider",
+    "settings_provider",
+    "advanced_providers",
+]
+
+advanced_providers = [
+    contacts_provider,
+    facts_provider,
+    follow_ups_provider,
+    knowledge_provider,
+    relationships_provider,
+    roles_provider,
+    agent_settings_provider,
+    settings_provider,
+]

package/elizaos/advanced_capabilities/providers/agent_settings.py

@@ -0,0 +1,60 @@
+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
+
+
+SENSITIVE_KEY_PATTERNS = (
+    "key",
+    "secret",
+    "password",
+    "token",
+    "credential",
+    "auth",
+    "private",
+)
+
+
+async def get_agent_settings_context(
+    runtime: IAgentRuntime,
+    message: Memory,
+    state: State | None = None,
+) -> ProviderResult:
+    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)
+
+    sections: list[str] = []
+    if safe_settings:
+        sections.append("# Agent Settings")
+        for key, value in safe_settings.items():
+            display_value = value if len(value) <= 50 else value[:50] + "..."
+            sections.append(f"- {key}: {display_value}")
+
+    context_text = "\n".join(sections) if sections else ""
+
+    return ProviderResult(
+        text=context_text,
+        values={
+            "settingsCount": len(safe_settings),
+            "hasSettings": len(safe_settings) > 0,
+        },
+        data={
+            "settings": safe_settings,
+        },
+    )
+
+
+agent_settings_provider = Provider(
+    name="AGENT_SETTINGS",
+    description="Provides the agent's current configuration settings (filtered for security)",
+    get=get_agent_settings_context,
+    dynamic=True,
+)

package/elizaos/advanced_capabilities/providers/contacts.py

@@ -0,0 +1,77 @@
+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
+
+
+async def get_contacts_context(
+    runtime: IAgentRuntime,
+    message: Memory,
+    state: State | None = None,
+) -> ProviderResult:
+    from elizaos.bootstrap.services.rolodex import RolodexService
+
+    rolodex_service = runtime.get_service("rolodex")
+    if not rolodex_service or not isinstance(rolodex_service, RolodexService):
+        return ProviderResult(text="", values={}, data={})
+
+    contacts = await rolodex_service.get_all_contacts()
+
+    if not contacts:
+        return ProviderResult(text="No contacts in rolodex.", values={"contactCount": 0}, data={})
+
+    entities = await asyncio.gather(
+        *(runtime.get_entity(str(contact.entity_id)) for contact in contacts)
+    )
+    contact_details: list[dict[str, str]] = []
+    for contact, entity in zip(contacts, entities, strict=False):
+        name = entity.name if entity and entity.name else "Unknown"
+        contact_details.append(
+            {
+                "id": str(contact.entity_id),
+                "name": name,
+                "categories": ",".join(contact.categories),
+                "tags": ",".join(contact.tags),
+            }
+        )
+
+    grouped: dict[str, list[dict[str, str]]] = {}
+    for detail in contact_details:
+        for cat in detail["categories"].split(","):
+            cat = cat.strip()
+            if cat:
+                grouped.setdefault(cat, []).append(detail)
+
+    text_summary = f"You have {len(contacts)} contacts in your rolodex:\n"
+
+    for category, items in grouped.items():
+        text_summary += f"\n{category.capitalize()}s ({len(items)}):\n"
+        for item in items:
+            text_summary += f"- {item['name']}"
+            if item["tags"]:
+                text_summary += f" [{item['tags']}]"
+            text_summary += "\n"
+
+    category_counts = {cat: len(items) for cat, items in grouped.items()}
+
+    return ProviderResult(
+        text=text_summary.strip(),
+        values={
+            "contactCount": len(contacts),
+            **category_counts,
+        },
+        data=category_counts,
+    )
+
+
+contacts_provider = Provider(
+    name="CONTACTS",
+    description="Provides contact information from the rolodex",
+    get=get_contacts_context,
+    dynamic=True,
+)

package/elizaos/advanced_capabilities/providers/facts.py

@@ -0,0 +1,82 @@
+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_facts_context(
+    runtime: IAgentRuntime,
+    message: Memory,
+    state: State | None = None,
+) -> ProviderResult:
+    sections: list[str] = []
+    facts_list: list[dict[str, str]] = []
+
+    entity_id = message.entity_id
+    room_id = message.room_id
+
+    if entity_id:
+        sender_facts = await runtime.get_memories(
+            entity_id=entity_id,
+            memory_type="fact",
+            limit=10,
+        )
+
+        if sender_facts:
+            sender = await runtime.get_entity(entity_id)
+            sender_name = sender.name if sender and sender.name else "User"
+            sections.append(f"\n## Facts about {sender_name}")
+
+            for fact in sender_facts:
+                if fact.content and fact.content.text:
+                    fact_text = fact.content.text
+                    if len(fact_text) > 200:
+                        fact_text = fact_text[:200] + "..."
+                    facts_list.append(
+                        {"entityId": str(entity_id), "entityName": sender_name, "fact": fact_text}
+                    )
+                    sections.append(f"- {fact_text}")
+
+    if room_id:
+        room_facts = await runtime.get_memories(
+            room_id=room_id,
+            memory_type="fact",
+            limit=5,
+        )
+
+        if room_facts:
+            sections.append("\n## Room Context Facts")
+            for fact in room_facts:
+                if fact.content and fact.content.text:
+                    fact_text = fact.content.text
+                    if len(fact_text) > 200:
+                        fact_text = fact_text[:200] + "..."
+                    facts_list.append({"roomId": str(room_id), "fact": fact_text})
+                    sections.append(f"- {fact_text}")
+
+    context_text = ""
+    if sections:
+        context_text = "# Known Facts" + "\n".join(sections)
+
+    return ProviderResult(
+        text=context_text,
+        values={
+            "factCount": len(facts_list),
+            "hasFacts": len(facts_list) > 0,
+        },
+        data={
+            "facts": facts_list,
+        },
+    )
+
+
+facts_provider = Provider(
+    name="FACTS",
+    description="Provides known facts about entities learned through conversation",
+    get=get_facts_context,
+    dynamic=True,
+)

package/elizaos/advanced_capabilities/providers/follow_ups.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+import asyncio
+from datetime import UTC, datetime
+from typing import TYPE_CHECKING
+
+from elizaos.types import Provider, ProviderResult
+
+if TYPE_CHECKING:
+    from elizaos.types import IAgentRuntime, Memory, State
+
+
+async def get_follow_ups_context(
+    runtime: IAgentRuntime,
+    message: Memory,
+    state: State | None = None,
+) -> ProviderResult:
+    from elizaos.bootstrap.services.follow_up import FollowUpService
+
+    follow_up_service = runtime.get_service("follow_up")
+    if not follow_up_service or not isinstance(follow_up_service, FollowUpService):
+        return ProviderResult(text="", values={}, data={})
+
+    upcoming = await follow_up_service.get_upcoming_follow_ups(days_ahead=7, include_overdue=True)
+
+    if not upcoming:
+        return ProviderResult(
+            text="No upcoming follow-ups scheduled.", values={"followUpCount": 0}, data={}
+        )
+
+    now = datetime.now(UTC)
+
+    overdue_items: list[dict[str, str]] = []
+    upcoming_items: list[dict[str, str]] = []
+
+    entities = await asyncio.gather(*(runtime.get_entity(str(task.entity_id)) for task in upcoming))
+    for task, entity in zip(upcoming, entities, strict=False):
+        scheduled = datetime.fromisoformat(task.scheduled_at.replace("Z", "+00:00"))
+        name = entity.name if entity and entity.name else "Unknown"
+
+        item = {
+            "entityId": str(task.entity_id),
+            "name": name,
+            "scheduledAt": task.scheduled_at,
+            "reason": task.reason,
+            "priority": task.priority,
+        }
+
+        if scheduled < now:
+            days_overdue = (now - scheduled).days
+            item["daysOverdue"] = str(days_overdue)
+            overdue_items.append(item)
+        else:
+            days_until = (scheduled - now).days
+            item["daysUntil"] = str(days_until)
+            upcoming_items.append(item)
+
+    text_summary = f"You have {len(upcoming)} follow-up(s) scheduled:\n"
+
+    if overdue_items:
+        text_summary += f"\nOverdue ({len(overdue_items)}):\n"
+        for item in overdue_items:
+            text_summary += f"- {item['name']} ({item['daysOverdue']} days overdue)"
+            if item.get("reason"):
+                text_summary += f" - {item['reason']}"
+            text_summary += "\n"
+
+    if upcoming_items:
+        text_summary += f"\nUpcoming ({len(upcoming_items)}):\n"
+        for item in upcoming_items:
+            days = int(item["daysUntil"])
+            if days == 0:
+                time_str = "today"
+            elif days == 1:
+                time_str = "tomorrow"
+            else:
+                time_str = f"in {days} days"
+            text_summary += f"- {item['name']} ({time_str})"
+            if item.get("reason"):
+                text_summary += f" - {item['reason']}"
+            text_summary += "\n"
+
+    suggestions = await follow_up_service.get_follow_up_suggestions()
+    if suggestions:
+        text_summary += "\nSuggested follow-ups:\n"
+        for s in suggestions[:3]:
+            text_summary += (
+                f"- {s.entity_name} ({s.days_since_last_contact} days since last contact)\n"
+            )
+
+    return ProviderResult(
+        text=text_summary.strip(),
+        values={
+            "followUpCount": len(upcoming),
+            "overdueCount": len(overdue_items),
+            "upcomingCount": len(upcoming_items),
+            "suggestionsCount": len(suggestions),
+        },
+        data={
+            "followUpCount": len(upcoming),
+            "overdueCount": len(overdue_items),
+            "upcomingCount": len(upcoming_items),
+            "suggestionsCount": len(suggestions),
+        },
+    )
+
+
+follow_ups_provider = Provider(
+    name="FOLLOW_UPS",
+    description="Provides information about upcoming follow-ups and reminders",
+    get=get_follow_ups_context,
+    dynamic=True,
+)

package/elizaos/advanced_capabilities/providers/knowledge.py

@@ -0,0 +1,83 @@
+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_knowledge_context(
+    runtime: IAgentRuntime,
+    message: Memory,
+    state: State | None = None,
+) -> ProviderResult:
+    sections: list[str] = []
+    knowledge_entries: list[dict[str, str]] = []
+
+    query_text = ""
+    if message.content and message.content.text:
+        query_text = message.content.text
+
+    if not query_text:
+        return ProviderResult(
+            text="", values={"knowledgeCount": 0, "hasKnowledge": False}, data={"entries": []}
+        )
+
+    relevant_knowledge = await runtime.search_knowledge(
+        query=query_text,
+        limit=5,
+    )
+
+    for entry in relevant_knowledge:
+        # Handle both dict and object entries
+        if isinstance(entry, dict):
+            content = entry.get("content", {})
+            text = content.get("text", "") if isinstance(content, dict) else ""
+            entry_id = entry.get("id", "")
+            metadata = entry.get("metadata", {})
+        else:
+            content = getattr(entry, "content", None)
+            text = getattr(content, "text", "") if content else ""
+            entry_id = getattr(entry, "id", "")
+            metadata = getattr(entry, "metadata", {})
+
+        if text:
+            knowledge_text = text
+            if len(knowledge_text) > 500:
+                knowledge_text = knowledge_text[:500] + "..."
+
+            source = "unknown"
+            if isinstance(metadata, dict):
+                source = str(metadata.get("source", "unknown"))
+
+            entry_dict = {
+                "id": str(entry_id) if entry_id else "",
+                "text": knowledge_text,
+                "source": source,
+            }
+            knowledge_entries.append(entry_dict)
+            sections.append(f"- {knowledge_text}")
+
+    context_text = "# Relevant Knowledge\n" + "\n".join(sections) if sections else ""
+
+    return ProviderResult(
+        text=context_text,
+        values={
+            "knowledgeCount": len(knowledge_entries),
+            "hasKnowledge": len(knowledge_entries) > 0,
+        },
+        data={
+            "entries": knowledge_entries,
+            "query": query_text,
+        },
+    )
+
+
+knowledge_provider = Provider(
+    name="KNOWLEDGE",
+    description="Provides relevant knowledge from the agent's knowledge base based on semantic similarity",
+    get=get_knowledge_context,
+    dynamic=True,
+)