Update app.py

app.py

@@ -1,6 +1,6 @@
+# InfinateCodeGenerator - Ultimate Merged Edition (v1.0.1) - patched
 """
-InfinateCodeGenerator - Ultimate Merged Edition (v1.0.0)
-Consolidated, hardened, and production-ready version.
+Consolidated, hardened, and production-ready version (patched call_model & retries).
 """
 import os
 import sys
@@ -149,12 +149,20 @@ def extract_chunk_content(chunk: Any) -> Optional[str]:
     """Extracts content from various possible streaming chunk formats."""
     try:
         if isinstance(chunk, dict) and (choices := chunk.get("choices")):
+            # typical OpenAI-like streaming chunk shape
             delta = choices[0].get("delta", {})
-            # streaming chunk structure
             return delta.get("content") or delta.get("text")
-        elif hasattr(chunk, 'delta') and hasattr(chunk.delta, 'content'):
+        # HF newer shapes may use 'generations' inside chunk
+        if isinstance(chunk, dict) and "generations" in chunk:
+            gens = chunk.get("generations") or []
+            parts = []
+            for g in gens:
+                if isinstance(g, dict) and "text" in g:
+                    parts.append(g["text"])
+            return "".join(parts) if parts else None
+        # some streaming yields objects with .delta or .content attributes
+        if hasattr(chunk, 'delta') and hasattr(chunk.delta, 'content'):
             return chunk.delta.content
-        # sometimes streaming yields strings directly
         if isinstance(chunk, str):
             return chunk
     except Exception:
@@ -162,86 +170,167 @@ def extract_chunk_content(chunk: Any) -> Optional[str]:
     return None
 
 def call_model(client: InferenceClient, system: str, user: str, is_python: bool, **settings) -> str:
-    """Calls the appropriate LLM with retry logic and fallbacks.
+    """Calls the appropriate LLM with retry logic and multiple fallbacks.
     Tries non-streaming first (more reliable), falls back to streaming.
     """
+    if client is None:
+        return "<<ERROR: No inference client provided>>"
+
     primary_model = PYTHON_MODEL if is_python else OTHER_MODEL
-    models_to_try = [primary_model] + FALLBACK_MODELS
-    
+    models_to_try = [primary_model] + [m for m in FALLBACK_MODELS if m != primary_model]
+
     logging.info(f"Calling model for {'Python' if is_python else 'Other'} project. Primary: {primary_model}")
-    logging.info(f"Settings: {settings}")
-    
+    logging.debug(f"Raw settings: {settings}")
+
     messages = [{"role": "system", "content": system}, {"role": "user", "content": user}]
-    
-    # Clean up settings - remove any invalid parameters
-    valid_settings = {
-        "temperature": settings.get("temperature", 0.5),
-        "top_p": settings.get("top_p", 0.9),
-        "max_tokens": settings.get("max_new_tokens", settings.get("max_tokens", 4096))
-    }
-    
-    logging.info(f"Using cleaned settings: {valid_settings}")
-    
+
+    # Build robust settings: include both keys some API variants accept
+    cleaned = {}
+    cleaned["temperature"] = settings.get("temperature", DEFAULT_TEMPERATURE)
+    cleaned["top_p"] = settings.get("top_p", DEFAULT_TOP_P)
+    max_new = settings.get("max_new_tokens", settings.get("max_tokens", DEFAULT_MAX_TOKENS))
+    try:
+        max_new = int(max_new)
+    except Exception:
+        max_new = DEFAULT_MAX_TOKENS
+    cleaned["max_new_tokens"] = max_new
+    # also include max_tokens for API variants
+    cleaned["max_tokens"] = max_new
+
+    logging.info(f"Using cleaned settings: temperature={cleaned['temperature']}, top_p={cleaned['top_p']}, max_new_tokens={cleaned['max_new_tokens']}")
+
     last_exception = None
+
     for model_name in models_to_try:
-        # First attempt: non-streaming call (more reliable across client versions/models)
-        try:
-            logging.info(f"Attempting non-streaming call to {model_name}")
-            resp = client.chat_completion(messages, model=model_name, stream=False, **valid_settings)
-            # resp can be dict-like or string; try multiple extraction methods
-            response_text = ""
+        attempt = 0
+        # try a couple of times per model with decreasing tokens if necessary
+        while attempt < 3:
+            attempt += 1
             try:
-                if isinstance(resp, dict):
-                    # Common HF shapes
-                    if "generated_text" in resp and isinstance(resp["generated_text"], str):
-                        response_text = resp["generated_text"]
-                    elif "text" in resp and isinstance(resp["text"], str):
-                        response_text = resp["text"]
-                    elif "choices" in resp and resp["choices"]:
-                        choice = resp["choices"][0]
-                        # choice may contain 'message' with 'content'
-                        if isinstance(choice, dict):
-                            if "message" in choice and isinstance(choice["message"], dict):
-                                response_text = choice["message"].get("content") or choice["message"].get("text", "") or ""
+                logging.info(f"Attempting non-streaming call to {model_name} (attempt {attempt})")
+                # Try named-argument style first (most robust)
+                try:
+                    resp = client.chat_completion(messages=messages, model=model_name, stream=False, **cleaned)
+                except TypeError as te:
+                    # Some client versions expect different parameter names - try a second shape
+                    logging.debug(f"TypeError calling chat_completion: {te}")
+                    try:
+                        resp = client.chat_completion(messages=messages, model=model_name, **cleaned)
+                    except Exception as e:
+                        raise
+                except Exception as e:
+                    # bubble up to outer exception handling
+                    raise
+
+                response_text = ""
+                # Parse many possible shapes
+                try:
+                    if isinstance(resp, dict):
+                        # common HF shapes
+                        if "generated_text" in resp and isinstance(resp["generated_text"], str):
+                            response_text = resp["generated_text"]
+                        elif "text" in resp and isinstance(resp["text"], str):
+                            response_text = resp["text"]
+                        elif "choices" in resp and resp["choices"]:
+                            choice = resp["choices"][0]
+                            if isinstance(choice, dict):
+                                if "message" in choice and isinstance(choice["message"], dict):
+                                    response_text = choice["message"].get("content") or choice["message"].get("text", "") or ""
+                                else:
+                                    response_text = choice.get("text") or choice.get("message") or ""
                             else:
-                                response_text = choice.get("text") or choice.get("message") or ""
-                elif isinstance(resp, str):
-                    response_text = resp
+                                response_text = str(choice)
+                        elif "generations" in resp and resp["generations"]:
+                            gens = resp["generations"]
+                            parts = []
+                            for g in gens:
+                                if isinstance(g, dict) and "text" in g:
+                                    parts.append(g.get("text", ""))
+                                elif hasattr(g, "text"):
+                                    parts.append(getattr(g, "text"))
+                            response_text = "".join(parts)
+                        else:
+                            # fallback: inspect nested keys
+                            if "data" in resp and isinstance(resp["data"], list) and resp["data"]:
+                                # e.g., {'data':[{'text': '...'}]}
+                                first = resp["data"][0]
+                                if isinstance(first, dict) and "text" in first:
+                                    response_text = first["text"]
+                    elif isinstance(resp, (list, tuple)):
+                        # maybe list of generation dicts
+                        parts = []
+                        for item in resp:
+                            if isinstance(item, dict) and "text" in item:
+                                parts.append(item["text"])
+                            else:
+                                parts.append(str(item))
+                        response_text = "".join(parts)
+                    elif isinstance(resp, str):
+                        response_text = resp
+                    else:
+                        # last resort: str()
+                        response_text = str(resp)
+                except Exception as e:
+                    write_error_log(e, f"Non-stream parsing failed for model {model_name}")
+                    response_text = ""
+
+                if response_text and response_text.strip():
+                    logging.info(f"✓ Successfully got response from {model_name} ({len(response_text)} chars)")
+                    return response_text
                 else:
-                    # Fallback to string representation
-                    response_text = str(resp)
+                    logging.warning(f"Non-streaming returned empty response from {model_name}, attempt {attempt}.")
+                    # fall through to streaming fallback below
             except Exception as e:
-                write_error_log(e, f"Non-stream parsing failed for model {model_name}")
+                last_exception = e
+                write_error_log(e, f"Non-stream model {model_name} failed on attempt {attempt}")
+                logging.error(f"Non-stream error for {model_name}: {str(e)[:200]}")
 
-            if response_text and response_text.strip():
-                logging.info(f"✓ Successfully got response from {model_name} ({len(response_text)} chars)")
-                return response_text
-            else:
-                logging.warning(f"Non-streaming returned empty response from {model_name}")
-        except Exception as e:
-            # Save and try streaming fallback below
-            last_exception = e
-            write_error_log(e, f"Non-stream model {model_name} failed, attempting stream fallback")
-            logging.error(f"Non-stream error for {model_name}: {str(e)[:200]}")
-            # fall through to streaming attempt
+            # Streaming fallback
+            try:
+                logging.info(f"Attempting streaming call to {model_name} (attempt {attempt})")
+                # streaming - some versions yield objects, some strings
+                try:
+                    stream_iter = client.chat_completion(messages=messages, model=model_name, stream=True, **cleaned)
+                except TypeError:
+                    # Try alternate call-signature
+                    stream_iter = client.chat_completion(messages=messages, model=model_name, stream=True)
+                except Exception as e:
+                    raise
+
+                collected = []
+                try:
+                    for chunk in stream_iter:
+                        piece = extract_chunk_content(chunk)
+                        if piece:
+                            collected.append(piece)
+                    response = "".join(collected).strip()
+                except Exception as e:
+                    # some streaming iterables need to be exhausted differently; safely cast to string
+                    write_error_log(e, "Streaming parsing failed")
+                    response = ""
+                if response:
+                    logging.info(f"✓ Successfully got streaming response from {model_name} ({len(response)} chars)")
+                    return response
+                else:
+                    logging.warning(f"Streaming returned empty response from {model_name} (attempt {attempt})")
+            except Exception as e:
+                last_exception = e
+                write_error_log(e, f"Streaming model {model_name} failed on attempt {attempt}")
+                logging.error(f"Streaming error for {model_name}: {str(e)[:200]}")
+                # reduce tokens and retry
+                time.sleep(1 + attempt * 0.5)
+                # reduce token budget to try avoid model refusing or failing
+                cleaned["max_new_tokens"] = max(256, int(cleaned["max_new_tokens"] * 0.5))
+                cleaned["max_tokens"] = cleaned["max_new_tokens"]
+                logging.info(f"Reduced max_new_tokens to {cleaned['max_new_tokens']} and retrying")
+                continue
+
+            # if reached here (no response), reduce tokens and retry
+            cleaned["max_new_tokens"] = max(256, int(cleaned["max_new_tokens"] * 0.6))
+            cleaned["max_tokens"] = cleaned["max_new_tokens"]
+            logging.info(f"No response; reduced max_new_tokens to {cleaned['max_new_tokens']} and will retry (attempt {attempt})")
+            time.sleep(0.8 + attempt * 0.3)
 
-        # Streaming fallback (older code path)
-        try:
-            logging.info(f"Attempting streaming call to {model_name}")
-            stream = client.chat_completion(messages, model=model_name, stream=True, **valid_settings)
-            response = "".join(piece for chunk in stream if (piece := extract_chunk_content(chunk)))
-            if response.strip():
-                logging.info(f"✓ Successfully got streaming response from {model_name} ({len(response)} chars)")
-                return response
-            else:
-                logging.warning(f"Streaming returned empty response from {model_name}")
-        except Exception as e:
-            last_exception = e
-            write_error_log(e, f"Streaming model {model_name} failed")
-            logging.error(f"Streaming error for {model_name}: {str(e)[:200]}")
-            time.sleep(1)  # basic backoff and continue to next model
-            continue
-            
     logging.error(f"❌ ALL MODELS FAILED. Last error: {last_exception}")
     return f"<<ERROR: All models failed. Last error: {sanitize_log_message(str(last_exception))}>>"
 
@@ -254,8 +343,11 @@ def validate_files_dict(files: Dict[str, str]) -> bool:
 
 def parse_meta(text: str) -> Optional[Dict[str, Any]]:
     """Parses model output to extract code files, trying structured JSON first, then falling back to heuristics."""
+    if not text or not isinstance(text, str):
+        return None
+
     # Strict JSON/META block parsing
-    for pattern in [r"```json\s*(.*?)```", r"```meta\s*(.*?)```", r"```META\s*(.*?)```"]:
+    for pattern in [r"```json\s*(.*?)```", r"```meta\s*(.*?)```", r"```META\s*(.*?)```", r"<META>(.*?)</META>"]:
         match = re.search(pattern, text, re.DOTALL | re.IGNORECASE)
         if match:
             try:
@@ -267,24 +359,40 @@ def parse_meta(text: str) -> Optional[Dict[str, Any]]:
             except (json.JSONDecodeError, TypeError) as e:
                 logging.warning(f"JSON parse failed: {e}")
                 continue
-    
+
+    # Also try to detect a top-level JSON blob
+    try:
+        parsed_full = json.loads(text.strip())
+        if isinstance(parsed_full, dict) and "files" in parsed_full and validate_files_dict(parsed_full["files"]):
+            logging.info("Parsed raw JSON response as META")
+            return parsed_full
+    except Exception:
+        pass
+
     # Fallback to heuristic parsing of code blocks
     files = {}
-    
+
     # Try to find filename markers before code blocks
-    # Patterns like: # File: main.py or ## main.py or **main.py**
     filename_patterns = [
         r'#\s*[Ff]ile:\s*([\w/._-]+\.[\w]+)',
         r'##\s*([\w/._-]+\.[\w]+)',
-        r'\*\*\s*([\w/._-]+\.[\w]+)\s*\*\*'
+        r'\*\*\s*([\w/._-]+\.[\w]+)\s*\*\*',
+        r'^\s*([\w\-/_.]+?\.(?:py|txt|md|json|yaml|yml))\s*:\s*$',  # e.g., "main.py:" on its own line
     ]
-    
+
     all_filenames = []
     for pattern in filename_patterns:
-        all_filenames.extend(re.findall(pattern, text))
-    
-    code_blocks = re.findall(r"```(?:\w+)?\s*([\s\S]*?)```", text, re.DOTALL)
-    
+        all_filenames.extend(re.findall(pattern, text, flags=re.MULTILINE))
+
+    # Grab all fenced code blocks
+    code_blocks = re.findall(r"```(?:[\w+-]+)?\s*([\s\S]*?)```", text, re.DOTALL)
+
+    # Also capture indented/code-block-like sections (fallback)
+    if not code_blocks:
+        # naive: split by two or more newlines and keep blocks that look like code
+        chunks = [c for c in re.split(r"\n{2,}", text) if len(c.splitlines()) > 1]
+        code_blocks = chunks[:6]  # limit
+
     if not code_blocks:
         logging.warning("No code blocks found in model response")
         return None
@@ -294,41 +402,49 @@ def parse_meta(text: str) -> Optional[Dict[str, Any]]:
         block_content = block.strip()
         if not block_content:
             continue
-            
+
         if i < len(all_filenames):
             filename = all_filenames[i]
         else:
             # Guess filename based on content
             if "def test_" in block_content or "import pytest" in block_content:
-                filename = f"test_main.py"
+                filename = f"tests/test_main.py" if not block_content.startswith("test_") else f"{block_content.splitlines()[0][:50]}.py"
             elif "requirements" in text.lower() and i == 0:
                 filename = "requirements.txt"
-            elif "# README" in block_content or "## " in block_content[:100]:
+            elif "# README" in block_content or block_content.startswith("# ") or block_content.lower().strip().startswith("readme"):
                 filename = "README.md"
             else:
                 filename = f"main.py" if i == 0 else f"file_{i}.py"
-        
+
+        # ensure relative path safe
         files[filename] = block_content
 
     if validate_files_dict(files) and files:
         logging.info(f"Heuristic parsing extracted {len(files)} files: {list(files.keys())}")
         return {"files": files, "changelog": "Extracted files via heuristic parsing."}
-    
+
+    # As a last resort, if the whole output looks like a single file, place it into main.py
+    if text.strip():
+        files = {"main.py": text.strip()}
+        if validate_files_dict(files):
+            logging.info("Parsed whole response into main.py as last resort")
+            return {"files": files, "changelog": "Fallback single-file parse."}
+
     logging.error("Failed to extract any valid files from model response")
     return None
 
 # ---------- Enhanced evaluators ----------
 def run_evaluators(workdir: Path) -> Dict[str, Any]:
     out = {}
-    
+
     rc, txt = run_cmd([sys.executable, "-m", "flake8", ".", "--count", "--max-line-length=100"], cwd=str(workdir))
     out["flake8_pass"] = rc == 0
     out["flake8_out"] = txt
-    
+
     rc, txt = run_cmd([sys.executable, "-m", "bandit", "-r", ".", "-f", "txt"], cwd=str(workdir))
     out["bandit_pass"] = rc == 0 or "No issues" in txt
     out["bandit_out"] = txt
-    
+
     test_files = list(workdir.glob("**/test_*.py")) + list(workdir.glob("**/*_test.py"))
     if test_files:
         rc, txt = run_cmd([sys.executable, "-m", "pytest", "--maxfail=1", "--tb=short"], cwd=str(workdir))
@@ -336,10 +452,10 @@ def run_evaluators(workdir: Path) -> Dict[str, Any]:
     else:
         out["pytest_pass"] = False
     out["pytest_out"] = txt if test_files else "No tests"
-    
+
     rc, txt = run_cmd([sys.executable, "-m", "black", "--check", "."], cwd=str(workdir))
     out["black_pass"] = rc == 0
-    
+
     complexity = 5.0
     rc, txt = run_cmd([sys.executable, "-m", "radon", "cc", ".", "-s", "-a"], cwd=str(workdir))
     if rc == 0:
@@ -350,16 +466,16 @@ def run_evaluators(workdir: Path) -> Dict[str, Any]:
             except:
                 pass
     out["complexity"] = complexity
-    
+
     # Calculate weighted score
     style = 100.0 if (out["flake8_pass"] and out["black_pass"]) else 50.0
     security = 100.0 if out["bandit_pass"] else 30.0
     tests = 100.0 if out["pytest_pass"] else 20.0
     maintainability = max(0.0, 100.0 - (complexity - 5.0) * 10.0) if complexity > 5 else 100.0
-    
+
     w = EVAL_WEIGHTS
     score = w["style"] * style + w["security"] * security + w["tests"] * tests + w["maintainability"] * maintainability
-    
+
     out["quality_score"] = round(max(0.0, min(100.0, score)), 1)
     out["breakdown"] = {
         "style": round(style, 1),
@@ -367,7 +483,7 @@ def run_evaluators(workdir: Path) -> Dict[str, Any]:
         "tests": round(tests, 1),
         "maintainability": round(maintainability, 1)
     }
-    
+
     return out
 
 # ---------- AI features ----------
@@ -380,7 +496,7 @@ def generate_code_review(client: Optional[InferenceClient], token: str, files: D
 Quality: Flake8={'Pass' if eval_results.get('flake8_pass') else 'Fail'}, Tests={'Pass' if eval_results.get('pytest_pass') else 'Fail'}
 
 Give 2-3 specific, actionable improvements:"""
