P15B: repair active-adapter API and match Ref2VA geometry at 1024px

Technical retry repair only: same model, adapter, prompt, reference order, seed, steps, duration and generate_p15b route. Fix callable active_adapters and remove 2048px split-half mismatch.

app.py

@@ -25,10 +25,10 @@ import gradio as gr
 
 MODEL_REPO = "MiniMaxAI/MiniMax-H3"
 MODEL_REVISION = "939557dc319dd91227e30195a763f272ba7f8765"
-CONDITIONER_SPACE = "multimodalart/qwen3vl-conditioner"
-# The packet's original conditioner SHA (20d92357...) is no longer the live Space HEAD. The current HEAD was
-# re-audited on 2026-08-12: /encode_ref2va is still present with the v02 media/kinds/canvas/num_frames contract.
-CONDITIONER_REVISION = "be67d10cd315e08efc4554d85c24751c62e566d5"
+CONDITIONER_SPACE = "ifroyou/minimax-h3-conditioner-p15b-1024"
+# Source-faithful fork of multimodalart/qwen3vl-conditioner at be67d10c, pinned to the same MiniMax-H3 revision and
+# /encode_ref2va schema. The only inference change is the packet-locked 1024px Ref2VA image short edge.
+CONDITIONER_REVISION = "21e66c83442369d6ae3a7a50b020da039656db54"
 CONDITIONER_ENDPOINT = "/encode_ref2va"
 P15B_ADAPTER_REPO = "Inner-Reflections/MiniMax-H3-Looping-Sketch-Anime"
 P15B_ADAPTER_FILE = "minimax_h3_looping_sketch_anime_v1.safetensors"
@@ -49,10 +49,11 @@ GPU_SIZE = os.environ.get("H3_GPU_SIZE", "xlarge")
 # Bounds on what `get_duration` may reserve. The pool reserves whatever number it is given, so a flat ceiling for every
 # request is what makes an account hit "too many ZeroGPU credits allocated to running tasks".
 MIN_GPU_DURATION = int(os.environ.get("H3_GPU_DURATION_MIN", "120"))
-# P15B uses xlarge (2x quota). With the 1024px reference cap, MM01 prices around 658 provider seconds and MM02
-# around 756 seconds under the published bound. A 900-second backend ceiling keeps one request's xlarge reservation
-# below a fresh 2,400-second user window while the client performs the stricter input-specific guard.
+# `MAX_GPU_DURATION` remains the route-wide safety ceiling. P15B has a tighter, packet-specific ceiling because its
+# 1024px references and frozen 4–5 second takes were analytically bounded below 950 seconds. Keeping this lower
+# ceiling in the GPU decorator is what makes the client-side quota receipt enforceable rather than aspirational.
 MAX_GPU_DURATION = 1100
+P15B_MAX_GPU_DURATION = int(os.environ.get("P15B_MAX_GPU_DURATION", "944"))
 
 # Must stay identical to the conditioner's table: the *label* goes over the wire, so a canvas that half does not know
 # is rejected there and surfaces as a failure here.
