toposync-ext-streaming 0.7.9__tar.gz → 0.8.0__tar.gz

{toposync_ext_streaming-0.7.9 → toposync_ext_streaming-0.8.0}/.gitignore

@@ -38,3 +38,4 @@ extensions/streaming/src/toposync_ext_streaming/bin/ffmpeg/**/ffmpeg*
 extensions/vision/models/
 
 *.temporary.*
+.playwright-mcp/*

toposync_ext_streaming-0.7.9/README.md → toposync_ext_streaming-0.8.0/PKG-INFO

@@ -1,3 +1,16 @@
+Metadata-Version: 2.4
+Name: toposync-ext-streaming
+Version: 0.8.0
+Summary: Toposync first-party extension: streaming settings, API surface, and pipeline sink bootstrap.
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.11
+Requires-Dist: numpy>=1.26
+Requires-Dist: opencv-python-headless>=4.10
+Requires-Dist: toposync-core>=0.3.3
+Requires-Dist: websockets>=12.0
+Description-Content-Type: text/markdown
+
 # Toposync Streaming Extension
 
 Extension ID: `com.toposync.streaming`
@@ -729,6 +742,15 @@ All endpoints are under `/api/streams`.
 ### Home Assistant
 - `GET /api/streams/home-assistant/cameras`
 
+For Home Assistant running in Docker Compose, the RTSP URL in this manifest must
+use a host reachable from the Home Assistant container. Enable
+`engine.expose_to_lan`, restart the streaming engine, and set
+`TOPOSYNC_HOME_ASSISTANT_RTSP_HOST` to the Compose service name or another
+container-reachable hostname, for example `toposync`. If the endpoint would
+otherwise return a loopback RTSP URL for a non-loopback request host, the
+manifest omits `rtsp_url` and reports a blocking error instead of publishing an
+unusable `rtsp://127.0.0.1:...` URL.
+
 ### Distributed settings
 - `GET /api/streams/distributed/settings/{server_id}`
 
@@ -968,6 +990,10 @@ To enable LAN viewers:
 
 Notes:
 - `GET /api/streams/transmissions/{id}/urls` chooses the host component based on the current request host when `expose_to_lan` is enabled.
+- `GET /api/streams/home-assistant/cameras` follows the same rule, but a
+  Compose-based Home Assistant often needs `TOPOSYNC_HOME_ASSISTANT_RTSP_HOST`
+  so the advertised RTSP host is the Toposync service name visible from the Home
+  Assistant container.
 - If MediaMTX runs behind Docker/NAT, advertise the reachable LAN host with `TOPOSYNC_STREAMING_WEBRTC_ADDITIONAL_HOSTS` and publish the static ICE UDP port configured by `TOPOSYNC_STREAMING_WEBRTC_LOCAL_UDP_ADDRESS`.
 - MediaMTX still restricts publishing and API access to localhost IPs; LAN exposure is for viewer playback only.
 

toposync_ext_streaming-0.7.9/PKG-INFO → toposync_ext_streaming-0.8.0/README.md

@@ -1,16 +1,3 @@
-Metadata-Version: 2.4
-Name: toposync-ext-streaming
-Version: 0.7.9
-Summary: Toposync first-party extension: streaming settings, API surface, and pipeline sink bootstrap.
-License-Expression: MIT
-License-File: LICENSE
-Requires-Python: >=3.11
-Requires-Dist: numpy>=1.26
-Requires-Dist: opencv-python-headless>=4.10
-Requires-Dist: toposync-core>=0.3.3
-Requires-Dist: websockets>=12.0
-Description-Content-Type: text/markdown
-
 # Toposync Streaming Extension
 
 Extension ID: `com.toposync.streaming`
@@ -742,6 +729,15 @@ All endpoints are under `/api/streams`.
 ### Home Assistant
 - `GET /api/streams/home-assistant/cameras`
 
+For Home Assistant running in Docker Compose, the RTSP URL in this manifest must
+use a host reachable from the Home Assistant container. Enable
+`engine.expose_to_lan`, restart the streaming engine, and set
+`TOPOSYNC_HOME_ASSISTANT_RTSP_HOST` to the Compose service name or another
+container-reachable hostname, for example `toposync`. If the endpoint would
+otherwise return a loopback RTSP URL for a non-loopback request host, the
+manifest omits `rtsp_url` and reports a blocking error instead of publishing an
+unusable `rtsp://127.0.0.1:...` URL.
+
 ### Distributed settings
 - `GET /api/streams/distributed/settings/{server_id}`
 
@@ -981,6 +977,10 @@ To enable LAN viewers:
 
 Notes:
 - `GET /api/streams/transmissions/{id}/urls` chooses the host component based on the current request host when `expose_to_lan` is enabled.
+- `GET /api/streams/home-assistant/cameras` follows the same rule, but a
+  Compose-based Home Assistant often needs `TOPOSYNC_HOME_ASSISTANT_RTSP_HOST`
+  so the advertised RTSP host is the Toposync service name visible from the Home
+  Assistant container.
 - If MediaMTX runs behind Docker/NAT, advertise the reachable LAN host with `TOPOSYNC_STREAMING_WEBRTC_ADDITIONAL_HOSTS` and publish the static ICE UDP port configured by `TOPOSYNC_STREAMING_WEBRTC_LOCAL_UDP_ADDRESS`.
 - MediaMTX still restricts publishing and API access to localhost IPs; LAN exposure is for viewer playback only.
 

{toposync_ext_streaming-0.7.9 → toposync_ext_streaming-0.8.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "toposync-ext-streaming"
-version = "0.7.9"
+version = "0.8.0"
 description = "Toposync first-party extension: streaming settings, API surface, and pipeline sink bootstrap."
 readme = "README.md"
 license = "MIT"

{toposync_ext_streaming-0.7.9 → toposync_ext_streaming-0.8.0}/src/toposync_ext_streaming/api/models.py

@@ -1034,6 +1034,9 @@ class StreamingEngineStatusResponse(BaseModel):
     warnings: list[str] = Field(default_factory=list)
     restart_count: int = Field(default=0, ge=0)
     orphan_pids: list[int] = Field(default_factory=list)
+    port_policy: Literal["stable", "flexible"] = "flexible"
+    port_resolution: str = "preferred"
+    port_blocking_errors: list[str] = Field(default_factory=list)
 
 
 class StreamingMseSidecarStatusResponse(BaseModel):

{toposync_ext_streaming-0.7.9 → toposync_ext_streaming-0.8.0}/src/toposync_ext_streaming/api/routes.py

@@ -33,7 +33,7 @@ from toposync.runtime.pipelines.operators_sinks import _encode_image_bytes
 from toposync.runtime.pipelines.templates import camera_names_by_id, safe_pipeline_name
 from toposync.runtime.services import ServiceRegistry
 
-from ..streaming.engine_manager import MediaMtxEngineManager
+from ..streaming.engine_manager import MediaMtxEngineManager, MediaMtxPortResolutionError
 from ..streaming.go2rtc_binary import extract_go2rtc_binary, find_installed_go2rtc_binary
 from ..streaming.go2rtc_manager import Go2RtcSidecarManager, Go2RtcSidecarStatus
 from ..streaming.camera_ingest import (
@@ -852,7 +852,19 @@ def _build_network_contract(
             media_url_origin=media_url_origin,
         )
 
-    fail_on_mismatch = _env_bool("TOPOSYNC_FAIL_STREAM_URLS_ON_PORT_MISMATCH")
+    explicit_expected_ports = any(
+        value is not None
+        for value in (
+            expected_ports.direct_api,
+            expected_ports.rtsp,
+            expected_ports.hls,
+            expected_ports.webrtc,
+            expected_ports.webrtc_udp,
+            expected_ports.api,
+        )
+    )
+    strict_contract = environment == "home_assistant_addon" or explicit_expected_ports
+    fail_on_mismatch = _env_bool("TOPOSYNC_FAIL_STREAM_URLS_ON_PORT_MISMATCH") or strict_contract
     status: Literal["ok", "port_mismatch", "proxy_required", "proxy_unavailable"] = "ok"
 
     def compare_port(
@@ -869,11 +881,16 @@ def _build_network_contract(
         actual = getattr(actual_ports, key)
         if expected is None or actual is None or int(expected) == int(actual):
             return
-        message = f"{label} active port {actual} does not match expected add-on port {expected}."
+        expected_label = (
+            "expected add-on port"
+            if environment == "home_assistant_addon"
+            else "expected streaming port"
+        )
+        message = f"{label} active port {actual} does not match {expected_label} {expected}."
         warnings.append(message)
         if status == "ok":
             status = "port_mismatch"
-        if blocking_when_failed and fail_on_mismatch:
+        if (blocking_when_failed and fail_on_mismatch) or strict_contract:
             blocking_errors.append(message)
 
     compare_port(
@@ -2626,7 +2643,12 @@ def _url_has_loopback_host(url: str | None) -> bool:
         host = str(urllib_parse.urlsplit(str(url or "")).hostname or "").strip().lower()
     except Exception:
         return False
-    return host in {"localhost", "::1"} or host.startswith("127.")
+    return _host_is_loopback(host)
+
+
+def _host_is_loopback(host: str | None) -> bool:
+    normalized = str(host or "").strip().lower()
+    return normalized in {"localhost", "::1"} or normalized.startswith("127.")
 
 
 def _url_host_for_rtsp(url: str | None) -> str:
@@ -2940,10 +2962,17 @@ async def _build_home_assistant_camera_item(
             blocking_errors.append(f"Failed to resolve remote Home Assistant camera playback: {exc}")
     else:
         engine_path = resolve_output_engine_path(transmission, output)
+        home_assistant_rtsp_host = _home_assistant_rtsp_host(request)
         rtsp_url = await _engine_manager(request).get_read_url_for_path(
             engine_path,
-            host=_home_assistant_rtsp_host(request),
+            host=home_assistant_rtsp_host,
         )
+        if _url_has_loopback_host(rtsp_url) and not _host_is_loopback(home_assistant_rtsp_host):
+            blocking_errors.append(
+                "Local streaming engine returned a loopback RTSP URL for Home Assistant camera playback; "
+                "enable engine.expose_to_lan and set TOPOSYNC_HOME_ASSISTANT_RTSP_HOST to a host reachable by Home Assistant."
+            )
+            rtsp_url = None
         redacted_rtsp_url = _redact_url_credentials(rtsp_url)
 
     role = variant.role if variant is not None else None
@@ -5874,6 +5903,7 @@ async def _sync_pipeline_output_publication_nodes(
         graph = pipeline.graph if isinstance(pipeline.graph, dict) else {}
         nodes = graph.get("nodes") if isinstance(graph.get("nodes"), list) else []
         changed = False
+        publication_targets: dict[str, tuple[str, str, str]] = {}
         for node in nodes:
             if not isinstance(node, dict):
                 continue
@@ -5885,11 +5915,25 @@ async def _sync_pipeline_output_publication_nodes(
                 continue
             cfg = node.get("config") if isinstance(node.get("config"), dict) else {}
             expected_transmission_id = _publication_transmission_id(publication)
-            if str(cfg.get("transmission_id") or "").strip() == expected_transmission_id:
-                continue
-            next_cfg = {**cfg, "transmission_id": expected_transmission_id}
-            node["config"] = next_cfg
-            changed = True
+            expected_output_id = f"hls_{_publication_quality_profile(publication)}"
+            expected_quality_profile_id = _publication_quality_profile(publication)
+            publication_targets[node_id] = (
+                expected_transmission_id,
+                expected_output_id,
+                expected_quality_profile_id,
+            )
+            if str(cfg.get("transmission_id") or "").strip() != expected_transmission_id:
+                next_cfg = {**cfg, "transmission_id": expected_transmission_id}
+                node["config"] = next_cfg
+                changed = True
+        if publication_targets:
+            updated_gate_ids = _sync_demand_gates_for_publication_targets(
+                graph=graph,
+                nodes=nodes,
+                publication_targets=publication_targets,
+            )
+            if updated_gate_ids:
+                changed = True
         if not changed:
             continue
         updated = pipeline.model_copy(update={"graph": graph})
@@ -5908,6 +5952,87 @@ async def _sync_pipeline_output_publication_nodes(
     return changed_pipelines
 
 
+def _sync_demand_gates_for_publication_targets(
+    *,
+    graph: dict[str, Any],
+    nodes: list[Any],
+    publication_targets: dict[str, tuple[str, str, str]],
+) -> list[str]:
+    if not publication_targets:
+        return []
+    edges = graph.get("edges") if isinstance(graph.get("edges"), list) else []
+    downstream_by_node: dict[str, set[str]] = {}
+    for edge in edges:
+        if not isinstance(edge, dict):
+            continue
+        source = edge.get("from")
+        target = edge.get("to")
+        if not isinstance(source, dict) or not isinstance(target, dict):
+            continue
+        source_node = str(source.get("node") or "").strip()
+        target_node = str(target.get("node") or "").strip()
+        if not source_node or not target_node:
+            continue
+        downstream_by_node.setdefault(source_node, set()).add(target_node)
+
+    changed_gate_ids: list[str] = []
+    for node in nodes:
+        if not isinstance(node, dict):
+            continue
+        if str(node.get("operator") or "").strip() != "stream.demand_gate":
+            continue
+        gate_id = str(node.get("id") or "").strip()
+        if not gate_id:
+            continue
+        reachable_publications = [
+            publish_node_id
+            for publish_node_id in publication_targets
+            if _graph_node_reaches(gate_id, publish_node_id, downstream_by_node)
+        ]
+        if len(reachable_publications) != 1:
+            continue
+        transmission_id, output_id, quality_profile_id = publication_targets[reachable_publications[0]]
+        cfg = node.get("config") if isinstance(node.get("config"), dict) else {}
+        demand_scope = str(cfg.get("demand_scope") or "").strip().lower()
+        use_specific_output = demand_scope == "output"
+        next_cfg = {**cfg, "transmission_id": transmission_id}
+        if use_specific_output:
+            next_cfg["demand_scope"] = "output"
+            next_cfg["output_id"] = str(cfg.get("output_id") or "").strip() or output_id
+            next_cfg["quality_profile_id"] = str(cfg.get("quality_profile_id") or "").strip() or quality_profile_id
+        else:
+            next_cfg["demand_scope"] = "transmission"
+            next_cfg["output_id"] = ""
+            next_cfg["quality_profile_id"] = ""
+        if next_cfg == cfg:
+            continue
+        node["config"] = next_cfg
+        changed_gate_ids.append(gate_id)
+    return changed_gate_ids
+
+
+def _graph_node_reaches(
+    source_node_id: str,
+    target_node_id: str,
+    downstream_by_node: dict[str, set[str]],
+) -> bool:
+    if source_node_id == target_node_id:
+        return True
+    seen: set[str] = set()
+    stack = [source_node_id]
+    while stack:
+        current = stack.pop()
+        if current in seen:
+            continue
+        seen.add(current)
+        for child in downstream_by_node.get(current, set()):
+            if child == target_node_id:
+                return True
+            if child not in seen:
+                stack.append(child)
+    return False
+
+
 async def _delete_camera_live_pipelines(
     *,
     request: Request,
@@ -6153,6 +6278,10 @@ def create_streaming_router() -> APIRouter:
                     path_auth=path_auth,
                     path_configs=path_configs,
                 )
+        except MediaMtxPortResolutionError as exc:
+            raise HTTPException(
+                status_code=409, detail=f"Streaming engine port contract is blocked: {exc}"
+            ) from exc
         except Exception as exc:
             raise HTTPException(
                 status_code=500, detail=f"Failed to apply streaming settings: {exc}"
@@ -6277,6 +6406,7 @@ def create_streaming_router() -> APIRouter:
 
         warnings: list[str] = []
         warnings.extend(list(status.warnings))
+        warnings.extend(list(status.port_blocking_errors))
         if not settings.engine.enabled:
             warnings.append("Engine is disabled in settings.")
         if settings.engine.enabled and not status.running:
@@ -6354,6 +6484,9 @@ def create_streaming_router() -> APIRouter:
             warnings=warnings,
             restart_count=status.restart_count,
             orphan_pids=orphan_pids,
+            port_policy=status.port_policy if status.port_policy in {"stable", "flexible"} else "flexible",
+            port_resolution=status.port_resolution,
+            port_blocking_errors=list(status.port_blocking_errors),
         )
 
     @router.post("/engine/download", response_model=StreamingEngineStatusResponse)
@@ -6416,6 +6549,10 @@ def create_streaming_router() -> APIRouter:
                 ),
                 path_configs=build_camera_ingest_path_configs(camera_ingest_by_id),
             )
+        except MediaMtxPortResolutionError as exc:
+            raise HTTPException(
+                status_code=409, detail=f"Streaming engine port contract is blocked: {exc}"
+            ) from exc
         except Exception as exc:
             raise HTTPException(
                 status_code=500, detail=f"Failed to start streaming engine: {exc}"
@@ -6477,6 +6614,10 @@ def create_streaming_router() -> APIRouter:
                 ),
                 path_configs=build_camera_ingest_path_configs(camera_ingest_by_id),
             )
+        except MediaMtxPortResolutionError as exc:
+            raise HTTPException(
+                status_code=409, detail=f"Streaming engine port contract is blocked: {exc}"
+            ) from exc
         except Exception as exc:
             raise HTTPException(
                 status_code=500, detail=f"Failed to restart streaming engine: {exc}"
@@ -6532,6 +6673,12 @@ def create_streaming_router() -> APIRouter:
                     ),
                     path_configs=build_camera_ingest_path_configs(camera_ingest_by_id),
                 )
+            except MediaMtxPortResolutionError as exc:
+                suffix = f" (killed {len(killed_pids)} stale process(es))" if killed_pids else ""
+                raise HTTPException(
+                    status_code=409,
+                    detail=f"Streaming engine port contract is blocked: {exc}{suffix}",
+                ) from exc
             except Exception as exc:
                 suffix = f" (killed {len(killed_pids)} stale process(es))" if killed_pids else ""
                 raise HTTPException(
@@ -6864,6 +7011,10 @@ def create_streaming_router() -> APIRouter:
             await _apply_streaming_engine_state(request, settings=saved)
         except HTTPException:
             raise
+        except MediaMtxPortResolutionError as exc:
+            raise HTTPException(
+                status_code=409, detail=f"Streaming engine port contract is blocked: {exc}"
+            ) from exc
         except Exception as exc:
             raise HTTPException(
                 status_code=500, detail=f"Failed to apply streaming settings: {exc}"
@@ -6911,6 +7062,10 @@ def create_streaming_router() -> APIRouter:
             await _apply_streaming_engine_state(request, settings=saved)
         except HTTPException:
             raise
+        except MediaMtxPortResolutionError as exc:
+            raise HTTPException(
+                status_code=409, detail=f"Streaming engine port contract is blocked: {exc}"
+            ) from exc
         except Exception as exc:
             raise HTTPException(
                 status_code=500, detail=f"Failed to apply streaming settings: {exc}"
@@ -7111,6 +7266,10 @@ def create_streaming_router() -> APIRouter:
                 ),
                 path_configs=build_camera_ingest_path_configs(camera_ingest_by_id),
             )
+        except MediaMtxPortResolutionError as exc:
+            raise HTTPException(
+                status_code=409, detail=f"Streaming engine port contract is blocked: {exc}"
+            ) from exc
         except Exception as exc:
             raise HTTPException(
                 status_code=500, detail=f"Failed to apply streaming settings: {exc}"
@@ -7202,6 +7361,10 @@ def create_streaming_router() -> APIRouter:
                 ),
                 path_configs=build_camera_ingest_path_configs(camera_ingest_by_id),
             )
+        except MediaMtxPortResolutionError as exc:
+            raise HTTPException(
+                status_code=409, detail=f"Streaming engine port contract is blocked: {exc}"
+            ) from exc
         except Exception as exc:
             raise HTTPException(
                 status_code=500, detail=f"Failed to apply streaming settings: {exc}"
@@ -7271,6 +7434,10 @@ def create_streaming_router() -> APIRouter:
                 ),
                 path_configs=build_camera_ingest_path_configs(camera_ingest_by_id),
             )
+        except MediaMtxPortResolutionError as exc:
+            raise HTTPException(
+                status_code=409, detail=f"Streaming engine port contract is blocked: {exc}"
+            ) from exc
         except Exception as exc:
             raise HTTPException(
                 status_code=500, detail=f"Failed to apply streaming settings: {exc}"
@@ -7342,6 +7509,10 @@ def create_streaming_router() -> APIRouter:
                 ),
                 path_configs=build_camera_ingest_path_configs(camera_ingest_by_id),
             )
+        except MediaMtxPortResolutionError as exc:
+            raise HTTPException(
+                status_code=409, detail=f"Streaming engine port contract is blocked: {exc}"
+            ) from exc
         except Exception as exc:
             raise HTTPException(
                 status_code=500, detail=f"Failed to apply streaming settings: {exc}"
@@ -7390,6 +7561,10 @@ def create_streaming_router() -> APIRouter:
                 ),
                 path_configs=build_camera_ingest_path_configs(camera_ingest_by_id),
             )
+        except MediaMtxPortResolutionError as exc:
+            raise HTTPException(
+                status_code=409, detail=f"Streaming engine port contract is blocked: {exc}"
+            ) from exc
         except Exception as exc:
             raise HTTPException(
                 status_code=500, detail=f"Failed to apply streaming settings: {exc}"
@@ -8646,6 +8821,11 @@ def create_streaming_router() -> APIRouter:
                     ),
                     path_configs=build_camera_ingest_path_configs(camera_ingest_by_id),
                 )
+            except MediaMtxPortResolutionError as exc:
+                raise HTTPException(
+                    status_code=409,
+                    detail=f"Streaming engine port contract is blocked: {exc}",
+                ) from exc
             except Exception as exc:
                 raise HTTPException(
                     status_code=500, detail=f"Failed to rotate ingest credentials: {exc}"

{toposync_ext_streaming-0.7.9 → toposync_ext_streaming-0.8.0}/src/toposync_ext_streaming/pipelines/operators.py

@@ -8,7 +8,7 @@ import numpy
 from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator
 
 from toposync.runtime.pipelines.execution import PipelineRuntimeDependencies, SinkRuntime, SourceOperatorRuntime
-from toposync.runtime.pipelines.images import normalize_artifact_name
+from toposync.runtime.pipelines.images import MAIN_ARTIFACT_NAME, normalize_artifact_name
 from toposync.runtime.pipelines.operator_registry import OperatorDiagnostic, OperatorRegistry
 from toposync.runtime.pipelines.packet_contract import resolve_media_ts
 from toposync.runtime.pipelines.runtime import Lifecycle, Packet
@@ -85,11 +85,30 @@ class DemandGateConfig(BaseModel):
     model_config = ConfigDict(extra="forbid")
 
     transmission_id: str = ""
+    demand_scope: Literal["transmission", "output"] = "transmission"
     output_id: str = ""
     quality_profile_id: str = ""
     poll_interval_ms: int = Field(default=500, ge=100, le=10_000)
     fail_open: bool = True
 
+    @model_validator(mode="before")
+    @classmethod
+    def _normalize_legacy_scope(cls, value: Any) -> Any:
+        if not isinstance(value, dict):
+            return value
+        data = dict(value)
+        scope = str(data.get("demand_scope") or "").strip().lower()
+        if scope == "auto":
+            scope = "transmission"
+        if scope not in {"transmission", "output"}:
+            has_specific_output = bool(
+                str(data.get("output_id") or "").strip()
+                or str(data.get("quality_profile_id") or "").strip()
+            )
+            scope = "output" if has_specific_output else "transmission"
+        data["demand_scope"] = scope
+        return data
+
     @field_validator("transmission_id", "output_id", "quality_profile_id", mode="after")
     @classmethod
     def _trim(cls, value: str) -> str:
@@ -147,10 +166,11 @@ class DemandGateRuntime(SourceOperatorRuntime):
         self._last_open = is_open
         self._last_payload = payload
         lifecycle = Lifecycle.OPEN if is_open else Lifecycle.CLOSE
+        output_id, quality_profile_id = self._selected_demand_target()
         stream_id = _demand_gate_stream_id(
             self._config.transmission_id,
-            output_id=self._config.output_id,
-            quality_profile_id=self._config.quality_profile_id,
+            output_id=output_id,
+            quality_profile_id=quality_profile_id,
         )
         return Packet.create(
             stream_id=stream_id,
@@ -158,8 +178,9 @@ class DemandGateRuntime(SourceOperatorRuntime):
             payload={
                 "gate_open": bool(is_open),
                 "transmission_id": self._config.transmission_id,
-                "output_id": self._config.output_id,
-                "quality_profile_id": self._config.quality_profile_id,
+                "demand_scope": self._config.demand_scope,
+                "output_id": output_id,
+                "quality_profile_id": quality_profile_id,
                 **payload,
             },
         )
@@ -175,11 +196,12 @@ class DemandGateRuntime(SourceOperatorRuntime):
                 "reason": "services_unavailable",
             }
         try:
+            output_id, quality_profile_id = self._selected_demand_target()
             raw = await services.call(
                 "streaming.demand.snapshot",
                 transmission_id=self._config.transmission_id,
-                output_id=self._config.output_id,
-                quality_profile_id=self._config.quality_profile_id,
+                output_id=output_id,
+                quality_profile_id=quality_profile_id,
             )
         except Exception as exc:  # noqa: BLE001
             return bool(self._config.fail_open), {
@@ -199,6 +221,11 @@ class DemandGateRuntime(SourceOperatorRuntime):
             "matched_outputs": int(snapshot.get("matched_outputs") or 0),
         }
 
+    def _selected_demand_target(self) -> tuple[str, str]:
+        if self._config.demand_scope != "output":
+            return "", ""
+        return self._config.output_id, self._config.quality_profile_id
+
 
 def register_streaming_pipeline_operators(registry: OperatorRegistry) -> None:
     if registry.get("stream.demand_gate") is None:
@@ -227,6 +254,7 @@ def register_streaming_pipeline_operators(registry: OperatorRegistry) -> None:
         capabilities=["streaming", "sink", "realtime"],
         defaults=PublishVideoConfig(publication_enabled=True).model_dump(mode="json"),
         share_strategy="never",
+        requires_artifacts=[MAIN_ARTIFACT_NAME],
         requires_media_fields=["ts", "width", "height"],
         input_modalities=["video"],
         owner=EXTENSION_ID,