-    review = call_model(client, "You are a senior code reviewer.", prompt, is_python, token=token, max_tokens=400)
+    review = call_model(client, "You are a senior code reviewer.", prompt, is_python, max_new_tokens=400, temperature=0.2, top_p=0.8)
     return review if review and "<<ERROR" not in review else "No review"
 
 def generate_readme(client: Optional[InferenceClient], token: str, goal: str, files: Dict[str, str], is_python: bool) -> str:
@@ -392,7 +508,7 @@ Files:
 {summary}
 
 Include: description, installation, usage."""
-    readme = call_model(client, "You are a technical writer.", prompt, is_python, token=token, max_tokens=600)
+    readme = call_model(client, "You are a technical writer.", prompt, is_python, max_new_tokens=600, temperature=0.2, top_p=0.9)
     return readme if readme and "<<ERROR" not in readme else "# Project\n\nGenerated code."
 
 def create_initial_scaffold(client: Optional[InferenceClient], token: str, goal: str, is_python: bool) -> Optional[Dict[str, Any]]:
@@ -406,12 +522,15 @@ Create Version 0.1 scaffold:
 
 Return as META JSON with files mapping."""
     try:
-        response = call_model(client, system, prompt, is_python, token=token, max_tokens=3072)
-        if "<<ERROR" in response:
-            return None
-        meta = parse_meta(response)
-        if meta and meta.get("files") and validate_files_dict(meta["files"]):
-            return meta
+        response = call_model(client, system, prompt, is_python, max_new_tokens=3072, temperature=0.4)
+        if response and "<<ERROR" not in response:
+            meta = parse_meta(response)
+            if meta and meta.get("files") and validate_files_dict(meta["files"]):
+                return meta
+            else:
+                # Save raw scaffold response for debugging
+                with open("/tmp/failed_scaffold_response.txt", "w") as f:
+                    f.write(response)
     except Exception as e:
         write_error_log(e, "Scaffold failed")
     return None
