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

package/elizaos/__init__.py

@@ -108,7 +108,6 @@ from elizaos.types import (
     string_to_uuid,
 )
 from elizaos.types.database import IDatabaseAdapter  # noqa: E402
-from elizaos.types.environment import ChannelType  # noqa: E402
 from elizaos.types.primitives import (  # noqa: E402
     ChannelType,
     Content,

package/elizaos/advanced_capabilities/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 (
@@ -34,6 +36,25 @@ def _convert_spec_examples() -> list[list[ActionExample]]:
     return convert_spec_examples(_spec)
 
 
+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"]
@@ -79,7 +100,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,
@@ -100,24 +126,53 @@ 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"},
+            )
 
-        scheduled_at = datetime.fromisoformat(scheduled_at_str.replace("Z", "+00:00"))
+        entity_id_uuid = parsed_entity_id or message_entity_id
 
-        from uuid import UUID as StdUUID
+        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
 
-        entity_id = message.entity_id
-        entity_id_uuid = StdUUID(str(entity_id)) if entity_id else None
-        if entity_id_uuid:
-            await follow_up_service.schedule_follow_up(
-                entity_id=entity_id_uuid,
-                scheduled_at=scheduled_at,
-                reason=reason,
-                priority=priority,
-                message=follow_up_message,
+        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"},
+            )
+
+        await follow_up_service.schedule_follow_up(
+            entity_id=entity_id_uuid,
+            scheduled_at=scheduled_at,
+            reason=reason,
+            priority=priority,
+            message=follow_up_message,
+        )
+
         response_text = f"I've scheduled a follow-up with {contact_name} for {scheduled_at.strftime('%B %d, %Y')}. Reason: {reason}"
 
         if callback:
@@ -127,11 +182,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,

package/elizaos/advanced_capabilities/actions/send_message.py

@@ -1,187 +1,12 @@
-from __future__ import annotations
+"""Advanced capabilities SEND_MESSAGE action.
 
-import contextlib
-from dataclasses import dataclass, field
-from typing import TYPE_CHECKING
+Keep this action implementation aligned with bootstrap to guarantee identical
+target parsing and dispatch behavior across capability variants.
+"""
 
-from elizaos.generated.spec_helpers import require_action_spec
-from elizaos.types import Action, ActionExample, ActionResult, Content
-from elizaos.types.memory import Memory as MemoryType
-
-if TYPE_CHECKING:
-    from elizaos.types import HandlerCallback, HandlerOptions, IAgentRuntime, Memory, State
-
-# Get text content from centralized specs
-_spec = require_action_spec("SEND_MESSAGE")
-
-
-def _convert_spec_examples() -> list[list[ActionExample]]:
-    """Convert spec examples to ActionExample format."""
-    spec_examples = _spec.get("examples", [])
-    if not isinstance(spec_examples, list):
-        return []
-    result: list[list[ActionExample]] = []
-    for example in spec_examples:
-        if not isinstance(example, list):
-            continue
-        row: list[ActionExample] = []
-        for msg in example:
-            if not isinstance(msg, dict):
-                continue
-            content = msg.get("content", {})
-            text = ""
-            actions: list[str] | None = None
-            if isinstance(content, dict):
-                text_val = content.get("text", "")
-                text = str(text_val) if text_val else ""
-                actions_val = content.get("actions")
-                if isinstance(actions_val, list) and all(isinstance(a, str) for a in actions_val):
-                    actions = list(actions_val)
-            row.append(
-                ActionExample(
-                    name=str(msg.get("name", "")),
-                    content=Content(text=text, actions=actions),
-                )
-            )
-        if row:
-            result.append(row)
-    return result
-
-
-@dataclass
-class SendMessageAction:
-    name: str = _spec["name"]
-    similes: list[str] = field(default_factory=lambda: list(_spec.get("similes", [])))
-    description: str = _spec["description"]
-
-    async def validate(
-        self, runtime: IAgentRuntime, message: Memory, _state: State | None = None
-    ) -> bool:
-        if message.content and message.content.target:
-            return True
-        return True
-
-    async def handler(
-        self,
-        runtime: IAgentRuntime,
-        message: Memory,
-        state: State | None = None,
-        options: HandlerOptions | None = None,
-        callback: HandlerCallback | None = None,
-        responses: list[Memory] | None = None,
-    ) -> ActionResult:
-        message_text = ""
-        if responses and responses[0].content:
-            message_text = str(responses[0].content.text or "")
-
-        if not message_text:
-            return ActionResult(
-                text="No message content to send",
-                values={"success": False, "error": "no_content"},
-                data={"actionName": "SEND_MESSAGE"},
-                success=False,
-            )
-
-        from uuid import UUID as StdUUID
-
-        target_room_id_val: str | None = str(message.room_id) if message.room_id else None
-        target_entity_id: str | None = None
-
-        if message.content and message.content.target:
-            target = message.content.target
-            if isinstance(target, dict):
-                room_str = target.get("roomId")
-                entity_str = target.get("entityId")
-                if room_str:
-                    with contextlib.suppress(ValueError):
-                        target_room_id_val = str(StdUUID(str(room_str)))
-                if entity_str:
-                    with contextlib.suppress(ValueError):
-                        target_entity_id = str(StdUUID(str(entity_str)))
-
-        if not target_room_id_val:
-            return ActionResult(
-                text="No target room specified",
-                values={"success": False, "error": "no_target"},
-                data={"actionName": "SEND_MESSAGE"},
-                success=False,
-            )
-
-        message_content = Content(
-            text=message_text,
-            source="agent",
-            actions=["SEND_MESSAGE"],
-        )
-
-        # Create the message memory for event emission
-        import time
-        import uuid as uuid_module
-
-        from elizaos.types.primitives import as_uuid
-
-        message_memory = MemoryType(
-            id=as_uuid(str(uuid_module.uuid4())),
-            entity_id=runtime.agent_id,
-            room_id=as_uuid(target_room_id_val) if target_room_id_val else None,
-            content=message_content,
-            created_at=int(time.time() * 1000),
-        )
-
-        await runtime.create_memory(
-            content=message_content,
-            room_id=target_room_id_val,
-            entity_id=runtime.agent_id,
-            memory_type="message",
-            metadata={
-                "type": "SEND_MESSAGE",
-                "targetEntityId": str(target_entity_id) if target_entity_id else None,
-            },
-        )
-
-        # Emit MESSAGE_SENT event
-        await runtime.emit_event(
-            "MESSAGE_SENT",
-            {
-                "runtime": runtime,
-                "source": "send-message-action",
-                "message": message_memory,
-            },
-        )
-
-        response_content = Content(
-            text=f"Message sent: {message_text[:50]}...",
-            actions=["SEND_MESSAGE"],
-        )
-
-        if callback:
-            await callback(response_content)
-
-        return ActionResult(
-            text="Message sent to room",
-            values={
-                "success": True,
-                "messageSent": True,
-                "targetRoomId": str(target_room_id_val),
-                "targetEntityId": str(target_entity_id) if target_entity_id else None,
-            },
-            data={
-                "actionName": "SEND_MESSAGE",
-                "targetRoomId": str(target_room_id_val),
-                "messagePreview": message_text[:100],
-            },
-            success=True,
-        )
-
-    @property
-    def examples(self) -> list[list[ActionExample]]:
-        return _convert_spec_examples()
-
-
-send_message_action = Action(
-    name=SendMessageAction.name,
-    similes=SendMessageAction().similes,
-    description=SendMessageAction.description,
-    validate=SendMessageAction().validate,
-    handler=SendMessageAction().handler,
-    examples=SendMessageAction().examples,
+from elizaos.bootstrap.actions.send_message import (  # re-export for parity
+    SendMessageAction,
+    send_message_action,
 )
+
+__all__ = ["SendMessageAction", "send_message_action"]

package/elizaos/advanced_memory/memory_service.py

@@ -95,38 +95,36 @@ class MemoryService(Service):
     @classmethod
     async def start(cls, runtime):
         svc = cls(runtime=runtime)
-        # read settings
-        settings = runtime.character.settings or {}
-        if (v := settings.get("MEMORY_SUMMARIZATION_THRESHOLD")) is not None and isinstance(
+        if (v := runtime.get_setting("MEMORY_SUMMARIZATION_THRESHOLD")) is not None and isinstance(
             v, (int, float, str)
         ):
             svc._config.short_term_summarization_threshold = int(v)
-        if (v := settings.get("MEMORY_RETAIN_RECENT")) is not None and isinstance(
+        if (v := runtime.get_setting("MEMORY_RETAIN_RECENT")) is not None and isinstance(
             v, (int, float, str)
         ):
             svc._config.short_term_retain_recent = int(v)
-        if (v := settings.get("MEMORY_SUMMARIZATION_INTERVAL")) is not None and isinstance(
+        if (v := runtime.get_setting("MEMORY_SUMMARIZATION_INTERVAL")) is not None and isinstance(
             v, (int, float, str)
         ):
             svc._config.short_term_summarization_interval = int(v)
-        if (v := settings.get("MEMORY_MAX_NEW_MESSAGES")) is not None and isinstance(
+        if (v := runtime.get_setting("MEMORY_MAX_NEW_MESSAGES")) is not None and isinstance(
             v, (int, float, str)
         ):
             svc._config.summary_max_new_messages = int(v)
-        if (v := settings.get("MEMORY_LONG_TERM_ENABLED")) is not None:
+        if (v := runtime.get_setting("MEMORY_LONG_TERM_ENABLED")) is not None:
             if str(v).lower() == "false":
                 svc._config.long_term_extraction_enabled = False
             elif str(v).lower() == "true":
                 svc._config.long_term_extraction_enabled = True
-        if (v := settings.get("MEMORY_CONFIDENCE_THRESHOLD")) is not None and isinstance(
+        if (v := runtime.get_setting("MEMORY_CONFIDENCE_THRESHOLD")) is not None and isinstance(
             v, (int, float, str)
         ):
             svc._config.long_term_confidence_threshold = float(v)
-        if (v := settings.get("MEMORY_EXTRACTION_THRESHOLD")) is not None and isinstance(
+        if (v := runtime.get_setting("MEMORY_EXTRACTION_THRESHOLD")) is not None and isinstance(
             v, (int, float, str)
         ):
             svc._config.long_term_extraction_threshold = int(v)
-        if (v := settings.get("MEMORY_EXTRACTION_INTERVAL")) is not None and isinstance(
+        if (v := runtime.get_setting("MEMORY_EXTRACTION_INTERVAL")) is not None and isinstance(
             v, (int, float, str)
         ):
             svc._config.long_term_extraction_interval = int(v)
@@ -146,7 +144,7 @@ class MemoryService(Service):
         return f"memory:extraction:{entity_id}:{room_id}"
 
     async def get_last_extraction_checkpoint(self, entity_id: UUID, room_id: UUID) -> int:
-        runtime = self.runtime
+        runtime = self._runtime
         key = self._checkpoint_key(entity_id, room_id)
         if runtime is not None and getattr(runtime, "_adapter", None) is not None:
             cached = await runtime.get_cache(key)
@@ -163,7 +161,7 @@ class MemoryService(Service):
     async def set_last_extraction_checkpoint(
         self, entity_id: UUID, room_id: UUID, message_count: int
     ) -> None:
-        runtime = self.runtime
+        runtime = self._runtime
         key = self._checkpoint_key(entity_id, room_id)
         if runtime is not None and getattr(runtime, "_adapter", None) is not None:
             _ = await runtime.set_cache(key, int(message_count))
@@ -182,7 +180,7 @@ class MemoryService(Service):
         return current_cp > last_cp
 
     async def get_current_session_summary(self, room_id: UUID) -> SessionSummary | None:
-        runtime = self.runtime
+        runtime = self._runtime
         if runtime is None:
             return None
 
@@ -234,7 +232,7 @@ class MemoryService(Service):
         topics: list[str] | None = None,
         metadata: dict[str, object] | None = None,
     ) -> SessionSummary:
-        runtime = self.runtime
+        runtime = self._runtime
         s = SessionSummary(
             id=uuid4(),
             agent_id=agent_id,
@@ -279,7 +277,7 @@ class MemoryService(Service):
     async def update_session_summary(
         self, summary_id: UUID, room_id: UUID, **updates: object
     ) -> None:
-        runtime = self.runtime
+        runtime = self._runtime
         if runtime is not None and getattr(runtime, "_adapter", None) is not None:
             existing = await self.get_current_session_summary(room_id)
             if not existing or existing.id != summary_id:
@@ -350,7 +348,7 @@ class MemoryService(Service):
         source: str | None = None,
         metadata: dict[str, object] | None = None,
     ) -> LongTermMemory:
-        runtime = self.runtime
+        runtime = self._runtime
         m = LongTermMemory(
             id=uuid4(),
             agent_id=agent_id,
@@ -394,7 +392,7 @@ class MemoryService(Service):
     ) -> list[LongTermMemory]:
         if limit <= 0:
             return []
-        runtime = self.runtime
+        runtime = self._runtime
         if runtime is not None and getattr(runtime, "_adapter", None) is not None:
             db_mems = await runtime.get_memories(
                 {

package/elizaos/advanced_planning/planning_service.py

@@ -10,7 +10,7 @@ from uuid import UUID, uuid4
 from google.protobuf.json_format import MessageToDict
 
 from elizaos.logger import Logger
-from elizaos.types.components import ActionContext, ActionResult, HandlerCallback, HandlerOptions
+from elizaos.types.components import ActionContext, ActionResult, HandlerCallback
 from elizaos.types.memory import Memory
 from elizaos.types.primitives import Content
 from elizaos.types.service import Service
@@ -538,6 +538,8 @@ Focus on:
         ]
         results = await asyncio.gather(*tasks, return_exceptions=True)
         for r in results:
+            if isinstance(r, Exception):
+                raise RuntimeError(f"Plan step failed during parallel execution: {r}") from r
             if isinstance(r, ActionResult):
                 execution.results.append(r)
 
@@ -586,6 +588,10 @@ Focus on:
 
             for step, r in zip(ready_batch, results, strict=False):
                 completed_count += 1
+                if isinstance(r, Exception):
+                    raise RuntimeError(
+                        f"Plan step '{step.action_name}' failed during DAG execution: {r}"
+                    ) from r
                 if isinstance(r, ActionResult):
                     execution.results.append(r)
 
@@ -622,13 +628,16 @@ Focus on:
             if execution.abort_event.is_set():
                 raise RuntimeError("Plan execution aborted")
             try:
-                options = HandlerOptions(
-                    action_context=action_context,
-                    parameters=step.parameters,
-                )
-                # Attach extra execution context (allowed by extra="allow")
-                options.previous_results = previous_results  # type: ignore[attr-defined]
-                options.context = {"workingMemory": execution.working_memory}  # type: ignore[attr-defined]
+                options = type(
+                    "_PlanningHandlerOptions",
+                    (),
+                    {
+                        "action_context": action_context,
+                        "parameters": step.parameters,
+                        "previous_results": previous_results,
+                        "context": {"workingMemory": execution.working_memory},
+                    },
+                )()
 
                 validate_fn = getattr(action, "validate", None) or getattr(
                     action, "validate_fn", None
@@ -641,12 +650,15 @@ Focus on:
                 if result is None:
                     return None
 
-                if result.data is None:
-                    result.data = {}
-                if isinstance(result.data, dict):
-                    result.data["stepId"] = str(step.id)
-                    result.data["actionName"] = step.action_name
-                    result.data["executedAt"] = int(time.time() * 1000)
+                step_metadata = {
+                    "stepId": str(step.id),
+                    "actionName": step.action_name,
+                    "executedAt": int(time.time() * 1000),
+                }
+                if isinstance(result.data, dict) or hasattr(result.data, "update"):
+                    result.data.update(step_metadata)
+                else:
+                    result.data = step_metadata
                 return result
             except Exception as e:
                 retries += 1