Update app.py

app.py

@@ -12,8 +12,7 @@ from google.generativeai import types # Import types for configuration and tools
 from huggingface_hub import create_repo, list_models, upload_file, constants
 from huggingface_hub.utils import build_hf_headers, get_session, hf_raise_for_status
 
-# Add debugging print to check environment variable immediately
-print(f"Attempting to read GOOGLE_API_KEY from environment: {os.environ.get('GOOGLE_API_KEY')}")
+# Removed the debugging print that attempts to read GOOGLE_API_KEY from environment
 
 
 # --- Helper functions for Hugging Face integration ---
@@ -139,6 +138,7 @@ def get_container_logs_action(repo_id, profile, token):
 
 def configure_gemini(api_key: str | None, model_name: str | None) -> str:
     """Configures the Gemini API and checks if the model is accessible."""
+    # Check for empty string "" as well as None
     if not api_key:
         return "⚠️ Gemini API key is not set."
     if not model_name:
@@ -157,7 +157,7 @@ def configure_gemini(api_key: str | None, model_name: str | None) -> str:
 def call_gemini(prompt: str, api_key: str, model_name: str, use_grounding: bool = False) -> str:
     """Calls the Gemini API with a given prompt, optionally using grounding."""
     # This check is crucial - it will raise an error *before* the API call if prereqs aren't met
-    if not api_key or not model_name:
+    if not api_key or not model_name: # Check for empty string "" as well as None
         raise ValueError("Gemini API key or model not set.")
     try:
         genai.configure(api_key=api_key)
@@ -222,6 +222,7 @@ def add_bot_message(history: list[dict], bot_message: str) -> list[dict]:
 
 # Add an initial welcome message to the chatbot (defined outside Blocks to be called by load chain)
 def greet():
+    # Updated welcome message to reflect the change in API key handling
     return [{"role": "assistant", "content": "Welcome! Please log in to Hugging Face and provide your Google AI Studio API key to start building Spaces. Once ready, type 'generate me a gradio app called myapp' or 'create' to begin."}]
 
 # Helper function to update send button interactivity based on prereqs
