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

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/basic_capabilities/providers/time.py

@@ -1,8 +1,8 @@
 from __future__ import annotations
 
-from datetime import UTC, datetime
 from typing import TYPE_CHECKING
 
+from elizaos.deterministic import get_prompt_reference_datetime
 from elizaos.generated.spec_helpers import require_provider_spec
 from elizaos.types import Provider, ProviderResult
 
@@ -18,9 +18,12 @@ async def get_time_context(
     message: Memory,
     state: State | None = None,
 ) -> ProviderResult:
-    _ = runtime, message, state
-
-    now = datetime.now(UTC)
+    now = get_prompt_reference_datetime(
+        runtime,
+        message,
+        state,
+        "provider:time",
+    )
     iso_string = now.isoformat()
     timestamp_ms = int(now.timestamp() * 1000)
     human_readable = now.strftime("%A, %B %d, %Y at %H:%M:%S UTC")

package/elizaos/bootstrap/__init__.py

@@ -1,7 +1,12 @@
 """elizaOS Bootstrap Plugin - Python implementation."""
 
-from .plugin import bootstrap_plugin, create_bootstrap_plugin
-from .types import CapabilityConfig
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .plugin import bootstrap_plugin, create_bootstrap_plugin
+    from .types import CapabilityConfig
 
 __version__ = "2.0.0-alpha.0"
 __all__ = [
@@ -10,3 +15,17 @@ __all__ = [
     "CapabilityConfig",
     "__version__",
 ]
+
+
+def __getattr__(name: str) -> object:
+    if name in {"bootstrap_plugin", "create_bootstrap_plugin"}:
+        from .plugin import bootstrap_plugin, create_bootstrap_plugin
+
+        if name == "bootstrap_plugin":
+            return bootstrap_plugin
+        return create_bootstrap_plugin
+    if name == "CapabilityConfig":
+        from .types import CapabilityConfig
+
+        return CapabilityConfig
+    raise AttributeError(f"module '{__name__}' has no attribute '{name}'")

package/elizaos/bootstrap/actions/schedule_follow_up.py

@@ -3,8 +3,10 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 from datetime import datetime
 from typing import TYPE_CHECKING
+from uuid import UUID as StdUUID
 
 from elizaos.bootstrap.utils.xml import parse_key_value_xml
+from elizaos.deterministic import get_prompt_reference_datetime
 from elizaos.generated.spec_helpers import require_action_spec
 from elizaos.prompts import SCHEDULE_FOLLOW_UP_TEMPLATE
 from elizaos.types import (
@@ -48,6 +50,25 @@ def _convert_spec_examples() -> list[list[ActionExample]]:
     return []
 
 
+def _normalize_priority(raw_priority: str) -> str:
+    normalized = raw_priority.strip().lower()
+    if normalized in {"high", "medium", "low"}:
+        return normalized
+    return "medium"
+
+
+def _coerce_uuid(value: object | None) -> StdUUID | None:
+    if value is None:
+        return None
+    text = str(value).strip()
+    if not text:
+        return None
+    try:
+        return StdUUID(text)
+    except ValueError:
+        return None
+
+
 @dataclass
 class ScheduleFollowUpAction:
     name: str = _spec["name"]
@@ -93,7 +114,12 @@ class ScheduleFollowUpAction:
             )
 
         state = await runtime.compose_state(message, ["RECENT_MESSAGES", "ENTITIES"])
-        state.values["currentDateTime"] = datetime.utcnow().isoformat()
+        state.values["currentDateTime"] = get_prompt_reference_datetime(
+            runtime,
+            message,
+            state,
+            "action:schedule_follow_up",
+        ).isoformat()
 
         prompt = runtime.compose_prompt_from_state(
             state=state,
@@ -114,14 +140,46 @@ class ScheduleFollowUpAction:
         contact_name = str(parsed.get("contactName", ""))
         scheduled_at_str = str(parsed.get("scheduledAt", ""))
         reason = str(parsed.get("reason", "Follow-up"))
-        priority = str(parsed.get("priority", "medium"))
+        priority = _normalize_priority(str(parsed.get("priority", "medium")))
         follow_up_message = str(parsed.get("message", ""))
+        parsed_entity_id = _coerce_uuid(parsed.get("entityId"))
+        message_entity_id = _coerce_uuid(message.entity_id)
+
+        try:
+            scheduled_at = datetime.fromisoformat(scheduled_at_str.replace("Z", "+00:00"))
+        except ValueError:
+            return ActionResult(
+                text="Could not parse the follow-up date/time",
+                success=False,
+                values={"error": True},
+                data={"error": "Invalid follow-up datetime"},
+            )
+
+        entity_id_uuid = parsed_entity_id or message_entity_id
+        if entity_id_uuid is None and contact_name:
+            contacts = await rolodex_service.search_contacts(search_term=contact_name)
+            if contacts:
+                entity_id_uuid = contacts[0].entity_id
 
-        scheduled_at = datetime.fromisoformat(scheduled_at_str.replace("Z", "+00:00"))
+        if entity_id_uuid is None:
+            return ActionResult(
+                text=f"Could not determine which contact to schedule for ({contact_name}).",
+                success=False,
+                values={"error": True},
+                data={"error": "Missing contact entity id"},
+            )
+
+        contact = await rolodex_service.get_contact(entity_id_uuid)
+        if contact is None:
+            return ActionResult(
+                text=f"Contact '{contact_name}' was not found in the rolodex.",
+                success=False,
+                values={"error": True},
+                data={"error": "Contact not found"},
+            )
 
-        entity_id = message.entity_id
         await follow_up_service.schedule_follow_up(
-            entity_id=entity_id,
+            entity_id=entity_id_uuid,
             scheduled_at=scheduled_at,
             reason=reason,
             priority=priority,
@@ -137,11 +195,11 @@ class ScheduleFollowUpAction:
             text=response_text,
             success=True,
             values={
-                "contactId": str(entity_id),
+                "contactId": str(entity_id_uuid),
                 "scheduledAt": scheduled_at.isoformat(),
             },
             data={
-                "contactId": str(entity_id),
+                "contactId": str(entity_id_uuid),
                 "contactName": contact_name,
                 "scheduledAt": scheduled_at.isoformat(),
                 "reason": reason,