reactor-runtime 3.8.2__tar.gz → 3.9.0__tar.gz

reactor_runtime-3.9.0/PKG-INFO

@@ -0,0 +1,214 @@
+Metadata-Version: 2.4
+Name: reactor-runtime
+Version: 3.9.0
+Summary: A Python framework for building real-time, interactive video models
+Author: Reactor
+Author-email: Reactor <team@reactor.inc>
+License-Expression: Apache-2.0
+License-File: LICENSE
+License-File: NOTICE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Typing :: Typed
+Requires-Dist: av>=18.0.0
+Requires-Dist: fastapi>=0.139.0
+Requires-Dist: numpy>=2.1
+Requires-Dist: prometheus-client>=0.26.0
+Requires-Dist: protobuf>=7.35.1
+Requires-Dist: pyyaml>=6.0.3
+Requires-Dist: reactor-webrtc==0.24.0
+Requires-Dist: uvicorn>=0.49.0
+Requires-Dist: livekit==1.1.21 ; extra == 'livekit'
+Requires-Python: >=3.12
+Project-URL: Source, https://github.com/reactor-team/reactor-runtime
+Provides-Extra: livekit
+Description-Content-Type: text/markdown
+
+<div align="center">
+
+<img src="assets/banner.png" alt="Reactor Runtime" width="100%" />
+
+**Build real-time AI models in Python.**
+
+[📖 Documentation](https://docs.reactor.inc/deploy/overview) · [🚀 Quickstart](https://docs.reactor.inc/deploy/development/quickstart) · [🌐 Reactor](https://reactor.inc)
+
+</div>
+
+---
+
+Reactor Runtime turns an inference pipeline into a real-time, interactive media and data stream. You write `load()` and `generate()`; the runtime drives them one step at a time and handles the session lifecycle, the media transport (WebRTC, or a LiveKit room), and the wire protocol that connects clients to your model. Viewers watch frames as they are generated and change what the model is doing mid-stream, with no restart and no re-queue.
+
+## Highlights
+
+- 📡 **Real-time streaming.** Frames reach clients over WebRTC as your model produces them, not after a whole video is done. The runtime paces playout from the time each step took, so a model needs no rate limiter of its own.
+- 🎮 **Live interaction.** Clients send commands mid-generation: change a prompt, move a camera, adjust a parameter. The next frame reflects it.
+- 🔌 **No transport code.** You never import a WebRTC library, manage a WebSocket, or encode video. The runtime ships its own media engine as a wheel, so a plain Python container is all a model needs.
+- 🏠 **LiveKit rooms.** A session can join a LiveKit room: the model's tracks are published there, and every other participant in the room is a client.
+- ✅ **Typed, validated commands.** Declare the commands your model accepts with standard Python types and constraints. The runtime validates every payload before your handler runs and compiles the surface into an OpenAPI schema that drives typed client SDKs.
+- 🗂️ **Step results.** Start a session with its input and a number of steps, and keep each step's output as a folder of files.
+- 🔎 **Traceable logs.** `get_logger()` writes structured records, and every record a session writes carries its id, so one filter recovers a whole run.
+- 📦 **One container, anywhere.** The `reactor` CLI scaffolds a workspace, builds a small image, and runs it locally. The same image deploys to [Reactor](https://reactor.inc)'s GPU cloud unchanged.
+
+## How it works
+
+You ship one `ReactorApp` subclass: the application the runtime drives and the client talks to. Declare the media it sends and the state a client can set, load your weights once, and write what one step of generation does:
+
+```python
+from pathlib import Path
+
+from reactor_runtime import InputField, InputState, Output, ReactorApp, Video
+
+
+class MyState(InputState):
+    prompt: str = InputField(default="a sunny meadow", moderate=True, description="Scene to render.")
+    paused: bool = InputField(default=False, description="Hold generation on the last frame.")
+
+
+class MyOutput(Output):
+    main_video: Video
+
+
+class MyModel(ReactorApp):
+    state: MyState
+
+    def load(self, config_path: Path | None) -> None:
+        self.pipe = load_my_pipeline()
+
+    def generate(self, input: MyState) -> MyOutput:
+        return MyOutput(main_video=self.pipe.forward(prompt=input.prompt))
+```
+
+That is a complete application. The runtime calls `generate()` in a loop for as long as someone is watching and emits what it returns. Every public field on `MyState` is a command the client can send: here `set_prompt` and `set_paused`, validated from the fields, and the next step reads the new values.
+
+A step is three calls, and `generate()` is the one you must write. `process_input()` runs before it and decides whether a step can happen: return the input `generate()` gets, or raise `ApplicationError("reason")` to skip the step. `process_output(outcome)` runs after it, with the result or the error, and returns the media to emit; a message sent there with `await self.send()` reaches the client before the step's frames. Both have defaults, so the model above writes neither.
+
+```python
+from reactor_runtime import ApplicationError, MessageField, ModelMessage, StepOutcome
+
+
+class FrameReady(ModelMessage):
+    prompt: str = MessageField(description="The prompt this frame was rendered from.")
+
+
+class MyModel(ReactorApp):
+    state: MyState
+
+    async def process_input(self) -> MyState:
+        if self.state.paused:
+            raise ApplicationError("paused")
+        return self.state
+
+    def generate(self, input: MyState) -> MyOutput: ...
+
+    async def process_output(self, outcome: StepOutcome) -> Output | None:
+        if outcome.error is not None:
+            raise outcome.error
+        await self.send(FrameReady(prompt=self.state.prompt))
+        return outcome.to_output()
+```
+
+`generate()` fails by raising, and the exception reaches `process_output()` as `outcome.error`. Recover an error you expect there and return `None` to go on to the next step. Re-raise anything else to end the session with an error, as the default `process_output()` does.
+
+Commands and lifecycle hooks such as `@session_started` and `@connected` run between steps, never during one. A command handler refuses by raising `CommandError(code, message)`, which fails the caller's own request. For a loop that is not one step per emit, override `run()` and write it against `emit()`, `send()`, and `complete_step()`.
+
+A session can also start with its setup in hand and run a set number of steps: `POST /start_session` takes a `starting_input` of state values and commands, and `steps`, and the session ends once the model has reported that many. Each step can be kept as a folder of files, turned on in `reactor.yaml`:
+
+```yaml
+runtime:
+  step_results:
+    enabled: true
+    video: {codec: h264, preset: veryfast, crf: 23}   # or codec: h265
+    audio: {codec: aac, bitrate_kbps: 128}
+    queue: 8
+```
+
+A step's tracks are saved as one `output.mp4`, with a `result.json` that lists the step's files, and `GET /sessions/{id}/steps` serves the folders.
+
+A session can also be stepped: `POST /start_session` with `"generation": "stepped"` runs one step per `RequestStep` a client sends on the data channel instead of streaming, and answers each request with a `StepResult` that carries the step's media, so a stepped client must negotiate data-channel chunking. The model code is the same in both modes; a model that overrides `run()` or `submit_command()` cannot be stepped. The [stepped echo example](./examples/stepped_echo/README.md) answers each step with what it saw, so a client can check every part of its request.
+
+A session can join a LiveKit room. The room connection publishes the model's output tracks, and every other participant in the room is a client of the session. The model's `reactor.yaml` says which RPC methods, data topics, and byte streams reach which of its commands, messages, and input tracks:
+
+```yaml
+runtime:
+  livekit:
+    rpc:
+      - method: lk.clear_buffer        # a call to this method runs clear_buffer
+        command: clear_buffer
+      - method: lk.playback_finished   # sending playback_finished calls this method
+        message: playback_finished
+    topics: [avatar]                   # a data packet on avatar.<command> runs <command>
+    media_inputs:
+      lk.audio_stream: agent_audio     # byte streams on this topic feed agent_audio
+```
+
+The LiveKit SDK is an optional part of the runtime, so a model that joins rooms lists `reactor-runtime[livekit]` in its `requirements.txt`. A running session joins a room through a connection of its own:
+
+```text
+POST /sessions/{session_id}/transport/livekit/connections
+{"url": "wss://example.livekit.cloud", "token": "eyJhbGciOi..."}
+```
+
+Scaffold, build, and run it with the CLI:
+
+```sh
+reactor init my-model
+cd my-model
+reactor run
+```
+
+`reactor run` builds a container with the runtime inside and serves WebRTC signaling on port 8080. Point a browser at it with the [JS SDK](https://docs.reactor.inc/sdk-reference/using-the-sdk), or connect from the [Reactor Sandbox](https://reactor-sandbox.vercel.app/) and watch frames stream immediately.
+
+Log from the same import, passing context as keyword arguments:
+
+```python
+from reactor_runtime import get_logger
+
+logger = get_logger(__name__)
+
+logger.info("scene changed", prompt=self.prompt)
+```
+
+Records render as `key=value` text, or as one JSON object per line under `REACTOR_LOG_FORMAT=json`. Every record written during a session carries its id and the runtime's lifecycle state, including the records of `logging.getLogger()` and of the libraries your model imports.
+
+## Install
+
+Everything runs through the [`reactor` CLI](https://docs.reactor.inc/deploy/platform/installation). There is nothing to install on your host but the CLI and Docker; the runtime ships inside the image the CLI builds for your workspace.
+
+```sh
+brew install reactor-team/tools/reactor-cli
+```
+
+Not on macOS, or pinning a release in CI? See [Install the CLI](https://docs.reactor.inc/deploy/platform/installation).
+
+## Learn more
+
+- [Quickstart](https://docs.reactor.inc/deploy/development/quickstart): from zero to a model deployed on Reactor's GPUs
+- [Runtime overview](https://docs.reactor.inc/deploy/development/overview): what the runtime handles, and the outline of a model
+- [Model anatomy](https://docs.reactor.inc/deploy/development/reactor-app/model-anatomy): every member of a `ReactorApp`, line by line
+- [The step loop](https://docs.reactor.inc/deploy/development/reactor-app/step-loop): `process_input()`, `generate()`, `process_output()`, and the frame rate
+- [Events and messages](https://docs.reactor.inc/deploy/development/reactor-app/events-and-messages): commands, refusals with `CommandError`, and messages to clients
+- [Video and audio tracks](https://docs.reactor.inc/deploy/development/reactor-app/video-and-audio-tracks): output and input tracks, and how input is buffered
+- [Starter example](./examples/starter/README.md): the model `reactor init` scaffolds: one class, `generate()` alone, the smallest complete `ReactorApp`
+- [Echo example](./examples/echo/README.md): the client's webcam and microphone in, an effect applied, both sent back, in batches
+- [Waypoint example](./examples/waypoint/README.md): a world model on a GPU, seeded from an upload and steered live
+- [Stepped echo example](./examples/stepped_echo/README.md): one frame and a JSON report back for every step, the reference for a stepped session
+
+## Development
+
+This repository holds the runtime package itself: the authoring interface, the session runner, the media transport, and the wire protocol. To work on it, use [mise](https://mise.jdx.dev/), which pins the toolchain and forwards every task through a thin `make` shim:
+
+```sh
+mise run install      # install deps, generate wire bindings, and git hooks
+mise run lint         # ruff check, ruff format --check, and mise.lock drift
+mise run format       # apply ruff formatting
+mise run typecheck    # ty (strict)
+mise run test         # unit tests on the floor Python
+mise run test-matrix  # unit tests on every supported Python
+```
+
+## License
+
+Licensed under the [Apache License, Version 2.0](./LICENSE).

reactor_runtime-3.9.0/README.md

@@ -0,0 +1,185 @@
+<div align="center">
+
+<img src="assets/banner.png" alt="Reactor Runtime" width="100%" />
+
+**Build real-time AI models in Python.**
+
+[📖 Documentation](https://docs.reactor.inc/deploy/overview) · [🚀 Quickstart](https://docs.reactor.inc/deploy/development/quickstart) · [🌐 Reactor](https://reactor.inc)
+
+</div>
+
+---
+
+Reactor Runtime turns an inference pipeline into a real-time, interactive media and data stream. You write `load()` and `generate()`; the runtime drives them one step at a time and handles the session lifecycle, the media transport (WebRTC, or a LiveKit room), and the wire protocol that connects clients to your model. Viewers watch frames as they are generated and change what the model is doing mid-stream, with no restart and no re-queue.
+
+## Highlights
+
+- 📡 **Real-time streaming.** Frames reach clients over WebRTC as your model produces them, not after a whole video is done. The runtime paces playout from the time each step took, so a model needs no rate limiter of its own.
+- 🎮 **Live interaction.** Clients send commands mid-generation: change a prompt, move a camera, adjust a parameter. The next frame reflects it.
+- 🔌 **No transport code.** You never import a WebRTC library, manage a WebSocket, or encode video. The runtime ships its own media engine as a wheel, so a plain Python container is all a model needs.
+- 🏠 **LiveKit rooms.** A session can join a LiveKit room: the model's tracks are published there, and every other participant in the room is a client.
+- ✅ **Typed, validated commands.** Declare the commands your model accepts with standard Python types and constraints. The runtime validates every payload before your handler runs and compiles the surface into an OpenAPI schema that drives typed client SDKs.
+- 🗂️ **Step results.** Start a session with its input and a number of steps, and keep each step's output as a folder of files.
+- 🔎 **Traceable logs.** `get_logger()` writes structured records, and every record a session writes carries its id, so one filter recovers a whole run.
+- 📦 **One container, anywhere.** The `reactor` CLI scaffolds a workspace, builds a small image, and runs it locally. The same image deploys to [Reactor](https://reactor.inc)'s GPU cloud unchanged.
+
+## How it works
+
+You ship one `ReactorApp` subclass: the application the runtime drives and the client talks to. Declare the media it sends and the state a client can set, load your weights once, and write what one step of generation does:
+
+```python
+from pathlib import Path
+
+from reactor_runtime import InputField, InputState, Output, ReactorApp, Video
+
+
+class MyState(InputState):
+    prompt: str = InputField(default="a sunny meadow", moderate=True, description="Scene to render.")
+    paused: bool = InputField(default=False, description="Hold generation on the last frame.")
+
+
+class MyOutput(Output):
+    main_video: Video
+
+
+class MyModel(ReactorApp):
+    state: MyState
+
+    def load(self, config_path: Path | None) -> None:
+        self.pipe = load_my_pipeline()
+
+    def generate(self, input: MyState) -> MyOutput:
+        return MyOutput(main_video=self.pipe.forward(prompt=input.prompt))
+```
+
+That is a complete application. The runtime calls `generate()` in a loop for as long as someone is watching and emits what it returns. Every public field on `MyState` is a command the client can send: here `set_prompt` and `set_paused`, validated from the fields, and the next step reads the new values.
+
+A step is three calls, and `generate()` is the one you must write. `process_input()` runs before it and decides whether a step can happen: return the input `generate()` gets, or raise `ApplicationError("reason")` to skip the step. `process_output(outcome)` runs after it, with the result or the error, and returns the media to emit; a message sent there with `await self.send()` reaches the client before the step's frames. Both have defaults, so the model above writes neither.
+
+```python
+from reactor_runtime import ApplicationError, MessageField, ModelMessage, StepOutcome
+
+
+class FrameReady(ModelMessage):
+    prompt: str = MessageField(description="The prompt this frame was rendered from.")
+
+
+class MyModel(ReactorApp):
+    state: MyState
+
+    async def process_input(self) -> MyState:
+        if self.state.paused:
+            raise ApplicationError("paused")
+        return self.state
+
+    def generate(self, input: MyState) -> MyOutput: ...
+
+    async def process_output(self, outcome: StepOutcome) -> Output | None:
+        if outcome.error is not None:
+            raise outcome.error
+        await self.send(FrameReady(prompt=self.state.prompt))
+        return outcome.to_output()
+```
+
+`generate()` fails by raising, and the exception reaches `process_output()` as `outcome.error`. Recover an error you expect there and return `None` to go on to the next step. Re-raise anything else to end the session with an error, as the default `process_output()` does.
+
+Commands and lifecycle hooks such as `@session_started` and `@connected` run between steps, never during one. A command handler refuses by raising `CommandError(code, message)`, which fails the caller's own request. For a loop that is not one step per emit, override `run()` and write it against `emit()`, `send()`, and `complete_step()`.
+
+A session can also start with its setup in hand and run a set number of steps: `POST /start_session` takes a `starting_input` of state values and commands, and `steps`, and the session ends once the model has reported that many. Each step can be kept as a folder of files, turned on in `reactor.yaml`:
+
+```yaml
+runtime:
+  step_results:
+    enabled: true
+    video: {codec: h264, preset: veryfast, crf: 23}   # or codec: h265
+    audio: {codec: aac, bitrate_kbps: 128}
+    queue: 8
+```
+
+A step's tracks are saved as one `output.mp4`, with a `result.json` that lists the step's files, and `GET /sessions/{id}/steps` serves the folders.
+
+A session can also be stepped: `POST /start_session` with `"generation": "stepped"` runs one step per `RequestStep` a client sends on the data channel instead of streaming, and answers each request with a `StepResult` that carries the step's media, so a stepped client must negotiate data-channel chunking. The model code is the same in both modes; a model that overrides `run()` or `submit_command()` cannot be stepped. The [stepped echo example](./examples/stepped_echo/README.md) answers each step with what it saw, so a client can check every part of its request.
+
+A session can join a LiveKit room. The room connection publishes the model's output tracks, and every other participant in the room is a client of the session. The model's `reactor.yaml` says which RPC methods, data topics, and byte streams reach which of its commands, messages, and input tracks:
+
+```yaml
+runtime:
+  livekit:
+    rpc:
+      - method: lk.clear_buffer        # a call to this method runs clear_buffer
+        command: clear_buffer
+      - method: lk.playback_finished   # sending playback_finished calls this method
+        message: playback_finished
+    topics: [avatar]                   # a data packet on avatar.<command> runs <command>
+    media_inputs:
+      lk.audio_stream: agent_audio     # byte streams on this topic feed agent_audio
+```
+
+The LiveKit SDK is an optional part of the runtime, so a model that joins rooms lists `reactor-runtime[livekit]` in its `requirements.txt`. A running session joins a room through a connection of its own:
+
+```text
+POST /sessions/{session_id}/transport/livekit/connections
+{"url": "wss://example.livekit.cloud", "token": "eyJhbGciOi..."}
+```
+
+Scaffold, build, and run it with the CLI:
+
+```sh
+reactor init my-model
+cd my-model
+reactor run
+```
+
+`reactor run` builds a container with the runtime inside and serves WebRTC signaling on port 8080. Point a browser at it with the [JS SDK](https://docs.reactor.inc/sdk-reference/using-the-sdk), or connect from the [Reactor Sandbox](https://reactor-sandbox.vercel.app/) and watch frames stream immediately.
+
+Log from the same import, passing context as keyword arguments:
+
+```python
+from reactor_runtime import get_logger
+
+logger = get_logger(__name__)
+
+logger.info("scene changed", prompt=self.prompt)
+```
+
+Records render as `key=value` text, or as one JSON object per line under `REACTOR_LOG_FORMAT=json`. Every record written during a session carries its id and the runtime's lifecycle state, including the records of `logging.getLogger()` and of the libraries your model imports.
+
+## Install
+
+Everything runs through the [`reactor` CLI](https://docs.reactor.inc/deploy/platform/installation). There is nothing to install on your host but the CLI and Docker; the runtime ships inside the image the CLI builds for your workspace.
+
+```sh
+brew install reactor-team/tools/reactor-cli
+```
+
+Not on macOS, or pinning a release in CI? See [Install the CLI](https://docs.reactor.inc/deploy/platform/installation).
+
+## Learn more
+
+- [Quickstart](https://docs.reactor.inc/deploy/development/quickstart): from zero to a model deployed on Reactor's GPUs
+- [Runtime overview](https://docs.reactor.inc/deploy/development/overview): what the runtime handles, and the outline of a model
+- [Model anatomy](https://docs.reactor.inc/deploy/development/reactor-app/model-anatomy): every member of a `ReactorApp`, line by line
+- [The step loop](https://docs.reactor.inc/deploy/development/reactor-app/step-loop): `process_input()`, `generate()`, `process_output()`, and the frame rate
+- [Events and messages](https://docs.reactor.inc/deploy/development/reactor-app/events-and-messages): commands, refusals with `CommandError`, and messages to clients
+- [Video and audio tracks](https://docs.reactor.inc/deploy/development/reactor-app/video-and-audio-tracks): output and input tracks, and how input is buffered
+- [Starter example](./examples/starter/README.md): the model `reactor init` scaffolds: one class, `generate()` alone, the smallest complete `ReactorApp`
+- [Echo example](./examples/echo/README.md): the client's webcam and microphone in, an effect applied, both sent back, in batches
+- [Waypoint example](./examples/waypoint/README.md): a world model on a GPU, seeded from an upload and steered live
+- [Stepped echo example](./examples/stepped_echo/README.md): one frame and a JSON report back for every step, the reference for a stepped session
+
+## Development
+
+This repository holds the runtime package itself: the authoring interface, the session runner, the media transport, and the wire protocol. To work on it, use [mise](https://mise.jdx.dev/), which pins the toolchain and forwards every task through a thin `make` shim:
+
+```sh
+mise run install      # install deps, generate wire bindings, and git hooks
+mise run lint         # ruff check, ruff format --check, and mise.lock drift
+mise run format       # apply ruff formatting
+mise run typecheck    # ty (strict)
+mise run test         # unit tests on the floor Python
+mise run test-matrix  # unit tests on every supported Python
+```
+
+## License
+
+Licensed under the [Apache License, Version 2.0](./LICENSE).

{reactor_runtime-3.8.2 → reactor_runtime-3.9.0}/pyproject.toml

@@ -10,7 +10,7 @@ module-name = [
 namespace = true
 
 [tool.reactor-wire]
-version = "1.20261013.10"
+version = "1.20261022.18"
 
 [tool.ruff]
 line-length = 100
@@ -64,6 +64,7 @@ convention = "google"
 
 [tool.ruff.lint.per-file-ignores]
 "tests/**" = ["D"]
+"endurance-tests/unit/**" = ["D"]
 
 [tool.ty.environment]
 python = ".venv"
@@ -73,14 +74,18 @@ extra-paths = [
     "examples/starter",
     "examples/echo",
     "examples/waypoint",
+    "examples/stepped_echo",
     "tests/unit/transport/webrtc",
     "tests/contract",
+    "endurance-tests",
+    "endurance-tests/model",
 ]
 
 [tool.ty.src]
 include = [
     "src",
     "tests",
+    "endurance-tests",
     "examples",
 ]
 exclude = [
@@ -89,13 +94,19 @@ exclude = [
 ]
 
 [tool.pytest.ini_options]
-testpaths = ["tests"]
+testpaths = [
+    "tests",
+    "endurance-tests/unit",
+]
 asyncio_mode = "auto"
-pythonpath = ["."]
+pythonpath = [
+    ".",
+    "endurance-tests",
+]
 
 [project]
 name = "reactor-runtime"
-version = "3.8.2"
+version = "3.9.0"
 description = "A Python framework for building real-time, interactive video models"
 readme = "README.md"
 license = "Apache-2.0"
@@ -119,7 +130,7 @@ dependencies = [
     "prometheus-client>=0.26.0",
     "protobuf>=7.35.1",
     "pyyaml>=6.0.3",
-    "reactor-webrtc==0.22.1",
+    "reactor-webrtc==0.24.0",
     "uvicorn>=0.49.0",
 ]
 
@@ -127,14 +138,21 @@ dependencies = [
 name = "Reactor"
 email = "team@reactor.inc"
 
+[project.optional-dependencies]
+livekit = ["livekit==1.1.21"]
+
 [project.urls]
 Source = "https://github.com/reactor-team/reactor-runtime"
 
 [dependency-groups]
 dev = [
+    "certifi>=2026.10.19",
     "httpx>=0.28.1",
+    "livekit==1.1.21",
+    "livekit-api>=1.2.2",
     "opencv-python-headless>=4.10",
     "pillow>=10.1",
+    "psutil>=7.0",
     "pytest",
     "pytest-asyncio",
     "types-protobuf",

{reactor_runtime-3.8.2 → reactor_runtime-3.9.0}/pyproject.toml.orig

@@ -16,11 +16,11 @@ namespace = true
 # gates the pin against proto/, so a release cannot ship a schema older than the
 # sources it was built from.
 [tool.reactor-wire]
-version = "1.20261013.10"
+version = "1.20261022.18"
 
 [project]
 name = "reactor-runtime"
-version = "3.8.2"
+version = "3.9.0"
 description = "A Python framework for building real-time, interactive video models"
 readme = "README.md"
 license = "Apache-2.0"
@@ -42,18 +42,29 @@ dependencies = [
     "prometheus-client>=0.26.0",
     "protobuf>=7.35.1",
     "pyyaml>=6.0.3",
-    "reactor-webrtc==0.22.1",
+    "reactor-webrtc==0.24.0",
     "uvicorn>=0.49.0",
 ]
 
+[project.optional-dependencies]
+# The LiveKit transport. A model that joins LiveKit rooms lists
+# `reactor-runtime[livekit]` in its requirements; the runtime pin stays the
+# CLI's `build.runtime_version`.
+livekit = ["livekit==1.1.21"]
+
 [project.urls]
 Source = "https://github.com/reactor-team/reactor-runtime"
 
 [dependency-groups]
 dev = [
+    "certifi>=2026.10.19",
     "httpx>=0.28.1",
+    # The LiveKit transport and the token minting its tests use.
+    "livekit==1.1.21",
+    "livekit-api>=1.2.2",
     "opencv-python-headless>=4.10",
     "pillow>=10.1",
+    "psutil>=7.0",
     "pytest",
     "pytest-asyncio",
     "types-protobuf",
@@ -121,6 +132,7 @@ convention = "google"
 
 [tool.ruff.lint.per-file-ignores]
 "tests/**" = ["D"]
+"endurance-tests/unit/**" = ["D"]
 
 [tool.ty.environment]
 python = ".venv"
@@ -131,20 +143,25 @@ python-version = "3.12"
 # its tests can import their sibling `conftest` for the shared peer fakes; and
 # the contract suite, so its tests can import their sibling `contract_helpers`;
 # and each example workspace, whose two modules import each other as top-level
-# names, the way the runtime imports a workspace.
+# names, the way the runtime imports a workspace; the endurance suite's
+# root, so its `endurance` package resolves; and its model, imported by name.
 extra-paths = [
     ".",
     "examples/starter",
     "examples/echo",
     "examples/waypoint",
+    "examples/stepped_echo",
     "tests/unit/transport/webrtc",
     "tests/contract",
+    "endurance-tests",
+    "endurance-tests/model",
 ]
 
 [tool.ty.src]
-# Check the package, its tests, and the example models; scripts/ ships developer
-# tooling that is not part of the published package surface.
-include = ["src", "tests", "examples"]
+# Check the package, its tests, the endurance suite, and the example models;
+# scripts/ ships developer tooling that is not part of the published package
+# surface.
+include = ["src", "tests", "endurance-tests", "examples"]
 # Generated bindings ship their own stubs.
 exclude = [
     "src/reactor_wire",
@@ -155,8 +172,9 @@ exclude = [
 ]
 
 [tool.pytest.ini_options]
-testpaths = ["tests"]
+testpaths = ["tests", "endurance-tests/unit"]
 asyncio_mode = "auto"
 # The example models live at the repo root (outside the package) so they are not
-# shipped; put the root on the path so the suite can import them.
-pythonpath = ["."]
+# shipped; put the root on the path so the suite can import them. The endurance
+# suite's root holds its `endurance` package.
+pythonpath = [".", "endurance-tests"]

{reactor_runtime-3.8.2 → reactor_runtime-3.9.0}/src/reactor_runtime/core/__init__.py

@@ -22,6 +22,9 @@ from reactor_runtime.core.model import (
     UploadedFile,
 )
 from reactor_runtime.core.service import (
+    LiveKitBlockError,
+    LiveKitConfig,
+    LiveKitRpcMethod,
     RecordingConfig,
     RuntimeConfig,
     ServiceComponent,
@@ -36,19 +39,26 @@ from reactor_runtime.core.session import (
 from reactor_runtime.core.stats import TransportReading, TransportTrackReading
 from reactor_runtime.core.transport import (
     Connection,
+    ConnectionOriginSource,
     ConnectionSink,
     FrameStageSource,
+    InputTrackWatcher,
+    MessageObserver,
+    MessageStageSource,
+    ReplyRoute,
     TransportStatsSource,
 )
 from reactor_runtime.core.typespec import TypeSpec
 from reactor_runtime.core.values import (
     ClientConnectionStat,
+    ClientEnvironment,
     ClientStatsBatch,
     ClientTrackDirection,
     ClientTrackStat,
     CommandFailure,
     CompletedStep,
     ConnectionCapabilities,
+    ConnectionOrigin,
     ConnId,
     FrameStage,
     Health,
@@ -56,7 +66,11 @@ from reactor_runtime.core.values import (
     InputFrame,
     MediaBundle,
     MediaChunk,
+    MessageStage,
+    RequestedStep,
     RuntimeState,
+    StepRefusal,
+    StepRefusalKind,
     TrackData,
     TrackDirection,
     TrackInfo,
@@ -68,6 +82,7 @@ __all__ = [
     "ClientConnected",
     "ClientConnectionStat",
     "ClientDisconnected",
+    "ClientEnvironment",
     "ClientStatsBatch",
     "ClientTrackDirection",
     "ClientTrackStat",
@@ -78,6 +93,8 @@ __all__ = [
     "ConnId",
     "Connection",
     "ConnectionCapabilities",
+    "ConnectionOrigin",
+    "ConnectionOriginSource",
     "ConnectionSink",
     "EndReason",
     "FieldInfo",
@@ -88,10 +105,19 @@ __all__ = [
     "HealthStatus",
     "InputField",
     "InputFrame",
+    "InputTrackWatcher",
+    "LiveKitBlockError",
+    "LiveKitConfig",
+    "LiveKitRpcMethod",
     "MediaBundle",
     "MediaChunk",
+    "MessageObserver",
+    "MessageStage",
+    "MessageStageSource",
     "ReactorEvent",
     "RecordingConfig",
+    "ReplyRoute",
+    "RequestedStep",
     "RuntimeConfig",
     "RuntimeState",
     "ServiceComponent",
@@ -100,6 +126,8 @@ __all__ = [
     "SessionStarted",
     "SessionState",
     "StartingInputApplied",
+    "StepRefusal",
+    "StepRefusalKind",
     "StepResultsConfig",
     "TrackData",
     "TrackDirection",