@elizaos/python 2.0.0-alpha.11 → 2.0.0-alpha.26

package/elizaos/basic_capabilities/providers/contacts.py

@@ -0,0 +1,79 @@
+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("CONTACTS")
+
+
+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={})
+
+    contact_details: list[dict[str, str]] = []
+    for contact in contacts:
+        entity = await runtime.get_entity(contact.entity_id)
+        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=_spec["name"],
+    description=_spec["description"],
+    get=get_contacts_context,
+    dynamic=_spec.get("dynamic", True),
+    position=_spec.get("position"),
+)

package/elizaos/basic_capabilities/providers/facts.py

@@ -0,0 +1,87 @@
+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("FACTS")
+
+
+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=_spec["name"],
+    description=_spec["description"],
+    get=get_facts_context,
+    dynamic=_spec.get("dynamic", True),
+    position=_spec.get("position"),
+)

package/elizaos/basic_capabilities/providers/follow_ups.py

@@ -0,0 +1,117 @@
+from __future__ import annotations
+
+from datetime import UTC, datetime
+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("FOLLOW_UPS")
+
+
+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]] = []
+
+    for task in upcoming:
+        scheduled = datetime.fromisoformat(task.scheduled_at.replace("Z", "+00:00"))
+        entity = await runtime.get_entity(task.entity_id)
+        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=_spec["name"],
+    description=_spec["description"],
+    get=get_follow_ups_context,
+    dynamic=_spec.get("dynamic", True),
+    position=_spec.get("position"),
+)

package/elizaos/basic_capabilities/providers/knowledge.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from elizaos.generated.spec_helpers import require_provider_spec
+from elizaos.types import Provider, ProviderResult
+from elizaos.types.database import MemorySearchOptions
+
+if TYPE_CHECKING:
+    from elizaos.types import IAgentRuntime, Memory, State
+
+# Get text content from centralized specs
+_spec = require_provider_spec("KNOWLEDGE")
+
+
+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": []}
+        )
+
+    # 1. Fetch recent messages to get embeddings
+    recent_messages = await runtime.get_memories(
+        room_id=message.room_id, limit=5, table_name="messages"
+    )
+
+    # 2. Extract valid embeddings
+    embeddings = [m.embedding for m in recent_messages if m and m.embedding]
+
+    relevant_knowledge = []
+    # 3. Search using the most recent embedding if available
+    if embeddings:
+        primary_embedding = embeddings[0]
+        params = MemorySearchOptions(
+            table_name="knowledge",
+            room_id=message.room_id,
+            embedding=primary_embedding,
+            match_threshold=0.75,
+            match_count=5,
+            unique=True,
+        )
+        relevant_knowledge = await runtime.search_memories(params)
+    elif query_text:
+        # Fallback to search_knowledge if no embeddings found?
+        # TS implementation might rely on search_memories logic handling missing embedding?
+        # No, TS skips if no embedding.
+        pass
+
+    for entry in relevant_knowledge:
+        if entry.content and entry.content.text:
+            knowledge_text = entry.content.text
+            if len(knowledge_text) > 500:
+                knowledge_text = knowledge_text[:500] + "..."
+
+            entry_dict = {
+                "id": str(entry.id) if entry.id else "",
+                "text": knowledge_text,
+                "source": str(entry.metadata.get("source", "unknown"))
+                if entry.metadata
+                else "unknown",
+            }
+            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=_spec["name"],
+    description=_spec["description"],
+    get=get_knowledge_context,
+    dynamic=_spec.get("dynamic", True),
+    position=_spec.get("position"),
+)

package/elizaos/basic_capabilities/providers/relationships.py

@@ -0,0 +1,107 @@
+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("RELATIONSHIPS")
+
+
+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(entity_id=entity_id)
+    except Exception as e:
+        runtime.logger.debug(
+            {"src": "provider:relationships", "agentId": runtime.agent_id, "error": str(e)},
+            "Failed to get relationships",
+        )
+        relationships = []
+
+    if not relationships:
+        return ProviderResult(
+            text="No relationships found.",
+            values={"relationshipCount": 0},
+            data={"relationships": []},
+        )
+
+    sorted_relationships = sorted(
+        relationships,
+        key=lambda r: (r.get("metadata", {}) or {}).get("interactions", 0),
+        reverse=True,
+    )[:30]
+
+    formatted_relationships: list[str] = []
+    entity_cache: dict[object, str] = {}
+    for rel in sorted_relationships:
+        target_id = rel.get("targetEntityId")
+        if not target_id:
+            continue
+
+        target_name = entity_cache.get(target_id)
+        if target_name is None:
+            target_entity = await runtime.get_entity(target_id)
+            target_name = target_entity.name if target_entity else str(target_id)[:8]
+            entity_cache[target_id] = 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=_spec["name"],
+    description=_spec["description"],
+    get=get_relationships,
+    dynamic=_spec.get("dynamic", True),
+    position=_spec.get("position"),
+)

package/elizaos/basic_capabilities/providers/roles.py

@@ -0,0 +1,96 @@
+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("ROLES")
+
+
+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):
+                for entity_id, role in roles.items():
+                    entity = await runtime.get_entity(entity_id)
+                    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=_spec["name"],
+    description=_spec["description"],
+    get=get_roles,
+    dynamic=_spec.get("dynamic", True),
+    position=_spec.get("position"),
+)

package/elizaos/basic_capabilities/providers/settings.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from elizaos.bootstrap.providers.agent_settings import SENSITIVE_KEY_PATTERNS
+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("SETTINGS")
+
+
+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=_spec["name"],
+    description=_spec["description"],
+    get=get_settings_context,
+    dynamic=_spec.get("dynamic", True),
+    position=_spec.get("position"),
+)

package/elizaos/bootstrap/autonomy/__init__.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
-from .action import send_to_admin_action
+from .action import disable_autonomy_action, enable_autonomy_action, send_to_admin_action
+from .evaluators import post_action_evaluator
 from .providers import admin_chat_provider, autonomy_status_provider
 from .routes import autonomy_routes
 from .service import AUTONOMY_SERVICE_TYPE, AutonomyService
@@ -12,6 +13,9 @@ __all__ = [
     "AutonomyService",
     "AUTONOMY_SERVICE_TYPE",
     "send_to_admin_action",
+    "enable_autonomy_action",
+    "disable_autonomy_action",
+    "post_action_evaluator",
     "admin_chat_provider",
     "autonomy_status_provider",
     "autonomy_routes",