Enforce confidence threshold during generation

Co-authored-by: OpenAI Codex <codex@openai.com>

AGENTS.md

@@ -278,6 +278,12 @@ technical cutaway animation.
   returned real Modal analysis for `Target Reticle` at `0.7` confidence with 3
   parts, and `/generate_scene` returned `renderer: three`, `render_mode: three`,
   and no HTML field.
+- Implemented the `FEATURE.md` confidence-threshold re-spec on June 14, 2026:
+  the slider is enabled before the first upload, sends `confidence_threshold`
+  only with `/generate_scene`, no longer re-renders cached analysis on slider
+  movement, and the server clamps/coerces the threshold before selecting
+  `render_mode`. The browser now trusts the server's `render_mode` and only
+  downgrades when geometry or annotation data is missing.
 
 ## Next Work
 

app.py

@@ -17,6 +17,7 @@ from fastapi.responses import JSONResponse
 from PIL import Image, UnidentifiedImageError
 
 from snap2sim.backend import InferenceClient, Settings
+from snap2sim.schema import normalize_confidence_threshold
 
 try:
     from gradio import Server
@@ -99,13 +100,19 @@ def analyze_image_http(payload: dict[str, Any]) -> dict[str, Any]:
 
 
 @app.api(name="generate_scene")
-def generate_scene_api(analysis: dict[str, Any]) -> dict[str, Any]:
-    return _generate_scene(analysis)
+def generate_scene_api(
+    analysis: dict[str, Any],
+    confidence_threshold: float | None = None,
+) -> dict[str, Any]:
+    return _generate_scene(analysis, confidence_threshold)
 
 
 @app.post("/generate_scene")
 def generate_scene_http(payload: dict[str, Any]) -> dict[str, Any]:
-    return _generate_scene(payload.get("analysis") or {})
+    return _generate_scene(
+        payload.get("analysis") or {},
+        payload.get("confidence_threshold"),
+    )
 
 
 def _analyze_image(image_base64: str) -> dict[str, Any]:
@@ -113,8 +120,11 @@ def _analyze_image(image_base64: str) -> dict[str, Any]:
     return InferenceClient(Settings()).analyze_image(image)
 
 
-def _generate_scene(analysis: dict[str, Any]) -> dict[str, Any]:
-    return InferenceClient(Settings()).generate_scene(analysis)
+def _generate_scene(analysis: dict[str, Any], threshold: Any = None) -> dict[str, Any]:
+    return InferenceClient(Settings()).generate_scene(
+        analysis,
+        normalize_confidence_threshold(threshold),
+    )
 
 
 def _decode_image(image_base64: str) -> Image.Image:

index.html

@@ -592,7 +592,7 @@
         <button id="resetViewButton" class="tool-button" type="button" disabled>Reset view</button>
         <label class="threshold-control" for="confidenceThreshold">
           <span>Min confidence</span>
-          <input id="confidenceThreshold" class="threshold-slider" type="range" min="0" max="1" step="0.05" value="0.5" aria-describedby="thresholdValue" disabled>
+          <input id="confidenceThreshold" class="threshold-slider" type="range" min="0" max="1" step="0.05" value="0.5" aria-describedby="thresholdValue">
           <span id="thresholdValue" class="threshold-value" aria-live="polite">50%</span>
         </label>
       </div>
@@ -672,7 +672,6 @@
     let paused = false;
     let requestBusy = false;
     let coldStartTimer = 0;
-    let thresholdRenderTimer = 0;
     let fallbackRuntime = null;
     let currentPreviewUrl = "";
     let confidenceThreshold = DEFAULT_CONFIDENCE_THRESHOLD;
@@ -721,7 +720,6 @@
     });
     confidenceThresholdInput.addEventListener("input", () => {
       updateConfidenceThreshold();
-      scheduleThresholdRender();
     });
 
     async function runPipeline(file) {
@@ -746,7 +744,10 @@
         populateAnalysis(analysis);
 
         setStatus("RENDERING CUTAWAY...");
-        const scenePayload = await postJson("/generate_scene", { analysis });
+        const scenePayload = await postJson("/generate_scene", {
+          analysis,
+          confidence_threshold: confidenceThreshold
+        });
         renderScenePayload(scenePayload);
       } catch (error) {
         window.clearTimeout(coldStartTimer);
@@ -766,7 +767,6 @@
       playButton.textContent = "Play";
       playButton.disabled = true;
       resetViewButton.disabled = true;
-      confidenceThresholdInput.disabled = true;
       viewportHint.hidden = true;
       retryButton.hidden = true;
       window.lastAnalysis = null;
@@ -808,7 +808,7 @@
         window.lastAnalysis = analysis;
         window.lastScenePayload = payload;
       }
-      const renderMode = chooseRenderMode(analysis);
+      const renderMode = chooseRenderMode(payload, analysis);
       if (renderMode === "three" && hasUsableGeometry(analysis)) {
         buildDeterministicScene(analysis);
       } else if (renderMode === "annotate" && hasAnnotations(analysis)) {
@@ -818,15 +818,18 @@
       }
     }
 
