@elizaos/python 2.0.0-alpha.10

package/elizaos/basic_capabilities/providers/entities.py

@@ -0,0 +1,99 @@
+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("ENTITIES")
+
+
+async def get_entities_context(
+    runtime: IAgentRuntime,
+    message: Memory,
+    state: State | None = None,
+) -> ProviderResult:
+    room_id = message.room_id
+    sender_id = message.entity_id
+
+    sections: list[str] = []
+    entity_list: list[dict[str, str]] = []
+
+    if sender_id:
+        sender = await runtime.get_entity(sender_id)
+        if sender:
+            sender_info = {
+                "id": str(sender.id),
+                "name": sender.name or "Unknown",
+                "type": sender.entity_type or "user",
+                "role": "sender",
+            }
+            entity_list.append(sender_info)
+            sections.append(
+                f"- **{sender.name or 'Unknown'}** (sender): {sender.entity_type or 'user'}"
+            )
+
+    if room_id:
+        room = await runtime.get_room(room_id)
+        if room and room.world_id:
+            world = await runtime.get_world(room.world_id)
+            if world and world.metadata:
+                member_ids = world.metadata.get("members", [])
+                roles = world.metadata.get("roles", {})
+
+                for member_id in member_ids:
+                    if str(member_id) == str(sender_id):
+                        continue
+
+                    entity = await runtime.get_entity(member_id)
+                    if entity:
+                        role = roles.get(str(member_id), "member")
+                        entity_info = {
+                            "id": str(entity.id),
+                            "name": entity.name or "Unknown",
+                            "type": entity.entity_type or "user",
+                            "role": role,
+                        }
+                        entity_list.append(entity_info)
+                        sections.append(
+                            f"- **{entity.name or 'Unknown'}** ({role}): {entity.entity_type or 'user'}"
+                        )
+
+    agent_entity = await runtime.get_entity(runtime.agent_id)
+    if agent_entity:
+        agent_info = {
+            "id": str(agent_entity.id),
+            "name": agent_entity.name or runtime.character.name,
+            "type": "agent",
+            "role": "self",
+        }
+        entity_list.append(agent_info)
+        sections.append(f"- **{agent_entity.name or runtime.character.name}** (self): agent")
+
+    context_text = "# Entities in Context\n" + "\n".join(sections) if sections else ""
+
+    return ProviderResult(
+        text=context_text,
+        values={
+            "entityCount": len(entity_list),
+            "hasSender": sender_id is not None,
+            "agentId": str(runtime.agent_id),
+        },
+        data={
+            "entities": entity_list,
+            "senderId": str(sender_id) if sender_id else None,
+            "agentId": str(runtime.agent_id),
+        },
+    )
+
+
+entities_provider = Provider(
+    name=_spec["name"],
+    description=_spec["description"],
+    get=get_entities_context,
+    dynamic=_spec.get("dynamic", True),
+)

package/elizaos/basic_capabilities/providers/evaluators.py

@@ -0,0 +1,54 @@
+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_evaluators(
+    runtime: IAgentRuntime,
+    message: Memory,
+    state: State | None = None,
+) -> ProviderResult:
+    evaluator_info: list[dict[str, str]] = []
+
+    for evaluator in runtime.evaluators:
+        evaluator_info.append(
+            {
+                "name": evaluator.name,
+                "description": getattr(evaluator, "description", "No description"),
+            }
+        )
+
+    if not evaluator_info:
+        return ProviderResult(
+            text="No evaluators available.",
+            values={"evaluatorCount": 0},
+            data={"evaluators": []},
+        )
+
+    formatted_evaluators = "\n".join(f"- {e['name']}: {e['description']}" for e in evaluator_info)
+
+    text = f"# Available Evaluators\n{formatted_evaluators}"
+
+    return ProviderResult(
+        text=text,
+        values={
+            "evaluatorCount": len(evaluator_info),
+            "evaluatorNames": [e["name"] for e in evaluator_info],
+        },
+        data={
+            "evaluators": evaluator_info,
+        },
+    )
+
+
+evaluators_provider = Provider(
+    name="EVALUATORS",
+    description="Available evaluators for assessing agent behavior",
+    get=get_evaluators,
+    dynamic=False,
+)

package/elizaos/basic_capabilities/providers/providers_list.py

@@ -0,0 +1,55 @@
+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_providers_list(
+    runtime: IAgentRuntime,
+    message: Memory,
+    state: State | None = None,
+) -> ProviderResult:
+    provider_info: list[dict[str, str | bool]] = []
+
+    for provider in runtime.providers:
+        provider_info.append(
+            {
+                "name": provider.name,
+                "description": getattr(provider, "description", "No description"),
+                "dynamic": getattr(provider, "dynamic", True),
+            }
+        )
+
+    if not provider_info:
+        return ProviderResult(
+            text="No providers available.",
+            values={"providerCount": 0},
+            data={"providers": []},
+        )
+
+    formatted_providers = "\n".join(f"- {p['name']}: {p['description']}" for p in provider_info)
+
+    text = f"# Available Providers\n{formatted_providers}"
+
+    return ProviderResult(
+        text=text,
+        values={
+            "providerCount": len(provider_info),
+            "providerNames": [p["name"] for p in provider_info],
+        },
+        data={
+            "providers": provider_info,
+        },
+    )
+
+
+providers_list_provider = Provider(
+    name="PROVIDERS",
+    description="Available context providers",
+    get=get_providers_list,
+    dynamic=False,
+)

package/elizaos/basic_capabilities/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/basic_capabilities/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/basic_capabilities/providers/world.py

@@ -0,0 +1,93 @@
+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_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="WORLD",
+    description="Provides information about the current world context including settings and members",
+    get=get_world_context,
+    dynamic=True,
+)

package/elizaos/basic_capabilities/services/__init__.py

@@ -0,0 +1,18 @@
+"""Basic Services - Essential services for agent operation.
+
+Core services included by default in the bootstrap plugin.
+"""
+
+from .embedding import EmbeddingService
+from .task import TaskService
+
+__all__ = [
+    "EmbeddingService",
+    "TaskService",
+    "basic_services",
+]
+
+basic_services: list[type] = [
+    TaskService,
+    EmbeddingService,
+]

package/elizaos/basic_capabilities/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)