@elizaos/python 2.0.0-alpha.10

package/elizaos/bootstrap/providers/recent_messages.py

@@ -0,0 +1,85 @@
+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("RECENT_MESSAGES")
+
+
+async def get_recent_messages_context(
+    runtime: IAgentRuntime,
+    message: Memory,
+    state: State | None = None,
+) -> ProviderResult:
+    room_id = message.room_id
+    if not room_id:
+        return ProviderResult(
+            text="", values={"messageCount": 0, "hasHistory": False}, data={"messages": []}
+        )
+
+    sections: list[str] = []
+    message_list: list[dict[str, str | int]] = []
+
+    recent_messages = await runtime.get_memories(
+        room_id=room_id,
+        limit=20,
+        order_by="created_at",
+        order_direction="desc",
+    )
+
+    recent_messages = list(reversed(recent_messages))
+
+    for msg in recent_messages:
+        if not msg.content or not msg.content.text:
+            continue
+
+        sender_name = "Unknown"
+        if msg.entity_id:
+            entity = await runtime.get_entity(msg.entity_id)
+            if entity and entity.name:
+                sender_name = entity.name
+            elif str(msg.entity_id) == str(runtime.agent_id):
+                sender_name = runtime.character.name
+
+        message_text = msg.content.text
+        if len(message_text) > 300:
+            message_text = message_text[:300] + "..."
+
+        msg_dict = {
+            "id": str(msg.id) if msg.id else "",
+            "sender": sender_name,
+            "text": message_text,
+            "timestamp": msg.created_at or 0,
+        }
+        message_list.append(msg_dict)
+        sections.append(f"**{sender_name}**: {message_text}")
+
+    context_text = "# Recent Messages\n" + "\n".join(sections) if sections else ""
+
+    return ProviderResult(
+        text=context_text,
+        values={
+            "messageCount": len(message_list),
+            "hasHistory": len(message_list) > 0,
+            "roomId": str(room_id),
+        },
+        data={
+            "messages": message_list,
+            "roomId": str(room_id),
+        },
+    )
+
+
+recent_messages_provider = Provider(
+    name=_spec["name"],
+    description=_spec["description"],
+    get=get_recent_messages_context,
+    position=_spec.get("position"),
+    dynamic=_spec.get("dynamic", True),
+)

package/elizaos/bootstrap/providers/relationships.py

@@ -0,0 +1,106 @@
+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),
+)

package/elizaos/bootstrap/providers/roles.py

@@ -0,0 +1,95 @@
+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),
+)

package/elizaos/bootstrap/providers/settings.py

@@ -0,0 +1,55 @@
+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),
+)

package/elizaos/bootstrap/providers/time.py

@@ -0,0 +1,45 @@
+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("TIME")
+
+
+async def get_time_context(
+    runtime: IAgentRuntime,
+    message: Memory,
+    state: State | None = None,
+) -> ProviderResult:
+    _ = runtime, message, state
+
+    now = datetime.now(UTC)
+    iso_string = now.isoformat()
+    timestamp_ms = int(now.timestamp() * 1000)
+    human_readable = now.strftime("%A, %B %d, %Y at %H:%M:%S UTC")
+
+    text = (
+        f"The current date and time is {human_readable}. "
+        "Please use this as your reference for any time-based operations or responses."
+    )
+
+    return ProviderResult(
+        text=text,
+        values={"time": human_readable},
+        data={"timestamp": timestamp_ms, "isoString": iso_string},
+    )
+
+
+time_provider = Provider(
+    name=_spec["name"],
+    description=_spec["description"],
+    get=get_time_context,
+    dynamic=_spec.get("dynamic", True),
+)

package/elizaos/bootstrap/providers/world.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
+
+if TYPE_CHECKING:
+    from elizaos.types import IAgentRuntime, Memory, State
+
+# Get text content from centralized specs
+_spec = require_provider_spec("WORLD")
+
+
+async def get_world_context(
+    runtime: IAgentRuntime,
+    message: Memory,
+    state: State | None = None,
+) -> ProviderResult:
+    room_id = message.room_id
+    if not room_id:
+        return ProviderResult(text="", values={"hasWorld": False}, data={})
+
+    room = await runtime.get_room(room_id)
+    if not room or not room.world_id:
+        return ProviderResult(
+            text="",
+            values={"hasWorld": False, "roomId": str(room_id)},
+            data={"roomId": str(room_id)},
+        )
+
+    world = await runtime.get_world(room.world_id)
+    if not world:
+        return ProviderResult(
+            text="",
+            values={"hasWorld": False, "roomId": str(room_id)},
+            data={"roomId": str(room_id)},
+        )
+
+    sections: list[str] = []
+
+    sections.append(f"# World: {world.name or 'Unknown'}")
+    if world.metadata and world.metadata.get("description"):
+        sections.append(f"\n{world.metadata['description']}")
+
+    sections.append(f"\n## Current Room: {room.name or 'Unknown'}")
+    if room.metadata and room.metadata.get("topic"):
+        sections.append(f"Topic: {room.metadata['topic']}")
+
+    member_count = 0
+    if world.metadata and world.metadata.get("members"):
+        member_count = len(world.metadata["members"])
+    sections.append(f"\n## Members: {member_count}")
+
+    if world.metadata and world.metadata.get("settings"):
+        safe_settings = {
+            k: v
+            for k, v in world.metadata["settings"].items()
+            if not k.lower().endswith(("key", "secret", "password", "token"))
+        }
+        if safe_settings:
+            settings_list = [f"- {k}: {v}" for k, v in safe_settings.items()]
+            sections.append("\n## Settings\n" + "\n".join(settings_list))
+
+    context_text = "\n".join(sections)
+
+    return ProviderResult(
+        text=context_text,
+        values={
+            "hasWorld": True,
+            "worldId": str(world.id),
+            "worldName": world.name or "Unknown",
+            "roomId": str(room_id),
+            "roomName": room.name or "Unknown",
+            "memberCount": member_count,
+        },
+        data={
+            "world": {
+                "id": str(world.id),
+                "name": world.name,
+                "metadata": world.metadata,
+            },
+            "room": {
+                "id": str(room_id),
+                "name": room.name,
+                "metadata": room.metadata,
+            },
+        },
+    )
+
+
+world_provider = Provider(
+    name=_spec["name"],
+    description=_spec["description"],
+    get=get_world_context,
+    dynamic=_spec.get("dynamic", True),
+)