-    function chooseRenderMode(analysis) {
-      const confidence = typeof analysis.confidence === "number" ? analysis.confidence : 1;
-      if (hasAnnotations(analysis) && (confidence < confidenceThreshold || !hasUsableGeometry(analysis))) {
-        return "annotate";
-      }
-      if (hasUsableGeometry(analysis) && confidence >= confidenceThreshold) {
-        return "three";
+    function chooseRenderMode(payload, analysis) {
+      const serverMode = payload && typeof payload.render_mode === "string"
+        ? payload.render_mode
+        : analysis && typeof analysis.render_mode === "string"
+          ? analysis.render_mode
+          : "unavailable";
+      if (serverMode === "three") {
+        if (hasUsableGeometry(analysis)) return "three";
+        if (hasAnnotations(analysis)) return "annotate";
+        return "unavailable";
       }
-      if (hasAnnotations(analysis)) {
+      if (serverMode === "annotate" && hasAnnotations(analysis)) {
         return "annotate";
       }
       return "unavailable";
@@ -1260,7 +1263,7 @@
       requestBusy = active;
       progress.classList.toggle("active", active);
       uploadButton.disabled = active;
-      confidenceThresholdInput.disabled = active || !window.lastScenePayload;
+      confidenceThresholdInput.disabled = active;
     }
 
     function setStatus(message, error) {
@@ -1276,15 +1279,6 @@
       thresholdValue.textContent = Math.round(confidenceThreshold * 100) + "%";
     }
 
-    function scheduleThresholdRender() {
-      window.clearTimeout(thresholdRenderTimer);
-      thresholdRenderTimer = window.setTimeout(() => {
-        if (!requestBusy && window.lastScenePayload) {
-          renderScenePayload(window.lastScenePayload);
-        }
-      }, 90);
-    }
-
     function revealScan() {
       scanLine.classList.remove("active");
       void scanLine.offsetWidth;

snap2sim/backend.py

@@ -44,9 +44,9 @@ class InferenceClient:
 
         return validate_analysis(dict(EXAMPLE_ANALYSIS))
 
-    def generate_scene(self, analysis: dict[str, Any]) -> dict[str, Any]:
+    def generate_scene(self, analysis: dict[str, Any], threshold: Any = None) -> dict[str, Any]:
         valid_analysis = validate_analysis(analysis)
-        render_mode = select_render_mode(valid_analysis)
+        render_mode = select_render_mode(valid_analysis, threshold)
         renderer = "three" if render_mode == "three" else "photo"
         return {"renderer": renderer, "render_mode": render_mode, "analysis": valid_analysis}
 

snap2sim/schema.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import math
 from typing import Any, Literal
 
 MotionType = Literal["rotate", "translate", "oscillate", "static"]
@@ -216,24 +217,47 @@ _RENDER_MODES = {"three", "annotate", "unavailable"}
 DEFAULT_CONFIDENCE_THRESHOLD = 0.5
 
 
-def select_render_mode(analysis: dict[str, Any]) -> str:
+def normalize_confidence_threshold(threshold: Any = DEFAULT_CONFIDENCE_THRESHOLD) -> float:
+    if isinstance(threshold, bool) or threshold is None:
+        return DEFAULT_CONFIDENCE_THRESHOLD
+    try:
+        value = float(threshold)
+    except (TypeError, ValueError):
+        return DEFAULT_CONFIDENCE_THRESHOLD
+    if not math.isfinite(value):
+        return DEFAULT_CONFIDENCE_THRESHOLD
+    return max(0.0, min(1.0, value))
+
+
+def select_render_mode(
+    analysis: dict[str, Any],
+    threshold: Any = DEFAULT_CONFIDENCE_THRESHOLD,
+) -> str:
     """Pick the safest advisory renderer for a validated analysis payload."""
+    threshold = normalize_confidence_threshold(threshold)
     explicit_mode = analysis.get("render_mode")
-    if explicit_mode in _RENDER_MODES:
-        return str(explicit_mode)
 
     parts = analysis.get("parts") if isinstance(analysis, dict) else []
     has_geometry = any(isinstance(part, dict) and isinstance(part.get("geometry"), dict) for part in parts)
     has_annotation = any(isinstance(part, dict) and isinstance(part.get("annotation"), dict) for part in parts)
     confidence = analysis.get("confidence", 1)
-    low_confidence = _is_number(confidence) and float(confidence) < DEFAULT_CONFIDENCE_THRESHOLD
+    low_confidence = _is_number(confidence) and float(confidence) < threshold
     if has_annotation and (low_confidence or not has_geometry):
-        return "annotate"
-    if has_geometry and not low_confidence:
-        return "three"
-    if has_annotation:
-        return "annotate"
-    return "unavailable"
+        mode = "annotate"
+    elif has_geometry and not low_confidence:
+        mode = "three"
+    elif has_annotation:
+        mode = "annotate"
+    else:
+        mode = "unavailable"
+    if explicit_mode in _RENDER_MODES:
+        return _lower_render_mode(str(explicit_mode), mode)
+    return mode
+
+
+def _lower_render_mode(left: str, right: str) -> str:
+    rank = {"unavailable": 0, "annotate": 1, "three": 2}
+    return left if rank[left] <= rank[right] else right
 
 
 def validate_analysis(payload: dict[str, Any]) -> dict[str, Any]: