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

package/elizaos/bootstrap/services/embedding.py

@@ -1,8 +1,12 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+import asyncio
+import contextlib
+from collections import OrderedDict
+from typing import TYPE_CHECKING, Any
 
 from elizaos.types import ModelType, Service, ServiceType
+from elizaos.types.events import EventType
 
 if TYPE_CHECKING:
     from elizaos.types import IAgentRuntime
@@ -18,14 +22,28 @@ 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
+        self._queue_max_size: int = 1000
+        self._queue: asyncio.Queue[tuple[str | None, Any]] = asyncio.Queue(
+            maxsize=self._queue_max_size
+        )
+        self._pending_payload_keys: set[str] = set()
+        self._worker_task: asyncio.Task | None = None
 
     @classmethod
     async def start(cls, runtime: IAgentRuntime) -> EmbeddingService:
         service = cls()
         service._runtime = runtime
+
+        # Register event handler
+        event_name = EventType.Name(EventType.EVENT_TYPE_EMBEDDING_GENERATION_REQUESTED)
+        runtime.register_event(event_name, service._handle_embedding_request)
+
+        # Start worker
+        service._worker_task = asyncio.create_task(service._worker())
+
         runtime.logger.info(
             "Embedding service started",
             src="service:embedding",
@@ -34,6 +52,12 @@ class EmbeddingService(Service):
         return service
 
     async def stop(self) -> None:
+        if self._worker_task:
+            self._worker_task.cancel()
+            with contextlib.suppress(asyncio.CancelledError):
+                await self._worker_task
+            self._worker_task = None
+
         if self._runtime:
             self._runtime.logger.info(
                 "Embedding service stopped",
@@ -41,6 +65,8 @@ class EmbeddingService(Service):
                 agentId=str(self._runtime.agent_id),
             )
         self._cache.clear()
+        self._pending_payload_keys.clear()
+        self._queue = asyncio.Queue(maxsize=self._queue_max_size)
         self._runtime = None
 
     # Max characters for embedding input (~8K tokens at ~4 chars/token)
@@ -51,7 +77,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 +115,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 +134,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)
@@ -120,3 +148,173 @@ class EmbeddingService(Service):
             return 0.0
 
         return dot_product / (magnitude1 * magnitude2)
