Fix indentation errors in _generate_router_plan_streaming_internal

app.py

@@ -292,93 +292,93 @@ def _generate_router_plan_streaming_internal(
         return
 
     try:
-            prompt = build_router_prompt(
-                user_task=user_task,
-                context=context,
-                acceptance=acceptance,
-                extra_guidance=extra_guidance,
-                difficulty=difficulty,
-                tags=tags,
-            )
+        prompt = build_router_prompt(
+            user_task=user_task,
+            context=context,
+            acceptance=acceptance,
+            extra_guidance=extra_guidance,
+            difficulty=difficulty,
+            tags=tags,
+        )
+
+        generator = load_pipeline(model_choice)
+        
+        # Get the underlying model and tokenizer
+        model = generator.model
+        tokenizer = generator.tokenizer
+        
+        # Set up streaming
+        streamer = TextIteratorStreamer(tokenizer, skip_prompt=True, skip_special_tokens=True)
+        
+        # Prepare inputs
+        inputs = tokenizer(prompt, return_tensors="pt")
+        if hasattr(model, 'device'):
+            inputs = {k: v.to(model.device) for k, v in inputs.items()}
+        elif torch.cuda.is_available():
+            inputs = {k: v.cuda() for k, v in inputs.items()}
+        
+        # Start generation in a separate thread
+        generation_kwargs = {
+            **inputs,
+            "max_new_tokens": max_new_tokens,
+            "temperature": temperature,
+            "top_p": top_p,
+            "do_sample": True,
+            "streamer": streamer,
+            "eos_token_id": tokenizer.eos_token_id,
+            "pad_token_id": tokenizer.pad_token_id or tokenizer.eos_token_id,
+        }
+
+        def _generate():
+            with torch.inference_mode():
+                model.generate(**generation_kwargs)
+
+        thread = Thread(target=_generate)
+        thread.start()
+        
+        # Stream tokens
+        completion = ""
+        parsed_plan: Dict[str, Any] | None = None
+        validation_msg = "🔄 Generating..."
+
+        for new_text in streamer:
+            completion += new_text
+            chunk = completion
+            finished = False
+            display_plan = parsed_plan or {}
 
-            generator = load_pipeline(model_choice)
-            
-            # Get the underlying model and tokenizer
-            model = generator.model
-            tokenizer = generator.tokenizer
-            
-            # Set up streaming
-            streamer = TextIteratorStreamer(tokenizer, skip_prompt=True, skip_special_tokens=True)
-            
-            # Prepare inputs
-            inputs = tokenizer(prompt, return_tensors="pt")
-            if hasattr(model, 'device'):
-                inputs = {k: v.to(model.device) for k, v in inputs.items()}
-            elif torch.cuda.is_available():
-                inputs = {k: v.cuda() for k, v in inputs.items()}
-            
-            # Start generation in a separate thread
-            generation_kwargs = {
-                **inputs,
-                "max_new_tokens": max_new_tokens,
-                "temperature": temperature,
-                "top_p": top_p,
-                "do_sample": True,
-                "streamer": streamer,
-                "eos_token_id": tokenizer.eos_token_id,
-                "pad_token_id": tokenizer.pad_token_id or tokenizer.eos_token_id,
-            }
-
-            def _generate():
-                with torch.inference_mode():
-                    model.generate(**generation_kwargs)
-
-            thread = Thread(target=_generate)
-            thread.start()
-            
-            # Stream tokens
-            completion = ""
-            parsed_plan: Dict[str, Any] | None = None
-            validation_msg = "🔄 Generating..."
-
-            for new_text in streamer:
-                completion += new_text
-                chunk = completion
-                finished = False
-                display_plan = parsed_plan or {}
-
-                chunk, finished = trim_at_stop_sequences(chunk)
-
-                try:
-                    json_block = extract_json_from_text(chunk)
-                    candidate_plan = json.loads(json_block)
-                    ok, issues = validate_router_plan(candidate_plan)
-                    validation_msg = format_validation_message(ok, issues)
-                    parsed_plan = candidate_plan if ok else parsed_plan
-                    display_plan = candidate_plan
-                except Exception:
-                    # Ignore until JSON is complete
-                    pass
-
-                yield chunk, display_plan, validation_msg, prompt
-
-                if finished:
-                    completion = chunk
-                    break
-
-            # Final processing after streaming completes
-            thread.join()
-
-            completion = trim_at_stop_sequences(completion.strip())[0]
-            if parsed_plan is None:
-                try:
-                    json_block = extract_json_from_text(completion)
-                    parsed_plan = json.loads(json_block)
-                    ok, issues = validate_router_plan(parsed_plan)
-                    validation_msg = format_validation_message(ok, issues)
-                except Exception as exc:
-                    parsed_plan = {}
-                    validation_msg = f"❌ JSON parsing failed: {exc}"
+            chunk, finished = trim_at_stop_sequences(chunk)
+
+            try:
+                json_block = extract_json_from_text(chunk)
+                candidate_plan = json.loads(json_block)
+                ok, issues = validate_router_plan(candidate_plan)
+                validation_msg = format_validation_message(ok, issues)
+                parsed_plan = candidate_plan if ok else parsed_plan
+                display_plan = candidate_plan
+            except Exception:
+                # Ignore until JSON is complete
+                pass
+
+            yield chunk, display_plan, validation_msg, prompt
+
+            if finished:
+                completion = chunk
+                break
+
+        # Final processing after streaming completes
+        thread.join()
+
+        completion = trim_at_stop_sequences(completion.strip())[0]
+        if parsed_plan is None:
+            try:
+                json_block = extract_json_from_text(completion)
+                parsed_plan = json.loads(json_block)
+                ok, issues = validate_router_plan(parsed_plan)
+                validation_msg = format_validation_message(ok, issues)
+            except Exception as exc:
+                parsed_plan = {}
+                validation_msg = f"❌ JSON parsing failed: {exc}"
 
         yield completion, parsed_plan, validation_msg, prompt