@elizaos/python 2.0.0-alpha.3 → 2.0.0-alpha.31

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(str(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,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("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 = {
+            "tableName": "knowledge",
+            "roomId": str(message.room_id),
+            "embedding": primary_embedding,
+            "matchThreshold": 0.75,
+            "matchCount": 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/recent_messages.py

@@ -25,12 +25,17 @@ async def get_recent_messages_context(
 
     sections: list[str] = []
     message_list: list[dict[str, str | int]] = []
+    room = await runtime.get_room(room_id)
+    last_compaction_at = None
+    if room and getattr(room, "metadata", None):
+        last_compaction_at = room.metadata.get("lastCompactionAt")
 
     recent_messages = await runtime.get_memories(
         room_id=room_id,
         limit=20,
         order_by="created_at",
         order_direction="desc",
+        start=last_compaction_at,
     )
 
     recent_messages = list(reversed(recent_messages))

package/elizaos/basic_capabilities/providers/relationships.py

@@ -0,0 +1,113 @@
+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({"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(relationship: object) -> int:
+        if isinstance(relationship, dict):
+            metadata = relationship.get("metadata", {})
+            if isinstance(metadata, dict):
+                value = metadata.get("interactions", 0)
+                return int(value) if isinstance(value, (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=_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/basic_capabilities/services/embedding.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from collections import OrderedDict
 from typing import TYPE_CHECKING
 
 from elizaos.types import ModelType, Service, ServiceType
@@ -18,7 +19,7 @@ class EmbeddingService(Service):
 
     def __init__(self) -> None:
         self._runtime: IAgentRuntime | None = None
-        self._cache: dict[str, list[float]] = {}
+        self._cache: OrderedDict[str, list[float]] = OrderedDict()
         self._cache_enabled: bool = True
         self._max_cache_size: int = 1000
 
@@ -51,7 +52,9 @@ class EmbeddingService(Service):
             raise ValueError("Embedding service not started - no runtime available")
 
         if self._cache_enabled and text in self._cache:
-            return self._cache[text]
+            embedding = self._cache.pop(text)
+            self._cache[text] = embedding
+            return embedding
 
         # Truncate to stay within embedding model token limits
         embed_text = text
@@ -87,9 +90,10 @@ class EmbeddingService(Service):
         return embeddings
 
     def _add_to_cache(self, text: str, embedding: list[float]) -> None:
-        if len(self._cache) >= self._max_cache_size:
-            oldest_key = next(iter(self._cache))
-            del self._cache[oldest_key]
+        if text in self._cache:
+            self._cache.pop(text)
+        elif len(self._cache) >= self._max_cache_size:
+            self._cache.popitem(last=False)
         self._cache[text] = embedding
 
     def clear_cache(self) -> None:
@@ -105,8 +109,7 @@ class EmbeddingService(Service):
             raise ValueError("Cache size must be positive")
         self._max_cache_size = size
         while len(self._cache) > self._max_cache_size:
-            oldest_key = next(iter(self._cache))
-            del self._cache[oldest_key]
+            self._cache.popitem(last=False)
 
     async def similarity(self, text1: str, text2: str) -> float:
         embedding1 = await self.embed(text1)

package/elizaos/basic_capabilities/services/task.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from dataclasses import dataclass, field
 from datetime import UTC, datetime
-from enum import Enum
+from enum import StrEnum
 from typing import TYPE_CHECKING
 from uuid import UUID, uuid4
 
@@ -12,7 +12,7 @@ if TYPE_CHECKING:
     from elizaos.types import IAgentRuntime
 
 
-class TaskStatus(str, Enum):
+class TaskStatus(StrEnum):
     PENDING = "PENDING"
     IN_PROGRESS = "IN_PROGRESS"
     COMPLETED = "COMPLETED"
@@ -20,7 +20,7 @@ class TaskStatus(str, Enum):
     CANCELLED = "CANCELLED"
 
 
-class TaskPriority(str, Enum):
+class TaskPriority(StrEnum):
     LOW = "LOW"
     MEDIUM = "MEDIUM"
     HIGH = "HIGH"

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/__init__.py

@@ -7,6 +7,7 @@ from .mute_room import mute_room_action
 from .none import none_action
 from .remove_contact import remove_contact_action
 from .reply import reply_action
+from .reset_session import reset_session_action
 from .roles import update_role_action
 from .schedule_follow_up import schedule_follow_up_action
 from .search_contacts import search_contacts_action
@@ -26,6 +27,7 @@ __all__ = [
     "mute_room_action",
     "none_action",
     "remove_contact_action",
+    "reset_session_action",
     "reply_action",
     "schedule_follow_up_action",
     "search_contacts_action",
@@ -54,6 +56,7 @@ EXTENDED_ACTIONS = [
     generate_image_action,
     mute_room_action,
     remove_contact_action,
+    reset_session_action,
     schedule_follow_up_action,
     search_contacts_action,
     send_message_action,

package/elizaos/bootstrap/actions/reset_session.py

@@ -0,0 +1,3 @@
+from elizaos.advanced_memory.actions.reset_session import reset_session_action
+
+__all__ = ["reset_session_action"]