+
+    async def _handle_embedding_request(self, payload: Any) -> None:
+        """Handle embedding generation request event."""
+        payload_key = self._get_payload_key(payload)
+        if payload_key is not None:
+            if payload_key in self._pending_payload_keys:
+                return
+            self._pending_payload_keys.add(payload_key)
+
+        try:
+            await self._queue.put((payload_key, payload))
+        except Exception:
+            if payload_key is not None:
+                self._pending_payload_keys.discard(payload_key)
+            raise
+
+    def _get_payload_key(self, payload: Any) -> str | None:
+        memory_data = getattr(payload, "memory", None)
+        if memory_data is None:
+            extra = getattr(payload, "extra", None)
+            if hasattr(extra, "__getitem__"):
+                with contextlib.suppress(Exception):
+                    if "memory" in extra:
+                        memory_data = extra["memory"]
+        if memory_data is None and isinstance(payload, dict):
+            memory_data = payload.get("memory")
+        if memory_data is None:
+            return None
+
+        if isinstance(memory_data, dict):
+            memory_id = memory_data.get("id")
+        else:
+            memory_id = getattr(memory_data, "id", None)
+        if memory_id is None:
+            return None
+        return str(memory_id)
+
+    async def _worker(self) -> None:
+        """Background worker for processing embedding requests."""
+        while True:
+            try:
+                payload_key, payload = await self._queue.get()
+            except asyncio.CancelledError:
+                break
+
+            try:
+                await self._process_embedding_request(payload)
+            except Exception as e:
+                if self._runtime:
+                    self._runtime.logger.error(f"Error in embedding worker: {e}", exc_info=True)
+            finally:
+                if payload_key is not None:
+                    self._pending_payload_keys.discard(payload_key)
+                self._queue.task_done()
+
+    async def _process_embedding_request(self, payload: Any) -> None:
+        from elizaos.types.events import EventType
+        from elizaos.types.memory import Memory
+
+        # Extract memory from payload
+        # Handle both protobuf object and dict/wrapper
+        memory_data = None
+        if hasattr(payload, "memory"):  # specific payload
+            memory_data = payload.memory
+        elif hasattr(payload, "extra") and hasattr(
+            payload.extra, "__getitem__"
+        ):  # generic event payload
+            try:
+                # Check if 'memory' is in extra
+                # payload.extra might be a Struct or dict
+                if "memory" in payload.extra:
+                    from elizaos.runtime import _struct_value_to_python
+
+                    mem_val = payload.extra["memory"]
+                    if hasattr(mem_val, "struct_value"):
+                        if mem_val.HasField("struct_value"):
+                            memory_data = _struct_value_to_python(mem_val)
+                        else:
+                            memory_data = mem_val
+                    else:
+                        memory_data = mem_val
+            except Exception:
+                pass
+
+        if not memory_data:
+            return
+
+        # Convert to Memory object if needed
+        if isinstance(memory_data, dict):
+            memory = Memory(
+                id=memory_data.get("id"),
+                content=memory_data.get("content"),
+                room_id=memory_data.get("roomId") or memory_data.get("room_id"),
+                entity_id=memory_data.get("entityId")
+                or memory_data.get("entity_id")
+                or memory_data.get("userId")
+                or memory_data.get("user_id"),
+                agent_id=memory_data.get("agentId") or memory_data.get("agent_id"),
+            )
+            if "embedding" in memory_data:
+                memory.embedding = memory_data["embedding"]
+            if "metadata" in memory_data:
+                memory.metadata = memory_data["metadata"]
+        else:
+            memory = memory_data
+
+        if not memory.id:
+            return
+
+        if memory.embedding and len(memory.embedding) > 0:
+            return
+
+        text = (
+            memory.content.text
+            if hasattr(memory.content, "text")
+            else getattr(memory.content, "text", "")
+        )
+        if not text:
+            return
+
+        embedding_source_text = text
+
+        # Intent generation logic
+        if len(text) > 20:
+            has_intent = False
+            if memory.metadata and isinstance(memory.metadata, dict):
+                has_intent = "intent" in memory.metadata
+
+            if not has_intent:
+                prompt = (
+                    "Analyze the following message and extract the core user intent or a summary "
+                    "of what they are asking/saying. Return ONLY the intent text.\n"
+                    f'Message:\n"{text}"\n\nIntent:'
+                )
+
+                try:
+                    output = await self._runtime.use_model(ModelType.TEXT_SMALL, prompt=prompt)
+
+                    intent = str(output).strip()
+                    if intent:
+                        embedding_source_text = intent
+                        # Update metadata
+                        # Use custom metadata for intent
+                        memory.metadata.custom.custom_data["intent"] = intent
+                except Exception as e:
+                    self._runtime.logger.warning(f"Failed to generate intent: {e}")
+
+        # Generate embedding
+        try:
+            embedding = await self.embed(embedding_source_text)
+            # Protobuf repeated field assignment must extend or use slice
+            if hasattr(memory.embedding, "extend"):  # It's a repeated field
+                del memory.embedding[:]
+                memory.embedding.extend(embedding)
+            else:
+                # If it's a list (unlikely based on error)
+                memory.embedding = embedding
+
+            # Update in DB
+            if getattr(self._runtime, "_adapter", None):
+                await self._runtime._adapter.update_memory(memory)
+
+            # Emit completion
+            await self._runtime.emit_event(
+                EventType.Name(EventType.EVENT_TYPE_EMBEDDING_GENERATION_COMPLETED),
+                {"source": "embedding_service", "memory_id": str(memory.id)},
+            )
+
+        except Exception as e:
+            self._runtime.logger.error(f"Failed to generate embedding: {e}")

