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

package/elizaos/basic_capabilities/providers/__init__.py

@@ -6,7 +6,6 @@ Fundamental providers included by default in the bootstrap plugin.
 from .action_state import action_state_provider
 from .actions import actions_provider
 from .attachments import attachments_provider
-from .capabilities import capabilities_provider
 from .character import character_provider
 from .choice import choice_provider
 from .context_bench import context_bench_provider
@@ -22,7 +21,6 @@ __all__ = [
     "action_state_provider",
     "actions_provider",
     "attachments_provider",
-    "capabilities_provider",
     "character_provider",
     "choice_provider",
     "context_bench_provider",
@@ -40,7 +38,6 @@ basic_providers = [
     actions_provider,
     action_state_provider,
     attachments_provider,
-    capabilities_provider,
     character_provider,
     choice_provider,
     context_bench_provider,

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/agent_settings.py

@@ -0,0 +1,64 @@
+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("AGENT_SETTINGS")
+
+SENSITIVE_KEY_PATTERNS = (
+    "key",
+    "secret",
+    "password",
+    "token",
+    "credential",
+    "auth",
+    "private",
+)
+
+
+async def get_agent_settings_context(
+    runtime: IAgentRuntime,
+    message: Memory,
+    state: State | None = None,
+) -> ProviderResult:
+    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)
+
+    sections: list[str] = []
+    if safe_settings:
+        sections.append("# Agent Settings")
+        for key, value in safe_settings.items():
+            display_value = value if len(value) <= 50 else value[:50] + "..."
+            sections.append(f"- {key}: {display_value}")
+
+    context_text = "\n".join(sections) if sections else ""
+
+    return ProviderResult(
+        text=context_text,
+        values={
+            "settingsCount": len(safe_settings),
+            "hasSettings": len(safe_settings) > 0,
+        },
+        data={
+            "settings": safe_settings,
+        },
+    )
+
+
+agent_settings_provider = Provider(
+    name=_spec["name"],
+    description=_spec["description"],
+    get=get_agent_settings_context,
+    dynamic=_spec.get("dynamic", True),
+    position=_spec.get("position"),
+)

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/contacts.py

@@ -0,0 +1,79 @@
+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("CONTACTS")
+
+
+async def get_contacts_context(
+    runtime: IAgentRuntime,
+    message: Memory,
+    state: State | None = None,
+) -> ProviderResult:
+    from elizaos.bootstrap.services.rolodex import RolodexService
+
+    rolodex_service = runtime.get_service("rolodex")
+    if not rolodex_service or not isinstance(rolodex_service, RolodexService):
+        return ProviderResult(text="", values={}, data={})
+
+    contacts = await rolodex_service.get_all_contacts()
+
+    if not contacts:
+        return ProviderResult(text="No contacts in rolodex.", values={"contactCount": 0}, data={})
+
+    contact_details: list[dict[str, str]] = []
+    for contact in contacts:
+        entity = await runtime.get_entity(str(contact.entity_id))
+        name = entity.name if entity and entity.name else "Unknown"
+        contact_details.append(
+            {
+                "id": str(contact.entity_id),
+                "name": name,
+                "categories": ",".join(contact.categories),
+                "tags": ",".join(contact.tags),
+            }
+        )
+
+    grouped: dict[str, list[dict[str, str]]] = {}
+    for detail in contact_details:
+        for cat in detail["categories"].split(","):
+            cat = cat.strip()
+            if cat:
+                grouped.setdefault(cat, []).append(detail)
+
+    text_summary = f"You have {len(contacts)} contacts in your rolodex:\n"
+
+    for category, items in grouped.items():
+        text_summary += f"\n{category.capitalize()}s ({len(items)}):\n"
+        for item in items:
+            text_summary += f"- {item['name']}"
+            if item["tags"]:
+                text_summary += f" [{item['tags']}]"
+            text_summary += "\n"
+
+    category_counts = {cat: len(items) for cat, items in grouped.items()}
+
+    return ProviderResult(
+        text=text_summary.strip(),
+        values={
+            "contactCount": len(contacts),
+            **category_counts,
+        },
+        data=category_counts,
+    )
+
+
+contacts_provider = Provider(
+    name=_spec["name"],
+    description=_spec["description"],
+    get=get_contacts_context,
+    dynamic=_spec.get("dynamic", True),
+    position=_spec.get("position"),
+)

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/facts.py

@@ -0,0 +1,87 @@
+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("FACTS")
+
+
+async def get_facts_context(
+    runtime: IAgentRuntime,
+    message: Memory,
+    state: State | None = None,
+) -> ProviderResult:
+    sections: list[str] = []
+    facts_list: list[dict[str, str]] = []
+
+    entity_id = message.entity_id
+    room_id = message.room_id
+
+    if entity_id:
+        sender_facts = await runtime.get_memories(
+            entity_id=entity_id,
+            memory_type="fact",
+            limit=10,
+        )
+
+        if sender_facts:
+            sender = await runtime.get_entity(entity_id)
+            sender_name = sender.name if sender and sender.name else "User"
+            sections.append(f"\n## Facts about {sender_name}")
+
+            for fact in sender_facts:
+                if fact.content and fact.content.text:
+                    fact_text = fact.content.text
+                    if len(fact_text) > 200:
+                        fact_text = fact_text[:200] + "..."
+                    facts_list.append(
+                        {"entityId": str(entity_id), "entityName": sender_name, "fact": fact_text}
+                    )
+                    sections.append(f"- {fact_text}")
+
+    if room_id:
+        room_facts = await runtime.get_memories(
+            room_id=room_id,
+            memory_type="fact",
+            limit=5,
+        )
+
+        if room_facts:
+            sections.append("\n## Room Context Facts")
+            for fact in room_facts:
+                if fact.content and fact.content.text:
+                    fact_text = fact.content.text
+                    if len(fact_text) > 200:
+                        fact_text = fact_text[:200] + "..."
+                    facts_list.append({"roomId": str(room_id), "fact": fact_text})
+                    sections.append(f"- {fact_text}")
+
+    context_text = ""
+    if sections:
+        context_text = "# Known Facts" + "\n".join(sections)
+
+    return ProviderResult(
+        text=context_text,
+        values={
+            "factCount": len(facts_list),
+            "hasFacts": len(facts_list) > 0,
+        },
+        data={
+            "facts": facts_list,
+        },
+    )
+
+
+facts_provider = Provider(
+    name=_spec["name"],
+    description=_spec["description"],
+    get=get_facts_context,
+    dynamic=_spec.get("dynamic", True),
+    position=_spec.get("position"),
+)