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

package/elizaos/generated/spec_helpers.py

@@ -0,0 +1,175 @@
+"""
+Helper functions to lookup action/provider/evaluator specs by name.
+These allow language-specific implementations to import their text content
+(description, similes, examples) from the centralized specs.
+
+DO NOT EDIT the spec data - update packages/prompts/specs/** and regenerate.
+"""
+
+from .action_docs import (
+    ActionDoc,
+    EvaluatorDoc,
+    ProviderDoc,
+    all_action_docs,
+    all_evaluator_docs,
+    all_provider_docs,
+    core_action_docs,
+    core_evaluator_docs,
+    core_provider_docs,
+)
+
+
+def _get_items(doc: object, key: str) -> list[dict[str, object]]:
+    if not isinstance(doc, dict):
+        return []
+    raw = doc.get(key)
+    if not isinstance(raw, list):
+        return []
+    return [item for item in raw if isinstance(item, dict)]
+
+
+# Build lookup dicts for O(1) access
+_core_action_map: dict[str, ActionDoc] = {}
+for action in _get_items(core_action_docs, "actions"):
+    name = action.get("name")
+    if isinstance(name, str):
+        _core_action_map[name] = action  # type: ignore[assignment]
+
+_all_action_map: dict[str, ActionDoc] = {}
+for action in _get_items(all_action_docs, "actions"):
+    name = action.get("name")
+    if isinstance(name, str):
+        _all_action_map[name] = action  # type: ignore[assignment]
+
+_core_provider_map: dict[str, ProviderDoc] = {}
+for provider in _get_items(core_provider_docs, "providers"):
+    name = provider.get("name")
+    if isinstance(name, str):
+        _core_provider_map[name] = provider  # type: ignore[assignment]
+
+_all_provider_map: dict[str, ProviderDoc] = {}
+for provider in _get_items(all_provider_docs, "providers"):
+    name = provider.get("name")
+    if isinstance(name, str):
+        _all_provider_map[name] = provider  # type: ignore[assignment]
+
+_core_evaluator_map: dict[str, EvaluatorDoc] = {}
+for evaluator in _get_items(core_evaluator_docs, "evaluators"):
+    name = evaluator.get("name")
+    if isinstance(name, str):
+        _core_evaluator_map[name] = evaluator  # type: ignore[assignment]
+
+_all_evaluator_map: dict[str, EvaluatorDoc] = {}
+for evaluator in _get_items(all_evaluator_docs, "evaluators"):
+    name = evaluator.get("name")
+    if isinstance(name, str):
+        _all_evaluator_map[name] = evaluator  # type: ignore[assignment]
+
+
+def get_action_spec(name: str) -> ActionDoc | None:
+    """
+    Get an action spec by name from the core specs.
+
+    Args:
+        name: The action name (e.g., "REPLY", "IGNORE")
+
+    Returns:
+        The action spec or None if not found
+    """
+    return _core_action_map.get(name) or _all_action_map.get(name)
+
+
+def require_action_spec(name: str) -> ActionDoc:
+    """
+    Get an action spec by name, raising if not found.
+
+    Args:
+        name: The action name
+
+    Returns:
+        The action spec
+
+    Raises:
+        ValueError: If the action is not found
+    """
+    spec = get_action_spec(name)
+    if spec is None:
+        raise ValueError(f"Action spec not found: {name}")
+    return spec
+
+
+def get_provider_spec(name: str) -> ProviderDoc | None:
+    """
+    Get a provider spec by name from the core specs.
+
+    Args:
+        name: The provider name (e.g., "CHARACTER", "TIME")
+
+    Returns:
+        The provider spec or None if not found
+    """
+    return _core_provider_map.get(name) or _all_provider_map.get(name)
+
+
+def require_provider_spec(name: str) -> ProviderDoc:
+    """
+    Get a provider spec by name, raising if not found.
+
+    Args:
+        name: The provider name
+
+    Returns:
+        The provider spec
+
+    Raises:
+        ValueError: If the provider is not found
+    """
+    spec = get_provider_spec(name)
+    if spec is None:
+        raise ValueError(f"Provider spec not found: {name}")
+    return spec
+
+
+def get_evaluator_spec(name: str) -> EvaluatorDoc | None:
+    """
+    Get an evaluator spec by name from the core specs.
+
+    Args:
+        name: The evaluator name (e.g., "REFLECTION")
+
+    Returns:
+        The evaluator spec or None if not found
+    """
+    return _core_evaluator_map.get(name) or _all_evaluator_map.get(name)
+
+
+def require_evaluator_spec(name: str) -> EvaluatorDoc:
+    """
+    Get an evaluator spec by name, raising if not found.
+
+    Args:
+        name: The evaluator name
+
+    Returns:
+        The evaluator spec
+
+    Raises:
+        ValueError: If the evaluator is not found
+    """
+    spec = get_evaluator_spec(name)
+    if spec is None:
+        raise ValueError(f"Evaluator spec not found: {name}")
+    return spec
+
+
+__all__ = [
+    "ActionDoc",
+    "ProviderDoc",
+    "EvaluatorDoc",
+    "get_action_spec",
+    "require_action_spec",
+    "get_provider_spec",
+    "require_provider_spec",
+    "get_evaluator_spec",
+    "require_evaluator_spec",
+]

