reactor-runtime 2.7.7__tar.gz → 2.7.8__tar.gz

{reactor_runtime-2.7.7 → reactor_runtime-2.7.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reactor_runtime
-Version: 2.7.7
+Version: 2.7.8
 Summary: Reactor runtime with public model API
 Author-email: Reactor <team@reactor.inc>
 Requires-Python: >=3.9

{reactor_runtime-2.7.7 → reactor_runtime-2.7.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "reactor_runtime"
-version = "2.7.7"
+version = "2.7.8"
 description = "Reactor runtime with public model API"
 authors = [
 	{ name = "Reactor", email = "team@reactor.inc" }

{reactor_runtime-2.7.7 → reactor_runtime-2.7.8}/src/reactor_runtime/config.py

@@ -81,6 +81,37 @@ def _reset_legacy_warning_for_tests() -> None:
     _legacy_warned = False
 
 
+@dataclass
+class ModerationYamlConfig:
+    """Top-level ``moderation:`` block parsed from ``reactor.yaml``.
+
+    Model authors declare here whether content moderation runs for their
+    model. Defaults to ``enabled: false`` so existing models opt in
+    explicitly. Operational tuning (thresholds, concurrency, backend
+    choice, ``OPENAI_API_KEY``) stays in environment variables — this
+    block carries only the policy decision the model author owns.
+    """
+
+    enabled: bool = False
+
+    @classmethod
+    def from_dict(cls, raw: Optional[Dict[str, Any]]) -> "ModerationYamlConfig":
+        if not isinstance(raw, dict):
+            return cls()
+        enabled = raw.get("enabled", False)
+        # Strict bool check: `bool("false") is True` would silently flip
+        # moderation on for a YAML author who wrote `enabled: "false"`
+        # (quoted) or templated a `"0"` value. Safety-sensitive config —
+        # fail at parse time with a message that names the offending value.
+        if not isinstance(enabled, bool):
+            raise TypeError(
+                f"moderation.enabled in reactor.yaml must be a boolean, "
+                f"got {type(enabled).__name__}: {enabled!r}. "
+                'Did you accidentally quote the value (e.g. "false")?'
+            )
+        return cls(enabled=enabled)
+
+
 @dataclass
 class ReactorConfig:
     """Parsed ``reactor.yaml``.
@@ -119,6 +150,7 @@ class ReactorConfig:
     config_overrides: List[str] = field(default_factory=list)
     weights_path: Optional[str] = None
     recording: RecordingConfig = field(default_factory=RecordingConfig)
+    moderation: ModerationYamlConfig = field(default_factory=ModerationYamlConfig)
 
     @classmethod
     def from_dict(cls, raw: Dict[str, Any]) -> "ReactorConfig":
@@ -135,8 +167,9 @@ class ReactorConfig:
         runtime_section = raw.get("runtime")
         model_section = raw.get("model")
 
-        # Recording is a top-level sibling to runtime: / model:.
+        # Recording and moderation are top-level siblings to runtime: / model:.
         recording = RecordingConfig.from_dict(raw.get("recording"))
+        moderation = ModerationYamlConfig.from_dict(raw.get("moderation"))
 
         modern = isinstance(runtime_section, dict) or isinstance(model_section, dict)
 
@@ -161,6 +194,7 @@ class ReactorConfig:
                 config=runtime_section.get("config"),
                 weights_path=runtime_section.get("weights_path") or None,
                 recording=recording,
+                moderation=moderation,
             )
 
         if "model" not in raw:
@@ -177,4 +211,5 @@ class ReactorConfig:
             config=raw.get("config"),
             weights_path=raw.get("weights_path") or None,
             recording=recording,
+            moderation=moderation,
         )

{reactor_runtime-2.7.7 → reactor_runtime-2.7.8}/src/reactor_runtime/interface/defaults.py

@@ -51,6 +51,7 @@ class FieldInfo:
     min_length: Optional[int] = None
     max_length: Optional[int] = None
     choices: Optional[List[Any]] = None
+    moderate: bool = True
 
 
 def InputField(
@@ -63,6 +64,7 @@ def InputField(
     min_length: Optional[int] = None,
     max_length: Optional[int] = None,
     choices: Optional[List[Any]] = None,
+    moderate: bool = True,
 ) -> Any:
     """Declare a default value and validation constraints for a field.
 
@@ -81,6 +83,13 @@ def InputField(
         min_length: Minimum length for string/sequence values.
         max_length: Maximum length for string/sequence values.
         choices: Exhaustive list of allowed values.
+        moderate: Whether to submit this field's value to the content
+            moderation backend (when moderation is enabled platform-wide).
+            Defaults to ``True``. Only effective for free-text ``str``
+            fields (those without ``choices=``) and ``UploadedFile``
+            fields — typed, enum, and numeric fields are never moderated
+            because the schema validator rejects out-of-set payloads
+            before they reach the model.
     """
     if default_factory is not None:
         raise TypeError(
@@ -95,6 +104,7 @@ def InputField(
         min_length=min_length,
         max_length=max_length,
         choices=choices,
+        moderate=moderate,
     )
 
 
@@ -227,3 +237,5 @@ def field_info_to_json_schema(schema: Dict[str, Any], info: FieldInfo) -> None:
         schema["maxLength"] = info.max_length
     if info.choices is not None:
         schema["enum"] = info.choices
+    if not info.moderate:
+        schema["x-reactor-moderate"] = False

{reactor_runtime-2.7.7 → reactor_runtime-2.7.8}/src/reactor_runtime/runtime_api.py

@@ -14,7 +14,7 @@ import threading
 import uuid
 from abc import ABC, abstractmethod
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING, Any, Iterator, Optional
 
 from reactor_runtime.schema import ModelSchema
 from reactor_runtime.config import ReactorConfig
@@ -42,8 +42,61 @@ from reactor_runtime.utils.messages import (
 )
 from reactor_runtime.utils.log import get_logger
 
+# Content moderation is internal-only and stripped from the OSS PyPI release
+# by ``obfuscate.py`` (the leading underscore on the ``_moderation`` package
+# matches the convention used by ``_redis``, ``_proto``, etc.). OSS builds
+# fall through to ``self._moderator = None`` at runtime startup and emit a
+# WARN so operators don't run unmoderated by accident.
+try:
+    from reactor_runtime._moderation import (
+        ContentModerator,
+        ModerationResult,
+        ModerationTier,
+        SessionModerator,
+    )
+
+    _MODERATION_AVAILABLE = True
+except ImportError:  # pragma: no cover — OSS build path
+    ContentModerator = None  # type: ignore[misc,assignment]
+    ModerationResult = None  # type: ignore[misc,assignment]
+    ModerationTier = None  # type: ignore[misc,assignment]
+    SessionModerator = None  # type: ignore[misc,assignment]
+    _MODERATION_AVAILABLE = False
+
 logger = get_logger(__name__)
 
+
+def _iter_strings(value: Any) -> Iterator[str]:
+    """Yield every non-empty string leaf from a possibly-nested payload.
+
+    Used by :meth:`Runtime._schedule_moderation_for_event` to walk a
+    moderatable field's validated value. Top-level ``str`` is the easy
+    case; the recursion handles structured payloads where user text
+    can be nested — ``List[str]``, ``Dict[str, str]``, dataclass-shaped
+    args like ``List[ChatTurn]`` (deserialized as ``list[dict]``).
+    Without this, a model that opts into moderation could still be
+    bypassed by wrapping user text inside any structured argument —
+    the codex P1 finding on PR #2533.
+
+    ``UploadedFile`` instances are skipped here; uploads have their own
+    dispatch path (:meth:`get_moderate_upload_fields`) and would
+    otherwise double-fire on the bytes.
+    """
+    if isinstance(value, UploadedFile):
+        return
+    if isinstance(value, str):
+        if value:
+            yield value
+        return
+    if isinstance(value, dict):
+        for sub in value.values():
+            yield from _iter_strings(sub)
+        return
+    if isinstance(value, (list, tuple)):
+        for item in value:
+            yield from _iter_strings(item)
+
+
 _IDLING_INTERVAL_ENV_VAR = "IDLING_INTERVAL_SECONDS"
 _DEFAULT_IDLING_INTERVAL = 30.0
 
@@ -256,6 +309,45 @@ class Runtime(ModelStateMachine, ABC):
         self._shutdown_event: asyncio.Event = asyncio.Event()
         self._setup_signal_handlers()
 
+        # Content moderation. The on/off decision lives in
+        # ``reactor.yaml`` under ``moderation.enabled``; operational
+        # knobs and the backend API key come from env. ``None`` when the
+        # model opted out or when running an OSS build that has the
+        # ``_moderation`` package stripped. Every injection point guards
+        # with ``if self._moderator is not None``.
+        #
+        # Misconfiguration is fail-loud: if the model has declared it
+        # needs moderation (``moderation.enabled: true`` in reactor.yaml)
+        # but either the operational env is missing required secrets or
+        # the ``_moderation`` package isn't available (OSS build), the
+        # runtime refuses to start rather than silently admitting
+        # unmoderated input.
+        self._moderator: Optional["ContentModerator"] = None
+        self._session_moderator: Optional["SessionModerator"] = None
+        moderation_enabled = self.config.reactor_config.moderation.enabled
+        if _MODERATION_AVAILABLE:
+            self._moderator = ContentModerator.from_reactor_config(
+                self.config.reactor_config
+            )
+            if self._moderator is not None:
+                logger.info("Content moderation enabled")
+            else:
+                logger.info(
+                    "Content moderation disabled "
+                    "(moderation.enabled is not set in reactor.yaml)"
+                )
+        else:
+            if moderation_enabled:
+                raise RuntimeError(
+                    "reactor.yaml has 'moderation.enabled: true' but the "
+                    "_moderation package is not importable in this build "
+                    "(stripped OSS release or transitive import failure). "
+                    "Refusing to start unmoderated — set "
+                    "'moderation.enabled: false' in reactor.yaml or use an "
+                    "internal build that includes the _moderation module."
+                )
+            logger.debug("Content moderation module not present in this build (OSS)")
+
         # Start idling loop (runs continuously, only sends events when in READY state)
         self._start_idling_loop()
 
@@ -443,6 +535,14 @@ class Runtime(ModelStateMachine, ABC):
             self.model._push_event(Disconnected())
             logger.info("Pushed Disconnected event to model")
 
+        # Cancel any in-flight moderation tasks for this session — their
+        # enforcement target (this session) is going away regardless of
+        # the outcome.
+        sm = self._session_moderator
+        if sm is not None:
+            self._session_moderator = None
+            asyncio.create_task(sm.shutdown())
+
         self.loop.call_soon_threadsafe(self.send, ModelEvent.CLEANUP_COMPLETE)
 
     # -----------------------------------------------------------------
@@ -460,6 +560,124 @@ class Runtime(ModelStateMachine, ABC):
             self._schema_validator = SchemaValidator(schema.to_openapi())
         return self._schema_validator
 
+    # -----------------------------------------------------------------
+    # Moderation helpers
+    # -----------------------------------------------------------------
+
+    def _get_session_moderator(self) -> Optional["SessionModerator"]:
+        """Lazily build a per-session moderator bag for in-flight tasks.
+
+        Returns ``None`` when moderation is disabled, so callers can pass
+        the result through ``if`` without needing a separate enabled
+        check. The instance is cleared in :meth:`on_enter_CLOSING` so
+        each session gets a fresh failure counter.
+        """
+        if self._moderator is None:
+            return None
+        if self._session_moderator is None:
+            session_id = getattr(self, "session_id", None) or ""
+            self._session_moderator = self._moderator.for_session(session_id)
+        return self._session_moderator
+
+    def _schedule_moderation_for_event(
+        self,
+        cmd_name: str,
+        validated: dict,
+        validator: SchemaValidator,
+    ) -> None:
+        """Fire async moderation for any moderatable fields on *validated*."""
+        sm = self._get_session_moderator()
+        if sm is None:
+            return
+
+        for field_name in validator.get_moderate_text_fields(cmd_name):
+            value = validated.get(field_name)
+            # Recurse the value so List[str] / Dict[str, str] / dataclass
+            # payloads can't bypass moderation by wrapping user text in a
+            # structured argument (codex P1). See `_iter_strings`.
+            for text in _iter_strings(value):
+                sm.schedule_text_check(
+                    text, command=cmd_name, on_result=self._enforce_moderation
+                )
+
+        for field_name in validator.get_moderate_upload_fields(cmd_name):
+            value = validated.get(field_name)
+            if not isinstance(value, UploadedFile):
+                continue
+            if value.mime_type.startswith("image/"):
+                sm.schedule_image_check(
+                    value.data,
+                    value.mime_type,
+                    command=cmd_name,
+                    on_result=self._enforce_moderation,
+                )
+            elif value.mime_type.startswith("text/"):
+                try:
+                    text = value.data.decode("utf-8", errors="replace")
+                except Exception:
+                    text = ""
+                if text:
+                    sm.schedule_text_check(
+                        text, command=cmd_name, on_result=self._enforce_moderation
+                    )
+
+    async def _enforce_moderation(
+        self,
+        tier: "ModerationTier",
+        result: "ModerationResult",
+        input_kind: str,
+        command: str,
+    ) -> None:
+        """Send a moderation runtime message and, on terminate, stop the session.
+
+        Bound as the ``on_result`` callback on every scheduled check. The
+        50ms ``asyncio.sleep`` before ``STOP_SESSION`` gives the data
+        channel a window to flush the moderation message to the client —
+        without it the client sees a bare disconnect.
+        """
+        flagged_categories = sorted(c for c, v in result.categories.items() if v)
+        action = tier.value
+        message_text = (
+            "Session terminated due to policy violation."
+            if tier is ModerationTier.TERMINATE
+            else "Content was flagged for potential policy violations."
+        )
+
+        wrapped = RuntimeMessage(
+            data={
+                "type": RuntimeMessageType.MODERATION,
+                "data": {
+                    "action": action,
+                    "input_kind": input_kind,
+                    "command": command,
+                    "categories": flagged_categories,
+                    "message": message_text,
+                },
+            }
+        ).model_dump()
+        await self.send_out_runtime_message(wrapped)
+
+        if tier is ModerationTier.TERMINATE:
+            logger.error(
+                "Content moderation termination",
+                action=action,
+                input_kind=input_kind,
+                command=command,
+                categories=flagged_categories,
+            )
+            # Brief window to let the runtime message flush before the
+            # transport tears down.
+            await asyncio.sleep(0.05)
+            self.send(ModelEvent.STOP_SESSION)
+        else:
+            logger.warning(
+                "Content moderation warning",
+                action=action,
+                input_kind=input_kind,
+                command=command,
+                categories=flagged_categories,
+            )
+
     # -----------------------------------------------------------------
     # Inbound data channel messages
     # -----------------------------------------------------------------
@@ -666,6 +884,11 @@ class Runtime(ModelStateMachine, ABC):
 
         self.model._push_event(event)
 
+        # Schedule async moderation of any moderatable fields on the event.
+        # Fire-and-forget — the model already has the input; enforcement is
+        # post-hoc per the design.
+        self._schedule_moderation_for_event(cmd_name, validated, validator)
+
     async def _handle_file_uploaded(self, payload: dict) -> None:
         """Download an uploaded file and push a FileUploaded event to the model.
 
@@ -705,6 +928,28 @@ class Runtime(ModelStateMachine, ABC):
             size=size,
         )
 
+        # Ad-hoc file uploads (no command name) always default to moderated;
+        # the per-field ``moderate=False`` opt-out lives on ``InputField``
+        # declarations and doesn't apply here. The originating command is
+        # synthesised as ``"fileUploaded"`` for logging/categorisation.
+        sm = self._get_session_moderator()
+        if sm is not None and mime_type.startswith("image/"):
+            sm.schedule_image_check(
+                data,
+                mime_type,
+                command="fileUploaded",
+                on_result=self._enforce_moderation,
+            )
+        elif sm is not None and mime_type.startswith("text/"):
+            try:
+                text = data.decode("utf-8", errors="replace")
+            except Exception:
+                text = ""
+            if text:
+                sm.schedule_text_check(
+                    text, command="fileUploaded", on_result=self._enforce_moderation
+                )
+
     # -----------------------------------------------------------------
     # Trickle ICE (transport-agnostic)
     # -----------------------------------------------------------------
@@ -990,6 +1235,12 @@ class Runtime(ModelStateMachine, ABC):
             except Exception as e:
                 logger.warning("Failed to shutdown profiler", error=e)
 
+            if self._moderator is not None:
+                try:
+                    await self._moderator.close()
+                except Exception as e:
+                    logger.warning("Failed to close content moderator", error=e)
+
             if self.current_state == ModelState.READY:
                 self.send(ModelEvent.EVICTION)
 

reactor_runtime-2.7.8/src/reactor_runtime/schema_validator.py

@@ -0,0 +1,231 @@
+# Copyright (c) 2026 Reactor Technologies, Inc. All rights reserved.
+"""Schema-driven validation for inbound event messages.
+
+:class:`SchemaValidator` pre-compiles a JSON Schema validator for each
+event in an OpenAPI 3.1 document and provides a single :meth:`validate`
+entry point that validates incoming payloads against the event's request
+body schema.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Dict, Optional, Set, Tuple
+
+import jsonschema
+
+logger = logging.getLogger(__name__)
+
+
+class SchemaValidator:
+    """Pre-compiled JSON Schema validators for a model's events.
+
+    Accepts a raw OpenAPI 3.1 document (a plain dict).  The document
+    can come from runtime introspection, a static file, or a registry
+    — this class does not depend on how the schema was produced.
+
+    Instantiate once per session (or model load), then call
+    :meth:`validate` for each inbound message.
+    """
+
+    def __init__(self, openapi: Dict[str, Any]) -> None:
+        self._validators: Dict[str, jsonschema.Draft202012Validator] = {}
+        self._schemas: Dict[str, Dict[str, Any]] = {}
+        self._upload_fields: Dict[str, Set[str]] = {}
+        self._moderate_text_fields: Dict[str, Set[str]] = {}
+        self._moderate_upload_fields: Dict[str, Set[str]] = {}
+
+        paths = openapi.get("paths", {})
+        components = openapi.get("components", {}).get("schemas", {})
+
+        for path, path_item in paths.items():
+            event_name = path.removeprefix("/events/")
+            post = path_item.get("post", {})
+            body_content = post.get("requestBody", {}).get("content", {})
+            json_content = body_content.get("application/json", {})
+            body_schema = json_content.get("schema", {})
+
+            upload_fields: Set[str] = set()
+            moderate_text: Set[str] = set()
+            moderate_uploads: Set[str] = set()
+            for field_name, field_schema in body_schema.get("properties", {}).items():
+                is_upload = _is_upload_reference(field_schema)
+                if is_upload:
+                    upload_fields.add(field_name)
+
+                # Only fields explicitly opted out via x-reactor-moderate=False
+                # are skipped. Any other value (missing key, True, or a stray
+                # non-bool from a hand-edited schema) defaults to moderate —
+                # safe-by-default on this safety-sensitive path, so a typo
+                # like `x-reactor-moderate: 0` doesn't silently disable.
+                moderate = field_schema.get("x-reactor-moderate", True)
+                if moderate is False:
+                    continue
+
+                if is_upload:
+                    moderate_uploads.add(field_name)
+                elif _schema_has_free_text(field_schema, components):
+                    moderate_text.add(field_name)
+
+            self._upload_fields[event_name] = upload_fields
+            self._moderate_text_fields[event_name] = moderate_text
+            self._moderate_upload_fields[event_name] = moderate_uploads
+
+            resolved = _inline_refs(
+                body_schema,
+                openapi.get("components", {}).get("schemas", {}),
+            )
+            self._schemas[event_name] = resolved
+            self._validators[event_name] = jsonschema.Draft202012Validator(resolved)
+
+    def validate(
+        self, event_name: str, data: Dict[str, Any]
+    ) -> Tuple[Optional[Dict[str, Any]], Optional[str]]:
+        """Validate *data* against the schema for *event_name*.
+
+        Returns ``(data, None)`` on success, or
+        ``(None, error_message)`` on failure.
+        """
+        validator = self._validators.get(event_name)
+        if validator is None:
+            return None, f"Unknown event: {event_name}"
+
+        errors = list(validator.iter_errors(data))
+        if errors:
+            messages = "; ".join(e.message for e in errors[:3])
+            return None, f"Validation failed for {event_name}: {messages}"
+
+        return data, None
+
+    def get_upload_fields(self, event_name: str) -> Set[str]:
+        """Return field names with ``format: reactor-upload-reference``."""
+        return self._upload_fields.get(event_name, set())
+
+    def get_moderate_text_fields(self, event_name: str) -> Set[str]:
+        """Return free-text ``str`` field names that should be moderated.
+
+        Free-text means a ``string`` schema without an ``enum`` constraint.
+        Fields explicitly opted out via ``InputField(moderate=False)`` are
+        excluded.
+        """
+        return self._moderate_text_fields.get(event_name, set())
+
+    def get_moderate_upload_fields(self, event_name: str) -> Set[str]:
+        """Return upload-reference field names that should be moderated.
+
+        Fields explicitly opted out via ``InputField(moderate=False)`` are
+        excluded.
+        """
+        return self._moderate_upload_fields.get(event_name, set())
+
+
+def _schema_has_free_text(
+    schema: Dict[str, Any],
+    components: Dict[str, Any],
+    seen: Optional[Set[str]] = None,
+) -> bool:
+    """Return True if *schema* contains any free-text ``string`` leaf.
+
+    Walks the schema recursively — through ``anyOf`` / ``allOf`` / ``oneOf``
+    variants, into ``items`` (array element schemas), into
+    ``additionalProperties`` (open-ended object value schemas), into
+    nested ``properties`` (dataclass-style structured fields), and
+    through ``$ref`` (component references). Closed-set ``enum``
+    constraints stop the walk because the validator rejects out-of-set
+    values before they reach the model, so there's nothing user-
+    controlled to moderate.
+
+    Used at schema discovery to decide whether a top-level field is
+    eligible for text moderation. Authors with structured payloads
+    (e.g. ``chat_history: List[str]`` or ``turns: List[ChatTurn]``)
+    were silently bypassed by the previous top-level-string-only
+    check — codex P1 on PR #2533.
+    """
+    if seen is None:
+        seen = set()
+
+    # Resolve a $ref before doing anything else; component schemas can
+    # be self-referential (rare for OpenAPI bodies, but cheap to guard).
+    if "$ref" in schema:
+        ref_path = schema["$ref"]
+        if ref_path in seen:
+            return False
+        ref_name = ref_path.rsplit("/", 1)[-1]
+        resolved = components.get(ref_name)
+        if resolved is None:
+            return False
+        return _schema_has_free_text(resolved, components, seen | {ref_path})
+
+    # Closed-set values aren't user-controlled — skip.
+    if schema.get("enum") is not None:
+        return False
+
+    if schema.get("type") == "string":
+        return True
+
+    # Union variants (Optional[str], Union[str, int], etc.).
+    for keyword in ("anyOf", "allOf", "oneOf"):
+        for sub in schema.get(keyword, []):
+            if _schema_has_free_text(sub, components, seen):
+                return True
+
+    # Array element schema (List[str], List[ChatTurn], ...).
+    items = schema.get("items")
+    if isinstance(items, dict) and _schema_has_free_text(items, components, seen):
+        return True
+
+    # Open-ended objects (Dict[str, str], Dict[str, ChatTurn], ...).
+    addl = schema.get("additionalProperties")
+    if isinstance(addl, dict) and _schema_has_free_text(addl, components, seen):
+        return True
+
+    # Structured objects (dataclass-style fields).
+    for sub in schema.get("properties", {}).values():
+        if _schema_has_free_text(sub, components, seen):
+            return True
+
+    return False
+
+
+def _is_upload_reference(field_schema: Dict[str, Any]) -> bool:
+    """Check if a field schema references ReactorUploadReference.
+
+    Handles both direct ``$ref`` and ``Optional[UploadedFile]`` which
+    wraps the ``$ref`` inside an ``anyOf``.
+    """
+    ref = field_schema.get("$ref", "")
+    if "ReactorUploadReference" in ref:
+        return True
+    for sub in field_schema.get("anyOf", []):
+        if "ReactorUploadReference" in sub.get("$ref", ""):
+            return True
+    return False
+
+
+def _inline_refs(
+    schema: Dict[str, Any], component_schemas: Dict[str, Any]
+) -> Dict[str, Any]:
+    """Recursively resolve ``$ref`` pointers against component schemas."""
+    if "$ref" in schema:
+        ref_path = schema["$ref"]
+        ref_name = ref_path.rsplit("/", 1)[-1]
+        resolved = component_schemas.get(ref_name)
+        if resolved is None:
+            raise ValueError(f"$ref '{ref_path}' not found in component schemas")
+        return _inline_refs(resolved, component_schemas)
+
+    result = dict(schema)
+    if "properties" in result:
+        result["properties"] = {
+            k: _inline_refs(v, component_schemas)
+            for k, v in result["properties"].items()
+        }
+    if "items" in result and isinstance(result["items"], dict):
+        result["items"] = _inline_refs(result["items"], component_schemas)
+    for keyword in ("anyOf", "allOf", "oneOf"):
+        if keyword in result:
+            result[keyword] = [
+                _inline_refs(v, component_schemas) for v in result[keyword]
+            ]
+
+    return result

{reactor_runtime-2.7.7 → reactor_runtime-2.7.8}/src/reactor_runtime/utils/messages.py

@@ -35,6 +35,10 @@ class RuntimeMessageType(str, Enum):
     REQUEST_RECORDING = "requestRecording"
     CLIP_READY = "clipReady"
     CLIP_FAILED = "clipFailed"
+    # Content moderation events (warn / terminate) emitted to the client
+    # when a moderatable input is flagged. Carries the action tier,
+    # categories, and a short human-readable message.
+    MODERATION = "moderation"
 
 
 class ApplicationMessage(BaseModel):