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

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,9 +26,10 @@ from elizaos.types.components import (
     Evaluator,
     HandlerCallback,
     HandlerOptions,
+    PreEvaluatorResult,
     Provider,
 )
-from elizaos.types.database import AgentRunSummaryResult, IDatabaseAdapter, Log
+from elizaos.types.database import AgentRunSummaryResult, IDatabaseAdapter, Log, MemorySearchOptions
 from elizaos.types.environment import Entity, Room, World
 from elizaos.types.events import EventType
 from elizaos.types.memory import Memory
@@ -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__(
@@ -93,7 +144,7 @@ class AgentRuntime(IAgentRuntime):
         conversation_length: int = 32,
         log_level: str = "ERROR",
         disable_basic_capabilities: bool = False,
-        enable_extended_capabilities: bool = False,
+        advanced_capabilities: bool = False,
         action_planning: bool | None = None,
         llm_mode: LLMMode | None = None,
         check_should_respond: bool | None = None,
@@ -112,7 +163,7 @@ class AgentRuntime(IAgentRuntime):
             is_anonymous = True
 
         self._capability_disable_basic = disable_basic_capabilities
-        self._capability_enable_extended = enable_extended_capabilities
+        self._capability_advanced = advanced_capabilities
         self._capability_enable_autonomy = enable_autonomy
         self._is_anonymous_character = is_anonymous
         self._action_planning_option = action_planning
@@ -289,8 +340,8 @@ class AgentRuntime(IAgentRuntime):
             disable_basic = self._capability_disable_basic or (
                 char_settings.get("DISABLE_BASIC_CAPABILITIES") in (True, "true")
             )
-            enable_extended = self._capability_enable_extended or (
-                char_settings.get("ENABLE_EXTENDED_CAPABILITIES") in (True, "true")
+            advanced_capabilities = self._capability_advanced or (
+                char_settings.get("ADVANCED_CAPABILITIES") in (True, "true")
             )
             skip_character_provider = self._is_anonymous_character
 
@@ -298,12 +349,12 @@ class AgentRuntime(IAgentRuntime):
                 char_settings.get("ENABLE_AUTONOMY") in (True, "true")
             )
 
-            if disable_basic or enable_extended or skip_character_provider or enable_autonomy:
+            if disable_basic or advanced_capabilities or skip_character_provider or enable_autonomy:
                 from elizaos.bootstrap import CapabilityConfig, create_bootstrap_plugin
 
                 config = CapabilityConfig(
                     disable_basic=disable_basic,
-                    enable_extended=enable_extended,
+                    advanced_capabilities=advanced_capabilities,
                     skip_character_provider=skip_character_provider,
                     enable_autonomy=enable_autonomy,
                 )
@@ -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)
@@ -1057,12 +1136,17 @@ class AgentRuntime(IAgentRuntime):
         include_list: list[str] | None = None,
         only_include: bool = False,
         skip_cache: bool = False,
+        trajectory_phase: str | None = None,
     ) -> State:
         # If we're running inside a trajectory step, always bypass the state cache
         # so providers are executed and logged for training/benchmark traces.
         traj_step_id: str | None = None
         if message.metadata is not None:
             maybe_step = getattr(message.metadata, "trajectoryStepId", None)
+            if not maybe_step and hasattr(message.metadata, "message"):
+                # Check nested MessageMetadata for parsing parity
+                maybe_step = message.metadata.message.trajectory_step_id
+
             if isinstance(maybe_step, str) and maybe_step:
                 traj_step_id = maybe_step
                 skip_cache = True
@@ -1133,6 +1217,9 @@ class AgentRuntime(IAgentRuntime):
                     out[k] = _as_json_scalar(v)
             return out
 
+        # Resolve the purpose label for trajectory provider accesses
+        traj_purpose = f"compose_state:{trajectory_phase}" if trajectory_phase else "compose_state"
+
         text_parts: list[str] = []
         for provider in providers_to_run:
             if provider.private:
