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

package/elizaos/basic_capabilities/providers/actions.py

@@ -1,10 +1,16 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+import contextlib
+from typing import TYPE_CHECKING, TypeVar, cast
 
 from google.protobuf.json_format import MessageToDict
 
 from elizaos.action_docs import get_canonical_action_example_calls
+from elizaos.deterministic import (
+    build_conversation_seed,
+    build_deterministic_seed,
+    deterministic_int,
+)
 from elizaos.generated.spec_helpers import require_provider_spec
 from elizaos.types import Provider, ProviderResult
 from elizaos.types.components import ActionExample
@@ -23,10 +29,6 @@ if TYPE_CHECKING:
 _spec = require_provider_spec("ACTIONS")
 
 
-def format_action_names(actions: list[Action]) -> str:
-    return ", ".join(action.name for action in actions)
-
-
 def _format_parameter_type(schema: ActionParameterSchema) -> str:
     if schema.type == "number" and (schema.minimum is not None or schema.maximum is not None):
         min_val = schema.minimum if schema.minimum is not None else "∞"
@@ -35,9 +37,10 @@ def _format_parameter_type(schema: ActionParameterSchema) -> str:
     return schema.type
 
 
-def _get_param_schema(param: ActionParameter) -> object:
+def _get_param_schema(param: ActionParameter) -> ActionParameterSchema | None:
     """Get schema from ActionParameter, handling both Pydantic and protobuf variants."""
-    return getattr(param, "schema_def", None) or getattr(param, "schema", None)
+    schema = getattr(param, "schema_def", None) or getattr(param, "schema", None)
+    return cast("ActionParameterSchema | None", schema)
 
 
 def _format_action_parameters(parameters: list[ActionParameter]) -> str:
@@ -64,9 +67,23 @@ def _format_action_parameters(parameters: list[ActionParameter]) -> str:
     return "\n".join(lines)
 
 
-def format_actions(actions: list[Action]) -> str:
+T = TypeVar("T")
+
+
+def _deterministic_shuffle(items: list[T], seed: str, surface: str = "shuffle") -> list[T]:
+    shuffled = list(items)
+    for i in range(len(shuffled) - 1, 0, -1):
+        j = deterministic_int(seed, f"{surface}:{i}", i + 1)
+        shuffled[i], shuffled[j] = shuffled[j], shuffled[i]
+    return shuffled
+
+
+def format_actions(actions: list[Action], seed: str | None = None) -> str:
+    deterministic_seed = seed or build_deterministic_seed(
+        ["actions-format", ",".join(action.name for action in actions)]
+    )
     lines: list[str] = []
-    for action in actions:
+    for action in _deterministic_shuffle(actions, deterministic_seed, "actions"):
         line = f"- **{action.name}**: {action.description or 'No description'}"
         if action.parameters:
             params_text = _format_action_parameters(action.parameters)
@@ -83,7 +100,24 @@ def _replace_name_placeholders(text: str) -> str:
     return text
 
 
