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

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

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

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

{reactor_runtime-2.7.6 → 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.6 → 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.6 → reactor_runtime-2.7.8}/src/reactor_runtime/interface/internal/output_buffer.py

@@ -105,25 +105,9 @@ def split_batch(bundle: MediaBundle) -> List[MediaBundle]:
 class _FlushMarker:
     """Sentinel placed in :class:`OutputBuffer`'s queue by :meth:`flush`.
 
-    Carries no payload. When the emission loop dequeues an instance, it
-    resets ``_last_emitted`` *in-thread* and falls through to this
-    tick's empty-queue fallback (which dispatches a fresh
-    ``_create_black_bundle()`` with ``duplicate=True``).
-
-    The point of routing the session-boundary reset through the queue
-    rather than writing ``_last_emitted = None`` directly from
-    :meth:`flush` is to make the reset atomic with respect to the
-    emission thread: only the emission thread reads or writes
-    ``_last_emitted``, so the loop can never observe a half-applied
-    "queue drained but cached frame not yet cleared" state. Down-stream
-    callbacks already drop ``duplicate=True`` bundles (the wire
-    callback in ``_send_out_app_bundle_sync`` short-circuits, and the
-    :class:`~reactor_runtime.recording.session_recorder.SessionRecorder`
-    skips them when ``skip_leading_black`` is on and
-    ``recording_started`` is still False), so no stale frame would
-    reach the client or recording even without this guarantee — but
-    closing the race architecturally is cheaper than re-deriving that
-    safety argument for every callback added in the future.
+    Consumed by the emission thread, which resets ``_last_emitted`` and
+    dispatches a fresh black bundle with ``is_fresh_black=True``.  Doing
+    the reset in-thread keeps it atomic with the per-tick state read.
     """
 
 
@@ -152,13 +136,11 @@ class OutputBuffer:
         # Ordered list of per-tick observers.  Callbacks fire in
         # registration order on every emission tick; an exception in
         # one callback is logged and does not block the others.
-        self._callbacks: List[Callable[[MediaBundle, bool], None]] = []
+        self._callbacks: List[Callable[[MediaBundle, bool, bool], None]] = []
         self._callbacks_lock: threading.Lock = threading.Lock()
 
-        # Queue items are normally MediaBundle, but flush() also puts a
-        # _FlushMarker sentinel here. We type the queue as ``object`` so
-        # both shapes are valid; the emission loop discriminates with
-        # ``isinstance``.
+        # Holds MediaBundle plus the _FlushMarker sentinel; the
+        # emission loop discriminates by isinstance.
         self._q: queue.Queue[object] = queue.Queue(maxsize=queue_depth)
 
         # FPS control — store both rate and period to avoid 1/fps on every tick
@@ -182,29 +164,18 @@ class OutputBuffer:
     # Callbacks
     # ------------------------------------------------------------------
 
-    def add_callback(self, fn: Callable[[MediaBundle, bool], None]) -> None:
-        """Register a per-tick callback.
+    def add_callback(self, fn: Callable[[MediaBundle, bool, bool], None]) -> None:
+        """Register a per-tick callback ``(bundle, duplicate, is_fresh_black)``.
 
-        Idempotent: registering the same ``fn`` twice leaves the
-        callback list with a single entry. This mirrors
-        :meth:`remove_callback` which has always been a no-op on
-        already-unregistered functions — callers shouldn't have to
-        track registration state.
-
-        The callback receives ``(bundle, duplicate)`` on every emission
-        tick.  Callbacks fire in registration order and are isolated
-        from each other: an exception raised by one is logged and the
-        remaining callbacks still fire.
+        Idempotent — re-registering the same ``fn`` is a no-op.
+        Callbacks fire in registration order with exceptions isolated.
         """
         with self._callbacks_lock:
             if fn not in self._callbacks:
                 self._callbacks.append(fn)
 
-    def remove_callback(self, fn: Callable[[MediaBundle, bool], None]) -> None:
-        """Deregister a previously added callback.
-
-        No-op if *fn* was never registered.
-        """
+    def remove_callback(self, fn: Callable[[MediaBundle, bool, bool], None]) -> None:
+        """Deregister a previously added callback (no-op if not registered)."""
         with self._callbacks_lock:
             try:
                 self._callbacks.remove(fn)
@@ -320,27 +291,30 @@ class OutputBuffer:
     # Stage 3: Emission loop
     # ------------------------------------------------------------------
 
-    def _dispatch(self, bundle: MediaBundle, duplicate: bool) -> None:
+    def _dispatch(
+        self,
+        bundle: MediaBundle,
+        duplicate: bool,
+        *,
+        is_fresh_black: bool = False,
+    ) -> None:
         """Fire every registered callback in order with error isolation.
 