package/elizaos/media/mime.py

@@ -12,14 +12,14 @@ from urllib.parse import urlparse
 
 # Try to import python-magic for MIME sniffing, fallback to filetype
 try:
-    import magic
+    import magic  # type: ignore[import-not-found]
 
     HAS_MAGIC = True
 except ImportError:
     HAS_MAGIC = False
 
 try:
-    import filetype
+    import filetype  # type: ignore[import-not-found]
 
     HAS_FILETYPE = True
 except ImportError:

package/elizaos/media/search.py

@@ -109,36 +109,36 @@ def merge_hybrid_results(
     by_id: dict[str, dict] = {}
 
     # Add vector search results
-    for r in vector:
-        by_id[r.id] = {
-            "id": r.id,
-            "path": r.path,
-            "start_line": r.start_line,
-            "end_line": r.end_line,
-            "source": r.source,
-            "snippet": r.snippet,
-            "vector_score": r.vector_score,
+    for vector_result in vector:
+        by_id[vector_result.id] = {
+            "id": vector_result.id,
+            "path": vector_result.path,
+            "start_line": vector_result.start_line,
+            "end_line": vector_result.end_line,
+            "source": vector_result.source,
+            "snippet": vector_result.snippet,
+            "vector_score": vector_result.vector_score,
             "text_score": 0.0,
         }
 
     # Merge keyword search results
-    for r in keyword:
-        if r.id in by_id:
-            existing = by_id[r.id]
-            existing["text_score"] = r.text_score
+    for keyword_result in keyword:
+        if keyword_result.id in by_id:
+            existing = by_id[keyword_result.id]
+            existing["text_score"] = keyword_result.text_score
             # Prefer keyword snippet if available (may have highlights)
-            if r.snippet:
-                existing["snippet"] = r.snippet
+            if keyword_result.snippet:
+                existing["snippet"] = keyword_result.snippet
         else:
-            by_id[r.id] = {
-                "id": r.id,
-                "path": r.path,
-                "start_line": r.start_line,
-                "end_line": r.end_line,
-                "source": r.source,
-                "snippet": r.snippet,
+            by_id[keyword_result.id] = {
+                "id": keyword_result.id,
+                "path": keyword_result.path,
+                "start_line": keyword_result.start_line,
+                "end_line": keyword_result.end_line,
+                "source": keyword_result.source,
+                "snippet": keyword_result.snippet,
                 "vector_score": 0.0,
-                "text_score": r.text_score,
+                "text_score": keyword_result.text_score,
             }
 
     # Calculate weighted scores and create results

package/elizaos/runtime.py

@@ -1,14 +1,22 @@
 from __future__ import annotations
 
 import asyncio
+import contextlib
 import re
 import uuid
 import xml.etree.ElementTree as ET
-from collections.abc import AsyncIterator, Awaitable, Callable
+from collections.abc import AsyncIterator, Awaitable, Callable, Mapping, MutableMapping
 from dataclasses import dataclass
 from typing import Any
 
+from google.protobuf.struct_pb2 import Value as StructValue
+
 from elizaos.action_docs import with_canonical_action_docs, with_canonical_evaluator_docs
+from elizaos.deterministic import (
+    build_conversation_seed,
+    deterministic_hex,
+    deterministic_uuid,
+)
 from elizaos.logger import Logger, create_logger
 from elizaos.settings import decrypt_secret, get_salt
 from elizaos.types.agent import Character, TemplateType
@@ -18,6 +26,7 @@ from elizaos.types.components import (
     Evaluator,
     HandlerCallback,
     HandlerOptions,
+    PreEvaluatorResult,
     Provider,
 )
 from elizaos.types.database import AgentRunSummaryResult, IDatabaseAdapter, Log
@@ -81,6 +90,48 @@ class StreamingModelHandlerWrapper:
 
 _anonymous_agent_counter = 0
 
+_MISSING = object()
+
+
+def _struct_value_to_python(value: StructValue) -> object | None:
+    kind = value.WhichOneof("kind")
+    if kind == "null_value":
+        return None
+    if kind == "number_value":
+        return value.number_value
+    if kind == "string_value":
+        return value.string_value
+    if kind == "bool_value":
+        return value.bool_value
+    if kind == "struct_value":
+        return {
+            key: _struct_value_to_python(item) for key, item in value.struct_value.fields.items()
+        }
+    if kind == "list_value":
+        return [_struct_value_to_python(item) for item in value.list_value.values]
+    return None
+
+
+def _is_struct_compatible(value: object) -> bool:
+    if value is None:
+        return True
+    if isinstance(value, (str, int, float, bool)):
+        return True
+    if isinstance(value, list):
+        return all(_is_struct_compatible(item) for item in value)
+    if isinstance(value, Mapping):
+        return all(
+            isinstance(map_key, str) and _is_struct_compatible(map_value)
+            for map_key, map_value in value.items()
+        )
+    return False
+
+
+def _to_runtime_setting_value(value: object | None) -> str | bool | int | float | None:
+    if value is None or isinstance(value, (str, bool, int, float)):
+        return value
+    return str(value)
+
 
 class AgentRuntime(IAgentRuntime):
     def __init__(
@@ -354,37 +405,58 @@ class AgentRuntime(IAgentRuntime):
         if secret:
             if self._character.secrets is None:
                 self._character.secrets = {}
-            if isinstance(self._character.secrets, dict):
+            if isinstance(self._character.secrets, MutableMapping):
                 self._character.secrets[key] = value  # type: ignore[assignment]
             else:
                 # Fall back to internal settings dict for protobuf objects
-                self._settings[key] = value
+                self._settings[key] = _to_runtime_setting_value(value)
             return
 
         # Try to set on character.settings if it's a dict
-        if isinstance(self._character.settings, dict):
+        if isinstance(self._character.settings, MutableMapping):
             self._character.settings[key] = value  # type: ignore[assignment]
+            return
+
+        settings_extra = getattr(self._character.settings, "extra", None)
+        if (
+            settings_extra is not None
+            and hasattr(settings_extra, "update")
+            and _is_struct_compatible(value)
+        ):
+            settings_extra.update({key: value})
         else:
             # Fall back to internal settings dict for protobuf objects
-            self._settings[key] = value
+            self._settings[key] = _to_runtime_setting_value(value)
 
     def get_setting(self, key: str) -> object | None:
         settings = self._character.settings
         secrets = self._character.secrets
 
-        nested_secrets: dict[str, object] | None = None
-        if isinstance(settings, dict):
+        nested_secrets: Mapping[str, object] | None = None
+        extra_value: object = _MISSING
+        if isinstance(settings, Mapping):
             nested = settings.get("secrets")
-            if isinstance(nested, dict):
+            if isinstance(nested, Mapping):
                 nested_secrets = nested
+        else:
+            settings_extra = getattr(settings, "extra", None)
+            settings_fields = getattr(settings_extra, "fields", None)
+            if isinstance(settings_fields, Mapping) and key in settings_fields:
+                struct_candidate = settings_fields[key]
+                if isinstance(struct_candidate, StructValue):
+                    extra_value = _struct_value_to_python(struct_candidate)
+                else:
+                    extra_value = struct_candidate
 
         value: object | None
-        if isinstance(secrets, dict) and key in secrets:
+        if isinstance(secrets, Mapping) and key in secrets:
             value = secrets.get(key)
-        elif isinstance(settings, dict) and key in settings:
+        elif isinstance(settings, Mapping) and key in settings:
             value = settings.get(key)
-        elif isinstance(nested_secrets, dict) and key in nested_secrets:
+        elif isinstance(nested_secrets, Mapping) and key in nested_secrets:
             value = nested_secrets.get(key)
+        elif extra_value is not _MISSING:
+            value = extra_value
         else:
             value = self._settings.get(key)
 
@@ -409,12 +481,17 @@ class AgentRuntime(IAgentRuntime):
 
     def get_all_settings(self) -> dict[str, object | None]:
         keys: set[str] = set(self._settings.keys())
-        if isinstance(self._character.settings, dict):
+        if isinstance(self._character.settings, Mapping):
             keys.update(self._character.settings.keys())
             nested = self._character.settings.get("secrets")
-            if isinstance(nested, dict):
+            if isinstance(nested, Mapping):
                 keys.update(nested.keys())
-        if isinstance(self._character.secrets, dict):
+        else:
+            settings_extra = getattr(self._character.settings, "extra", None)
+            settings_fields = getattr(settings_extra, "fields", None)
+            if isinstance(settings_fields, Mapping):
+                keys.update(settings_fields.keys())
+        if isinstance(self._character.secrets, Mapping):
             keys.update(self._character.secrets.keys())
 
         return {k: self.get_setting(k) for k in keys}
@@ -608,8 +685,14 @@ class AgentRuntime(IAgentRuntime):
                     errors.append(
                         f"Required parameter '{param_def.name}' was not provided for action {action.name}"
                     )
-                elif getattr(param_def.schema, "default_value", None):
-                    validated[param_def.name] = param_def.schema.default_value
+                else:
+                    default_value = getattr(param_def.schema, "default_value", None)
+                    if isinstance(default_value, StructValue):
+                        parsed_default = _struct_value_to_python(default_value)
+                        if parsed_default is not None:
+                            validated[param_def.name] = parsed_default
+                    elif default_value is not None:
+                        validated[param_def.name] = default_value
                 continue
 
             schema_type = param_def.schema.type
@@ -770,6 +853,7 @@ class AgentRuntime(IAgentRuntime):
                                 if data_params is not None:
                                     # Convert protobuf Struct to dict for _parse_action_params
                                     from google.protobuf.json_format import MessageToDict
+
                                     if hasattr(data_params, "DESCRIPTOR"):
                                         params_raw = MessageToDict(data_params)
                                     else:
@@ -802,11 +886,8 @@ class AgentRuntime(IAgentRuntime):
                         actionName=action.name,
                         errors=errors,
                     )
-                    try:
+                    with contextlib.suppress(AttributeError, ValueError):
                         options_obj.parameter_errors = errors
-                    except (AttributeError, ValueError):
-                        # Protobuf HandlerOptions may not have parameter_errors field
-                        pass
 
                 if validated_params:
                     from google.protobuf import struct_pb2
@@ -891,7 +972,7 @@ class AgentRuntime(IAgentRuntime):
         self,
         message: Memory,
         state: State | None = None,
-    ) -> "PreEvaluatorResult":
+    ) -> PreEvaluatorResult:
         """Run phase='pre' evaluators as middleware before memory storage.
 
         Pre-evaluators can inspect, rewrite, or block a message before it
@@ -902,8 +983,6 @@ class AgentRuntime(IAgentRuntime):
         Returns:
             A merged PreEvaluatorResult.
         """
-        from elizaos.types.components import PreEvaluatorResult
-
         pre_evaluators = [e for e in self._evaluators if getattr(e, "phase", "post") == "pre"]
         if not pre_evaluators:
             return PreEvaluatorResult(blocked=False)
@@ -1982,6 +2061,12 @@ class AgentRuntime(IAgentRuntime):
 
         schema_key = ",".join(s.field for s in schema)
         model_schema_key = f"{model_type_str}:{schema_key}"
+        deterministic_seed = build_conversation_seed(
+            self,
+            None,
+            state,
+            f"dynamic-prompt:{model_schema_key}",
+        )
 
         # Get validation level from settings or options (mirrors TypeScript behavior)
         default_context_level = 2
@@ -2023,7 +2108,11 @@ class AgentRuntime(IAgentRuntime):
                     row.validate_field if row.validate_field is not None else default_validate
                 )
                 if needs_validation:
-                    per_field_codes[row.field] = str(uuid.uuid4())[:8]
+                    per_field_codes[row.field] = deterministic_hex(
+                        deterministic_seed,
+                        f"field-code:{row.field}",
+                        8,
+                    )
 
         # Streaming extractor (created on first iteration if streaming enabled)
         extractor: ValidationStreamExtractor | None = None
@@ -2147,9 +2236,18 @@ class AgentRuntime(IAgentRuntime):
             example_lines.append(container_end)
             example = "\n".join(example_lines)
 
-            init_code = str(uuid.uuid4())
-            mid_code = str(uuid.uuid4())
-            final_code = str(uuid.uuid4())
+            init_code = deterministic_uuid(
+                deterministic_seed,
+                f"init-code:{current_retry}",
+            )
+            mid_code = deterministic_uuid(
+                deterministic_seed,
+                f"mid-code:{current_retry}",
+            )
+            final_code = deterministic_uuid(
+                deterministic_seed,
+                f"final-code:{current_retry}",
+            )
 
             section_start = "<output>" if is_xml else "# Strict Output instructions"
             section_end = "</output>" if is_xml else ""
@@ -2223,25 +2321,40 @@ end code: {final_code}
                 if not stream_fields and any(row.field == "text" for row in schema):
                     stream_fields = ["text"]
 