@@ -234,16 +235,19 @@ def check_send_button_ready(profile: gr.OAuthProfile | None, token: gr.OAuthToke
     print(f"  Received profile type: {type(profile)}, is None: {profile is None}")
     print(f"  Received token type: {type(token)}, is None: {token is None}")
     # For api_key, print part of the key if not None for verification, be careful with full key
-    print(f"  Received api_key is None: {api_key is None}, first 5 chars: {api_key[:5] if api_key else 'N/A'}")
+    # Also check for empty string for printing
+    api_key_display = api_key[:5] if api_key else ('Empty String' if isinstance(api_key, str) and api_key == "" else 'N/A')
+    print(f"  Received api_key is None: {api_key is None}, is Empty String: {api_key == '' if isinstance(api_key, str) else 'N/A'}, first 5 chars or status: {api_key_display}")
     print(f"  Received model_name: {model_name}")
     # --- END ENHANCED DEBUGGING LOGS ---
 
     is_logged_in    = profile is not None and token is not None
-    is_gemini_ready = api_key is not None and model_name is not None
+    # Gemini is ready if api_key is a non-empty string AND model_name is set
+    is_gemini_ready = isinstance(api_key, str) and api_key != "" and model_name is not None
 
     # --- CONTINUED DEBUGGING LOGS ---
     print(f"  HF check: {profile is not None} and {token is not None} = {is_logged_in}")
-    print(f"  Gemini check: {api_key is not None} and {model_name is not None} = {is_gemini_ready}")
+    print(f"  Gemini check: {isinstance(api_key, str)} and {api_key != ''} and {model_name is not None} = {is_gemini_ready}")
     # --- END CONTINUED DEBUGGING LOGS ---
 
     is_ready = is_logged_in and is_gemini_ready
@@ -261,8 +265,11 @@ def ai_workflow_chat(
     history: list[dict],
     hf_profile: gr.OAuthProfile | None,
     hf_token:   gr.OAuthToken   | None,
-    gemini_api_key: str         | None,
-    gemini_model:   str         | None,
+    # gemini_api_key and gemini_model are inputs, but their *state* is managed by change handlers,
+    # so we don't yield them back in this version. They are read from the state at the start
+    # of the function call.
+    gemini_api_key: str         | None, # Read key from state
+    gemini_model:   str         | None, # Read model from state
     repo_id_state:  str | None,
     workflow_state: str,
     space_sdk:      str,
@@ -290,8 +297,7 @@ def ai_workflow_chat(
     str | None,       # 8: Updated repo name (for repo_name_state state)
     str | None,       # 9: Updated generated code (for generated_code_state state)
     bool,             # 10: Updated use_grounding_state (for use_grounding_state state)
-    str | None,       # 11: Updated gemini_key state (Explicitly yield key)
-    str | None,       # 12: Updated gemini_model state (Explicitly yield model)
+    # gemini_key, gemini_model removed from outputs based on new key handling strategy
 ]:
     """
     Generator function to handle the AI workflow state machine.
@@ -322,35 +328,32 @@ def ai_workflow_chat(
     # Yield immediately to update the chat UI with the user's message
     # This provides immediate feedback to the user while the AI processes
     # Ensure all state variables and UI outputs are yielded back in the correct order
-    # INCLUDE gemini_api_key and gemini_model in the yield tuple
+    # NOTE: gemini_key and gemini_model are NOT yielded back
     yield (history, repo_id, state, updated_preview, updated_run, updated_build,
-           attempts, app_desc, repo_name, generated_code, use_grounding, gemini_api_key, gemini_model)
+           attempts, app_desc, repo_name, generated_code, use_grounding)
 
     try:
         # --- State Machine Logic based on the current 'state' variable ---
 
-        if state == STATE_IDLE:
-            # Check workflow prerequisites before starting any workflow actions
-            # The Send button should already be disabled if these aren't met, but double-check
-            # Note: These checks here are for the *workflow logic*, not the button interactivity logic.
-            # The button state is controlled by check_send_button_ready and the .then chains.
-            if not (hf_profile and hf_token):
-                # This case should ideally not be reachable if the button is correctly disabled
-                history = add_bot_message(history, "Workflow paused: Please log in to Hugging Face first.")
-                # INCLUDE gemini_api_key and gemini_model in the yield tuple
-                yield (history, repo_id, state, updated_preview, updated_run, updated_build,
-                       attempts, app_desc, repo_name, generated_code, use_grounding, gemini_api_key, gemini_model)
-                return # Stop workflow execution for this click
+        # Although button interactivity prevents reaching here without key/model,
+        # the checks remain as a safeguard for the workflow logic itself.
+        if not (hf_profile and hf_token):
+            history = add_bot_message(history, "Workflow paused: Please log in to Hugging Face first.")
+            # NOTE: gemini_key and gemini_model are NOT yielded back
+            yield (history, repo_id, state, updated_preview, updated_run, updated_build,
+                   attempts, app_desc, repo_name, generated_code, use_grounding)
+            return # Stop workflow execution for this click
 
-            if not (gemini_api_key and gemini_model):
-                 # This case should also ideally not be reachable if the button is correctly disabled
-                 history = add_bot_message(history, "Workflow cannot start: Please ensure your Gemini API key is entered and a model is selected.")
-                 # INCLUDE gemini_api_key and gemini_model in the yield tuple
-                 yield (history, repo_id, state, updated_preview, updated_run, updated_build,
-                        attempts, app_desc, repo_name, generated_code, use_grounding, gemini_api_key, gemini_model)
-                 return # Stop workflow execution for this click
+        # Check if API key is non-empty string and model is set
+        if not (isinstance(gemini_api_key, str) and gemini_api_key != "" and gemini_model):
+             history = add_bot_message(history, "Workflow cannot start: Please ensure your Gemini API key is entered and a model is selected.")
+             # NOTE: gemini_key and gemini_model are NOT yielded back
+             yield (history, repo_id, state, updated_preview, updated_run, updated_build,
+                    attempts, app_desc, repo_name, generated_code, use_grounding)
+             return # Stop workflow execution for this click
 
 
+        if state == STATE_IDLE:
             # Look for specific commands in the user's message
             reset_match = "reset" in message.lower()
             # Capture app description AND repo name using regex
@@ -363,9 +366,9 @@ def ai_workflow_chat(
                 history = add_bot_message(history, "Workflow reset.")
                 # Yield updated history and reset state variables to their initial values
                 # Also reset UI outputs to their initial state
-                # INCLUDE gemini_api_key and gemini_model in the yield tuple (pass current values through)
+                # NOTE: gemini_key and gemini_model are NOT yielded back (they are managed by change handlers)
                 yield (history, None, STATE_IDLE, "<p>No Space created yet.</p>", "", "", 0,
-                       None, None, None, False, gemini_api_key, gemini_model) # Reset use_grounding to default False, and other states to None/default
+                       None, None, None, False) # Reset use_grounding to default False, and other states to None/default
                 # No return needed after yield in this generator pattern; execution for this click ends here.
 
             elif generate_match:
@@ -378,9 +381,9 @@ def ai_workflow_chat(
                 repo_name = new_repo_name
                 app_desc = new_app_desc
                 # Yield updated history and state variables (pass UI outputs through)
-                # INCLUDE gemini_api_key and gemini_model in the yield tuple
+                # NOTE: gemini_key and gemini_model are NOT yielded back
                 yield (history, repo_id, state, updated_preview, updated_run, updated_build,
-                       attempts, app_desc, repo_name, generated_code, use_grounding, gemini_api_key, gemini_model)
+                       attempts, app_desc, repo_name, generated_code, use_grounding)
                 # No return needed
 
             elif create_match:
@@ -390,9 +393,9 @@ def ai_workflow_chat(
                  state = STATE_CREATING_SPACE # Transition state to creation
                  repo_name = new_repo_name # Store the validated repo name
                  # Yield updated history and state variables (pass UI outputs through)
-                 # INCLUDE gemini_api_key and gemini_model in the yield tuple
+                 # NOTE: gemini_key and gemini_model are NOT yielded back
                  yield (history, repo_id, state, updated_preview, updated_run, updated_build,
-                        attempts, app_desc, repo_name, generated_code, use_grounding, gemini_api_key, gemini_model)
+                        attempts, app_desc, repo_name, generated_code, use_grounding)
                  # No return needed
 
             elif "create" in message.lower() and not repo_id:
@@ -400,18 +403,18 @@ def ai_workflow_chat(
                 history = add_bot_message(history, "Okay, what should the Space be called? (e.g., `my-awesome-app`)")
                 state = STATE_AWAITING_REPO_NAME # Transition to the state where we wait for the name
                 # Yield updated history and state (pass UI outputs through)
-                # INCLUDE gemini_api_key and gemini_model in the yield tuple
+                # NOTE: gemini_key and gemini_model are NOT yielded back
                 yield (history, repo_id, state, updated_preview, updated_run, updated_build,
-                       attempts, app_desc, repo_name, generated_code, use_grounding, gemini_api_key, gemini_model)
+                       attempts, app_desc, repo_name, generated_code, use_grounding)
                 # No return needed
 
             else:
                 # Command not recognized in IDLE state
                 history = add_bot_message(history, "Command not recognized. Try 'generate me a gradio app called myapp', or 'reset'.")
                 # Yield updated history and current state (pass UI outputs through)
-                # INCLUDE gemini_api_key and gemini_model in the yield tuple
+                # NOTE: gemini_key and gemini_model are NOT yielded back
                 yield (history, repo_id, state, updated_preview, updated_run, updated_build,
-                       attempts, app_desc, repo_name, generated_code, use_grounding, gemini_api_key, gemini_model)
+                       attempts, app_desc, repo_name, generated_code, use_grounding)
                 # No return needed
 
 
@@ -423,9 +426,9 @@ def ai_workflow_chat(
              if not new_repo_name or re.search(r'[^a-zA-Z0-9_-]', new_repo_name) or len(new_repo_name) > 100:
                  history = add_bot_message(history, "Invalid name. Please provide a single word/slug for the Space name (letters, numbers, underscores, hyphens only, max 100 chars).")
                  # Stay in AWAITING_REPO_NAME state and yield message (pass UI outputs through)
-                 # INCLUDE gemini_api_key and gemini_model in the yield tuple
+                 # NOTE: gemini_key and gemini_model are NOT yielded back
                  yield (history, repo_id, state, updated_preview, updated_run, updated_build,
-                        attempts, app_desc, repo_name, generated_code, use_grounding, gemini_api_key, gemini_model)
+                        attempts, app_desc, repo_name, generated_code, use_grounding)
                  # No return needed
 
              else:
@@ -434,9 +437,9 @@ def ai_workflow_chat(
                  repo_name = new_repo_name # Store the validated repo name
                  # Yield updated history, state, and repo name. UI outputs remain unchanged for now.
                  # The next click will proceed from the STATE_CREATING_SPACE block.
-                 # INCLUDE gemini_api_key and gemini_model in the yield tuple
+                 # NOTE: gemini_key and gemini_model are NOT yielded back
                  yield (history, repo_id, state, updated_preview, updated_run, updated_build,
-                        attempts, app_desc, repo_name, generated_code, use_grounding, gemini_api_key, gemini_model)
+                        attempts, app_desc, repo_name, generated_code, use_grounding)
                  # No return needed
 
         # Note: Each 'elif' block below represents a distinct step in the workflow triggered
@@ -447,9 +450,9 @@ def ai_workflow_chat(
              if not repo_name:
                  history = add_bot_message(history, "Internal error: Repo name missing for creation. Resetting.")
                  # Reset relevant states and UI outputs on critical error
-                 # INCLUDE gemini_api_key and gemini_model in the yield tuple (pass current values through)
+                 # NOTE: gemini_key and gemini_model are NOT yielded back
                  yield (history, None, STATE_IDLE, "<p>Error creating space.</p>", "", "", 0,
-                       None, None, None, use_grounding, gemini_api_key, gemini_model) # Pass grounding state through
+                       None, None, None, use_grounding) # Pass grounding state through
                  # No return needed
 
              else:
@@ -461,17 +464,17 @@ def ai_workflow_chat(
                      history = add_bot_message(history, f"✅ Space `{repo_id}` created. Click 'Send' to generate and upload code.")
                      state = STATE_GENERATING_CODE # Transition to the next state
                      # Yield updated state variables and history, and the new iframe HTML
-                     # INCLUDE gemini_api_key and gemini_model in the yield tuple
+                     # NOTE: gemini_key and gemini_model are NOT yielded back
                      yield (history, repo_id, state, updated_preview, updated_run, updated_build,
-                            attempts, app_desc, repo_name, generated_code, use_grounding, gemini_api_key, gemini_model) # Pass logs and grounding through
+                            attempts, app_desc, repo_name, generated_code, use_grounding) # Pass logs and grounding through
                      # No return needed
 
                  except Exception as e:
                      history = add_bot_message(history, f"❌ Error creating space: {e}. Click 'reset'.")
                      # Yield error message and reset state on failure
-                     # INCLUDE gemini_api_key and gemini_model in the yield tuple (pass current values through)
+                     # NOTE: gemini_key and gemini_model are NOT yielded back
                      yield (history, None, STATE_IDLE, "<p>Error creating space.</p>", "", "", 0,
-                           None, None, None, use_grounding, gemini_api_key, gemini_model) # Pass logs and grounding through
+                           None, None, None, use_grounding) # Pass logs and grounding through
                      # No return needed
 
 
@@ -490,11 +493,12 @@ Return **only** the python code block for `app.py`. Do not include any extra tex
                  if use_grounding:
                      history = add_bot_message(history, "(Using Grounding with Google Search)")
                  # Yield to show message before the potentially time-consuming API call
-                 # INCLUDE gemini_api_key and gemini_model in the yield tuple
+                 # NOTE: gemini_key and gemini_model are NOT yielded back
                  yield (history, repo_id, state, updated_preview, updated_run, updated_build,
-                        attempts, app_desc, repo_name, generated_code, use_grounding, gemini_api_key, gemini_model)
+                        attempts, app_desc, repo_name, generated_code, use_grounding)
 
                  # Perform the Gemini API call to generate code, optionally using grounding
+                 # Use the gemini_api_key and gemini_model inputs directly (which come from state)
                  code = call_gemini(prompt, gemini_api_key, gemini_model, use_grounding=use_grounding)
                  code = code.strip()
                  # Clean up common markdown code block formatting if present
@@ -512,17 +516,17 @@ Return **only** the python code block for `app.py`. Do not include any extra tex
                  state = STATE_UPLOADING_APP_PY # Transition to the upload state
                  generated_code = code # Store the generated code in the state variable for the next step
                  # Yield updated state variables and history (pass UI outputs and other states through)
-                 # INCLUDE gemini_api_key and gemini_model in the yield tuple
+                 # NOTE: gemini_key and gemini_model are NOT yielded back
                  yield (history, repo_id, state, updated_preview, updated_run, updated_build,
-                        attempts, app_desc, repo_name, generated_code, use_grounding, gemini_api_key, gemini_model)
+                        attempts, app_desc, repo_name, generated_code, use_grounding)
                  # No return needed
 
              except Exception as e:
                  history = add_bot_message(history, f"❌ Error generating code: {e}. Click 'reset'.")
                  # Yield error message and reset state on failure
-                 # INCLUDE gemini_api_key and gemini_model in the yield tuple (pass current values through)
+                 # NOTE: gemini_key and gemini_model are NOT yielded back
                  yield (history, None, STATE_IDLE, updated_preview, updated_run, updated_build, 0,
-                       None, None, None, use_grounding, gemini_api_key, gemini_model)
+                       None, None, None, use_grounding)
                  # No return needed
 
 
@@ -531,17 +535,17 @@ Return **only** the python code block for `app.py`. Do not include any extra tex
              code_to_upload = generated_code
              if not code_to_upload:
                   history = add_bot_message(history, "Internal error: No code to upload. Resetting.")
-                  # INCLUDE gemini_api_key and gemini_model in the yield tuple (pass current values through)
+                  # NOTE: gemini_key and gemini_model are NOT yielded back
                   yield (history, None, STATE_IDLE, updated_preview, updated_run, updated_build, 0,
-                        None, None, None, use_grounding, gemini_api_key, gemini_model)
+                        None, None, None, use_grounding)
                   # No return needed
 
              else:
                  history = add_bot_message(history, "☁️ Uploading `app.py`...")
                  # Yield to show message before the upload action (pass UI outputs and states through)
-                 # INCLUDE gemini_api_key and gemini_model in the yield tuple
+                 # NOTE: gemini_key and gemini_model are NOT yielded back
                  yield (history, repo_id, state, updated_preview, updated_run, updated_build,
-                        attempts, app_desc, repo_name, generated_code, use_grounding, gemini_api_key, gemini_model)
+                        attempts, app_desc, repo_name, generated_code, use_grounding)
 
                  try:
                      # Perform the file upload action
@@ -550,26 +554,26 @@ Return **only** the python code block for `app.py`. Do not include any extra tex
                      state = STATE_GENERATING_REQUIREMENTS # Transition state
                      generated_code = None # Clear the stored code after use to free memory/state space
                      # Yield updated state variables and history (pass UI outputs and other states through)
-                     # INCLUDE gemini_api_key and gemini_model in the yield tuple
+                     # NOTE: gemini_key and gemini_model are NOT yielded back
                      yield (history, repo_id, state, updated_preview, updated_run, updated_build,
-                            attempts, app_desc, repo_name, generated_code, use_grounding, gemini_api_key, gemini_model)
+                            attempts, app_desc, repo_name, generated_code, use_grounding)
                      # No return needed
 
                  except Exception as e:
                      history = add_bot_message(history, f"❌ Error uploading `app.py`: {e}. Click 'reset'.")
                      # Yield error message and reset state on failure
-                     # INCLUDE gemini_api_key and gemini_model in the yield tuple (pass current values through)
+                     # NOTE: gemini_key and gemini_model are NOT yielded back
                      yield (history, None, STATE_IDLE, updated_preview, updated_run, updated_build, 0,
-                           None, None, None, use_grounding, gemini_api_key, gemini_model)
+                           None, None, None, use_grounding)
                      # No return needed
 
 
         elif state == STATE_GENERATING_REQUIREMENTS:
              history = add_bot_message(history, "📄 Generating `requirements.txt`...")
              # Yield to show message before generating requirements (pass UI outputs and states through)
-             # INCLUDE gemini_api_key and gemini_model in the yield tuple
+             # NOTE: gemini_key and gemini_model are NOT yielded back
              yield (history, repo_id, state, updated_preview, updated_run, updated_build,
-                    attempts, app_desc, repo_name, generated_code, use_grounding, gemini_api_key, gemini_model)
+                    attempts, app_desc, repo_name, generated_code, use_grounding)
 
              # Logic to determine required packages based on SDK and keywords in the app description
              reqs_list = ["gradio"] if space_sdk == "gradio" else ["streamlit"]
@@ -610,9 +614,9 @@ Return **only** the python code block for `app.py`. Do not include any extra tex
              state = STATE_UPLOADING_REQUIREMENTS # Transition state
              generated_code = reqs_content # Store requirements content
              # Yield updated state variables and history (pass UI outputs and other states through)
-             # INCLUDE gemini_api_key and gemini_model in the yield tuple
+             # NOTE: gemini_key and gemini_model are NOT yielded back
              yield (history, repo_id, state, updated_preview, updated_run, updated_build,
-                    attempts, app_desc, repo_name, generated_code, use_grounding, gemini_api_key, gemini_model)
+                    attempts, app_desc, repo_name, generated_code, use_grounding)
                      # No return needed
 
 
@@ -621,17 +625,17 @@ Return **only** the python code block for `app.py`. Do not include any extra tex
             reqs_content_to_upload = generated_code
             if not reqs_content_to_upload:
                  history = add_bot_message(history, "Internal error: No requirements content to upload. Resetting.")
-                 # INCLUDE gemini_api_key and gemini_model in the yield tuple (pass current values through)
+                 # NOTE: gemini_key and gemini_model are NOT yielded back
                  yield (history, None, STATE_IDLE, updated_preview, updated_run, updated_build, 0,
-                        None, None, None, use_grounding, gemini_api_key, gemini_model)
+                        None, None, None, use_grounding)
                  # No return needed
 
             else:
                  history = add_bot_message(history, "☁️ Uploading `requirements.txt`...")
                  # Yield message before upload (pass UI outputs and states through)
-                 # INCLUDE gemini_api_key and gemini_model in the yield tuple
+                 # NOTE: gemini_key and gemini_model are NOT yielded back
                  yield (history, repo_id, state, updated_preview, updated_run, updated_build,
-                        attempts, app_desc, repo_name, generated_code, use_grounding, gemini_api_key, gemini_model)
+                        attempts, app_desc, repo_name, generated_code, use_grounding)
 
                  try:
                      # Perform requirements file upload
@@ -640,25 +644,25 @@ Return **only** the python code block for `app.py`. Do not include any extra tex
                      state = STATE_GENERATING_README # Transition state
                      generated_code = None # Clear content after use
                      # Yield updated state variables and history (pass UI outputs and other states through)
-                     # INCLUDE gemini_api_key and gemini_model in the yield tuple
+                     # NOTE: gemini_key and gemini_model are NOT yielded back
                      yield (history, repo_id, state, updated_preview, updated_run, updated_build,
-                            attempts, app_desc, repo_name, generated_code, use_grounding, gemini_api_key, gemini_model)
+                            attempts, app_desc, repo_name, generated_code, use_grounding)
                      # No return needed
 
                  except Exception as e:
                      history = add_bot_message(history, f"❌ Error uploading `requirements.txt`: {e}. Click 'reset'.")
                      # Yield error message and reset state on failure
-                     # INCLUDE gemini_api_key and gemini_model in the yield tuple (pass current values through)
+                     # NOTE: gemini_key and gemini_model are NOT yielded back
                      yield (history, None, STATE_IDLE, updated_preview, updated_run, updated_build, 0,
-                           None, None, None, use_grounding, gemini_api_key, gemini_model)
+                           None, None, None, use_grounding)
                      # No return needed
 
         elif state == STATE_GENERATING_README:
             history = add_bot_message(history, "📝 Generating `README.md`...")
             # Yield message before generating README (pass UI outputs and states through)
-            # INCLUDE gemini_api_key and gemini_model in the yield tuple
+            # NOTE: gemini_key and gemini_model are NOT yielded back
             yield (history, repo_id, state, updated_preview, updated_run, updated_build,
-                   attempts, app_desc, repo_name, generated_code, use_grounding, gemini_api_key, gemini_model)
+                   attempts, app_desc, repo_name, generated_code, use_grounding)
 
             # Generate simple README content with Space metadata header
             readme_title = repo_name if repo_name else "My Awesome Space"
@@ -685,9 +689,9 @@ This Space was automatically generated by an AI workflow using Google Gemini and
             state = STATE_UPLOADING_README # Transition state
             generated_code = readme_content # Store README content
             # Yield updated state variables and history (pass UI outputs and other states through)
-            # INCLUDE gemini_api_key and gemini_model in the yield tuple
+            # NOTE: gemini_key and gemini_model are NOT yielded back
             yield (history, repo_id, state, updated_preview, updated_run, updated_build,
-                   attempts, app_desc, repo_name, generated_code, use_grounding, gemini_api_key, gemini_model)
+                   attempts, app_desc, repo_name, generated_code, use_grounding)
             # No return needed
 
 
@@ -696,17 +700,17 @@ This Space was automatically generated by an AI workflow using Google Gemini and
             readme_content_to_upload = generated_code
             if not readme_content_to_upload:
                  history = add_bot_message(history, "Internal error: No README content to upload. Resetting.")
-                 # INCLUDE gemini_api_key and gemini_model in the yield tuple (pass current values through)
+                 # NOTE: gemini_key and gemini_model are NOT yielded back
                  yield (history, None, STATE_IDLE, updated_preview, updated_run, updated_build, 0,
-                        None, None, None, use_grounding, gemini_api_key, gemini_model)
+                        None, None, None, use_grounding)
                  # No return needed
 
             else:
                  history = add_bot_message(history, "☁️ Uploading `README.md`...")
                  # Yield message before upload (pass UI outputs and states through)
-                 # INCLUDE gemini_api_key and gemini_model in the yield tuple
+                 # NOTE: gemini_key and gemini_model are NOT yielded back
                  yield (history, repo_id, state, updated_preview, updated_run, updated_build,
-                        attempts, app_desc, repo_name, generated_code, use_grounding, gemini_api_key, gemini_model)
+                        attempts, app_desc, repo_name, generated_code, use_grounding)
 
                  try:
                      # Perform README file upload
@@ -715,25 +719,25 @@ This Space was automatically generated by an AI workflow using Google Gemini and
                      state = STATE_CHECKING_LOGS_BUILD # Transition to checking build logs
                      generated_code = None # Clear content after use
                      # Yield updated state variables and history (pass UI outputs and other states through)
-                     # INCLUDE gemini_api_key and gemini_model in the yield tuple
+                     # NOTE: gemini_key and gemini_model are NOT yielded back
                      yield (history, repo_id, state, updated_preview, updated_run, updated_build,
-                            attempts, app_desc, repo_name, generated_code, use_grounding, gemini_api_key, gemini_model)
+                            attempts, app_desc, repo_name, generated_code, use_grounding)
                      # No return needed
 
                  except Exception as e:
                      history = add_bot_message(history, f"❌ Error uploading `README.md`: {e}. Click 'reset'.")
                      # Yield error message and reset state on failure
-                     # INCLUDE gemini_api_key and gemini_model in the yield tuple (pass current values through)
+                     # NOTE: gemini_key and gemini_model are NOT yielded back
                      yield (history, None, STATE_IDLE, updated_preview, updated_run, updated_build, 0,
-                           None, None, None, use_grounding, gemini_api_key, gemini_model)
+                           None, None, None, use_grounding)
                      # No return needed
 
         elif state == STATE_CHECKING_LOGS_BUILD:
              history = add_bot_message(history, "🔍 Fetching build logs...")
              # Yield message before fetching logs (which includes a delay) (pass UI outputs and states through)
-             # INCLUDE gemini_api_key and gemini_model in the yield tuple
+             # NOTE: gemini_key and gemini_model are NOT yielded back
              yield (history, repo_id, state, updated_preview, updated_run, updated_build,
-                    attempts, app_desc, repo_name, generated_code, use_grounding, gemini_api_key, gemini_model)
+                    attempts, app_desc, repo_name, generated_code, use_grounding)
 
              # Fetch build logs from HF Space
              build_logs_text = get_build_logs_action(repo_id, hf_profile, hf_token)
@@ -744,27 +748,27 @@ This Space was automatically generated by an AI workflow using Google Gemini and
                   history = add_bot_message(history, "⚠️ Build logs indicate potential issues. Please inspect above. Click 'Send' to check container logs (app might still start despite build warnings).")
                   state = STATE_CHECKING_LOGS_RUN # Transition even on build error, to see if container starts
                   # Yield updated state, logs, and variables
-                  # INCLUDE gemini_api_key and gemini_model in the yield tuple
+                  # NOTE: gemini_key and gemini_model are NOT yielded back
                   yield (history, repo_id, state, updated_preview, updated_run, updated_build,
-                         attempts, app_desc, repo_name, generated_code, use_grounding, gemini_api_key, gemini_model)
+                         attempts, app_desc, repo_name, generated_code, use_grounding)
                   # No return needed
 
              else:
                   history = add_bot_message(history, "✅ Build logs fetched. Click 'Send' to check container logs.")
                   state = STATE_CHECKING_LOGS_RUN # Transition to next log check
                   # Yield updated state, logs, and variables
-                  # INCLUDE gemini_api_key and gemini_model in the yield tuple
+                  # NOTE: gemini_key and gemini_model are NOT yielded back
                   yield (history, repo_id, state, updated_preview, updated_run, updated_build,
-                         attempts, app_desc, repo_name, generated_code, use_grounding, gemini_api_key, gemini_model)
+                         attempts, app_desc, repo_name, generated_code, use_grounding)
                   # No return needed
 
 
         elif state == STATE_CHECKING_LOGS_RUN:
              history = add_bot_message(history, "🔍 Fetching container logs...")
              # Yield message before fetching logs (includes a delay) (pass UI outputs and states through)
-             # INCLUDE gemini_api_key and gemini_model in the yield tuple
+             # NOTE: gemini_key and gemini_model are NOT yielded back
              yield (history, repo_id, state, updated_preview, updated_run, updated_build,
-                    attempts, app_desc, repo_name, generated_code, use_grounding, gemini_api_key, gemini_model)
+                    attempts, app_desc, repo_name, generated_code, use_grounding)
 
              # Fetch container logs from HF Space
              container_logs_text = get_container_logs_action(repo_id, hf_profile, hf_token)
@@ -776,9 +780,9 @@ This Space was automatically generated by an AI workflow using Google Gemini and
                   history = add_bot_message(history, f"❌ Errors detected in container logs. Attempting debug fix #{attempts}/{MAX_DEBUG_ATTEMPTS}. Click 'Send' to proceed.")
                   state = STATE_DEBUGGING_CODE # Transition to the debugging state
                   # Yield updated state, logs, attempts, and variables
-                  # INCLUDE gemini_api_key and gemini_model in the yield tuple
+                  # NOTE: gemini_key and gemini_model are NOT yielded back
                   yield (history, repo_id, state, updated_preview, updated_run, updated_build,
-                         attempts, app_desc, repo_name, generated_code, use_grounding, gemini_api_key, gemini_model)
+                         attempts, app_desc, repo_name, generated_code, use_grounding)
                   # No return needed
 
              elif ("error" in updated_run.lower() or "exception" in updated_run.lower()) and attempts >= MAX_DEBUG_ATTEMPTS:
@@ -786,9 +790,9 @@ This Space was automatically generated by an AI workflow using Google Gemini and
                   history = add_bot_message(history, f"❌ Errors detected in container logs. Max debug attempts ({MAX_DEBUG_ATTEMPTS}) reached. Please inspect logs manually or click 'reset'.")
                   state = STATE_COMPLETE # Workflow ends on failure after attempts
                   # Yield updated state, logs, attempts, and variables
-                  # INCLUDE gemini_api_key and gemini_model in the yield tuple
+                  # NOTE: gemini_key and gemini_model are NOT yielded back
                   yield (history, repo_id, state, updated_preview, updated_run, updated_build,
-                         attempts, app_desc, repo_name, generated_code, use_grounding, gemini_api_key, gemini_model)
+                         attempts, app_desc, repo_name, generated_code, use_grounding)
                   # No return needed
 
              else:
@@ -796,9 +800,9 @@ This Space was automatically generated by an AI workflow using Google Gemini and
                   history = add_bot_message(history, "✅ App appears to be running successfully! Check the iframe above. Click 'reset' to start a new project.")
                   state = STATE_COMPLETE # Workflow ends on success
                   # Yield updated state, logs, attempts, and variables
-                  # INCLUDE gemini_api_key and gemini_model in the yield tuple
+                  # NOTE: gemini_key and gemini_model are NOT yielded back
                   yield (history, repo_id, state, updated_preview, updated_run, updated_build,
-                         attempts, app_desc, repo_name, generated_code, use_grounding, gemini_api_key, gemini_model)
+                         attempts, app_desc, repo_name, generated_code, use_grounding)
                   # No return needed
 
 
@@ -807,9 +811,9 @@ This Space was automatically generated by an AI workflow using Google Gemini and
              if use_grounding:
                   history = add_bot_message(history, "(Using Grounding with Google Search)")
              # Yield message before Gemini API call (pass UI outputs and states through)
-             # INCLUDE gemini_api_key and gemini_model in the yield tuple
+             # NOTE: gemini_key and gemini_model are NOT yielded back
              yield (history, repo_id, state, updated_preview, updated_run, updated_build,
-                    attempts, app_desc, repo_name, generated_code, use_grounding, gemini_api_key, gemini_model)
+                    attempts, app_desc, repo_name, generated_code, use_grounding)
 
              # Construct prompt for Gemini including the container logs
              debug_prompt = f"""
@@ -826,6 +830,7 @@ Return **only** the python code block for app.py. Do not include any extra text,
                   # Call Gemini to generate the corrected code, optionally using grounding
                   # Note: Grounding might be less effective for debugging based *only* on logs,
                   # but we include the option as requested.
+                  # Use the gemini_api_key and gemini_model inputs directly (which come from state)
                   fix_code = call_gemini(debug_prompt, gemini_api_key, gemini_model, use_grounding=use_grounding)
                   fix_code = fix_code.strip()
                   # Clean up potential markdown formatting
@@ -843,17 +848,17 @@ Return **only** the python code block for app.py. Do not include any extra text,
                   state = STATE_UPLOADING_FIXED_APP_PY # Transition to the upload state for the fix
                   generated_code = fix_code # Store the generated fix code
                   # Yield updated state, code, and variables (pass UI outputs and states through)
-                  # INCLUDE gemini_api_key and gemini_model in the yield tuple
+                  # NOTE: gemini_key and gemini_model are NOT yielded back
                   yield (history, repo_id, state, updated_preview, updated_run, updated_build,
-                         attempts, app_desc, repo_name, generated_code, use_grounding, gemini_api_key, gemini_model)
+                         attempts, app_desc, repo_name, generated_code, use_grounding)
                   # No return needed
 
              except Exception as e:
                   history = add_bot_message(history, f"❌ Error generating debug code: {e}. Click 'reset'.")
                   # Yield error message and reset state on failure
-                  # INCLUDE gemini_api_key and gemini_model in the yield tuple (pass current values through)
+                  # NOTE: gemini_key and gemini_model are NOT yielded back
                   yield (history, None, STATE_IDLE, updated_preview, updated_run, updated_build, 0,
-                         None, None, None, use_grounding, gemini_api_key, gemini_model)
+                         None, None, None, use_grounding)
                   # No return needed
 
         elif state == STATE_UPLOADING_FIXED_APP_PY:
@@ -861,17 +866,17 @@ Return **only** the python code block for app.py. Do not include any extra text,
              fixed_code_to_upload = generated_code
              if not fixed_code_to_upload:
                   history = add_bot_message(history, "Internal error: No fixed code available to upload. Resetting.")
-                  # INCLUDE gemini_api_key and gemini_model in the yield tuple (pass current values through)
+                  # NOTE: gemini_key and gemini_model are NOT yielded back
                   yield (history, None, STATE_IDLE, updated_preview, updated_run, updated_build, 0,
-                        None, None, None, use_grounding, gemini_api_key, gemini_model)
+                        None, None, None, use_grounding)
                   # No return needed
 
              else:
                   history = add_bot_message(history, "☁️ Uploading fixed `app.py`...")
                   # Yield message before upload (pass UI outputs and states through)
-                  # INCLUDE gemini_api_key and gemini_model in the yield tuple
+                  # NOTE: gemini_key and gemini_model are NOT yielded back
                   yield (history, repo_id, state, updated_preview, updated_run, updated_build,
-                         attempts, app_desc, repo_name, generated_code, use_grounding, gemini_api_key, gemini_model)
+                         attempts, app_desc, repo_name, generated_code, use_grounding)
 
                   try:
                       # Perform the upload of the fixed app.py