@@ -423,7 +542,7 @@ def import_project(zip_file) -> Dict[str, str]:
         files = {}
         with zipfile.ZipFile(zip_file.name, 'r') as zf:
             for filename in zf.namelist():
-                if filename.endswith(('.py', '.txt', '.md', '.json', '.yaml')):
+                if filename.endswith(('.py', '.txt', '.md', '.json', '.yaml', '.yml')):
                     try:
                         content = zf.read(filename).decode('utf-8')
                         files[filename] = content
@@ -451,9 +570,9 @@ class CodeGenController:
         self.infinite_mode = infinite_mode
         self.is_python = is_python
         self.model_name = PYTHON_MODEL if is_python else OTHER_MODEL
-        
+
         logging.info(f"Controller initialized for {'Python' if is_python else 'Other'} with model: {self.model_name}")
-        
+
         self.history: List[Dict] = []
         self.current_files: Dict[str, str] = {}
         self.current_code: str = ""
@@ -464,16 +583,16 @@ class CodeGenController:
         self.best_zip: Optional[str] = None
         self.best_review: str = ""
         self.best_readme: str = ""
-        
+
         self.stop_flag = Path(tempfile.gettempdir()) / f"stop_{uuid.uuid4().hex[:8]}"
-    
+
     def cleanup_workdir(self, workdir: Path):
         try:
             if workdir.exists():
                 shutil.rmtree(workdir)
         except Exception as e:
             write_error_log(e, f"Failed to cleanup workdir {workdir}")
