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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: reactor_runtime
-Version: 2.7.7
+Version: 2.7.9
 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.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "reactor_runtime"
-version = "2.7.7"
+version = "2.7.9"
 description = "Reactor runtime with public model API"
 authors = [
 	{ name = "Reactor", email = "team@reactor.inc" }
@@ -87,4 +87,4 @@ gst = [
 # Legacy releases used `X.Y.Z-g<short-sha>` (e.g. `1.4.1-g5660eed`); the wheel
 # stripped the `-g<sha>` suffix. fetch-proto.py still understands that shape
 # for back-compat with old pins, but new bumps should track the calendar format.
-version = "1.20260514.12095"
+version = "1.20260527.14467"

{reactor_runtime-2.7.7 → reactor_runtime-2.7.9}/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.9}/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.9}/src/reactor_runtime/model_state.py

@@ -31,6 +31,7 @@ class ModelEvent(Enum):
     CLEANUP_COMPLETE = "cleanup_complete"
     EVICTION = "eviction"
     IDLING = "idling"
+    SESSION_ACTIVE = "session_active"
 
 
 class ModelStateMachine:
@@ -72,6 +73,15 @@ class ModelStateMachine:
         ModelEvent.IDLING: [
             (ModelState.READY, ModelState.READY),
         ],
+        # SESSION_ACTIVE is the analog of IDLING during a live session: a
+        # periodic liveness ping sent while the runtime is serving a
+        # session (WAITING / STREAMING / ORPHANED). All three transitions
+        # are self-loops since the event carries no state change.
+        ModelEvent.SESSION_ACTIVE: [
+            (ModelState.WAITING, ModelState.WAITING),
+            (ModelState.STREAMING, ModelState.STREAMING),
+            (ModelState.ORPHANED, ModelState.ORPHANED),
+        ],
     }
 
     def __init__(self, initial_state: ModelState = ModelState.CREATED):
@@ -98,7 +108,10 @@ class ModelStateMachine:
 
         if to_state is None:
             log_fn = logger.warning
-            if event == ModelEvent.IDLING:
+            # IDLING and SESSION_ACTIVE are high-frequency liveness pings;
+            # legitimate races with state transitions can produce rejected
+            # events that don't deserve a warning.
+            if event in (ModelEvent.IDLING, ModelEvent.SESSION_ACTIVE):
                 log_fn = logger.debug
             log_fn(
                 "Illegal state transition",
@@ -108,7 +121,7 @@ class ModelStateMachine:
             return False
 
         log_fn = logger.info
-        if event == ModelEvent.IDLING:
+        if event in (ModelEvent.IDLING, ModelEvent.SESSION_ACTIVE):
             log_fn = logger.debug
 
         log_fn(
@@ -145,7 +158,18 @@ class ModelStateMachine:
             handler(**kwargs)
 
     def _call_enter_handler(self, state: ModelState, previous_state: ModelState):
-        """Call the appropriate on_enter_<state> method."""
+        """Call the appropriate on_enter_<state> method.
+
+        Self-loop transitions (``state == previous_state``) skip the
+        ``on_enter_*`` hook — those hooks are designed to run on actual
+        state changes, not on every heartbeat. This matters for
+        liveness-ping events like ``IDLING`` and ``SESSION_ACTIVE`` whose
+        from/to states are identical: re-running ``on_enter_WAITING`` /
+        ``on_enter_ORPHANED`` on every tick would, e.g., cancel and
+        restart the orphan timeout, preventing it from ever firing.
+        """
+        if state == previous_state:
+            return
         handler_name = f"on_enter_{state.value}"
         handler = getattr(self, handler_name, None)
         if handler:
@@ -191,6 +215,9 @@ class ModelStateMachine:
     def on_before_idling(self, **kwargs):
         pass
 
+    def on_before_session_active(self, **kwargs):
+        pass
+
     # on_enter_<state> methods
     def on_enter_CREATED(self, previous_state: ModelState):
         pass