@@ -880,25 +885,25 @@ Return **only** the python code block for app.py. Do not include any extra text,
                       state = STATE_CHECKING_LOGS_RUN # Go back to checking run logs after uploading the fix
                       generated_code = None # Clear code after use
                       # Yield updated state, code, and variables (pass UI outputs and states through)
-                      # INCLUDE gemini_api_key and gemini_model in the yield tuple
+                      # NOTE: gemini_key and gemini_model are NOT yielded back
                       yield (history, repo_id, state, updated_preview, updated_run, updated_build,
-                             attempts, app_desc, repo_name, generated_code, use_grounding, gemini_api_key, gemini_model)
+                             attempts, app_desc, repo_name, generated_code, use_grounding)
                       # No return needed
 
                   except Exception as e:
                       history = add_bot_message(history, f"❌ Error uploading fixed `app.py`: {e}. Click 'reset'.")
                       # Yield error message and reset state on failure
-                      # INCLUDE gemini_api_key and gemini_model in the yield tuple (pass current values through)
+                      # NOTE: gemini_key and gemini_model are NOT yielded back
                       yield (history, None, STATE_IDLE, updated_preview, updated_run, updated_build, 0,
-                            None, None, None, use_grounding, gemini_api_key, gemini_model)
+                            None, None, None, use_grounding)
                       # No return needed
 
         elif state == STATE_COMPLETE:
              # If in the complete state, the workflow is finished for this project.
              # Subsequent clicks just add user messages; we simply yield the current state.
-             # INCLUDE gemini_api_key and gemini_model in the yield tuple
+             # NOTE: gemini_key and gemini_model are NOT yielded back
              yield (history, repo_id, state, updated_preview, updated_run, updated_build,
-                    attempts, app_desc, repo_name, generated_code, use_grounding, gemini_api_key, gemini_model)
+                    attempts, app_desc, repo_name, generated_code, use_grounding)
              # No return needed
 
 
@@ -908,9 +913,9 @@ Return **only** the python code block for app.py. Do not include any extra text,
         history = add_bot_message(history, error_message)
         print(f"Critical Error in state {state}: {e}") # Log the error for debugging purposes
         # Yield an error state and reset essential workflow variables on critical failure
-        # INCLUDE gemini_api_key and gemini_model in the yield tuple (pass current values through)
+        # NOTE: gemini_key and gemini_model are NOT yielded back
         yield (history, None, STATE_IDLE, updated_preview, updated_run, updated_build, 0,
-               None, None, None, use_grounding, gemini_api_key, gemini_model) # Include use_grounding
+               None, None, None, use_grounding) # Include use_grounding
         # No return needed after yield
 
 
@@ -921,8 +926,8 @@ with gr.Blocks(title="AI-Powered HF Space App Builder") as ai_builder_tab:
     # Define these first as they might be used in default values for components
     hf_profile   = gr.State(None)
     hf_token     = gr.State(None)