-                stream_message_id = f"stream-{uuid.uuid4().hex[:12]}"
+                stream_message_id = "stream-" + deterministic_hex(
+                    deterministic_seed,
+                    f"stream-message-id:{current_retry}",
+                    20,
+                )
+
+                on_stream_chunk = options.on_stream_chunk
+                on_stream_event = options.on_stream_event
+
+                def _emit_chunk(
+                    chunk: str,
+                    _field: str | None,
+                    cb=on_stream_chunk,
+                    msg_id=stream_message_id,
+                ) -> None:
+                    if cb is not None:
+                        cb(chunk, msg_id)
+
+                def _emit_event(
+                    event: StreamEvent,
+                    cb=on_stream_event,
+                    msg_id=stream_message_id,
+                ) -> None:
+                    if cb is not None:
+                        cb(event, msg_id)
 
-                # Capture stream_message_id in default parameter to avoid late binding
                 extractor = ValidationStreamExtractor(
                     ValidationStreamExtractorConfig(
                         level=validation_level,
                         schema=schema,
                         stream_fields=stream_fields,
                         expected_codes=per_field_codes,
-                        on_chunk=lambda chunk,
-                        _field,
-                        msg_id=stream_message_id: options.on_stream_chunk(chunk, msg_id)
-                        if options.on_stream_chunk
-                        else None,
-                        on_event=lambda event, msg_id=stream_message_id: options.on_stream_event(
-                            event, msg_id
-                        )
-                        if options.on_stream_event
-                        else None,
+                        on_chunk=_emit_chunk,
+                        on_event=_emit_event if on_stream_event is not None else None,
                         abort_signal=options.abort_signal,
                         has_rich_consumer=has_rich_consumer,
                     )

package/elizaos/services/message_service.py

@@ -430,9 +430,7 @@ class DefaultMessageService(IMessageService):
             # or rewrite it (e.g. redact credentials).
             pre_result = await runtime.evaluate_pre(message)
             if pre_result.blocked:
-                runtime.logger.warning(
-                    f"Message blocked by pre-evaluator: {pre_result.reason}"
-                )
+                runtime.logger.warning(f"Message blocked by pre-evaluator: {pre_result.reason}")
                 return MessageProcessingResult(
                     did_respond=False,
                     response_content=None,
@@ -440,9 +438,7 @@ class DefaultMessageService(IMessageService):
                     state=None,
                 )
             if pre_result.rewritten_text is not None:
-                runtime.logger.info(
-                    f"Pre-evaluator rewrote message text: {pre_result.reason}"
-                )
+                runtime.logger.info(f"Pre-evaluator rewrote message text: {pre_result.reason}")
                 message.content.text = pre_result.rewritten_text
 
             # Step 1: Save incoming message to memory (if adapter available)

package/elizaos/types/components.py

@@ -1,8 +1,7 @@
 from __future__ import annotations
 
 from collections.abc import Awaitable, Callable
-from dataclasses import dataclass, field
-from enum import Enum
+from dataclasses import dataclass
 from typing import TYPE_CHECKING, Literal, TypeAlias
 
 from elizaos.types.generated.eliza.v1 import components_pb2
@@ -47,6 +46,7 @@ class PreEvaluatorResult:
     rewritten_text: str | None = None
     reason: str | None = None
 
+
 # Proto-backed data types
 ActionExample = components_pb2.ActionExample
 ActionParameterSchema = components_pb2.ActionParameterSchema

package/elizaos/types/generated/__init__.py

@@ -0,0 +1,12 @@
+"""Generated protobuf modules for elizaOS types.
+
+This __init__.py adds the 'generated' directory to sys.path so that
+protobuf-generated files can resolve ``from eliza.v1 import …`` imports.
+"""
+
+import os
+import sys
+
+_generated_dir = os.path.dirname(os.path.abspath(__file__))
+if _generated_dir not in sys.path:
+    sys.path.insert(0, _generated_dir)