package/elizaos/bootstrap/services/__init__.py

@@ -0,0 +1,26 @@
+from .embedding import EmbeddingService
+from .follow_up import FollowUpService
+from .rolodex import RolodexService
+from .task import TaskService
+
+__all__ = [
+    "EmbeddingService",
+    "FollowUpService",
+    "RolodexService",
+    "TaskService",
+    "BASIC_SERVICES",
+    "EXTENDED_SERVICES",
+    "ALL_SERVICES",
+]
+
+BASIC_SERVICES = [
+    TaskService,
+    EmbeddingService,
+]
+
+EXTENDED_SERVICES: list[type] = [
+    RolodexService,
+    FollowUpService,
+]
+
+ALL_SERVICES = BASIC_SERVICES + EXTENDED_SERVICES

package/elizaos/bootstrap/services/embedding.py

@@ -0,0 +1,122 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from elizaos.types import ModelType, Service, ServiceType
+
+if TYPE_CHECKING:
+    from elizaos.types import IAgentRuntime
+
+
+class EmbeddingService(Service):
+    name = "embedding"
+    service_type = ServiceType.UNKNOWN
+
+    @property
+    def capability_description(self) -> str:
+        return "Text embedding service for generating and caching text embeddings."
+
+    def __init__(self) -> None:
+        self._runtime: IAgentRuntime | None = None
+        self._cache: dict[str, list[float]] = {}
+        self._cache_enabled: bool = True
+        self._max_cache_size: int = 1000
+
+    @classmethod
+    async def start(cls, runtime: IAgentRuntime) -> EmbeddingService:
+        service = cls()
+        service._runtime = runtime
+        runtime.logger.info(
+            "Embedding service started",
+            src="service:embedding",
+            agentId=str(runtime.agent_id),
+        )
+        return service
+
+    async def stop(self) -> None:
+        if self._runtime:
+            self._runtime.logger.info(
+                "Embedding service stopped",
+                src="service:embedding",
+                agentId=str(self._runtime.agent_id),
+            )
+        self._cache.clear()
+        self._runtime = None
+
+    # Max characters for embedding input (~8K tokens at ~4 chars/token)
+    MAX_EMBEDDING_CHARS = 32_000
+
+    async def embed(self, text: str) -> list[float]:
+        if self._runtime is None:
+            raise ValueError("Embedding service not started - no runtime available")
+
+        if self._cache_enabled and text in self._cache:
+            return self._cache[text]
+
+        # Truncate to stay within embedding model token limits
+        embed_text = text
+        if len(embed_text) > self.MAX_EMBEDDING_CHARS:
+            self._runtime.logger.warning(
+                "Truncating embedding input from %d to %d chars",
+                len(embed_text),
+                self.MAX_EMBEDDING_CHARS,
+                src="service:embedding",
+            )
+            embed_text = embed_text[: self.MAX_EMBEDDING_CHARS]
+
+        embedding = await self._runtime.use_model(
+            ModelType.TEXT_EMBEDDING,
+            text=embed_text,
+        )
+
+        if not isinstance(embedding, list):
+            raise ValueError(f"Expected list for embedding, got {type(embedding)}")
+
+        embedding = [float(x) for x in embedding]
+
+        if self._cache_enabled:
+            self._add_to_cache(text, embedding)
+
+        return embedding
+
+    async def embed_batch(self, texts: list[str]) -> list[list[float]]:
+        embeddings: list[list[float]] = []
+        for text in texts:
+            embedding = await self.embed(text)
+            embeddings.append(embedding)
+        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]
+        self._cache[text] = embedding
+
+    def clear_cache(self) -> None:
+        self._cache.clear()
+
+    def set_cache_enabled(self, enabled: bool) -> None:
+        self._cache_enabled = enabled
+        if not enabled:
+            self._cache.clear()
+
+    def set_max_cache_size(self, size: int) -> None:
+        if size <= 0:
+            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]
+
+    async def similarity(self, text1: str, text2: str) -> float:
+        embedding1 = await self.embed(text1)
+        embedding2 = await self.embed(text2)
+
+        dot_product = sum(a * b for a, b in zip(embedding1, embedding2, strict=True))
+        magnitude1 = sum(a * a for a in embedding1) ** 0.5
+        magnitude2 = sum(b * b for b in embedding2) ** 0.5
+
+        if magnitude1 == 0 or magnitude2 == 0:
+            return 0.0
+
+        return dot_product / (magnitude1 * magnitude2)