package/elizaos/bootstrap/services/rolodex.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from dataclasses import dataclass, field
 from datetime import datetime
-from enum import Enum
+from enum import StrEnum
 from typing import TYPE_CHECKING
 from uuid import UUID
 
@@ -12,7 +12,7 @@ if TYPE_CHECKING:
     from elizaos.types import IAgentRuntime
 
 
-class ContactCategory(str, Enum):
+class ContactCategory(StrEnum):
     FRIEND = "friend"
     FAMILY = "family"
     COLLEAGUE = "colleague"

package/elizaos/bootstrap/services/task.py

@@ -14,7 +14,7 @@ import asyncio
 import contextlib
 import time
 from dataclasses import dataclass
-from enum import Enum
+from enum import StrEnum
 from typing import TYPE_CHECKING, Any, Protocol, runtime_checkable
 from uuid import UUID, uuid4
 
@@ -27,7 +27,7 @@ if TYPE_CHECKING:
 TICK_INTERVAL_MS = 1000
 
 
-class TaskStatus(str, Enum):
+class TaskStatus(StrEnum):
     """Task status enum."""
 
     PENDING = "pending"
@@ -37,7 +37,7 @@ class TaskStatus(str, Enum):
     CANCELLED = "cancelled"
 
 
-class TaskPriority(str, Enum):
+class TaskPriority(StrEnum):
     """Task priority enum."""
 
     LOW = "low"

package/elizaos/deterministic.py

@@ -0,0 +1,193 @@
+from __future__ import annotations
+
+from datetime import UTC, datetime
+from hashlib import sha256
+from typing import Protocol
+from uuid import UUID
+
+DEFAULT_TIME_BUCKET_MS = 5 * 60 * 1000
+
+SeedPart = str | int | float | bool | None
+
+
+class RuntimeLike(Protocol):
+    @property
+    def agent_id(self) -> object: ...
+
+    @property
+    def character(self) -> object: ...
+
+    def get_setting(self, key: str) -> object | None: ...
+
+
+def _normalize_seed_part(part: SeedPart) -> str:
+    if part is None:
+        return "none"
+    return str(part)
+
+
+def _coerce_non_empty_string(value: object | None) -> str | None:
+    if value is None:
+        return None
+    as_text = str(value).strip()
+    if not as_text:
+        return None
+    return as_text
+
+
+def _get_field(obj: object | None, *names: str) -> object | None:
+    if obj is None:
+        return None
+
+    if isinstance(obj, dict):
+        for name in names:
+            if name in obj:
+                value = obj[name]
+                if value is not None and value != "":
+                    return value
+        return None
+
+    for name in names:
+        value = getattr(obj, name, None)
+        if value is not None and value != "":
+            return value
+    return None
+
+
+def build_deterministic_seed(parts: list[SeedPart]) -> str:
+    return "|".join(_normalize_seed_part(part) for part in parts)
+
+
+def deterministic_hex(seed: str, surface: str, length: int = 16) -> str:
+    if length <= 0:
+        return ""
+
+    output = ""
+    counter = 0
+    while len(output) < length:
+        payload = f"{seed}|{surface}|{counter}".encode()
+        output += sha256(payload).hexdigest()
+        counter += 1
+    return output[:length]
+
+
+def deterministic_int(seed: str, surface: str, max_exclusive: int) -> int:
+    if max_exclusive <= 1:
+        return 0
+    value = int(deterministic_hex(seed, surface, 12), 16)
+    return value % max_exclusive
+
+
+def deterministic_uuid(seed: str, surface: str) -> str:
+    return str(UUID(hex=deterministic_hex(seed, surface, 32)))
+
+
+def parse_boolean_setting(value: object | None) -> bool:
+    if isinstance(value, bool):
+        return value
+    if isinstance(value, (int, float)):
+        return value != 0
+    if isinstance(value, str):
+        normalized = value.strip().lower()
+        return normalized in ("1", "true", "yes", "on", "enabled")
+    return False
+
+
+def parse_positive_int_setting(value: object | None, fallback: int) -> int:
+    if isinstance(value, bool):
+        return fallback
+    if isinstance(value, (int, float)):
+        numeric = int(value)
+        return numeric if numeric > 0 else fallback
+    if isinstance(value, str):
+        try:
+            numeric = int(float(value))
+            return numeric if numeric > 0 else fallback
+        except ValueError:
+            return fallback
+    return fallback
+
+
+def build_conversation_seed(
+    runtime: RuntimeLike,
+    message: object | None,
+    state: object | None,
+    surface: str,
+    *,
+    bucket_ms: int | None = None,
+    now_ms: int | None = None,
+) -> str:
+    now_ms_value = now_ms if now_ms is not None else int(datetime.now(UTC).timestamp() * 1000)
+
+    state_data = _get_field(state, "data")
+    room_obj = _get_field(state_data, "room")
+    world_obj = _get_field(state_data, "world")
+
+    room_id = (
+        _coerce_non_empty_string(_get_field(room_obj, "id"))
+        or _coerce_non_empty_string(_get_field(state_data, "room_id", "roomId"))
+        or _coerce_non_empty_string(_get_field(message, "room_id", "roomId"))
+        or "room:none"
+    )
+    world_id = (
+        _coerce_non_empty_string(_get_field(world_obj, "id"))
+        or _coerce_non_empty_string(_get_field(room_obj, "world_id", "worldId"))
+        or _coerce_non_empty_string(_get_field(state_data, "world_id", "worldId"))
+        or _coerce_non_empty_string(_get_field(message, "world_id", "worldId"))
+        or "world:none"
+    )
+
+    character_obj = _get_field(runtime, "character")
+    character_id = (
+        _coerce_non_empty_string(_get_field(character_obj, "id"))
+        or _coerce_non_empty_string(_get_field(runtime, "agent_id"))
+        or "agent:none"
+    )
+
+    epoch_bucket = 0
+    if bucket_ms and bucket_ms > 0:
+        epoch_bucket = now_ms_value // bucket_ms
+
+    return build_deterministic_seed(
+        [
+            "eliza-prompt-cache-v1",
+            world_id,
+            room_id,
+            character_id,
+            epoch_bucket,
+            surface,
+        ]
+    )
+
+
+def get_prompt_reference_datetime(
+    runtime: RuntimeLike,
+    message: object | None,
+    state: object | None,
+    surface: str,
+    *,
+    now: datetime | None = None,
+) -> datetime:
+    now_utc = now.astimezone(UTC) if now is not None else datetime.now(UTC)
+    deterministic_enabled = parse_boolean_setting(
+        runtime.get_setting("PROMPT_CACHE_DETERMINISTIC_TIME")
+    )
+    if not deterministic_enabled:
+        return now_utc
+
+    bucket_ms = parse_positive_int_setting(
+        runtime.get_setting("PROMPT_CACHE_TIME_BUCKET_MS"),
+        DEFAULT_TIME_BUCKET_MS,
+    )
+    now_ms = int(now_utc.timestamp() * 1000)
+    seed = build_conversation_seed(
+        runtime,
+        message,
+        state,
+        surface,
+        bucket_ms=bucket_ms,
+        now_ms=now_ms,
+    )
+    bucket_start = (now_ms // bucket_ms) * bucket_ms
+    offset = deterministic_int(seed, "time-offset-ms", bucket_ms)
+    return datetime.fromtimestamp((bucket_start + offset) / 1000, tz=UTC)

package/elizaos/generated/__init__.py

@@ -0,0 +1 @@
+"""Auto-generated module package."""