-    # FIX: Initialize gemini_key state from env var on load
-    gemini_key   = gr.State(os.environ.get("GOOGLE_API_KEY"))
+    # CHANGED: Initialize gemini_key state to empty string, not from env var
+    gemini_key   = gr.State("")  # start with no key
     gemini_model = gr.State("gemini-1.5-flash") # Default selected model
     repo_id      = gr.State(None) # Stores the ID of the created Space
     workflow     = gr.State(STATE_IDLE) # Stores the current state of the AI workflow
@@ -945,12 +950,13 @@ with gr.Blocks(title="AI-Powered HF Space App Builder") as ai_builder_tab:
 
             gr.Markdown("## Google AI Studio / Gemini")
             # Define gemini_input and gemini_status before they are used in change handlers
+            # CHANGED: Blank out textbox on load and update info text
             gemini_input  = gr.Textbox(
-                label="API Key",
+                label="Your Google AI Studio API Key", # Changed label
                 type="password", # Hides input for security
                 interactive=True,
-                value=os.environ.get("GOOGLE_API_KEY"), # Pre-fill if GOOGLE_API_KEY env var is set
-                info="Get your key from Google AI Studio"
+                value="", # Don't pre-fill from env var
+                info="Enter your own key here" # Updated info text
             )
             gemini_status = gr.Markdown("") # Display Gemini configuration status
 