@@ -231,7 +232,7 @@ def get_duration(
     encode = 5 + reference_rows(references, num_frames) * 1e-3
     decode = DECODE_BASE + DECODE_PER_DEFAULT_CANVAS * (height * width * num_frames) / DEFAULT_CANVAS_PIXELS
     total = PLACEMENT_ALLOWANCE + encode + denoise + decode + 10 + LORA_ALLOWANCE * len(loras or ())
-    duration = max(MIN_GPU_DURATION, min(MAX_GPU_DURATION, int(total)))
+    duration = max(MIN_GPU_DURATION, min(MAX_GPU_DURATION, P15B_MAX_GPU_DURATION, int(total)))
     print(f"[ref2va] S={sequence} -> reserving {duration}s ({denoise:.0f}s of denoise at {steps} steps)", flush=True)
     return duration
 
@@ -642,7 +643,10 @@ def apply_loras(transformer, loras) -> list[str]:
 
     transformer.set_adapters(names, scales)
     if P15B_ADAPTER_NAME in names:
-        active = list(getattr(transformer, "active_adapters", []) or [])
+        # Diffusers/PEFT exposes this as a property in some releases and a bound method in others. Calling only the
+        # latter avoids the deterministic TypeError that occurred after the real adapter had already been loaded.
+        active_value = getattr(transformer, "active_adapters", [])
+        active = list(active_value() if callable(active_value) else (active_value or []))
         if P15B_ADAPTER_NAME not in active:
             raise RuntimeError(
                 f"P15B_ADAPTER_NOT_ACTIVE: expected={P15B_ADAPTER_NAME} active={active} target=transformer_ref"
@@ -835,7 +839,7 @@ def _prepare_reference_files(references: list[tuple[str, str]]) -> list[tuple[st
 
 
 def build_references(references: list[tuple[str, str]]):
-    """Decode references in order after applying the real image-resolution cap."""
+    """Decode the already-normalized references in the exact packed order."""
     from diffusers.modular_pipelines.minimax_h3 import (
         MiniMaxH3AudioReference,
         MiniMaxH3ImageReference,
@@ -843,7 +847,7 @@ def build_references(references: list[tuple[str, str]]):
     )
 
     classes = {"image": MiniMaxH3ImageReference, "video": MiniMaxH3VideoReference, "audio": MiniMaxH3AudioReference}
-    return [classes[kind].from_file(path) for kind, path in _prepare_reference_files(references)]
+    return [classes[kind].from_file(path) for kind, path in references]
 
 
 def audio_bearing(references: list[tuple[str, str]]) -> list[tuple[str, float]]:
@@ -978,8 +982,11 @@ def generate(
 
     from diffusers.utils import encode_video
 
-    images = [image_1, image_2, image_3, image_4, image_5, image_6, image_7, image_8, image_9]
-    references = collect(images, audio_path, video_path)
+    images = [image_1, image_2, image_3, image_4, image_5, image_6, image_7, image_8, image_9]
+    # The same normalized files must go to both split halves. Previously the generator capped its copy but the
+    # conditioner received full-size endpoints and silently rebuilt 2048px vision blocks, so the actual sequence
+    # exceeded the P15B reservation before denoising began.
+    references = _prepare_reference_files(collect(images, audio_path, video_path))
     check(prompt, references)
 
     # `0` is "leave it to the references" over the wire, which MiniMax-H3 accepts when exactly one of them carries a
@@ -1226,13 +1233,21 @@ def _p15b_reservation(scene: str, image_paths: list[str], video_path: str) -> di
     denoise = int(math.ceil(P15B_STEPS * (STEP_LINEAR * sequence + STEP_QUADRATIC * sequence**2) * SAFETY))
     encode = 5 + ref_rows * 1e-3
     decode = DECODE_BASE + DECODE_PER_DEFAULT_CANVAS * (height * width * num_frames) / DEFAULT_CANVAS_PIXELS
-    provider = max(MIN_GPU_DURATION, min(MAX_GPU_DURATION, int(math.ceil(PLACEMENT_ALLOWANCE + encode + denoise + decode + 10 + LORA_ALLOWANCE))))
+    provider = max(
+        MIN_GPU_DURATION,
+        min(
+            MAX_GPU_DURATION,
+            P15B_MAX_GPU_DURATION,
+            int(math.ceil(PLACEMENT_ALLOWANCE + encode + denoise + decode + 10 + LORA_ALLOWANCE)),
+        ),
+    )
     return {
         "scene": scene,
         "provider_reservation_seconds": provider,
         "xlarge_quota_multiplier": 2,
-        "conditioner_allowance_seconds": 120,
-        "total_quota_reservation_seconds": provider * 2 + 120,
+        # The dedicated conditioner endpoint is hard-decorated at 45 xlarge seconds, hence at most 90 quota seconds.
+        "conditioner_allowance_seconds": 90,
+        "total_quota_reservation_seconds": provider * 2 + 90,
         "text_token_bound": P15B_TEXT_TOKEN_BOUND,
         "sequence_rows_bound": sequence,
         "reference_rows": ref_rows,

h3_split_blocks.py

@@ -31,6 +31,29 @@ from diffusers.modular_pipelines.modular_pipeline import SequentialPipelineBlock
 from diffusers.modular_pipelines.modular_pipeline_utils import OutputParam
 
 
+P15B_REFERENCE_IMAGE_SHORT_EDGE = 1024
+
+
+class P15BRef2VASetupStep(MiniMaxH3Ref2VASetupStep):
+    """P15B's Ref2VA setup uses the packet-locked 1024px image short edge, never the upstream 2048px default."""
+
+    def __init__(
+        self,
+        max_images: int = 9,
+        max_videos: int = 3,
+        max_audios: int = 3,
+        max_references: int = 12,
+        reference_image_short_edge: int = P15B_REFERENCE_IMAGE_SHORT_EDGE,
+    ):
+        super().__init__(
+            max_images=max_images,
+            max_videos=max_videos,
+            max_audios=max_audios,
+            max_references=max_references,
+            reference_image_short_edge=reference_image_short_edge,
+        )
+
+
 def _wire_outputs(num_frames: bool = True) -> list[OutputParam]:
     """The wire format of the split. `num_frames` is declared by the `ref2va` half alone, whose setup resolves one."""
     return [
@@ -101,7 +124,7 @@ class MiniMaxH3Ref2VAConditionerBlocks(SequentialPipelineBlocks):
     """
 
     model_name = "minimax-h3"
-    block_classes = [MiniMaxH3Ref2VASetupStep, MiniMaxH3Ref2VATextEncoderStep]
+    block_classes = [P15BRef2VASetupStep, MiniMaxH3Ref2VATextEncoderStep]
     block_names = ["setup", "text_encoder"]
 
     @property
@@ -126,7 +149,7 @@ class MiniMaxH3Ref2VAGeneratorBlocks(SequentialPipelineBlocks):
 
     model_name = "minimax-h3"
     block_classes = [
-        MiniMaxH3Ref2VASetupStep,
+        P15BRef2VASetupStep,
         MiniMaxH3Ref2VAReferenceEncoderStep,
         MiniMaxH3Ref2VACoreDenoiseStep,
         MiniMaxH3AfterDenoiseStep,