Update app.py

app.py

@@ -169,14 +169,25 @@ def call_model(client: InferenceClient, system: str, user: str, is_python: bool,
     models_to_try = [primary_model] + FALLBACK_MODELS
     
     logging.info(f"Calling model for {'Python' if is_python else 'Other'} project. Primary: {primary_model}")
+    logging.info(f"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}")
+    
     last_exception = None
     for model_name in models_to_try:
         # First attempt: non-streaming call (more reliable across client versions/models)
         try:
-            resp = client.chat_completion(messages, model=model_name, stream=False, **settings)
+            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 = ""
             try:
@@ -203,26 +214,35 @@ def call_model(client: InferenceClient, system: str, user: str, is_python: bool,
                 write_error_log(e, f"Non-stream parsing failed for model {model_name}")
 
             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 (older code path)
         try:
-            stream = client.chat_completion(messages, model=model_name, stream=True, **settings)
+            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}")
+    logging.error(f"❌ ALL MODELS FAILED. Last error: {last_exception}")
     return f"<<ERROR: All models failed. Last error: {sanitize_log_message(str(last_exception))}>>"
 
 # ---------- Robust parsing ----------
@@ -418,7 +438,12 @@ def import_project(zip_file) -> Dict[str, str]:
 class CodeGenController:
     def __init__(self, token: str, goal: str, instructions: str, settings: Dict, max_iters: int, infinite_mode: bool, is_python: bool):
         self.token = token
-        self.client = InferenceClient(token=token)
+        try:
+            self.client = InferenceClient(token=token)
+            logging.info("✓ InferenceClient initialized successfully")
+        except Exception as e:
+            logging.error(f"Failed to initialize InferenceClient: {e}")
+            raise
         self.goal = goal
         self.instructions = instructions
         self.settings = settings
@@ -427,6 +452,8 @@ class CodeGenController:
         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 = ""
@@ -705,15 +732,23 @@ def create_ui():
         def start_gen(goal, init_code, instructions, hf_tok, inf_mode, max_it, temp, top, max_tok):
             token = get_token_from_env_or_manual(hf_tok)
             if not token:
-                yield ("ERROR: No HF token found", "", "", "", {}, "", "", "", "", {}, "", None, "", {})
+                error_msg = "ERROR: No HF token found. Please provide a Hugging Face token."
+                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}
-            controller = CodeGenController(token, goal, instructions, settings, int(max_it), inf_mode, detect_language(goal, init_code))
+            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()