Fix: Pre-create GPU wrappers at module load time for startup detection

- Create GPU-decorated functions at module load time (not dynamically)
- This ensures spaces.GPU decorators are detected during startup
- Pre-create wrappers for all durations from 60-1800 seconds (every 60s)
- Fix closure variable capture issue
- Slider value now properly controls GPU duration allocation

app.py

@@ -387,16 +387,38 @@ def _generate_router_plan_streaming_internal(
         yield "", {}, error_msg, ""
 
 
-def _create_gpu_wrapper(duration: int):
-    """Create a GPU-decorated wrapper function with specific duration."""
+# Pre-create GPU wrappers for common durations at module load time
+# This ensures spaces.GPU decorators are detected during startup
+_GPU_WRAPPERS: Dict[int, Any] = {}
+
+# Create wrappers for durations: 60, 120, 180, 240, 300, 360, 420, 480, 540, 600, 
+# 720, 840, 960, 1080, 1200, 1320, 1440, 1560, 1680, 1800 (every 60s from 60 to 1800)
+def _make_gpu_wrapper(duration: int):
+    """Factory function to create GPU-decorated wrapper with closure over duration."""
     @spaces.GPU(duration=duration)
-    def wrapper(*args, **kwargs):
-        yield from _generate_router_plan_streaming_internal(*args, **kwargs)
+    def wrapper(
+        user_task: str,
+        context: str,
+        acceptance: str,
+        extra_guidance: str,
+        difficulty: str,
+        tags: str,
+        model_choice: str,
+        max_new_tokens: int,
+        temperature: float,
+        top_p: float,
+        gpu_duration: int,
+    ):
+        yield from _generate_router_plan_streaming_internal(
+            user_task, context, acceptance, extra_guidance,
+            difficulty, tags, model_choice, max_new_tokens,
+            temperature, top_p, duration
+        )
     return wrapper
 
-
-# Cache for GPU wrappers to avoid recreating them
-_gpu_wrapper_cache: Dict[int, Any] = {}
+# Pre-create all wrappers at module load time
+for duration in range(60, 1801, 60):
+    _GPU_WRAPPERS[duration] = _make_gpu_wrapper(duration)
 
 
 def generate_router_plan_streaming(
@@ -415,17 +437,14 @@ def generate_router_plan_streaming(
     """
     Generate router plan with streaming output.
     
-    Uses user-specified gpu_duration to create a dynamically decorated function.
+    Uses user-specified gpu_duration to select the appropriate GPU wrapper.
     """
-    # Round to nearest 60 seconds for caching efficiency
+    # Round to nearest 60 seconds and clamp between 60 and 1800
     rounded_duration = ((gpu_duration + 30) // 60) * 60
-    rounded_duration = max(60, min(1800, rounded_duration))  # Clamp between 60 and 1800
-    
-    # Get or create wrapper with this duration
-    if rounded_duration not in _gpu_wrapper_cache:
-        _gpu_wrapper_cache[rounded_duration] = _create_gpu_wrapper(rounded_duration)
+    rounded_duration = max(60, min(1800, rounded_duration))
     
-    wrapper = _gpu_wrapper_cache[rounded_duration]
+    # Get the pre-created wrapper with this duration
+    wrapper = _GPU_WRAPPERS[rounded_duration]
     yield from wrapper(
         user_task, context, acceptance, extra_guidance,
         difficulty, tags, model_choice, max_new_tokens,