-def format_action_examples(actions: list[Action], max_examples: int = 10) -> str:
+def _replace_name_placeholders_seeded(text: str, seed: str, example_index: int) -> str:
+    names = ["Alex", "Jordan", "Sam", "Taylor", "Riley"]
+    output = text
+    for placeholder_index in range(1, 6):
+        name_index = deterministic_int(
+            seed,
+            f"example:{example_index}:name:{placeholder_index}",
+            len(names),
+        )
+        output = output.replace(f"{{{{name{placeholder_index}}}}}", names[name_index])
+    return output
+
+
+def format_action_examples(
+    actions: list[Action],
+    max_examples: int = 10,
+    seed: str | None = None,
+) -> str:
     """
     Format a deterministic subset of action examples for prompt context.
 
@@ -92,27 +126,60 @@ def format_action_examples(actions: list[Action], max_examples: int = 10) -> str
     if max_examples <= 0:
         return ""
 
-    examples: list[list[ActionExample]] = []
-    for action in sorted(actions, key=lambda a: a.name):
-        if not action.examples:
-            continue
-        for ex in action.examples:
-            if isinstance(ex, list) and ex:
-                examples.append(ex)
-            if len(examples) >= max_examples:
-                break
-        if len(examples) >= max_examples:
-            break
-
-    if not examples:
+    actions_with_examples = [
+        action
+        for action in actions
+        if action.examples and isinstance(action.examples, list) and len(action.examples) > 0
+    ]
+    if not actions_with_examples:
         return ""
 
+    examples_copy: list[list[list[ActionExample]]] = [
+        [example for example in (action.examples or []) if isinstance(example, list) and example]
+        for action in actions_with_examples
+    ]
+    available_action_indices = [
+        idx for idx, action_examples in enumerate(examples_copy) if action_examples
+    ]
+
+    selection_seed = seed or build_deterministic_seed(
+        [
+            "action-examples",
+            ",".join(action.name for action in actions_with_examples),
+            max_examples,
+        ]
+    )
+
+    selected_examples: list[list[ActionExample]] = []
+    iteration = 0
+    while len(selected_examples) < max_examples and available_action_indices:
+        random_index = deterministic_int(
+            selection_seed,
+            f"action-index:{iteration}",
+            len(available_action_indices),
+        )
+        action_index = available_action_indices[random_index]
+        action_examples = examples_copy[action_index]
+
+        example_index = deterministic_int(
+            selection_seed,
+            f"example-index:{iteration}",
+            len(action_examples),
+        )
+        selected_examples.append(action_examples.pop(example_index))
+        iteration += 1
+
+        if not action_examples:
+            available_action_indices.pop(random_index)
+
     blocks: list[str] = []
-    for ex in examples:
+    for example_index, ex in enumerate(selected_examples):
         lines: list[str] = []
         for msg in ex:
             msg_text = msg.content.text if msg.content and msg.content.text else ""
-            lines.append(f"{msg.name}: {_replace_name_placeholders(msg_text)}")
+            lines.append(
+                f"{msg.name}: {_replace_name_placeholders_seeded(msg_text, selection_seed, example_index)}"
+            )
         blocks.append("\n".join(lines))
 
     return "\n\n".join(blocks)
@@ -182,6 +249,17 @@ def format_action_call_examples(actions: list[Action], max_examples: int = 5) ->
     return "\n\n".join(blocks)
 
 
+def format_action_names(actions: list[Action], seed: str | None = None) -> str:
+    if not actions:
+        return ""
+
+    deterministic_seed = seed or build_deterministic_seed(
+        ["action-names", ",".join(action.name for action in actions)]
+    )
+    shuffled = _deterministic_shuffle(actions, deterministic_seed, "actions")
+    return ", ".join(action.name for action in shuffled)
+
+
 async def get_actions(
     runtime: IAgentRuntime,
     message: Memory,
@@ -193,16 +271,27 @@ async def get_actions(
         # Support both validate and validate_fn for backwards compatibility
         validate_fn = getattr(action, "validate", None) or getattr(action, "validate_fn", None)
         if validate_fn:
-            is_valid = await validate_fn(runtime, message, state)
+            try:
+                is_valid = await validate_fn(runtime, message, state)
+            except Exception:
+                if hasattr(runtime, "logger"):
+                    with contextlib.suppress(Exception):
+                        runtime.logger.warning(
+                            f"Action validation failed for {action.name}; excluding from prompt"
+                        )
+                is_valid = False
             if is_valid:
                 validated_actions.append(action)
         else:
             # If no validation function, include the action
             validated_actions.append(action)
 
-    action_names = format_action_names(validated_actions)
-    actions_text = format_actions(validated_actions)
-    examples_text = format_action_examples(validated_actions, max_examples=10)
+    action_seed = build_conversation_seed(runtime, message, state, "provider:actions")
+    action_names = format_action_names(validated_actions, seed=f"{action_seed}:names")
+    actions_text = format_actions(validated_actions, seed=f"{action_seed}:descriptions")
+    examples_text = format_action_examples(
+        validated_actions, max_examples=10, seed=f"{action_seed}:examples"
+    )
     call_examples_text = format_action_call_examples(validated_actions, max_examples=5)
 
     text_parts: list[str] = [f"Possible response actions: {action_names}"]

package/elizaos/basic_capabilities/providers/character.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from collections.abc import Iterable
 from typing import TYPE_CHECKING
 
 from elizaos.generated.spec_helpers import require_provider_spec
@@ -27,6 +28,19 @@ def _resolve_name_list(items: list[str], name: str) -> list[str]:
     return [_resolve_name(s, name) for s in items]
 
 
+def _coerce_text_list(value: object) -> list[str]:
+    """Normalize protobuf repeated fields and plain Python values to list[str]."""
+    if value is None:
+        return []
+    if isinstance(value, str):
+        return [value]
+    if isinstance(value, (list, tuple)):
+        return [str(item) for item in value]
+    if isinstance(value, Iterable):
+        return [str(item) for item in value]
+    return [str(value)]
+
+
 async def get_character_context(
     runtime: IAgentRuntime,
     message: Memory,
@@ -47,11 +61,7 @@ async def get_character_context(
         sections.append(f"\n## Bio\n{bio_text}")
 
     if character.adjectives:
-        adjectives = (
-            character.adjectives
-            if isinstance(character.adjectives, list)
-            else [character.adjectives]
-        )
+        adjectives = _coerce_text_list(character.adjectives)
         resolved_adjectives = _resolve_name_list(adjectives, agent_name)
         sections.append(f"\n## Personality Traits\n{', '.join(resolved_adjectives)}")
 
@@ -65,34 +75,22 @@ async def get_character_context(
         sections.append(f"\n## Background\n{lore_text}")
 
     if character.topics:
-        topics = character.topics if isinstance(character.topics, list) else [character.topics]
+        topics = _coerce_text_list(character.topics)
         resolved_topics = _resolve_name_list(topics, agent_name)
         sections.append(f"\n## Knowledge Areas\n{', '.join(resolved_topics)}")
 
     if character.style:
         style_sections: list[str] = []
         if character.style.all:
-            all_style = (
-                character.style.all
-                if isinstance(character.style.all, list)
-                else [character.style.all]
-            )
+            all_style = _coerce_text_list(character.style.all)
             resolved_all = _resolve_name_list(all_style, agent_name)
             style_sections.append(f"General: {', '.join(resolved_all)}")
         if character.style.chat:
-            chat_style = (
-                character.style.chat
-                if isinstance(character.style.chat, list)
-                else [character.style.chat]
-            )
+            chat_style = _coerce_text_list(character.style.chat)
             resolved_chat = _resolve_name_list(chat_style, agent_name)
             style_sections.append(f"Chat: {', '.join(resolved_chat)}")
         if character.style.post:
-            post_style = (
-                character.style.post
-                if isinstance(character.style.post, list)
-                else [character.style.post]
-            )
+            post_style = _coerce_text_list(character.style.post)
             resolved_post = _resolve_name_list(post_style, agent_name)
             style_sections.append(f"Posts: {', '.join(resolved_post)}")
         if style_sections:

package/elizaos/basic_capabilities/providers/current_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_current_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:current_time",
+    )
 
     iso_timestamp = now.isoformat()
     human_readable = now.strftime("%A, %B %d, %Y at %H:%M:%S UTC")

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/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/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 (
@@ -48,6 +50,25 @@ def _convert_spec_examples() -> list[list[ActionExample]]:
     return []
 
 
+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"]
@@ -93,7 +114,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,
@@ -114,14 +140,46 @@ 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"},
+            )
+
+        entity_id_uuid = parsed_entity_id or message_entity_id
+        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
 
-        scheduled_at = datetime.fromisoformat(scheduled_at_str.replace("Z", "+00:00"))
+        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"},
+            )
 
-        entity_id = message.entity_id
         await follow_up_service.schedule_follow_up(
-            entity_id=entity_id,
+            entity_id=entity_id_uuid,
             scheduled_at=scheduled_at,
             reason=reason,
             priority=priority,
@@ -137,11 +195,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,