-    
+
     def start_scaffolding(self) -> bool:
         scaffold = create_initial_scaffold(self.client, self.token, self.goal, self.is_python)
         if scaffold and scaffold.get("files"):
@@ -492,12 +611,12 @@ class CodeGenController:
         self.current_code = "\n\n".join(f"# {n}\n{c}" for n, c in self.current_files.items())
         self.best_files = dict(self.current_files)
         return False
-    
+
     def perform_iteration(self, iteration: int) -> Dict[str, Any]:
         parent = Path(tempfile.mkdtemp(prefix="infgen_"))
         workdir = parent / f"iter_{iteration}_{uuid.uuid4().hex[:6]}"
         workdir.mkdir(parents=True, exist_ok=True)
-        
+
         try:
             system = """You are a Level 5 Principal Software Engineer specializing in production-ready code.
 Follow Defensive Programming, TDD, and best practices.
@@ -528,15 +647,29 @@ CRITICAL RULES:
 
 Return the perfected code in META format."""
 
+            # Attempt the model call, with extra retry attempts and reduced token fallback
             response = call_model(self.client, system, prompt, self.is_python, **self.settings)
 
-            if "<<ERROR" in response:
-                logging.error(f"Model returned error: {response[:200]}")
-                return {"success": False, "warning": "Model error - keeping previous code"}
+            if not response or "<<ERROR" in response:
+                logging.error(f"Model returned error or empty: {response[:200]}")
+                # Save response for debugging if available
+                with open(f"/tmp/failed_response_{iteration}.txt", "w") as f:
+                    f.write(response or "<<EMPTY RESPONSE>>")
+                # Try one conservative retry with reduced token budget before failing
+                logging.info("Attempting a conservative retry with reduced tokens...")
+                conservative_settings = dict(self.settings)
+                conservative_settings["max_new_tokens"] = min(1024, int(conservative_settings.get("max_new_tokens", 1024)))
+                conservative_settings["temperature"] = min(0.3, float(conservative_settings.get("temperature", 0.3)))
+                response_retry = call_model(self.client, system, prompt, self.is_python, **conservative_settings)
+                if response_retry and "<<ERROR" not in response_retry:
+                    response = response_retry
+                else:
+                    # write debug file already done
+                    return {"success": False, "warning": "Model error - keeping previous code"}
 
             meta = parse_meta(response)
             if not meta or not meta.get("files"):
-                logging.error(f"Parse failed. Response preview: {response[:500]}")
+                logging.error(f"Parse failed. Response preview: {response[:1000]}")
                 # Save failed response for debugging
                 with open(f"/tmp/failed_response_{iteration}.txt", "w") as f:
                     f.write(response)
@@ -545,12 +678,12 @@ Return the perfected code in META format."""
             files = meta["files"]
             write_files(workdir, files)
             eval_results = run_evaluators(workdir)
-            
+
             review = generate_code_review(self.client, self.token, files, eval_results, self.is_python)
             readme = generate_readme(self.client, self.token, self.goal, files, self.is_python)
             files["README.md"] = readme
             write_files(workdir, {"README.md": readme})
-            
+
             zip_path = make_zip(workdir)
 
             return {
@@ -561,17 +694,17 @@ Return the perfected code in META format."""
         except Exception as e:
             write_error_log(e, "Iteration exception")
             return {"success": False, "warning": f"Exception: {str(e)}"}
-    
+
     def run_loop(self) -> Generator:
         iteration = 1
         max_iterations = 999999 if self.infinite_mode else self.max_iters
-        
+
         if not self.current_files:
             self.start_scaffolding()
-        
+
         initial_state = {"stop_flag_path": str(self.stop_flag)}
         yield self.format_output(f"Starting with {self.model_name}...", iteration, max_iterations, initial_state)
-        
+
         while iteration <= max_iterations:
             if self.stop_flag.exists():
                 try:
@@ -581,11 +714,11 @@ Return the perfected code in META format."""
                     pass
                 yield self.format_output("⛔ Stopped by user", iteration, max_iterations)
                 break
-            
+
             yield self.format_output(f"🔄 Iteration {iteration}/{max_iterations} running...", iteration, max_iterations)
-            
+
             result = self.perform_iteration(iteration)
-            
+
             if not result.get("success"):
                 warning_msg = result.get("warning", "Unknown iteration error")
                 logging.warning(f"Iteration {iteration} failed: {warning_msg}")
@@ -597,11 +730,11 @@ Return the perfected code in META format."""
 
             eval_res = result.get("eval", {})
             score = eval_res.get("quality_score", 0)
-            
+
             self.history.append({"iteration": iteration, "eval": eval_res})
             self.current_files = result["files"]
             self.current_code = "\n\n".join(f"# {n}\n{c}" for n, c in self.current_files.items())
-            
+
             if score > self.best_score:
                 if self.best_workspace:
                     self.cleanup_workdir(Path(self.best_workspace))
@@ -616,29 +749,29 @@ Return the perfected code in META format."""
             else:
                 # Even if score didn't improve, still update current_files for next iteration
                 logging.info(f"Score {score}/100 - keeping best: {self.best_score}/100")
-            
+
             if result.get("workdir") and result.get("workdir") != self.best_workspace:
                 self.cleanup_workdir(Path(result["workdir"]))
-            
+
             yield self.format_output(f"Iteration {iteration} complete: {score}/100", iteration, max_iterations)
-            
+
             iteration += 1
             time.sleep(0.3)
-        
+
         yield self.format_output(f"Complete! Best: {self.best_score}/100", iteration - 1, max_iterations)
-    
+
     def format_output(self, log_msg: str, iteration: int, max_iters: int, state: Optional[Dict] = None):
         progress = f"Iteration {iteration}/{max_iters if max_iters < 999999 else 'INF'}" if iteration <= max_iters else "Complete"
-        
+
         main = self.best_files.get("main.py", "# Generating code...")
         test = next((v for k, v in self.best_files.items() if 'test' in k and k.endswith('.py')), "# No tests yet...")
         req = self.best_files.get("requirements.txt", "# No requirements yet...")
         readme = self.best_files.get("README.md", "# Generating README...")
         other = {k: v for k, v in self.best_files.items() if k not in [
-            "main.py", next((k for k in self.best_files if 'test' in k and k.endswith('.py')), None), 
+            "main.py", next((k for k in self.best_files if 'test' in k and k.endswith('.py')), None),
             "requirements.txt", "README.md"
         ]}
-        
+
         return (
             f"[{time.strftime('%X')}] {sanitize_log_message(log_msg)}", self.model_name, progress,
             generate_metrics_html(self.history), self.best_eval, main, test, req, readme, other,
@@ -649,26 +782,26 @@ Return the perfected code in META format."""
 def generate_metrics_html(history: List[Dict]) -> str:
     if not history:
         return "<div style='padding:12px'>No metrics yet</div>"