@@ -1155,18 +1242,18 @@ class AgentRuntime(IAgentRuntime):
 
             # Log provider access to trajectory service (if available)
             if traj_step_id and traj_logger is not None:
-                try:
-                    user_text = message.content.text or ""
+                # Trajectory logging must never break core message flow.
+                with contextlib.suppress(Exception):
                     traj_logger.log_provider_access(
                         step_id=traj_step_id,
                         provider_name=provider.name,
-                        data=_as_json_dict(result.data or {}),
-                        purpose="compose_state",
-                        query={"message": _as_json_scalar(user_text)},
+                        data={
+                            "textLength": len(result.text) if result.text else 0,
+                            "hasValues": bool(result.values),
+                            "hasData": bool(result.data),
+                        },
+                        purpose=traj_purpose,
                     )
-                except Exception:
-                    # Trajectory logging must never break core message flow.
-                    pass
 
         state.text = "\n".join(text_parts)
         # Match TypeScript behavior: expose providers text under {{providers}}.
@@ -1260,16 +1347,25 @@ class AgentRuntime(IAgentRuntime):
                 max_tokens_raw = params.get("maxTokens") if isinstance(params, dict) else None
                 max_tokens = int(max_tokens_raw) if isinstance(max_tokens_raw, int) else 0
 
+                # Truncate embedding vectors to avoid bloating trajectory files
+                result_str = str(result)
+                is_embedding = "EMBEDDING" in str(effective_model_type).upper()
+                if is_embedding and len(result_str) > 200:
+                    dim = result_str.count(",") + 1
+                    result_str = f"[embedding vector dim={dim}]"
+                elif len(result_str) > 2000:
+                    result_str = result_str[:2000]
+
                 traj_svc.log_llm_call(  # type: ignore[call-arg]
                     step_id=step_id,
                     model=str(effective_model_type),
                     system_prompt=system_prompt,
-                    user_prompt=prompt,
-                    response=str(result),
+                    user_prompt=prompt[:2000] if prompt else "",
+                    response=result_str,
                     temperature=temperature,
                     max_tokens=max_tokens,
                     purpose="action",
-                    action_type="runtime.use_model",
+                    action_type="runtime.useModel",
                     latency_ms=max(0, end_ms - start_ms),
                 )
         except Exception:
@@ -1648,6 +1744,12 @@ class AgentRuntime(IAgentRuntime):
         if self._adapter:
             await self._adapter.delete_component(component_id)
 
+    async def search_memories(self, params: MemorySearchOptions) -> list[Memory]:
+        """Search memories by embedding."""
+        if not self._adapter:
+            raise RuntimeError("Database adapter not set")
+        return await self._adapter.search_memories(params)
+
     async def get_memories(
         self,
         params: dict[str, Any] | None = None,
@@ -1982,6 +2084,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 +2131,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 +2259,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 +2344,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,
                     )
@@ -2268,6 +2404,28 @@ end code: {final_code}
                     # Flush extractor and get final state
                     extractor.flush()
                     response_str = "".join(response_parts)
+
+                    # Log streaming response to trajectory (streaming bypasses use_model hook)
+                    try:
+                        from elizaos.trajectory_context import CURRENT_TRAJECTORY_STEP_ID
+
+                        step_id = CURRENT_TRAJECTORY_STEP_ID.get()
+                        traj_svc = self.get_service("trajectory_logger")
+                        if step_id and traj_svc is not None and hasattr(traj_svc, "log_llm_call"):
+                            traj_svc.log_llm_call(  # type: ignore[call-arg]
+                                step_id=step_id,
+                                model=stream_model_type,
+                                system_prompt="",
+                                user_prompt=str(params.get("prompt", ""))[:2000],
+                                response=response_str[:2000],
+                                temperature=0.0,
+                                max_tokens=int(params.get("maxTokens", 0)),
+                                purpose="action",
+                                action_type="dynamic_prompt_exec.stream",
+                                latency_ms=0,
+                            )
+                    except Exception:
+                        pass
                 else:
                     # Non-streaming mode: use use_model
                     response = await self.use_model(model_type_str, params)