@@ -1020,10 +1026,11 @@ with gr.Blocks(title="AI-Powered HF Space App Builder") as ai_builder_tab:
             )
 
             # Handle Gemini Key Input change: Update key state -> Configure Gemini status -> Check prereqs and update button interactivity
+            # This chain is crucial for the new key handling logic
             gemini_input.change(
-                lambda k: k, inputs=[gemini_input], outputs=[gemini_key] # Update gemini_key state
+                lambda k: k, inputs=[gemini_input], outputs=[gemini_key] # Update gemini_key state with textbox value
             ).then(
-                configure_gemini, inputs=[gemini_key, gemini_model], outputs=[gemini_status] # Update Gemini status
+                configure_gemini, inputs=[gemini_key, gemini_model], outputs=[gemini_status] # Update Gemini status based on new key
             ).then(
                 # Call the update function and bind its output to the button component
                 check_send_button_ready,
@@ -1032,10 +1039,11 @@ with gr.Blocks(title="AI-Powered HF Space App Builder") as ai_builder_tab:
             )
 
             # Handle Gemini Model Selector change: Update model state -> Configure Gemini status -> Check prereqs and update button interactivity
+            # This chain is crucial for the new key handling logic
             model_selector.change(
-                lambda m: m, inputs=[model_selector], outputs=[gemini_model] # Update gemini_model state
+                lambda m: m, inputs=[model_selector], outputs=[gemini_model] # Update gemini_model state with selected model
             ).then(
-                configure_gemini, inputs=[gemini_key, gemini_model], outputs=[gemini_status] # Update Gemini status
+                configure_gemini, inputs=[gemini_key, gemini_model], outputs=[gemini_status] # Update Gemini status based on new model
             ).then(
                 # Call the update function and bind its output to the button component
                 check_send_button_ready,
@@ -1069,21 +1077,21 @@ with gr.Blocks(title="AI-Powered HF Space App Builder") as ai_builder_tab:
                 inputs=[
                     user_input, chatbot, # UI component inputs (message, current chat history)
                     hf_profile, hf_token, # HF State variables
-                    gemini_key, gemini_model, # Gemini State variables
+                    # Pass gemini_key and gemini_model as inputs (their state is read here)
+                    gemini_key, gemini_model,
                     repo_id, workflow, sdk_state, # Workflow State variables
                     # UI component inputs whose *current values* are needed by the generator
-                    # These are NOT State variables with the same names
-                    iframe, run_txt, build_txt,
+                    iframe, run_txt, build_txt, # UI component inputs (current values)
                     debug_attempts, app_description, repo_name_state, generated_code_state, # Other State variables
-                    use_grounding_state # Add the new grounding state input
+                    use_grounding_state # Grounding state input
                 ],
                 outputs=[
                     chatbot, # Update Chatbot with new messages
                     repo_id, workflow, # Update workflow State variables
                     iframe, run_txt, build_txt, # Update UI component outputs
                     debug_attempts, app_description, repo_name_state, generated_code_state, # Update other State variables
-                    use_grounding_state, # Update the grounding state output (generators must yield/return all state they modify/pass through)
-                    gemini_key, gemini_model # ADDED: Explicitly yield and update Gemini states
+                    use_grounding_state # Update the grounding state output
+                    # REMOVED: gemini_key, gemini_model from outputs
                 ]
             ).success( # Chain a .success() event to run *after* the .click() handler completes without error
                  # Clear the user input textbox after the message is sent and processed
@@ -1101,15 +1109,15 @@ with gr.Blocks(title="AI-Powered HF Space App Builder") as ai_builder_tab:
         inputs=None,
         outputs=login_status # Update login status markdown
     ).then(
-        # Action 2: Configure Gemini using the initial state values (from env var if set)
-        # This uses the *initial* value of gemini_key and gemini_model state variables
+        # Action 2: Configure Gemini using the initial state values.
+        # Since gemini_key state starts as "", this will initially show a "key is not set" message.
         configure_gemini,
         inputs=[gemini_key, gemini_model],
         outputs=[gemini_status] # Update Gemini status display
     ).then(
-        # Action 3: Check prereqs and update send button interactivity based on initial states
-        # This uses the *initial* values of hf_profile, hf_token, gemini_key, and gemini_model states
-        check_send_button_ready, # Use the updated helper function
+        # Action 3: Check prereqs and update send button interactivity based on initial states.
+        # Since gemini_key state starts as "", button will initially be disabled.
+        check_send_button_ready,
         inputs=send_button_interactive_binding_inputs,
         outputs=[send_btn] # Update button interactivity using gr.update return value
     ).then(