-    
+
     html_parts = ["<div style='font-family:sans-serif'><h4>Quality Trend</h4><div style='background:#f8f9fa;padding:12px;border-radius:8px'>"]
     for h in history[-10:]:
         score = h.get("eval", {}).get("quality_score", 0)
         width = int(score * 2.5)
         color = "#10b981" if score >= 80 else "#f59e0b" if score >= 60 else "#ef4444"
         html_parts.append(f"<div style='margin:4px 0'>#{h.get('iteration')}: <div style='display:inline-block;width:{width}px;height:20px;background:{color};border-radius:4px'></div> {score}/100</div>")
-    
+
     scores = [h.get("eval", {}).get("quality_score", 0) for h in history]
     avg = sum(scores) / len(scores) if scores else 0
     best = max(scores) if scores else 0
     html_parts.append(f"<div style='margin-top:12px'><strong>Avg:</strong> {avg:.1f} | <strong>Best:</strong> {best:.1f}</div></div></div>")
-    
+
     return "".join(html_parts)
 
 # ---------- UI ----------
 def create_ui():
     with gr.Blocks(title="InfinateCodeGenerator Ultimate", theme=gr.themes.Soft()) as demo:
         gr.Markdown("# InfinateCodeGenerator - Ultimate Merged Edition\n*Controller architecture • Smart models • Multi-file UI • Never stops early*")
-        
+
         controller_state = gr.State({})
 
         with gr.Row():
@@ -736,20 +869,20 @@ def create_ui():
                 logging.error(error_msg)
                 yield (error_msg, "", "", "", {}, "", "", "", "", {}, "", None, "", {})
                 return
-            
+
             logging.info(f"Starting generation with token: {token[:10]}... (length: {len(token)})")
-            
+
             settings = {"temperature": temp, "top_p": top, "max_new_tokens": max_tok}
             is_python_project = detect_language(goal, init_code)
             logging.info(f"Detected project type: {'Python' if is_python_project else 'Other'}")
-            
+
             controller = CodeGenController(token, goal, instructions, settings, int(max_it), inf_mode, is_python_project)
-            
+
             if init_code and init_code.strip():
                 controller.current_files = {"main.py": init_code}
                 controller.current_code = init_code
                 logging.info("Using provided initial code")
-            
+
             yield from controller.run_loop()
 
         def set_stop(controller_state_val):
@@ -769,7 +902,7 @@ def create_ui():
             main_file, test_file, req_file, readme_file, other_files,
             review_display, download_zip, workspace_path, controller_state
         ]
-        
+
         start_btn.click(
             fn=start_gen,
             inputs=[project_goal, initial_code, improve_instructions, hf_token_manual, infinite_mode, max_iters, temperature, top_p, max_tokens],
@@ -786,4 +919,4 @@ if __name__ == "__main__":
         demo.queue().launch(server_name="0.0.0.0", server_port=7860)
     except Exception as e:
         print(f"Failed to launch Gradio app: {e}", file=sys.stderr)
-        sys.exit(1)
+        sys.exit(1)