-        We snapshot the callback list under the lock so callbacks that
-        register/deregister siblings during dispatch don't perturb the
-        current tick.  Each callback is wrapped so an exception in one
-        does not block the others.
+        Callbacks receive ``(bundle, duplicate, is_fresh_black)``.
+        ``is_fresh_black`` is ``True`` only on the synthesised black
+        the sentinel path emits at session boundaries; callbacks
+        choose how to interpret that separately from ``duplicate``.
+        Exceptions in one callback are logged and don't block the
+        rest.
         """
         with self._callbacks_lock:
             callbacks = list(self._callbacks)
         for fn in callbacks:
             try:
-                fn(bundle, duplicate)
+                fn(bundle, duplicate, is_fresh_black)
             except Exception as ex:
-                # ``logger.exception`` already attaches sys.exc_info()'s
-                # traceback; we also surface the type + message as
-                # structured fields so log queries on ``exc_type`` /
-                # ``exc_msg`` / ``callback`` work without traceback
-                # parsing. Without these explicit fields a silent
-                # malfunction in a downstream callback looks like
-                # "feature X didn't fire" with no obvious cause.
+                # Structured fields so log queries on exc_type /
+                # exc_msg / callback work without traceback parsing.
                 logger.exception(
                     "OutputBuffer callback raised; continuing with remaining callbacks",
                     callback=repr(fn),
@@ -361,19 +335,24 @@ class OutputBuffer:
                     item = None
 
                 bundle: Optional[MediaBundle] = None
+                sentinel_consumed = False
                 if isinstance(item, _FlushMarker):
-                    # Session-boundary reset, processed in the emission
-                    # thread so there is no cross-thread race with
-                    # flush(): clear the cached frame and fall through
-                    # to the empty-queue fallback below, which
-                    # dispatches duplicate=True black. mark_first_real_frame()
-                    # is gated on duplicate=False, so the recorder's
-                    # latch (REA-2323 / #2325) stays unset.
                     self._last_emitted = None
+                    sentinel_consumed = True
                 elif isinstance(item, MediaBundle):
                     bundle = item
 
-                if bundle is not None:
+                if sentinel_consumed:
+                    # Session-boundary black: tagged so the wire
+                    # forwards it (otherwise the client would stay
+                    # frozen on the previous frame), the recorder
+                    # ignores it.
+                    self._dispatch(
+                        self._create_black_bundle(),
+                        True,
+                        is_fresh_black=True,
+                    )
+                elif bundle is not None:
                     vtracks = bundle.get_tracks_by_kind(TrackKind.VIDEO)
                     if vtracks:
                         vd = vtracks[0].data
@@ -511,36 +490,16 @@ class OutputBuffer:
     def flush(self) -> None:
         """Drop pending bundles and request a session-boundary reset.
 
-        The reset of ``_last_emitted`` is performed by the emission
-        thread when it dequeues the :class:`_FlushMarker` sentinel,
-        making the operation race-free with the per-tick
-        "what do I emit?" decision in :meth:`_emission_loop`. After the
-        sentinel is consumed, the next emission tick synthesises
-        ``_create_black_bundle()`` with ``duplicate=True`` — the
-        correct pre-roll behaviour for a session boundary:
-
-        * the wire callback (``_send_out_app_bundle_sync``) drops
-          ``duplicate=True`` outright;
-        * the recorder's ``mark_first_real_frame()`` latch is not
-          tripped (REA-2323 / #2325), so the recording timeline only
-          starts at the next real model frame.
-
-        Safe to call from any thread; in practice ``flush()`` is
-        called from the model thread (``model-run``), the same thread
-        that calls :meth:`submit`, so there is no submit/flush race
-        on the producer side either.
+        The emission thread performs the actual reset of
+        ``_last_emitted`` when it dequeues the sentinel.  Then the
+        next tick emits a fresh black bundle tagged ``is_fresh_black``
+        — forwarded by the wire, ignored by the recorder.
         """
         self._drain_queue()
         try:
             self._q.put_nowait(_FLUSH_MARKER)
         except queue.Full:
-            # Unreachable in practice: the queue is bounded and the
-            # only producer (submit) runs on the same thread as
-            # flush, so nothing can refill the queue between drain
-            # and put. Log loudly if it ever happens and continue —
-            # the next real frame from the new session will set
-            # _last_emitted correctly even if the sentinel never
-            # lands.
+            # Same thread as submit(), so unreachable in practice.
             logger.warning(
                 "OutputBuffer.flush: queue full immediately after drain; "
                 "reset sentinel dropped"

{reactor_runtime-2.7.6 → reactor_runtime-2.7.8}/src/reactor_runtime/recording/session_recorder.py

@@ -250,10 +250,22 @@ class SessionRecorder:
     # OutputBuffer integration
     # ------------------------------------------------------------------
 
-    def _on_bundle_sync(self, bundle: MediaBundle, duplicate: bool) -> None:
-        """Enqueue a bundle for the feed worker; non-blocking."""
+    def _on_bundle_sync(
+        self,
+        bundle: MediaBundle,
+        duplicate: bool,
+        is_fresh_black: bool = False,
+    ) -> None:
+        """Enqueue a bundle for the feed worker; non-blocking.
+
+        Session-boundary synthesised black (``is_fresh_black``) is not
+        real model output and is invisible to the recording timeline:
+        no feed-queue write, no ``mark_first_real_frame`` consideration.
+        """
         if self._disabled or not self._started:
             return
+        if is_fresh_black:
+            return
         now = time.monotonic()
         if duplicate:
             if self._config.skip_leading_black and not self._markers.recording_started: