[feat]: Wire creation studio config to backend session init and generation

apps/dreamverse/arch.md

@@ -299,18 +299,47 @@ There are three related prompt paths in the current system:
 
 ## Initial Image And Segment Handling
 
-The frontend currently sends `initial_image` as part of session init or
+The frontend sends `initial_image` and, for first/last frame mode,
+`last_frame_image` as part of `session_init_v2`, `project_init_v1`, or
 `simple_generate`.
 
 The server:
 
-- validates and persists the image
-- uses it only for segment 1 when present
+- validates and persists the images
+- uses `initial_image` only for segment 1 when present
 - keeps continuation state for later segments in the GPU worker
 
 This means the runtime, not the frontend, decides how segment 1 image
 conditioning and later continuation conditioning are applied.
 
+## Creation Studio Config
+
+The lobby creation studio sends model, mode, aspect ratio, resolution, and
+duration with session init. The server parses these fields into a per-session
+creation config and echoes the resolved values back on `gpu_assigned` and
+`ltx2_stream_start` as `creation_config`.
+
+Incoming fields on `session_init_v2` and `project_init_v1`:
+
+- `generation_mode`: `t2va`, `fl2va`, or `ref2va` (canonical upstream IDs from #1834)
+- `model_id`: `fast-ltx2`, `fast-ltx23`, or `fast-h3`
+- `aspect_ratio`: one of `21:9`, `16:9`, `4:3`, `1:1`, `3:4`, `9:16`
+- `resolution`: one of `480p`, `720p`, `1080p`, `4k`
+- `duration_sec`: `5`, `10`, or `15`
+- `initial_image`: optional image payload for reference / first-frame modes
+- `last_frame_image`: optional image payload for first/last frame mode
+
+Echoed `creation_config` includes the resolved frame size,
+`num_frames`, and `generation_segment_cap` derived from `duration_sec`.
+
+Mode validation:
+
+- `ref2va` requires `initial_image`
+- `fl2va` requires both `initial_image` and `last_frame_image`
+
+Per-step generation uses the resolved `frame_width`, `frame_height`, and
+`num_frames` from the session creation config.
+
 ## Websocket Contract
 
 The websocket is the main integration surface between UI and runtime.

apps/dreamverse/dreamverse/creation_capabilities.py

@@ -0,0 +1,137 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from dreamverse.config import MODEL_REGISTRY
+
+# Canonical upstream wire IDs. FL2VA is tracked in #1834 but not wired on Dreamverse
+# streaming backends yet.
+LTX_LOBBY_GENERATION_MODES = frozenset({"t2va", "ref2va"})
+H3_LOBBY_GENERATION_MODES = frozenset({"t2va", "ref2va"})
+
+LTX_LOBBY_ASPECT_RATIOS = frozenset({"21:9", "16:9", "4:3", "1:1", "3:4", "9:16"})
+
+# Realtime FastLTX serving is validated through 1080p-class outputs; 4K is rejected
+# until the runtime path is tested on Dreamverse GPUs.
+LTX_LOBBY_RESOLUTIONS = frozenset({"480p", "720p", "1080p"})
+
+# FastH3 serves a fixed 768x1344 (16:9-class) output; lobby resolution is nominal.
+H3_LOBBY_ASPECT_RATIOS = frozenset({"16:9"})
+H3_LOBBY_RESOLUTIONS = frozenset({"720p"})
+
+LOBBY_DURATION_SEC = frozenset({5, 10, 15})
+
+UNSUPPORTED_GENERATION_MODE_MESSAGES = {
+    "fl2va": "First/last frame mode (FL2VA) is not supported yet.",
+}
+
+
+@dataclass(frozen=True)
+class ModelCreationCapabilities:
+    generation_modes: frozenset[str]
+    aspect_ratios: frozenset[str]
+    resolutions: frozenset[str]
+    duration_sec: frozenset[int]
+    unsupported_generation_modes: frozenset[str] = frozenset({"fl2va"})
+
+    def as_dict(self) -> dict[str, object]:
+        unsupported = {
+            mode: UNSUPPORTED_GENERATION_MODE_MESSAGES[mode]
+            for mode in sorted(self.unsupported_generation_modes)
+            if mode in UNSUPPORTED_GENERATION_MODE_MESSAGES
+        }
+        return {
+            "generation_modes": sorted(self.generation_modes),
+            "aspect_ratios": sorted(self.aspect_ratios),
+            "resolutions": sorted(self.resolutions),
+            "duration_sec": sorted(self.duration_sec),
+            "unsupported_generation_modes": unsupported,
+            "reference_assets": {
+                "mime_types": ["image/png", "image/jpeg", "image/webp"],
+                "max_bytes": 15 * 1024 * 1024,
+            },
+        }
+
+
+LTX_MODEL_CREATION_CAPABILITIES = ModelCreationCapabilities(
+    generation_modes=LTX_LOBBY_GENERATION_MODES,
+    aspect_ratios=LTX_LOBBY_ASPECT_RATIOS,
+    resolutions=LTX_LOBBY_RESOLUTIONS,
+    duration_sec=LOBBY_DURATION_SEC,
+)
+
+H3_MODEL_CREATION_CAPABILITIES = ModelCreationCapabilities(
+    generation_modes=H3_LOBBY_GENERATION_MODES,
+    aspect_ratios=H3_LOBBY_ASPECT_RATIOS,
+    resolutions=H3_LOBBY_RESOLUTIONS,
+    duration_sec=LOBBY_DURATION_SEC,
+)
+
+MODEL_CREATION_CAPABILITIES: dict[str, ModelCreationCapabilities] = {
+    "fast-ltx2": LTX_MODEL_CREATION_CAPABILITIES,
+    "fast-ltx23": LTX_MODEL_CREATION_CAPABILITIES,
+    "fast-h3": H3_MODEL_CREATION_CAPABILITIES,
+}
+
+
+def capabilities_for_model(model_id: str) -> ModelCreationCapabilities:
+    if model_id not in MODEL_REGISTRY:
+        raise ValueError(f"Unknown model_id: {model_id}")
+    return MODEL_CREATION_CAPABILITIES.get(model_id, LTX_MODEL_CREATION_CAPABILITIES)
+
+
+def lobby_capabilities_as_dict() -> dict[str, object]:
+    model_ids = sorted(MODEL_REGISTRY.keys())
+    models = {model_id: capabilities_for_model(model_id).as_dict() for model_id in model_ids}
+    union_modes: set[str] = set()
+    union_aspects: set[str] = set()
+    union_resolutions: set[str] = set()
+    union_durations: set[int] = set()
+    for caps in MODEL_CREATION_CAPABILITIES.values():
+        union_modes.update(caps.generation_modes)
+        union_aspects.update(caps.aspect_ratios)
+        union_resolutions.update(caps.resolutions)
+        union_durations.update(caps.duration_sec)
+    return {
+        "model_ids": model_ids,
+        "models": models,
+        "generation_modes": sorted(union_modes),
+        "aspect_ratios": sorted(union_aspects),
+        "resolutions": sorted(union_resolutions),
+        "duration_sec": sorted(union_durations),
+        "unsupported_generation_modes": dict(UNSUPPORTED_GENERATION_MODE_MESSAGES),
+        "reference_assets": {
+            "mime_types": ["image/png", "image/jpeg", "image/webp"],
+            "max_bytes": 15 * 1024 * 1024,
+        },
+    }
+
+
+# Backward-compatible alias used in tests.
+LOBBY_CREATION_CAPABILITIES = lobby_capabilities_as_dict()
+
+
+def validate_lobby_creation_config(
+    *,
+    model_id: str,
+    generation_mode: str,
+    aspect_ratio: str,
+    resolution: str,
+    duration_sec: int,
+) -> None:
+    if model_id not in MODEL_REGISTRY:
+        raise ValueError(f"Unknown model_id: {model_id}")
+
+    caps = capabilities_for_model(model_id)
+
+    if generation_mode in caps.unsupported_generation_modes:
+        raise ValueError(UNSUPPORTED_GENERATION_MODE_MESSAGES[generation_mode])
+    if generation_mode not in caps.generation_modes:
+        raise ValueError(f"Unsupported generation_mode: {generation_mode}")
+
+    if aspect_ratio not in caps.aspect_ratios:
+        raise ValueError(f"Unsupported aspect_ratio: {aspect_ratio}")
+    if resolution not in caps.resolutions:
+        raise ValueError(f"Unsupported resolution: {resolution}")
+    if duration_sec not in caps.duration_sec:
+        raise ValueError("duration_sec must be 5, 10, or 15.")

apps/dreamverse/dreamverse/generation_contracts.py

@@ -36,6 +36,10 @@ def generate_step(
         segment_idx: int,
         image_path: str | None,
         reset_conditioning: bool,
+        *,
+        frame_width: int | None = None,
+        frame_height: int | None = None,
+        num_frames: int | None = None,
     ) -> StepResult:
         ...
 

apps/dreamverse/dreamverse/generation_worker.py

@@ -80,13 +80,20 @@ def generate_step(
         segment_idx: int,
         image_path: str | None,
         reset_conditioning: bool,
+        *,
+        frame_width: int | None = None,
+        frame_height: int | None = None,
+        num_frames: int | None = None,
     ) -> StepResult:
         """Generate one segment through the selected model backend."""
         return self._require_backend().generate_step(
             prompt,
             segment_idx,
             image_path,
             reset_conditioning,
+            frame_width=frame_width,
+            frame_height=frame_height,
+            num_frames=num_frames,
         )
 
     def warmup(self, prompt: str) -> dict[str, float]:

apps/dreamverse/dreamverse/gpu_pool.py

@@ -189,6 +189,9 @@ def handle_command(cmd: Command):
                         segment_idx,
                         image_path=payload.image_path,
                         reset_conditioning=payload.reset_conditioning,
+                        frame_width=payload.frame_width,
+                        frame_height=payload.frame_height,
+                        num_frames=payload.num_frames,
                     )
                     head_trim_frames = step_result.head_trim_frames
                     head_trim_audio_frames = step_result.head_trim_audio_frames
@@ -753,6 +756,10 @@ async def user_step(
         segment_idx: int = 1,
         image_path: str | None = None,
         reset_conditioning: bool = False,
+        *,
+        frame_width: int | None = None,
+        frame_height: int | None = None,
+        num_frames: int | None = None,
     ) -> dict[str, float]:
         """Execute a generation step for a specific user.
 
@@ -766,6 +773,9 @@ async def user_step(
             segment_idx=segment_idx,
             image_path=image_path,
             reset_conditioning=bool(reset_conditioning),
+            frame_width=frame_width,
+            frame_height=frame_height,
+            num_frames=num_frames,
         )
         response = await self._send_command_tagged(Command(CommandType.USER_STEP, payload=payload, user_id=user_id),
                                                    timeout=1800.0)

apps/dreamverse/dreamverse/ltx2_generation.py

@@ -454,6 +454,10 @@ def generate_step(
         segment_idx: int,
         image_path: str | None,
         reset_conditioning: bool,
+        *,
+        frame_width: int | None = None,
+        frame_height: int | None = None,
+        num_frames: int | None = None,
     ) -> StepResult:
         """Execute one generation step; snapshot state for the next segment."""
         timings: dict = {}
@@ -464,9 +468,9 @@ def generate_step(
             prompt=prompt,
             negative_prompt="",
             save_video=False,
-            height=FRAME_HEIGHT,
-            width=FRAME_WIDTH,
-            num_frames=NUM_FRAMES,
+            height=frame_height or FRAME_HEIGHT,
+            width=frame_width or FRAME_WIDTH,
+            num_frames=num_frames or NUM_FRAMES,
             fps=24,
             num_inference_steps=NUM_INFERENCE_STEPS,
             guidance_scale=1.0,

apps/dreamverse/dreamverse/main.py

@@ -33,6 +33,7 @@
     prompt_config_router,
     curated_presets_router,
 )
+from dreamverse.routes.creation import creation_router
 from dreamverse.session.controller import SessionController
 
 
@@ -92,6 +93,7 @@ async def lifespan(app: FastAPI):
 app.include_router(build_health_router(lambda: runtime.gpu_pool))
 app.include_router(internal_monitor_router)
 app.include_router(prompt_config_router)
+app.include_router(creation_router)
 if DEVTOOLS_ENABLED:
     app.include_router(curated_presets_router)
 

apps/dreamverse/dreamverse/minimax_h3_generation.py

@@ -200,13 +200,18 @@ def generate_step(
         segment_idx: int,
         image_path: str | None,
         reset_conditioning: bool,
+        *,
+        frame_width: int | None = None,
+        frame_height: int | None = None,
+        num_frames: int | None = None,
     ) -> StepResult:
         """Generate one synchronized FastH3 segment and retain its last frame.
 
         Later segments use MiniMax H3's first-frame-to-video path. The first
         conditioned frame and its matching audio duration are trimmed before
         streaming so adjacent segments do not duplicate media.
         """
+        del frame_width, frame_height, num_frames
         if self.generator is None:
             raise RuntimeError("FastH3 generator is not initialized.")
         conditioning_image, uses_continuation = self._select_conditioning_image(