app.py

import gradio as gr
import re
import json
import os
import tempfile
import shlex
from huggingface_hub import HfApi

from build_logic import (
    _get_api_token as build_logic_get_api_token,
    whoami as build_logic_whoami,
    list_space_files_for_browsing,
    get_space_repository_info,
    get_space_file_content,
    update_space_file,
    parse_markdown as build_logic_parse_markdown,
    delete_space_file as build_logic_delete_space_file,
    get_space_runtime_status,
    apply_staged_file_changes,
    duplicate_space as build_logic_duplicate_space,
    list_user_spaces as build_logic_list_user_spaces,
    build_logic_set_space_privacy,
    build_logic_delete_space,
    build_logic_create_pull_request,
    build_logic_add_comment,
    build_logic_like_space,
    build_logic_create_space
)

from model_logic import (
    get_available_providers,
    get_models_for_provider,
    get_default_model_for_provider,
    generate_stream
)

backtick = chr(96)
bbb = f'{backtick}{backtick}{backtick}'

parsed_code_blocks_state_cache = []
BOT_ROLE_NAME = "assistant"

DEFAULT_SYSTEM_PROMPT = f"""You are an expert AI programmer and Hugging Face assistant. Your role is to generate code and file structures based on user requests, or to modify existing code provided by the user.

You operate in the context of a Hugging Face Space. You can propose file changes and trigger specific actions.

**File and Code Formatting:**
When you provide NEW code for a file, or MODIFIED code for an existing file, use the following format exactly:
### File: path/to/filename.ext
(You can add a short, optional, parenthesized description after the filename on the SAME line)
{bbb}language
# Your full code here
{bbb}

If the file is binary, or you cannot show its content, use this format:
### File: path/to/binaryfile.ext
[Binary file - approximate_size bytes]

When you provide a project file structure, use this format (for informational purposes, not parsed for changes):
## File Structure
{bbb}
📁 Root
  📄 file1.py
  📁 subfolder
    📄 file2.js
{bbb}

**Instructions and Rules:**
- The role name for your responses in the chat history must be '{BOT_ROLE_NAME}'.
- Adhere strictly to these formatting instructions.
- If you update a file, provide the FULL file content again under the same filename.
- Only the latest version of each file mentioned throughout the chat will be used for the final output. The system will merge your changes with the prior state before applying.

**Hugging Face Space Actions:**
To perform direct actions on the Hugging Face Space, use the `### HF_ACTION: COMMAND arguments...` command on a single line.
The system will parse these actions from your response and present them to the user for confirmation before executing.

Available commands:
- `CREATE_SPACE <owner>/<repo_name> --sdk <sdk> --private <true|false>`: Creates a new, empty space. SDK can be gradio, streamlit, docker, or static. Private is optional and defaults to false. Use this ONLY when the user explicitly asks to create a *new* space with a specific name. When using this action, also provide the initial file structure (e.g., app.py, README.md) using `### File:` blocks in the same response. The system will apply these files to the new space.
- `DUPLICATE_SPACE <new_owner>/<new_repo_name> --private <true|false>`: Duplicates the *currently loaded* space to a new space. Private is optional and defaults to false. This action is destructive if the target space already exists. Use this ONLY when the user explicitly asks to duplicate the space. When using this action, also provide the initial file structure (e.g., app.py, README.md) using `### File:` blocks in the same response. The system will apply these files to the new space.
- `DELETE_FILE path/to/file.ext`: Deletes a specific file from the current space.
- `SET_PRIVATE <true|false>`: Sets the privacy for the current space.
- `DELETE_SPACE`: Deletes the entire current space. THIS IS PERMANENT AND REQUIRES CAUTION. Only use this if the user explicitly and clearly asks to delete the space.
- `CREATE_PR <target_repo_id> --title "..." --body "..."`: Creates a Pull Request from the current space's main branch to the target repository (e.g., a model or dataset repo) main branch. Requires `--title` and `--body` arguments (quoted strings).
- `ADD_COMMENT "Your comment text"`: Adds a comment to the currently loaded space. Requires a quoted string comment text.
- `LIKE_SPACE`: Likes the currently loaded space.

You can issue multiple file updates and action commands in a single response. The system will process all of them into a single change plan. Note that the `DUPLICATE_SPACE` command, if present, will override any other file or space actions in the same response. Actions other than file changes are executed sequentially before any file changes are committed.

**Current Space Context:**
You will be provided with the current state of the files in the Space the user is interacting with. Use this information to understand the current project structure and content before proposing changes or actions. This context will appear after the user's message, starting with "## Current Space Context:". Do NOT include this context in your response. Only generate your response based on the user's request and the formatting rules above.

If no code or actions are requested, respond conversationally and help the user understand the Space Commander's capabilities.
"""

def escape_html_for_markdown(text):
    if not isinstance(text, str): return ""
    return text.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")

def _infer_lang_from_filename(filename):
    if not filename: return "plaintext"
    if '.' in filename:
        ext = filename.split('.')[-1].lower()
        mapping = {
            'py': 'python', 'js': 'javascript', 'ts': 'typescript', 'jsx': 'javascript', 'tsx': 'typescript',
            'html': 'html', 'htm': 'html', 'css': 'css', 'scss': 'scss', 'sass': 'sass', 'less': 'less',
            'json': 'json', 'xml': 'xml', 'yaml': 'yaml', 'yml': 'yaml', 'toml': 'toml',
            'md': 'markdown', 'rst': 'rst',
            'sh': 'bash', 'bash': 'bash', 'zsh': 'bash', 'bat': 'batch', 'cmd': 'batch', 'ps1': 'powershell',
            'c': 'c', 'h': 'c', 'cpp': 'cpp', 'hpp': 'cpp', 'cs': 'csharp', 'java': 'java',
            'rb': 'ruby', 'php': 'php', 'go': 'go', 'rs': 'rust', 'swift': 'swift', 'kt': 'kotlin', 'kts': 'kotlin',
            'sql': 'sql', 'dockerfile': 'docker', 'tf': 'terraform', 'hcl': 'terraform',
            'txt': 'plaintext', 'log': 'plaintext', 'ini': 'ini', 'conf': 'plaintext', 'cfg': 'plaintext',
            'csv': 'plaintext', 'tsv': 'tsv', 'err': 'plaintext',
            '.env': 'plaintext', '.gitignore': 'plaintext', '.npmrc': 'plaintext', '.gitattributes': 'plaintext',
            'makefile': 'makefile',
        }
        return mapping.get(ext, "plaintext")
    base_filename = os.path.basename(filename)
    if base_filename == 'Dockerfile': return 'docker'
    if base_filename == 'Makefile': return 'makefile'
    if base_filename.startswith('.'): return 'plaintext'
    return "plaintext"

def _clean_filename(filename_line_content):
    text = filename_line_content.strip()
    text = re.sub(r'[`\*_#]+', '', text).strip()
    text = re.split(r'\s*\(', text, 1)[0].strip()
    text = text.strip('\'":;,')
    text = text.lstrip('/')
    return text

def _parse_and_update_state_cache(latest_bot_message_content, current_files_state):
    current_files_dict = {f["filename"]: f.copy() for f in current_files_state if not f.get("is_structure_block")}
    structure_block_state = next((b for b in current_files_state if b.get("is_structure_block")), None)

    content = latest_bot_message_content or ""

    file_pattern = re.compile(r"### File:\s*(?P<filename_line>[^\n]+)\n(?:```(?P<lang>[\w\.\-\+]*)\n(?P<code>[\s\S]*?)\n```|(?P<binary_msg>\[Binary file(?: - [^\]]+)?\]))", re.MULTILINE)
    structure_pattern = re.compile(r"## File Structure\n```(?:(?P<struct_lang>[\w.-]*)\n)?(?P<structure_code>[\s\S]*?)\n```", re.MULTILINE)

    structure_match = structure_pattern.search(content)
    if structure_match:
        structure_block_state = {"filename": "File Structure (from AI)", "language": structure_match.group("struct_lang") or "plaintext", "code": structure_match.group("structure_code").strip(), "is_binary": False, "is_structure_block": True}

    current_message_proposed_filenames = []
    for match in file_pattern.finditer(content):
        filename = _clean_filename(match.group("filename_line"))
        if not filename: continue

        lang, code_block, binary_msg = match.group("lang"), match.group("code"), match.group("binary_msg")

        item_data = {"filename": filename, "is_binary": False, "is_structure_block": False}

        if code_block is not None:
            item_data["code"] = code_block.strip()
            item_data["language"] = (lang.strip().lower() if lang else _infer_lang_from_filename(filename))
            item_data["is_binary"] = False
        elif binary_msg is not None:
            item_data["code"] = binary_msg.strip()
            item_data["language"] = "binary"
            item_data["is_binary"] = True
        else: continue

        current_files_dict[filename] = item_data
        current_message_proposed_filenames.append(filename)

    updated_parsed_blocks = list(current_files_dict.values())
    if structure_block_state:
        updated_parsed_blocks.insert(0, structure_block_state)

    updated_parsed_blocks.sort(key=lambda b: (0, b["filename"]) if b.get("is_structure_block") else (1, b["filename"]))

    return updated_parsed_blocks, current_message_proposed_filenames

def _export_selected_logic(selected_filenames, space_line_name_for_md, parsed_blocks_for_export):
    results = {"output_str": "", "error_message": None, "download_filepath": None}
    file_blocks_for_export = [b for b in parsed_blocks_for_export if not b.get("is_structure_block")]
    all_filenames_in_state = sorted(list(set(b["filename"] for b in file_blocks_for_export)))

    output_lines = [f"# Space: {space_line_name_for_md}"]

    structure_block = next((b for b in parsed_blocks_for_export if b.get("is_structure_block")), None)
    if structure_block:
        output_lines.extend(["## File Structure", bbb, structure_block["code"].strip(), bbb, ""])
    else:
        output_lines.extend(["## File Structure", bbb, "📁 Root"])
        if all_filenames_in_state:
            for fname in all_filenames_in_state: output_lines.append(f"  📄 {fname}")
        output_lines.extend([bbb, ""])

    output_lines.append("Below are the contents of all files in the space:\n")

    blocks_to_export_content = sorted([b for b in file_blocks_for_export if not selected_filenames or b["filename"] in selected_filenames], key=lambda b: b["filename"])

    exported_content_count = 0
    for block in blocks_to_export_content:
        output_lines.append(f"### File: {block['filename']}")
        content = block.get('code', '')
        if block.get('is_binary') or content.startswith(("[Binary file", "[Error loading content:", "[Binary or Skipped file]")):
             output_lines.append(content)
        else:
            lang = block.get('language', 'plaintext') or 'plaintext'
            output_lines.extend([f"{bbb}{lang}", content, bbb])
        output_lines.append("")
        exported_content_count += 1

    if not exported_content_count:
        if selected_filenames: output_lines.append("*No selected files have editable content in the state.*")
        elif not all_filenames_in_state: output_lines.append("*No files in state to list structure or export.*")


    final_output_str = "\n".join(output_lines)
    results["output_str"] = final_output_str
    try:
        with tempfile.NamedTemporaryFile(mode="w", delete=False, suffix=".md", encoding='utf-8') as tmpfile:
            tmpfile.write(final_output_str); results["download_filepath"] = tmpfile.name
    except Exception as e:
        print(f"Error creating temp file for download: {e}")
        results["error_message"] = "Could not prepare file for download."
        results["download_filepath"] = None

    return results

def _convert_gr_history_to_api_messages(system_prompt, gr_history, current_user_message=None):
    messages = [{"role": "system", "content": system_prompt}] if system_prompt else []
    for user_msg, bot_msg in gr_history:
        if user_msg: messages.append({"role": "user", "content": user_msg})
        if bot_msg and isinstance(bot_msg, str): messages.append({"role": BOT_ROLE_NAME, "content": bot_msg})
    if current_user_message: messages.append({"role": "user", "content": current_user_message})
    return messages

def _generate_ui_outputs_from_cache(owner, space_name):
    global parsed_code_blocks_state_cache
    preview_md_val = "*No files in cache to display.*"
    space_line_name = f"{owner}/{space_name}" if owner and space_name else (owner or space_name or "your-space")
    export_result = _export_selected_logic(None, space_line_name, parsed_code_blocks_state_cache)
    formatted_md_val = export_result["output_str"]
    download_file = export_result["download_filepath"]
    formatted_md_val = formatted_md_val or "*Load or define a Space to see its Markdown structure.*"

    if parsed_code_blocks_state_cache:
        preview_md_lines = ["## Detected/Updated Files & Content (Latest Versions):"]
        file_blocks_in_cache = sorted([b for b in parsed_code_blocks_state_cache if not b.get("is_structure_block")], key=lambda b: b["filename"])
        structure_block_in_cache = next((b for b in parsed_code_blocks_state_cache if b.get("is_structure_block")), None)

        if structure_block_in_cache:
             preview_md_lines.append(f"\n----\n**File Structure:** (from AI)\n{bbb}\n{escape_html_for_markdown(structure_block_in_cache['code'].strip())}\n{bbb}\n")

        if file_blocks_in_cache:
            for block in file_blocks_in_cache:
                preview_md_lines.append(f"\n----\n**File:** `{escape_html_for_markdown(block['filename'])}`")
                if block.get('is_binary'): preview_md_lines.append(f" (Binary File or Skipped)\n")
                else: preview_md_lines.append(f" (Language: `{block['language']}`)\n")

                content = block.get('code', '')
                if block.get('is_binary') or content.startswith(("[Binary file", "[Error loading content:", "[Binary or Skipped file]")):
                     preview_md_lines.append(f"\n`{escape_html_for_markdown(content.strip())}`\n")
                else:
                     lang = block.get('language', 'plaintext') or 'plaintext'
                     preview_md_lines.append(f"\n{bbb}{lang}\n{content.strip()}\n{bbb}\n")
        preview_md_val = "\n".join(preview_md_lines)

    return formatted_md_val, preview_md_val, gr.update(value=download_file, interactive=download_file is not None)

def generate_and_stage_changes(ai_response_content, current_files_state, hf_owner_name, hf_repo_name):
    changeset = []
    current_files_dict = {f["filename"]: f for f in current_files_state if not f.get("is_structure_block")}
    ai_parsed_md = build_logic_parse_markdown(ai_response_content)
    ai_proposed_files_list = ai_parsed_md.get("files", [])
    ai_proposed_files_dict = {f["path"]: f for f in ai_proposed_files_list}

    action_pattern = re.compile(r"### HF_ACTION:\s*(?P<command_line>[^\n]+)", re.MULTILINE)
    potential_actions = []
    for match in action_pattern.finditer(ai_response_content):
        try:
            cmd_parts = shlex.split(match.group("command_line").strip())
            if not cmd_parts: continue
            command, args = cmd_parts[0].upper(), cmd_parts[1:]
            potential_actions.append({"command": command, "args": args, "raw_line": match.group("command_line").strip()})
        except Exception as e:
             print(f"Error parsing HF_ACTION line '{match.group('command_line').strip()}': {e}")


    duplicate_action = next((act for act in potential_actions if act["command"] == "DUPLICATE_SPACE"), None)

    if duplicate_action:
        cmd_parts = duplicate_action["args"]
        if cmd_parts:
            target_repo_id = cmd_parts[0]
            private = False
            if '--private' in cmd_parts:
                try: private_str = cmd_parts[cmd_parts.index('--private') + 1].lower()
                except IndexError: print("Warning: DUPLICATE_SPACE --private requires an argument.")
                else: private = private_str == 'true'
            source_repo_id = f"{hf_owner_name}/{hf_repo_name}" if hf_owner_name and hf_repo_name else None

            if source_repo_id:
                changeset.append({
                    "type": "DUPLICATE_SPACE",
                    "source_repo_id": source_repo_id,
                    "target_repo_id": target_repo_id,
                    "private": private
                })
                print(f"Staged exclusive DUPLICATE_SPACE action from {source_repo_id} to {target_repo_id}")
            else:
                 print(f"Warning: Cannot stage DUPLICATE_SPACE action, no Space currently loaded.")
                 changeset.append({"type": "Error", "message": "Cannot duplicate space, no Space currently loaded."})
        else:
            print(f"Warning: DUPLICATE_SPACE action requires a target repo_id.")
            changeset.append({"type": "Error", "message": "DUPLICATE_SPACE action requires a target repo_id (<new_owner>/<new_repo_name>)."})

        if changeset:
            md_summary = ["### 📋 Proposed Changes Plan (Exclusive Action)\n"]
            if changeset[0]["type"] == "DUPLICATE_SPACE":
                change = changeset[0]
                md_summary.append(f"- **📂 Duplicate Space:** Duplicate `{change.get('source_repo_id', '...')}` to `{change.get('target_repo_id', '...')}` (Private: {change.get('private', False)})")
                md_summary.append("\n**Warning:** This will overwrite the target space if it exists. No other file or space actions proposed by the AI in this turn will be applied.")
            else:
                 md_summary.append(f"- **Error staging DUPLICATE_SPACE:** {changeset[0].get('message', 'Unknown error')}")
                 md_summary.append("\nNo changes were staged due to the error in the DUPLICATE_SPACE command.")
                 changeset = []

            return changeset, "\n".join(md_summary)

    for action in potential_actions:
         command, args = action["command"], action["args"]

         if command == "CREATE_SPACE" and args:
             repo_id = args[0]
             sdk = "gradio"
             private = False
             if '--sdk' in args:
                 try: sdk = args[args.index('--sdk') + 1]
                 except IndexError: print("Warning: CREATE_SPACE --sdk requires an argument.")
             if '--private' in args:
                  try: private_str = args[args.index('--private') + 1].lower()
                  except IndexError: print("Warning: CREATE_SPACE --private requires an argument.")
                  else: private = private_str == 'true'
             changeset.append({"type": "CREATE_SPACE", "repo_id": repo_id, "sdk": sdk, "private": private})
             print(f"Staged CREATE_SPACE action for {repo_id}")

         elif command == "DELETE_FILE" and args:
             file_path = args[0]
             changeset.append({"type": "DELETE_FILE", "path": file_path})
             print(f"Staged DELETE_FILE action for {file_path}")

         elif command == "SET_PRIVATE" and args:
             private = args[0].lower() == 'true'
             changeset.append({"type": "SET_PRIVACY", "private": private, "repo_id": f"{hf_owner_name}/{hf_repo_name}"})
             print(f"Staged SET_PRIVACY action for {hf_owner_name}/{hf_repo_name} to {private}")

         elif command == "DELETE_SPACE":
             changeset.append({"type": "DELETE_SPACE", "owner": hf_owner_name, "space_name": hf_repo_name})
             print(f"Staged DELETE_SPACE action for {hf_owner_name}/{hf_repo_name}")

         elif command == "CREATE_PR" and args:
             target_repo_id = None
             title = ""
             body = ""
             try:
                 target_repo_id = args[0]
                 arg_string = shlex.join(args[1:])

                 title_match = re.search(r'--title\s+"([^"]*)"', arg_string)
                 if title_match: title = title_match.group(1)
                 else: print("Warning: CREATE_PR missing --title argument.")

                 body_match = re.search(r'--body\s+"([^"]*)"', arg_string)
                 if body_match: body = body_match.group(1)
                 else: print("Warning: CREATE_PR missing --body argument.")

                 if target_repo_id and title:
                     changeset.append({"type": "CREATE_PR", "source_repo_id": f"{hf_owner_name}/{hf_repo_name}", "target_repo_id": target_repo_id, "title": title, "body": body})
                     print(f"Staged CREATE_PR action to {target_repo_id}")
                 else:
                      # Changed from appending error to changeset to just printing error
                      # Action staging errors shouldn't block file changes if any were proposed
                      print("Warning: CREATE_PR requires target_repo_id and --title.")
             except Exception as e:
                 print(f"Error parsing CREATE_PR arguments: {e}")
                 # Changed from appending error to changeset to just printing error

         elif command == "ADD_COMMENT" and args:
             comment_text = None
             try:
                 comment_string = shlex.join(args)
                 comment_match = re.match(r'^"([^"]*)"$', comment_string)
                 if comment_match: comment_text = comment_match.group(1)
                 else:
                      comment_text = " ".join(args)
                      print(f"Warning: ADD_COMMENT argument was not a single quoted string, using raw args: '{comment_text}'")

                 if comment_text:
                     changeset.append({"type": "ADD_COMMENT", "repo_id": f"{hf_owner_name}/{hf_repo_name}", "comment": comment_text})
                     print(f"Staged ADD_COMMENT action on {hf_owner_name}/{hf_repo_name}")
                 else:
                      # Changed from appending error to changeset to just printing error
                      print("Warning: ADD_COMMENT requires comment text.")

             except Exception as e:
                 print(f"Error parsing ADD_COMMENT arguments: {e}")
                 # Changed from appending error to changeset to just printing error


         elif command == "LIKE_SPACE":
             if hf_owner_name and hf_repo_name:
                 changeset.append({"type": "LIKE_SPACE", "repo_id": f"{hf_owner_name}/{hf_repo_name}"})
                 print(f"Staged LIKE_SPACE action on {hf_owner_name}/{hf_repo_name}")
             else:
                 print(f"Warning: Cannot stage LIKE_SPACE action, no Space currently loaded.")
                 changeset.append({"type": "Error", "message": "Cannot like space, no Space currently loaded."})

    # Process file changes only if not an exclusive duplicate action
    if not duplicate_action:
        for file_info in ai_proposed_files_list:
            filename = file_info["path"]
            proposed_content = file_info["content"]

            if filename in current_files_dict:
                current_content = current_files_dict[filename].get("code", "")
                is_proposed_placeholder = proposed_content.startswith(("[Binary file", "[Error loading content:", "[Binary or Skipped file]"))

                if not is_proposed_placeholder and proposed_content != current_content:
                    lang = current_files_dict[filename].get("language") or _infer_lang_from_filename(filename)
                    changeset.append({"type": "UPDATE_FILE", "path": filename, "content": proposed_content, "lang": lang})
                elif is_proposed_placeholder:
                     print(f"Skipping staging update for {filename}: Proposed content is a placeholder.")

            else:
                # Creating a new file
                proposed_content = file_info["content"]
                if not (proposed_content.startswith("[Binary file") or proposed_content.startswith("[Error loading content:") or proposed_content.startswith("[Binary or Skipped file]")):
                    lang = _infer_lang_from_filename(filename)
                    changeset.append({"type": "CREATE_FILE", "path": filename, "content": proposed_content, "lang": lang})
                else:
                     print(f"Skipping staging create for {filename}: Proposed content is a placeholder.")


    if not changeset:
        md_summary = ["### 📋 Proposed Changes Plan", "\nThe AI did not propose any specific changes to files or the space.\n"]
    else:
        md_summary = ["### 📋 Proposed Changes Plan\n"]
        md_summary.append("The AI has proposed the following changes. Please review and confirm.")

        file_changes = [c for c in changeset if c['type'] in ['CREATE_FILE', 'UPDATE_FILE', 'DELETE_FILE']]
        space_actions = [c for c in changeset if c['type'] not in ['CREATE_FILE', 'UPDATE_FILE', 'DELETE_FILE']]

        if space_actions:
             md_summary.append("\n**Space Actions:**")
             for change in space_actions:
                 if change["type"] == "CREATE_SPACE":
                     md_summary.append(f"- **🚀 Create New Space:** `{change.get('repo_id', '...')}` (SDK: {change.get('sdk', 'gradio')}, Private: {change.get('private', False)})")
                 elif change["type"] == "DUPLICATE_SPACE":
                      md_summary.append(f"- **📂 Duplicate Space:** From `{change.get('source_repo_id', '...')}` to `{change.get('target_repo_id', '...')}` (Private: {change.get('private', False)})")
                 elif change["type"] == "SET_PRIVACY":
                     md_summary.append(f"- **🔒 Set Privacy:** Set `{change.get('repo_id', '...')}` to `private={change.get('private', False)}`")
                 elif change["type"] == "DELETE_SPACE":
                     md_summary.append(f"- **💥 DELETE ENTIRE SPACE:** `{change.get('owner', '...')}/{change.get('space_name', '...')}` **(DESTRUCTIVE ACTION)**")
                 elif change["type"] == "CREATE_PR":
                     md_summary.append(f"- **🤝 Create Pull Request:** From `{change.get('source_repo_id', '...')}` to `{change.get('target_repo_id', '...')}`")
                     md_summary.append(f"  - Title: `{change.get('title', '...')}`")
                     if change.get('body'): md_summary.append(f"  - Body: `{change.get('body', '...')[:100]}{'...' if len(change.get('comment', '')) > 100 else ''}`")
                 elif change["type"] == "ADD_COMMENT":
                      md_summary.append(f"- **💬 Add Comment:** On `{change.get('repo_id', '...')}`")
                      md_summary.append(f"  - Comment: `{change.get('comment', '...')[:100]}{'...' if len(change.get('comment', '')) > 100 else ''}`")
                 elif change["type"] == "LIKE_SPACE":
                      md_summary.append(f"- **👍 Like Space:** `{change.get('repo_id', '...')}`")
                 elif change["type"] == "Error":
                      md_summary.append(f"- **❌ Staging Error:** {change.get('message', 'Unknown error')}")

             md_summary.append("")

        if file_changes:
             md_summary.append("**File Changes:**")
             for change in file_changes:
                 if change["type"] == "CREATE_FILE":
                     md_summary.append(f"- **➕ Create File:** `{change['path']}`")
                 elif change["type"] == "UPDATE_FILE":
                     md_summary.append(f"- **🔄 Update File:** `{change['path']}`")
                 elif change["type"] == "DELETE_FILE":
                     md_summary.append(f"- **➖ Delete File:** `{change['path']}`")

    return changeset, "\n".join(md_summary)


def handle_chat_submit(user_message, chat_history, hf_api_key_input, provider_api_key_input, provider_select, model_select, system_prompt, hf_owner_name, hf_repo_name):
    global parsed_code_blocks_state_cache
    _chat_msg_in = user_message
    _chat_hist = list(chat_history)
    _chat_hist.append((user_message, None))

    # Yield initial state to show thinking and clear UI elements
    # Need to match the 11 chat_outputs
    yield (
        "", # chat_message_input
        _chat_hist, # chatbot_display
        "Thinking...", # status_output
        gr.update(), # detected_files_preview
        gr.update(), # formatted_space_output_display
        gr.update(interactive=False), # download_button
        [], # changeset_state (clear old changes)
        gr.update(value="*Processing AI response...*"), # changeset_display
        gr.update(visible=False), # confirm_accordion
        gr.update(visible=False), # confirm_button
        gr.update(visible=False) # cancel_button
    )

    current_sys_prompt = system_prompt.strip() or DEFAULT_SYSTEM_PROMPT
    space_id_for_context = f"{hf_owner_name}/{hf_repo_name}" if hf_owner_name and hf_repo_name else "your-space"
    export_result = _export_selected_logic(None, space_id_for_context, parsed_code_blocks_state_cache)
    current_files_context_md = export_result['output_str'] or "*No files currently loaded or defined.*"
    current_files_context = f"\n\n## Current Space Context: {space_id_for_context}\n{current_files_context_md}"

    user_message_with_context = user_message.strip() + current_files_context
    api_msgs = _convert_gr_history_to_api_messages(current_sys_prompt, _chat_hist[:-1], user_message_with_context)

    full_bot_response_content = ""
    try:
        streamer = generate_stream(provider_select, model_select, provider_api_key_input, api_msgs)
        for chunk in streamer:
            if chunk is None: continue
            full_bot_response_content += str(chunk)
            _chat_hist[-1] = (user_message, full_bot_response_content)
            # Yield during streaming
            yield (
                gr.update(), # chat_message_input (keep empty)
                _chat_hist, # chatbot_display (update chat history)
                f"Streaming from {model_select}...", # status_output
                gr.update(), # detected_files_preview (no update during stream)
                gr.update(), # formatted_space_output_display (no update during stream)
                gr.update(), # download_button (no update during stream)
                gr.update(), # changeset_state (no update during stream)
                gr.update(value=f"*Processing AI response...*\n\n{full_bot_response_content[-200:]}..."), # changeset_display (show partial AI output)
                gr.update(visible=False), gr.update(visible=False), gr.update(visible=False) # confirm buttons hidden
            )

        if full_bot_response_content.startswith("Error:") or full_bot_response_content.startswith("API HTTP Error"):
            _status = full_bot_response_content
            _chat_hist[-1] = (user_message, _status) # Update chat with full error
            yield (
                 gr.update(), _chat_hist, _status,
                 gr.update(), gr.update(), gr.update(),
                 [], "*Error occurred, changes plan cleared.*", # Clear staged changes on error
                 gr.update(visible=False), gr.update(visible=False), gr.update(visible=False)
            )
            return

        parsed_code_blocks_state_cache, proposed_filenames_in_turn = _parse_and_update_state_cache(full_bot_response_content, parsed_code_blocks_state_cache)

        _formatted, _detected, _download_update = _generate_ui_outputs_from_cache(hf_owner_name, hf_repo_name)

        staged_changeset, summary_md = generate_and_stage_changes(full_bot_response_content, parsed_code_blocks_state_cache, hf_owner_name, hf_repo_name)

        _chat_hist[-1] = (user_message, full_bot_response_content) # Final update to chat history with full response

        if not staged_changeset:
            _status = "AI finished. No changes proposed."
            yield (
                gr.update(), # chat_message_input
                _chat_hist, # chatbot_display
                _status, # status_output
                gr.update(value=_detected), # detected_files_preview
                gr.update(value=_formatted), # formatted_space_output_display
                _download_update, # download_button
                [], # changeset_state (explicitly clear if no changes were staged)
                gr.update(value="*No changes proposed.*"), # changeset_display
                gr.update(visible=False), # confirm_accordion
                gr.update(visible=False), # confirm_button
                gr.update(visible=False) # cancel_button
            )
        else:
            _status = "AI finished. Change plan generated. Please review and confirm below."
            yield (
                gr.update(), # chat_message_input
                _chat_hist, # chatbot_display
                _status, # status_output
                gr.update(value=_detected), # detected_files_preview
                gr.update(value=_formatted), # formatted_space_output_display
                _download_update, # download_button
                staged_changeset, # changeset_state
                gr.update(value=summary_md), # changeset_display
                gr.update(visible=True), # confirm_accordion
                gr.update(visible=True), # confirm_button
                gr.update(visible=True) # cancel_button
            )

    except Exception as e:
        error_msg = f"An unexpected error occurred during chat submission: {type(e).__name__}: {e}"
        print(f"Error in handle_chat_submit: {e}")
        import traceback
        traceback.print_exc()
        # Ensure chat history is updated with error message
        if _chat_hist and _chat_hist[-1][0] == user_message:
             current_bot_response = _chat_hist[-1][1] or ""
             _chat_hist[-1] = (user_message, (current_bot_response + "\n\n" if current_bot_response else "") + error_msg)
        else:
             _chat_hist.append((user_message, error_msg))


        # Generate final UI state on error
        _formatted, _detected, _download_update = _generate_ui_outputs_from_cache(hf_owner_name, hf_repo_name)

        yield (
            gr.update(), # chat_message_input
            _chat_hist, # chatbot_display
            error_msg, # status_output
            gr.update(value=_detected), # detected_files_preview
            gr.update(value=_formatted), # formatted_space_output_display
            _download_update, # download_button
            [], # changeset_state (clear staged changes)
            gr.update(value="*Error occurred, changes plan cleared.*"), # changeset_display
            gr.update(visible=False), # confirm_accordion
            gr.update(visible=False), # confirm_button
            gr.update(visible=False) # cancel_button
        )


def handle_confirm_changes(hf_api_key, owner_name, space_name, changeset):
    global parsed_code_blocks_state_cache

    # Outputs for confirm_button.click (14 outputs)
    # [status_output, formatted_space_output_display, detected_files_preview, download_button,
    # confirm_accordion, confirm_button, cancel_button, changeset_state, changeset_display,
    # owner_name_input, space_name_input, file_browser_dropdown, space_iframe_display, space_runtime_status_display]

    _status = "Applying changes..."
    # Initial yield: Show loading, hide confirm UI, clear changeset display
    yield (
        gr.update(value=_status), # status_output
        gr.update(), # formatted_space_output_display
        gr.update(), # detected_files_preview
        gr.update(interactive=False), # download_button
        gr.update(visible=False), # confirm_accordion
        gr.update(visible=False), # confirm_button
        gr.update(visible=False), # cancel_button
        [], # changeset_state (clear staged changes immediately)
        gr.update(value="*Applying changes...*"), # changeset_display
        gr.update(), # owner_name_input
        gr.update(), # space_name_input
        gr.update(), # file_browser_dropdown
        gr.update(), # space_iframe_display
        gr.update(value="*Applying changes...*") # space_runtime_status_display
    )

    if not changeset:
        # This case should be prevented by hiding the button, but handle defensively
        yield (
            gr.update(value="No changes to apply."), # status_output
            gr.update(), gr.update(), gr.update(), # Keep displays as they were
            gr.update(visible=False), gr.update(visible=False), gr.update(visible=False), # Hide confirm UI
            [], # Clear changeset state
            gr.update(value="*No changes were staged.*"), # Clear changeset display
            gr.update(), gr.update(), gr.update(), gr.update(), gr.update() # Keep others as they were
        )
        return

    first_action = changeset[0] if changeset else None
    is_exclusive_duplicate = first_action and first_action.get('type') == 'DUPLICATE_SPACE'
    is_exclusive_delete = first_action and first_action.get('type') == 'DELETE_SPACE'

    final_overall_status = "Changes applied."
    reload_error = None

    if is_exclusive_duplicate:
        change = first_action
        if change.get("source_repo_id") and change.get("target_repo_id"):
            status_message = build_logic_duplicate_space(
                hf_api_key=hf_api_key,
                source_repo_id=change["source_repo_id"],
                target_repo_id=change["target_repo_id"],
                private=change.get("private", False)
            )
            final_overall_status = status_message

            target_repo_id = change['target_repo_id']
            new_owner, new_space_name = target_repo_id.split('/', 1) if '/' in target_repo_id else (None, target_repo_id)

            if not new_owner:
                 token, token_err = build_logic_get_api_token(hf_api_key)
                 if token_err:
                     print(f"Error getting token for new owner determination: {token_err}")
                     new_owner = None
                 else:
                    try: user_info = build_logic_whoami(token=token); new_owner = user_info.get('name')
                    except Exception as e:
                         print(f"Error auto-detecting owner from token for new space: {e}")
                         new_owner = None

            # Yield status update before reloading
            yield (
                 gr.update(value=f"{final_overall_status} | Attempting to load the new Space [{target_repo_id}]..."), # status_output
                 gr.update(), gr.update(), gr.update(), # Keep displays as they are
                 gr.update(visible=False), gr.update(visible=False), gr.update(visible=False), # Hide confirm UI
                 [], # Clear changeset state
                 gr.update(value="*Reloading new space state...*"), # Clear changeset display
                 gr.update(value=new_owner), gr.update(value=new_space_name), # Update owner/space fields
                 gr.update(), gr.update(), gr.update() # Keep others as they are (will be updated after reload)
            )

            if new_owner and new_space_name:
                sdk, file_list, err_list = get_space_repository_info(hf_api_key, new_space_name, new_owner)
                if err_list:
                    reload_error = f"Error reloading file list after duplication: {err_list}"
                    parsed_code_blocks_state_cache = []
                    file_browser_update = gr.update(visible=False, choices=[], value=None)
                    iframe_update = gr.update(value=None, visible=False)
                else:
                    loaded_files = []
                    for file_path in file_list:
                        content, err_get = get_space_file_content(hf_api_key, new_space_name, new_owner, file_path)
                        lang = _infer_lang_from_filename(file_path)
                        is_binary = lang == "binary" or (err_get is not None)
                        code = f"[Error loading content: {err_get}]" if err_get else (content or "")
                        loaded_files.append({"filename": file_path, "code": code, "language": lang, "is_binary": is_binary, "is_structure_block": False})
                    parsed_code_blocks_state_cache = loaded_files

                    file_browser_update = gr.update(visible=True, choices=sorted([f["filename"] for f in parsed_code_blocks_state_cache if not f.get("is_structure_block")] or []), value=None)

                    if new_owner and new_space_name:
                         sub_owner = re.sub(r'[^a-z0-9\-]+', '-', new_owner.lower()).strip('-') or 'owner'
                         sub_repo = re.sub(r'[^a-z0-9\-]+', '-', new_space_name.lower()).strip('-') or 'space'
                         iframe_url = f"https://{sub_owner}-{sub_repo}{'.static.hf.space' if sdk == 'static' else '.hf.space'}"
                         iframe_update = gr.update(value=f'<iframe src="{iframe_url}?__theme=light&embed=true" width="100%" height="500px"></iframe>', visible=True)
                    else:
                         iframe_update = gr.update(value=None, visible=False)

                runtime_status_md = handle_refresh_space_status(hf_api_key, new_owner, new_space_name)
                runtime_status_update = gr.update(value=runtime_status_md)


            else:
                 reload_error = "Cannot load new Space state: Owner or Space Name missing after duplication."
                 parsed_code_blocks_state_cache = [] # Clear cache if reload fails
                 file_browser_update = gr.update(visible=False, choices=[], value=None)
                 iframe_update = gr.update(value=None, visible=False)
                 runtime_status_update = gr.update(value="*Runtime status unavailable after duplication reload failure.*")


            _formatted, _detected, _download = _generate_ui_outputs_from_cache(new_owner, new_space_name)
            final_overall_status_with_reload = final_overall_status + (f" | Reload Status: {reload_error}" if reload_error else f" | Reload Status: New Space [{new_owner}/{new_space_name}] state refreshed.")

            yield (
                 gr.update(value=final_overall_status_with_reload), # status_output
                 gr.update(value=_formatted), # formatted_space_output_display
                 gr.update(value=_detected), # detected_files_preview
                 _download, # download_button
                 gr.update(visible=False), gr.update(visible=False), gr.update(visible=False), # Hide confirm UI
                 [], # changeset_state
                 gr.update(value="*No changes proposed.*"), # changeset_display
                 gr.update(value=new_owner), gr.update(value=new_space_name), # Update owner/space fields
                 file_browser_update, iframe_update, runtime_status_update # Update file browser, iframe, status
            )


        else:
             final_overall_status = "Duplicate Action Error: Invalid duplicate changeset format."
             _formatted, _detected, _download = _generate_ui_outputs_from_cache(owner_name, space_name) # Stay on original space state
             runtime_status_md = handle_refresh_space_status(hf_api_key, owner_name, space_name)
             yield (
                 gr.update(value=final_overall_status), # status_output
                 gr.update(value=_formatted), gr.update(value=_detected), _download, # Keep current space display
                 gr.update(visible=False), gr.update(visible=False), gr.update(visible=False), # Hide confirm UI
                 [], gr.update(value="*No changes proposed.*"), # Clear changeset
                 gr.update(), gr.update(), gr.update(), gr.update(), gr.update(value=runtime_status_md) # Keep other fields
             )

    elif is_exclusive_delete:
         change = first_action
         delete_owner = change.get('owner') or owner_name
         delete_space = change.get('space_name') or space_name
         delete_repo_id_target = f"{delete_owner}/{delete_space}" if delete_owner and delete_space else None
         current_repo_id = f"{owner_name}/{space_name}" if owner_name and space_name else None

         if not delete_repo_id_target or delete_repo_id_target != current_repo_id:
             final_overall_status = f"DELETE_SPACE Error: Action blocked. Cannot delete '{delete_repo_id_target}'. Only deletion of the currently loaded space ('{current_repo_id}') is permitted via AI action."
             print(f"Blocked DELETE_SPACE action via confirm: requested '{delete_repo_id_target}', current '{current_repo_id}'.")
             # Stay on the current space state if deletion is blocked
             _formatted, _detected, _download = _generate_ui_outputs_from_cache(owner_name, space_name)
             runtime_status_update = handle_refresh_space_status(hf_api_key, owner_name, space_name)
             owner_update = gr.update()
             space_update = gr.update()
             file_browser_update = gr.update()
             iframe_update = gr.update()
         else:
             status_message = build_logic_delete_space(hf_api_key, delete_owner, delete_space)
             final_overall_status = status_message
             if "Successfully" in status_message:
                  parsed_code_blocks_state_cache = [] # Clear cache on successful delete
                  _formatted, _detected, _download = _generate_ui_outputs_from_cache(None, None) # Clear UI displays
                  owner_update = gr.update(value="")
                  space_update = gr.update(value="")
                  file_browser_update = gr.update(visible=False, choices=[], value=None)
                  iframe_update = gr.update(value=None, visible=False)
                  runtime_status_update = gr.update(value="*Space deleted, runtime status unavailable.*")
             else:
                  # Stay on the current space state if deletion fails
                  _formatted, _detected, _download = _generate_ui_outputs_from_cache(owner_name, space_name)
                  owner_update = gr.update()
                  space_update = gr.update()
                  file_browser_update = gr.update()
                  iframe_update = gr.update()
                  runtime_status_update = handle_refresh_space_status(hf_api_key, owner_name, space_name)


         yield (
             gr.update(value=final_overall_status), # status_output
             gr.update(value=_formatted), gr.update(value=_detected), _download, # Update displays based on success/failure
             gr.update(visible=False), gr.update(visible=False), gr.update(visible=False), # Hide confirm UI
             [], gr.update(value="*No changes proposed.*"), # Clear changeset
             owner_update, space_update, file_browser_update, iframe_update, runtime_status_update # Update fields based on success/failure
         )


    else: # Non-exclusive actions (combination of space actions and file changes)
        action_status_messages = []
        file_change_operations = []
        errors_occurred = False

        for change in changeset:
            try:
                # Execute space actions first
                if change['type'] == 'CREATE_SPACE':
                    repo_id_to_create = change.get('repo_id')
                    if repo_id_to_create:
                         # Note: manual create space function takes markdown. AI generated changes don't provide markdown directly for create space action.
                         # We'll rely on subsequent file operations in the changeset for content.
                         # For now, just create the empty repo or ensure it exists.
                         msg = build_logic_create_space(hf_api_key, repo_id_to_create.split('/')[1], repo_id_to_create.split('/')[0] if '/' in repo_id_to_create else None, change.get('sdk', 'gradio'), "", change.get('private', False))
                         action_status_messages.append(f"CREATE_SPACE: {msg}")
                    else:
                         msg = "CREATE_SPACE Error: Target repo_id not specified."
                         action_status_messages.append(msg)
                         errors_occurred = True

                elif change['type'] == 'SET_PRIVACY':
                     repo_id_to_set_privacy = change.get('repo_id') or f"{owner_name}/{space_name}"
                     if repo_id_to_set_privacy and owner_name and space_name: # Only allow setting privacy on the currently loaded space via AI action
                         msg = build_logic_set_space_privacy(hf_api_key, repo_id_to_set_privacy, change['private'])
                         action_status_messages.append(f"SET_PRIVACY: {msg}")
                     else:
                         msg = "SET_PRIVACY Error: Cannot set privacy, no Space currently loaded."
                         action_status_messages.append(msg)
                         errors_occurred = True # Treat failure to apply action as error

                elif change['type'] == 'CREATE_PR':
                     source_repo = f"{owner_name}/{space_name}" if owner_name and space_name else None
                     if source_repo and change.get('target_repo_id') and change.get('title'):
                          msg = build_logic_create_pull_request(hf_api_key, source_repo, change['target_repo_id'], change['title'], change.get('body', ''))
                          action_status_messages.append(f"CREATE_PR: {msg}")
                     else:
                          msg = "CREATE_PR Error: Source/Target repo, title, or body missing or no Space loaded."
                          action_status_messages.append(msg)
                          errors_occurred = True

                elif change['type'] == 'ADD_COMMENT':
                     repo_id_to_comment = change.get('repo_id') or f"{owner_name}/{space_name}"
                     if repo_id_to_comment and owner_name and space_name and change.get('comment'): # Only allow adding comment on currently loaded space
                          msg = build_logic_add_comment(hf_api_key, repo_id_to_comment, change['comment'])
                          action_status_messages.append(f"ADD_COMMENT: {msg}")
                     else:
                          msg = "ADD_COMMENT Error: Cannot add comment, no Space loaded or comment text missing."
                          action_status_messages.append(msg)
                          errors_occurred = True

                elif change['type'] == 'LIKE_SPACE':
                     repo_id_to_like = change.get('repo_id') or f"{owner_name}/{space_name}"
                     if repo_id_to_like and owner_name and space_name: # Only allow liking currently loaded space
                          msg = build_logic_like_space(hf_api_key, repo_id_to_like)
                          action_status_messages.append(f"LIKE_SPACE: {msg}")
                     else:
                          msg = "LIKE_SPACE Error: Cannot like space, no Space currently loaded."
                          action_status_messages.append(msg)
                          errors_occurred = True

                elif change['type'] == 'Error':
                     msg = f"Staging Error: {change.get('message', 'Unknown error')}"
                     action_status_messages.append(msg)
                     errors_occurred = True # Treat staging error as execution error

                elif change['type'] in ['CREATE_FILE', 'UPDATE_FILE', 'DELETE_FILE']:
                    file_change_operations.append(change)

            except Exception as e:
                 msg = f"Error processing action {change.get('type', 'Unknown')}: {e}"
                 action_status_messages.append(msg)
                 print(f"Error processing action {change.get('type', 'Unknown')}: {e}")
                 import traceback
                 traceback.print_exc()
                 errors_occurred = True


        file_commit_status = ""
        if file_change_operations:
             if owner_name and space_name:
                  file_commit_status = apply_staged_file_changes(hf_api_key, owner_name, space_name, file_change_operations)
                  if "Error" in file_commit_status: errors_occurred = True
             else:
                  file_commit_status = "File Commit Error: Cannot commit file changes, no Space currently loaded."
                  errors_occurred = True
        else:
             file_commit_status = "No file changes (create/update/delete) to commit."


        final_overall_status = " | ".join(action_status_messages)
        if file_commit_status and file_commit_status != "No file changes (create/update/delete) to commit.":
            if final_overall_status: final_overall_status += " | "
            final_overall_status += file_commit_status
        if not final_overall_status: final_overall_status = "No operations were applied."

        _status_reload = f"{final_overall_status} | Reloading Space state..."
        # Yield status update before reloading
        yield (
             gr.update(value=_status_reload), # status_output
             gr.update(), gr.update(), gr.update(), # Keep displays as they are
             gr.update(visible=False), gr.update(visible=False), gr.update(visible=False), # Hide confirm UI
             [], # Clear changeset state
             gr.update(value="*Reloading space state...*"), # Clear changeset display
             gr.update(), gr.update(), gr.update(), gr.update(), gr.update() # Keep others as they are (will be updated after reload)
        )


        # Reload Space state regardless of errors, to show current state
        refreshed_file_list = []
        repo_id_for_reload = f"{owner_name}/{space_name}" if owner_name and space_name else None

        if repo_id_for_reload:
            sdk, file_list, err_list = get_space_repository_info(hf_api_key, space_name, owner_name)
            if err_list:
                reload_error = f"Error reloading file list after changes: {err_list}"
                parsed_code_blocks_state_cache = []
                file_browser_update = gr.update(visible=False, choices=[], value=None)
                iframe_update = gr.update(value=None, visible=False)
            else:
                refreshed_file_list = file_list
                loaded_files = []
                for file_path in refreshed_file_list:
                    content, err_get = get_space_file_content(hf_api_key, space_name, owner_name, file_path)
                    lang = _infer_lang_from_filename(file_path)
                    is_binary = lang == "binary" or (err_get is not None)
                    code = f"[Error loading content: {err_get}]" if err_get else (content or "")
                    loaded_files.append({"filename": file_path, "code": code, "language": lang, "is_binary": is_binary, "is_structure_block": False})
                parsed_code_blocks_state_cache = loaded_files

                file_browser_update = gr.update(visible=True, choices=sorted(refreshed_file_list or []), value=None)

                iframe_update = gr.update(value=None, visible=False) # Default to hidden
                if owner_name and space_name:
                     sub_owner = re.sub(r'[^a-z0-9\-]+', '-', owner_name.lower()).strip('-') or 'owner'
                     sub_repo = re.sub(r'[^a-z0-9\-]+', '-', space_name.lower()).strip('-') or 'space'
                     iframe_url = f"https://{sub_owner}-{sub_repo}{'.static.hf.space' if sdk == 'static' else '.hf.space'}"
                     iframe_update = gr.update(value=f'<iframe src="{iframe_url}?__theme=light&embed=true" width="100%" height="500px"></iframe>', visible=True)


            runtime_status_md = handle_refresh_space_status(hf_api_key, owner_name, space_name)
            runtime_status_update = gr.update(value=runtime_status_md)


        else:
            reload_error = "Cannot reload Space state: Owner or Space Name missing."
            parsed_code_blocks_state_cache = [] # Clear cache if reload fails
            file_browser_update = gr.update(visible=False, choices=[], value=None)
            iframe_update = gr.update(value=None, visible=False)
            runtime_status_update = gr.update(value="*Runtime status unavailable after reload failure.*")


        _formatted, _detected, _download = _generate_ui_outputs_from_cache(owner_name, space_name)

        final_overall_status_with_reload = final_overall_status + (f" | Reload Status: {reload_error}" if reload_error else " | Reload Status: Space state refreshed.")
        if errors_occurred: final_overall_status_with_reload = "Errors occurred during application: " + final_overall_status_with_reload

        yield (
            gr.update(value=final_overall_status_with_reload), # status_output
            gr.update(value=_formatted), # formatted_space_output_display
            gr.update(value=_detected), # detected_files_preview
            _download, # download_button
            gr.update(visible=False), gr.update(visible=False), gr.update(visible=False), # Hide confirm UI
            [], gr.update(value="*No changes proposed.*"), # Clear changeset
            gr.update(), gr.update(), file_browser_update, iframe_update, runtime_status_update # Update fields
        )


def handle_cancel_changes():
    global parsed_code_blocks_state_cache
    # Outputs for cancel_button.click (6 outputs)
    # [status_output, changeset_state, changeset_display, confirm_accordion, confirm_button, cancel_button]
    return (
        gr.update(value="Changes cancelled."), # status_output
        [], # changeset_state
        gr.update(value="*No changes proposed.*"), # changeset_display
        gr.update(visible=False), # confirm_accordion
        gr.update(visible=False), # confirm_button
        gr.update(visible=False) # cancel_button
    )


def update_models_dropdown(provider_select):
    if not provider_select: return gr.update(choices=[], value=None)
    models = get_models_for_provider(provider_select)
    default_model = get_default_model_for_provider(provider_select)
    selected_value = default_model if default_model in models else (models[0] if models else None)
    return gr.update(choices=models, value=selected_value)

def handle_detect_user(hf_api_key_ui, ui_owner_name_hint):
    # Outputs for detect_user_button.click (3 outputs)
    # [status_output, owner_name_input, list_spaces_display]

    _status = "Detecting user from token..."
    # Yield initial state to show loading status and clear potentially outdated owner/spaces list
    yield gr.update(value=_status), gr.update(value=""), gr.update(value="*Listing spaces...*")

    token, token_err = build_logic_get_api_token(hf_api_key_ui)
    if token_err:
        _status = f"Detection Error: {token_err}"
        yield gr.update(value=_status), gr.update(), gr.update(value="*Could not list spaces due to token error.*")
        return

    try:
        user_info = build_logic_whoami(token=token)
        owner_name = user_info.get('name')
        if not owner_name: raise Exception("Could not find user name from token.")
        _status = f"User detected: {owner_name}"
        owner_update = gr.update(value=owner_name)

        # Immediately trigger listing spaces using the detected owner
        # Assuming build_logic_list_user_spaces returns (list_of_space_names, error_string)
        spaces_list, list_err = build_logic_list_user_spaces(hf_api_key=token, owner=owner_name) # Pass token directly

        if list_err:
            list_spaces_update = gr.update(value=f"List Spaces Error: {list_err}")
            _status += f" | List Spaces Error: {list_err}"
        else:
            # Format the list of spaces into a markdown string here
            if not spaces_list:
                 list_spaces_md = f"*No spaces found for user/org `{owner_name}`.*"
            else:
                 list_spaces_md = f"### Spaces for `{owner_name}`\n"
                 for space in sorted(spaces_list):
                     list_spaces_md += f"- `{space}`\n"

            list_spaces_update = gr.update(value=list_spaces_md) # Pass the formatted markdown string

        yield gr.update(value=_status), owner_update, list_spaces_update

    except Exception as e:
        _status = f"Detection Error: Could not detect user from token: {e}"
        print(f"Error in handle_detect_user: {e}")
        import traceback
        traceback.print_exc()
        yield gr.update(value=_status), gr.update(), gr.update(value="*Could not list spaces due to user detection error.*")


def handle_load_existing_space(hf_api_key_ui, ui_owner_name, ui_space_name):
    global parsed_code_blocks_state_cache
    # Outputs for load_space_button.click (20 outputs)
    # [formatted_space_output_display, detected_files_preview, status_output, file_browser_dropdown,
    # owner_name_input, space_name_input, space_iframe_display, download_button, build_status_display,
    # edit_status_display, space_runtime_status_display, changeset_state, changeset_display, confirm_accordion,
    # confirm_button, cancel_button, list_spaces_display, target_owner_input, target_space_name_input, target_private_checkbox]

    _formatted_md_val, _detected_preview_val, _status_val = "*Loading files...*", "*Loading files...*", f"Loading Space: {ui_owner_name}/{ui_space_name}..."
    _file_browser_update, _iframe_html_update, _download_btn_update = gr.update(visible=False, choices=[], value=None), gr.update(value=None, visible=False), gr.update(interactive=False, value=None)
    _build_status_clear, _edit_status_clear, _runtime_status_clear = "*Manual build status...*", "*Select a file...*", "*Runtime/Repo status will appear here.*"
    _changeset_clear = []
    _changeset_summary_clear = "*No changes proposed.*"
    _confirm_ui_hidden = gr.update(visible=False)
    _list_spaces_display_clear = gr.update() # Don't clear list spaces display on load, it's controlled by its own button
    _target_owner_clear, _target_space_clear, _target_private_clear = gr.update(value=""), gr.update(value=""), gr.update(value=False)

    # Initial yield to show loading state
    yield (
        gr.update(value=_formatted_md_val), # formatted_space_output_display
        gr.update(value=_detected_preview_val), # detected_files_preview
        gr.update(value=_status_val), # status_output
        _file_browser_update, # file_browser_dropdown
        gr.update(value=ui_owner_name), # owner_name_input (show requested owner)
        gr.update(value=ui_space_name), # space_name_input (show requested space)
        _iframe_html_update, # space_iframe_display
        _download_btn_update, # download_button
        gr.update(value=_build_status_clear), # build_status_display
        gr.update(value=_edit_status_clear), # edit_status_display
        gr.update(value=_runtime_status_clear), # space_runtime_status_display
        _changeset_clear, # changeset_state (clear changes from previous space)
        gr.update(value=_changeset_summary_clear), # changeset_display (clear changes from previous space)
        _confirm_ui_hidden, _confirm_ui_hidden, _confirm_ui_hidden, # Hide confirm UI
        _list_spaces_display_clear, # list_spaces_display
        _target_owner_clear, # target_owner_input (clear target fields)
        _target_space_clear, # target_space_name_input (clear target fields)
        _target_private_clear # target_private_checkbox (clear target fields)
    )

    owner_to_use = ui_owner_name
    token, token_err = build_logic_get_api_token(hf_api_key_ui)
    if token_err:
        _status_val = f"Load Error: {token_err}"
        yield ( # Yield 20 elements
             gr.update(), gr.update(), gr.update(value=_status_val), gr.update(),
             gr.update(), gr.update(), gr.update(), gr.update(), gr.update(),
             gr.update(), gr.update(), gr.update(), gr.update(), gr.update(),
             gr.update(), gr.update(), gr.update(), gr.update(), gr.update(),
             gr.update()
        )
        return
    if not owner_to_use:
        try:
            user_info = build_logic_whoami(token=token)
            owner_to_use = user_info.get('name')
            if not owner_to_use: raise Exception("Could not find user name from token.")
            # Yield update for auto-detected owner
            yield ( # Yield 20 elements
                 gr.update(), gr.update(), gr.update(value=f"Loading Space: {owner_to_use}/{ui_space_name} (Auto-detected owner)..."), gr.update(),
                 gr.update(value=owner_to_use), gr.update(), gr.update(), gr.update(), gr.update(),
                 gr.update(), gr.update(), gr.update(), gr.update(), gr.update(),
                 gr.update(), gr.update(), gr.update(), gr.update(), gr.update(),
                 gr.update()
            )
        except Exception as e:
            _status_val = f"Load Error: Error auto-detecting owner: {e}"
            yield ( # Yield 20 elements
                 gr.update(), gr.update(), gr.update(value=_status_val), gr.update(),
                 gr.update(), gr.update(), gr.update(), gr.update(), gr.update(),
                 gr.update(), gr.update(), gr.update(), gr.update(), gr.update(),
                 gr.update(), gr.update(), gr.update(), gr.update(), gr.update(),
                 gr.update()
            )
            return

    if not owner_to_use or not ui_space_name:
        _status_val = "Load Error: Owner and Space Name are required."
        yield ( # Yield 20 elements
             gr.update(), gr.update(), gr.update(value=_status_val), gr.update(),
             gr.update(), gr.update(), gr.update(), gr.update(), gr.update(),
             gr.update(), gr.update(), gr.update(), gr.update(), gr.update(),
             gr.update(), gr.update(), gr.update(), gr.update(), gr.update(),
             gr.update()
        )
        return

    sdk, file_list, err = get_space_repository_info(hf_api_key_ui, ui_space_name, owner_to_use)

    if err:
        _status_val = f"Load Error: {err}"
        parsed_code_blocks_state_cache = []
        _formatted, _detected, _download = _generate_ui_outputs_from_cache(owner_to_use, ui_space_name)
        yield ( # Yield 20 elements
            gr.update(value=_formatted), # formatted_space_output_display
            gr.update(value=_detected), # detected_files_preview
            gr.update(value=_status_val), # status_output
            gr.update(visible=False, choices=[], value=None), # file_browser_dropdown
            gr.update(value=owner_to_use), gr.update(value=ui_space_name), # Keep owner/space fields
            gr.update(value=None, visible=False), # space_iframe_display
            _download, # download_button
            gr.update(), gr.update(), gr.update(value="*Runtime/Repo status unavailable after load error.*"), # Keep other status fields, clear runtime status
            [], gr.update(value="*No changes proposed.*"), gr.update(visible=False), gr.update(visible=False), gr.update(visible=False), # Clear changeset and hide confirm UI
            gr.update(), gr.update(), gr.update(), gr.update() # Keep other fields
        )
        return

    loaded_files = []
    for file_path in file_list:
        content, err_get = get_space_file_content(hf_api_key_ui, ui_space_name, owner_to_use, file_path)
        lang = _infer_lang_from_filename(file_path)
        is_binary = lang == "binary" or (err_get is not None)
        code = f"[Error loading content: {err_get}]" if err_get else (content or "")
        loaded_files.append({"filename": file_path, "code": code, "language": lang, "is_binary": is_binary, "is_structure_block": False})

    parsed_code_blocks_state_cache = loaded_files

    _formatted, _detected, _download = _generate_ui_outputs_from_cache(owner_to_use, ui_space_name)
    _status_val = f"Successfully loaded {len(file_list)} files from {owner_to_use}/{ui_space_name}. SDK: {sdk or 'unknown'}."

    file_browser_update = gr.update(visible=True, choices=sorted(file_list or []), value=None)

    iframe_update = gr.update(value=None, visible=False) # Default to hidden
    if owner_to_use and ui_space_name:
        sub_owner = re.sub(r'[^a-z0-9\-]+', '-', owner_to_use.lower()).strip('-') or 'owner'
        sub_repo = re.sub(r'[^a-z0-9\-]+', '-', ui_space_name.lower()).strip('-') or 'space'
        iframe_url = f"https://{sub_owner}-{sub_repo}{'.static.hf.space' if sdk == 'static' else '.hf.space'}"
        iframe_update = gr.update(value=f'<iframe src="{iframe_url}?__theme=light&embed=true" width="100%" height="500px"></iframe>', visible=True)


    runtime_status_md = handle_refresh_space_status(hf_api_key_ui, owner_to_use, ui_space_name)
    runtime_status_update = gr.update(value=runtime_status_md)


    yield ( # Final yield with 20 elements
        gr.update(value=_formatted), # formatted_space_output_display
        gr.update(value=_detected), # detected_files_preview
        gr.update(value=_status_val), # status_output
        file_browser_update, # file_browser_dropdown
        gr.update(value=owner_to_use), gr.update(value=ui_space_name), # Ensure fields are set in case of auto-detection
        iframe_update, # space_iframe_display
        _download, # download_button
        gr.update(), gr.update(), runtime_status_update, # Keep other status fields
        [], gr.update(value="*No changes proposed.*"), gr.update(visible=False), gr.update(visible=False), gr.update(visible=False), # Clear changeset and hide confirm UI
        gr.update(), gr.update(value=""), gr.update(value=""), gr.update(value=False) # Reset target fields and list spaces display (no update)
    )

def handle_build_space_button(hf_api_key_ui, ui_space_name_part, ui_owner_name_part, space_sdk_ui, is_private_ui, formatted_markdown_content):
    global parsed_code_blocks_state_cache
    # Outputs for build_space_button.click (14 outputs)
    # [build_status_display, space_iframe_display, file_browser_dropdown, owner_name_input, space_name_input,
    # changeset_state, changeset_display, confirm_accordion, confirm_button, cancel_button,
    # formatted_space_output_display, detected_files_preview, download_button, space_runtime_status_display]

    _build_status = "Starting manual space build process..."
    _iframe_html, _file_browser_update = gr.update(value=None, visible=False), gr.update(visible=False, choices=[], value=None)
    _changeset_clear = []
    _changeset_summary_clear = "*Manual build initiated, changes plan cleared.*"
    _confirm_ui_hidden = gr.update(visible=False)
    _formatted_md = formatted_markdown_content # Keep the source markdown
    _detected_preview = "*Loading files after build...*" # Placeholder during build

    # Initial yield: Show loading state
    yield (
        gr.update(value=_build_status), # build_status_display
        _iframe_html, # space_iframe_display
        _file_browser_update, # file_browser_dropdown
        gr.update(value=ui_owner_name_part), # owner_name_input
        gr.update(value=ui_space_name_part), # space_name_input
        _changeset_clear, # changeset_state (clear changes)
        gr.update(value=_changeset_summary_clear), # changeset_display (clear changes)
        _confirm_ui_hidden, _confirm_ui_hidden, _confirm_ui_hidden, # Hide confirm UI
        gr.update(value=_formatted_md), # formatted_space_output_display (keep markdown)
        gr.update(value=_detected_preview), # detected_files_preview (placeholder)
        gr.update(interactive=False), # download_button (disable during build)
        gr.update(value="*Building space, runtime status updating...*") # space_runtime_status_display
    )


    if not ui_space_name_part or "/" in ui_space_name_part:
        _build_status = f"Build Error: Invalid Space Name '{ui_space_name_part}'. Should not contain '/'."
        yield ( # Yield 14 elements
            gr.update(value=_build_status), gr.update(), gr.update(), gr.update(), gr.update(),
            gr.update(), gr.update(), gr.update(), gr.update(), gr.update(),
            gr.update(), gr.update(), gr.update(), gr.update()
        )
        return

    owner_to_use = ui_owner_name_part
    space_to_use = ui_space_name_part
    repo_id_target = f"{owner_to_use}/{space_to_use}" if owner_to_use else space_to_use # Handle case where owner is not specified

    token, token_err = build_logic_get_api_token(hf_api_key_ui)
    if token_err:
         _build_status = f"Build Error: API Token Error: {token_err}"
         yield ( # Yield 14 elements
            gr.update(value=_build_status), gr.update(), gr.update(), gr.update(), gr.update(),
            gr.update(), gr.update(), gr.update(), gr.update(), gr.update(),
            gr.update(), gr.update(), gr.update(), gr.update()
         )
         return

    # Auto-detect owner if not specified
    if not owner_to_use:
         try:
             user_info = build_logic_whoami(token=token)
             owner_to_use = user_info.get('name')
             repo_id_target = f"{owner_to_use}/{space_to_use}"
             if not owner_to_use: raise Exception("Could not find user name from token.")
             # Yield update for auto-detected owner
             yield ( # Yield 14 elements
                gr.update(), gr.update(), gr.update(), gr.update(value=owner_to_use), gr.update(),
                gr.update(), gr.update(), gr.update(), gr.update(), gr.update(),
                gr.update(), gr.update(), gr.update(), gr.update()
             )
         except Exception as e:
              _build_status = f"Build Error: Error auto-detecting owner: {e}"
              yield ( # Yield 14 elements
                 gr.update(value=_build_status), gr.update(), gr.update(), gr.update(), gr.update(),
                 gr.update(), gr.update(), gr.update(), gr.update(), gr.update(),
                 gr.update(), gr.update(), gr.update(), gr.update()
              )
              return

    api = HfApi(token=token)
    build_status_messages = []
    errors_occurred = False

    # Step 1: Create the space or ensure it exists
    try:
        api.create_repo(repo_id=repo_id_target, repo_type="space", space_sdk=space_sdk_ui, private=is_private_ui, exist_ok=True)
        build_status_messages.append(f"CREATE_SPACE: Successfully created or ensured space [{repo_id_target}](https://huggingface.co/spaces/{repo_id_target}) exists.")
    except Exception as e:
         msg = f"CREATE_SPACE Error: {e}"
         build_status_messages.append(msg)
         errors_occurred = True
         _build_status = f"Build Error: {msg}. Cannot proceed with file upload."; yield ( gr.update(value=_build_status), gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update() ); return

    _build_status = " | ".join(build_status_messages)
    yield ( gr.update(value=_build_status), gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update() )


    # Step 2: Apply file changes parsed from markdown
    parsed_content = build_logic_parse_markdown(formatted_markdown_content)
    proposed_files_list = parsed_content.get("files", [])
    file_changes_only_changeset = [{"type": "CREATE_FILE", "path": f["path"], "content": f["content"], "lang": _infer_lang_from_filename(f["path"])} for f in proposed_files_list]

    if file_changes_only_changeset:
        file_commit_status = apply_staged_file_changes(hf_api_key_ui, owner_to_use, space_to_use, file_changes_only_changeset)
        build_status_messages.append(file_commit_status)
        if "Error" in file_commit_status: errors_occurred = True
    else:
         build_status_messages.append("No files parsed from markdown to upload/update.")

    _build_status = " | ".join(build_status_messages)
    yield ( gr.update(value=_build_status), gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update() )


    # Step 3: Reload the space state after building
    _build_status_reload = f"{_build_status} | Reloading Space state..."
    yield ( gr.update(value=_build_status_reload), gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update(value="*Reloading after build...*") )


    sdk_built, file_list, err_list = get_space_repository_info(hf_api_key_ui, space_to_use, owner_to_use)

    if err_list:
        reload_error = f"Error reloading file list after build: {err_list}"
        parsed_code_blocks_state_cache = []
        _file_browser_update = gr.update(visible=False, choices=[], value=None)
        _iframe_html_update = gr.update(value=None, visible=False)
    else:
        loaded_files = []
        for file_path in file_list:
             content, err_get = get_space_file_content(hf_api_key_ui, space_to_use, owner_to_use, file_path)
             lang = _infer_lang_from_filename(file_path)
             is_binary = lang == "binary" or (err_get is not None)
             code = f"[Error loading content: {err_get}]" if err_get else (content or "")
             loaded_files.append({"filename": file_path, "code": code, "language": lang, "is_binary": is_binary, "is_structure_block": False})
        parsed_code_blocks_state_cache = loaded_files

        _file_browser_update = gr.update(visible=True, choices=sorted(file_list or []), value=None)

        _iframe_html_update = gr.update(value=None, visible=False) # Default to hidden
        if owner_to_use and space_to_use:
            sub_owner = re.sub(r'[^a-z0-9\-]+', '-', owner_to_use.lower()).strip('-') or 'owner'
            sub_repo = re.sub(r'[^a-z0-9\-]+', '-', space_to_use.lower()).strip('-') or 'space'
            iframe_url = f"https://{sub_owner}-{sub_repo}{'.static.hf.space' if sdk_built == 'static' else '.hf.space'}"
            _iframe_html_update = gr.update(value=f'<iframe src="{iframe_url}?__theme=light&embed=true" width="100%" height="700px"></iframe>', visible=True)


    runtime_status_md = handle_refresh_space_status(hf_api_key_ui, owner_to_use, space_to_use)
    runtime_status_update = gr.update(value=runtime_status_md)


    _build_status_final = _build_status + (f" | Reload Status: {reload_error}" if reload_error else " | Reload Status: Space state refreshed.")
    if errors_occurred: _build_status_final = "Errors occurred during build: " + _build_status_final


    _formatted, _detected, _download = _generate_ui_outputs_from_cache(owner_to_use, space_to_use)

    yield ( # Final yield with 14 elements
        gr.update(value=_build_status_final), # build_status_display
        _iframe_html_update, # space_iframe_display
        _file_browser_update, # file_browser_dropdown
        gr.update(value=owner_to_use), gr.update(value=space_to_use), # Ensure fields are set
        [], gr.update(value="*No changes proposed.*"), gr.update(visible=False), gr.update(visible=False), gr.update(visible=False), # Clear changeset and hide confirm UI
        gr.update(value=_formatted), gr.update(value=_detected), _download, runtime_status_update # Update displays
    )


def handle_load_file_for_editing(hf_api_key_ui, ui_space_name_part, ui_owner_name_part, selected_file_path):
    # Outputs for file_browser_dropdown.change (3 outputs) - Corrected list
    # [file_content_editor, edit_status_display, commit_message_input]

    if not selected_file_path:
        # Return gr.update() for all outputs to clear/reset them
        return (
            gr.update(value="", language="plaintext"), # file_content_editor
            gr.update(value="Select a file."), # edit_status_display
            gr.update(value="") # commit_message_input
        )

    content, err = get_space_file_content(hf_api_key_ui, ui_space_name_part, ui_owner_name_part, selected_file_path)
    if err:
        return (
            gr.update(value=f"[Error loading content: {err}]", language="plaintext"), # file_content_editor
            gr.update(value=f"Load Error: {err}"), # edit_status_display
            gr.update(value="") # commit_message_input
        )

    lang = _infer_lang_from_filename(selected_file_path)
    commit_msg = f"Update {selected_file_path}"
    return (
        gr.update(value=content or "", language=lang), # file_content_editor (ensure value is not None)
        gr.update(value=f"Loaded `{selected_file_path}`"), # edit_status_display
        gr.update(value=commit_msg) # commit_message_input
    )

def handle_commit_file_changes(hf_api_key_ui, ui_space_name_part, ui_owner_name_part, file_to_edit_path, edited_content, commit_message):
    # Outputs for update_file_button.click (5 outputs)
    # [edit_status_display, file_browser_dropdown, formatted_space_output_display, detected_files_preview, download_button]

    if not ui_owner_name_part or not ui_space_name_part:
         return "Commit Error: Cannot commit changes. Please load a space first.", gr.update(), gr.update(), gr.update(), gr.update()
    if not file_to_edit_path:
         return "Commit Error: No file selected for commit.", gr.update(), gr.update(), gr.update(), gr.update()

    status_msg = update_space_file(hf_api_key_ui, ui_space_name_part, ui_owner_name_part, file_to_edit_path, edited_content, commit_message)

    global parsed_code_blocks_state_cache
    file_browser_update = gr.update()
    if "Successfully" in status_msg:
        found = False
        for block in parsed_code_blocks_state_cache:
            if block["filename"] == file_to_edit_path and not block.get("is_structure_block"):
                block["code"] = edited_content
                block["language"] = _infer_lang_from_filename(file_to_edit_path)
                block["is_binary"] = False
                found = True
                break
        if not found:
             # If the file was newly created via manual edit (not AI)
             parsed_code_blocks_state_cache.append({
                 "filename": file_to_edit_path,
                 "code": edited_content,
                 "language": _infer_lang_from_filename(file_to_edit_path),
                 "is_binary": False,
                 "is_structure_block": False
             })
             parsed_code_blocks_state_cache.sort(key=lambda b: (0, b["filename"]) if b.get("is_structure_block") else (1, b["filename"]))

        # Refresh the file browser choices to include the new/updated file if necessary
        file_list, _ = list_space_files_for_browsing(hf_api_key_ui, ui_space_name_part, ui_owner_name_part)
        file_browser_update = gr.update(choices=sorted(file_list or []))

    _formatted, _detected, _download = _generate_ui_outputs_from_cache(ui_owner_name_part, ui_space_name_part)
    return status_msg, file_browser_update, gr.update(value=_formatted), gr.update(value=_detected), _download

def handle_delete_file(hf_api_key_ui, ui_space_name_part, ui_owner_name_part, file_to_delete_path):
    # Outputs for delete_file_button.click (7 outputs) - Corrected list
    # [edit_status_display, file_browser_dropdown, file_content_editor, commit_message_input,
    # formatted_space_output_display, detected_files_preview, download_button]

    if not ui_owner_name_part or not ui_space_name_part:
         return "Delete Error: Cannot delete file. Please load a space first.", gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update()
    if not file_to_delete_path:
        return "Delete Error: No file selected to delete.", gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update()

    status_msg = build_logic_delete_space_file(hf_api_key_ui, ui_space_name_part, ui_owner_name_part, file_to_delete_path)

    global parsed_code_blocks_state_cache
    file_browser_update = gr.update()
    file_content_editor_update = gr.update()
    commit_message_update = gr.update()

    if "Successfully" in status_msg:
        # Remove the deleted file from the cache
        parsed_code_blocks_state_cache = [b for b in parsed_code_blocks_state_cache if b["filename"] != file_to_delete_path]
        # Clear editor fields as the file is gone
        file_content_editor_update = gr.update(value="", language="plaintext") # Also reset language
        commit_message_update = gr.update(value="")
        # Refresh the file browser choices
        file_list, _ = list_space_files_for_browsing(hf_api_key_ui, ui_space_name_part, ui_owner_name_part)
        file_browser_update = gr.update(choices=sorted(file_list or []), value=None) # Reset selected value

    _formatted, _detected, _download = _generate_ui_outputs_from_cache(ui_owner_name_part, ui_space_name_part)
    return (
        status_msg, # edit_status_display
        file_browser_update, # file_browser_dropdown
        file_content_editor_update, # file_content_editor
        commit_message_update, # commit_message_input
        gr.update(value=_formatted), # formatted_space_output_display
        gr.update(value=_detected), # detected_files_preview
        _download # download_button
    )


def handle_refresh_space_status(hf_api_key_ui, ui_owner_name, ui_space_name):
    if not ui_owner_name or not ui_space_name:
        return "**Status Error:** Owner and Space Name must be provided to get status."

    status_details, err = get_space_runtime_status(hf_api_key_ui, ui_space_name, ui_owner_name)
    repo_info = None
    repo_info_err = None

    # Get repo info regardless of runtime status error
    sdk = None
    file_list = None
    sdk, file_list, repo_info_err = get_space_repository_info(hf_api_key_ui, ui_space_name, ui_owner_name)
    if not repo_info_err:
         repo_info = {"sdk": sdk, "file_count": len(file_list) if file_list is not None else 'N/A'}


    md_lines = []
    md_lines.append(f"### Status for {ui_owner_name}/{ui_space_name}\n")

    if err:
        md_lines.append(f"- **Runtime Status Error:** {err}\n")
    elif not status_details:
        md_lines.append("*Could not retrieve runtime status details.*\n")
    else:
        md_lines.append(f"- **Stage:** `{status_details.get('stage', 'N/A')}`\n")
        md_lines.append(f"- **Status:** `{status_details.get('status', 'N/A')}`\n")
        md_lines.append(f"- **Hardware:** `{status_details.get('hardware', 'N/A')}`\n")
        requested_hw = status_details.get('requested_hardware')
        if requested_hw: md_lines.append(f"- **Requested Hardware:** `{requested_hw}`\n")
        error_msg = status_details.get('error_message')
        if error_msg: md_lines.append(f"- **Error:** `{escape_html_for_markdown(error_msg)}`\n")
        log_link = status_details.get('full_log_link')
        if log_link and log_link != "#": md_lines.append(f"- [View Full Logs]({log_link})\n")
        # Add build logs link if available (common pattern in Space status)
        if ui_owner_name and ui_space_name:
             build_logs_url = f"https://huggingface.co/spaces/{ui_owner_name}/{ui_space_name}/build-logs"
             md_lines.append(f"- [View Build Logs]({build_logs_url})\n")


    md_lines.append("---")
    md_lines.append("### Repository Info\n")
    if repo_info_err:
         md_lines.append(f"- **Repo Info Error:** {repo_info_err}\n")
    elif repo_info:
         md_lines.append(f"- **SDK:** `{repo_info.get('sdk', 'N/A')}`\n")
         md_lines.append(f"- **File Count:** `{repo_info.get('file_count', 'N/A')}`\n")
         if ui_owner_name and ui_space_name: # Add repo link
             repo_url = f"https://huggingface.co/spaces/{ui_owner_name}/{ui_space_name}/tree/main"
             md_lines.append(f"- [View Repository Files]({repo_url})\n")

    else:
         md_lines.append("*Could not retrieve repository info.*")


    return "\n".join(md_lines)

def handle_list_spaces(hf_api_key_ui, ui_owner_name):
    # Outputs for list_spaces_button.click (1 output)
    # [list_spaces_display]
    token, token_err = build_logic_get_api_token(hf_api_key_ui)
    if token_err:
        return f"**List Spaces Error:** {token_err}"

    owner_to_list = ui_owner_name
    if not owner_to_list:
        try:
            user_info = build_logic_whoami(token=token)
            owner_to_list = user_info.get('name')
            if not owner_to_list: raise Exception("Could not find user name from token.")
        except Exception as e:
             return f"**List Spaces Error:** Error auto-detecting owner: {e}. Please specify Owner field."

    if not owner_to_list:
         return "**List Spaces Error:** Owner could not be determined. Please specify it in the Owner field."

    spaces_list, err = build_logic_list_user_spaces(hf_api_key=token, owner=owner_to_list) # Pass token directly

    if err:
        return f"**List Spaces Error:** {err}"

    if not spaces_list:
        return f"*No spaces found for user/org `{owner_to_list}`.*"

    md = f"### Spaces for `{owner_to_list}`\n"
    for space in sorted(spaces_list):
        md += f"- `{space}`\n"

    return md

def handle_manual_duplicate_space(hf_api_key_ui, source_owner, source_space_name, target_owner, target_space_name, target_private):
    # Outputs for duplicate_space_button.click (9 outputs)
    # [status_output, owner_name_input, space_name_input,
    # formatted_space_output_display, detected_files_preview, download_button,
    # file_browser_dropdown, space_iframe_display, space_runtime_status_display]

    global parsed_code_blocks_state_cache

    if not source_owner or not source_space_name:
        return "Duplicate Error: Please load a Space first to duplicate.", gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update()
    if not target_owner or not target_space_name:
        return "Duplicate Error: Target Owner and Target Space Name are required.", gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update()
    if "/" in target_space_name:
         return "Duplicate Error: Target Space Name should not contain '/'. Use Target Owner field for the owner part.", gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update()

    source_repo_id = f"{source_owner}/{source_space_name}"
    target_repo_id = f"{target_owner}/{target_space_name}"

    status_msg = f"Attempting to duplicate `{source_repo_id}` to `{target_repo_id}`..."
    # Initial yield
    yield (
        gr.update(value=status_msg), # status_output
        gr.update(), gr.update(), # Keep owner/space fields
        gr.update(), gr.update(), gr.update(interactive=False), # Keep file displays, disable download
        gr.update(visible=False, choices=[], value=None), gr.update(value=None, visible=False), # Clear file browser and iframe
        gr.update(value="*Duplicating space...*") # Clear runtime status
    )


    result_message = build_logic_duplicate_space(hf_api_key_ui, source_repo_id, target_repo_id, target_private)
    status_msg = f"Duplication Result: {result_message}"
    errors_occurred = "Error" in status_msg or "Failed" in status_msg


    # Yield status update before attempting reload
    _status_reload = f"{status_msg} | Attempting to load the new Space [{target_repo_id}]..."
    yield (
        gr.update(value=_status_reload), # status_output
        gr.update(value=target_owner), gr.update(value=target_space_name), # Update fields to new space
        gr.update(), gr.update(), gr.update(), gr.update(), gr.update(), gr.update(value="*Reloading new space...*") # Keep displays, clear runtime status
    )

    # Attempt to load the new space state regardless of duplication success, to show current state
    new_owner = target_owner
    new_space_name = target_space_name
    reload_error = None
    sdk = None

    if not errors_occurred: # Only attempt reload if duplication was successful
        sdk, file_list, err_list = get_space_repository_info(hf_api_key_ui, new_space_name, new_owner)

        if err_list:
            reload_error = f"Error reloading file list after duplication: {err_list}"
            parsed_code_blocks_state_cache = [] # Clear cache if reload fails
            _file_browser_update = gr.update(visible=False, choices=[], value=None)
            _iframe_html_update = gr.update(value=None, visible=False)
        else:
            loaded_files = []
            for file_path in file_list:
                content, err_get = get_space_file_content(hf_api_key_ui, new_space_name, new_owner, file_path)
                lang = _infer_lang_from_filename(file_path)
                is_binary = lang == "binary" or (err_get is not None)
                code = f"[Error loading content: {err_get}]" if err_get else (content or "")
                loaded_files.append({"filename": file_path, "code": code, "language": lang, "is_binary": is_binary, "is_structure_block": False})
            parsed_code_blocks_state_cache = loaded_files

            _file_browser_update = gr.update(visible=True, choices=sorted([f["filename"] for f in parsed_code_blocks_state_cache if not f.get("is_structure_block")] or []), value=None)
            _iframe_html_update = gr.update(value=None, visible=False) # Default to hidden
            if new_owner and new_space_name:
                 sub_owner = re.sub(r'[^a-z0-9\-]+', '-', new_owner.lower()).strip('-') or 'owner'
                 sub_repo = re.sub(r'[^a-z0-9\-]+', '-', new_space_name.lower()).strip('-') or 'space'
                 iframe_url = f"https://{sub_owner}-{sub_repo}{'.static.hf.space' if sdk == 'static' else '.hf.space'}"
                 _iframe_html_update = gr.update(value=f'<iframe src="{iframe_url}?__theme=light&embed=true" width="100%" height="500px"></iframe>', visible=True)

        runtime_status_md = handle_refresh_space_status(hf_api_key_ui, new_owner, new_space_name)
        runtime_status_update = gr.update(value=runtime_status_md)

    else: # If duplication had errors, don't attempt reload of new space, stay on current
        reload_error = "Reload skipped due to duplication errors."
        # Need to re-generate _formatted, _detected, _download based on source space if errors occurred
        _formatted, _detected, _download = _generate_ui_outputs_from_cache(source_owner, source_space_name)
        _file_browser_update = gr.update() # Keep current file browser state
        _iframe_html_update = gr.update() # Keep current iframe state
        runtime_status_update = handle_refresh_space_status(hf_api_key_ui, source_owner, source_space_name) # Refresh status of source space
        new_owner = source_owner # Revert fields to source space
        new_space_name = source_space_name


    # Generate final UI based on successful/failed reload
    if not errors_occurred:
        _formatted, _detected, _download = _generate_ui_outputs_from_cache(new_owner, new_space_name)

    final_overall_status_with_reload = status_msg + (f" | Reload Status: {reload_error}" if reload_error else f" | Reload Status: Space state refreshed ({new_owner}/{new_space_name}).")
    if errors_occurred: final_overall_status_with_reload = "Errors occurred during duplication: " + final_overall_status_with_reload

    yield ( # Final yield with 9 elements
        gr.update(value=final_overall_status_with_reload), # status_output
        gr.update(value=new_owner), gr.update(value=new_space_name), # Update owner/space fields
        gr.update(value=_formatted), gr.update(value=_detected), _download, # Update file displays
        _file_browser_update, _iframe_html_update, runtime_status_update # Update browser, iframe, status
    )


custom_theme = gr.themes.Base(primary_hue="teal", secondary_hue="purple", neutral_hue="zinc", text_size="sm", spacing_size="md", radius_size="sm", font=["System UI", "sans-serif"])
custom_css = """
body { background: linear-gradient(to bottom right, #2c3e50, #34495e); color: #ecf0f1; }
.gradio-container { background: transparent !important; }
.gr-box, .gr-panel, .gr-pill { background-color: rgba(44, 62, 80, 0.8) !important; border-color: rgba(189, 195, 199, 0.2) !important; }
.gr-textbox, .gr-dropdown, .gr-button, .gr-code, .gr-chat-message { border-color: rgba(189, 195, 199, 0.3) !important; background-color: rgba(52, 73, 94, 0.9) !important; color: #ecf0f1 !important; }
.gr-button.gr-button-primary { background-color: #1abc9c !important; color: white !important; border-color: #16a085 !important; }
.gr-button.gr-button-secondary { background-color: #9b59b6 !important; color: white !important; border-color: #8e44ad !important; }
.gr-button.gr-button-stop { background-color: #e74c3c !important; color: white !important; border-color: #c0392b !important; }
.gr-markdown { background-color: rgba(44, 62, 80, 0.7) !important; padding: 10px; border-radius: 5px; overflow-x: auto; }
.gr-markdown h1, .gr-markdown h2, .gr-markdown h3, .gr-markdown h4, .gr-markdown h5, .gr-markdown h6 { color: #ecf0f1 !important; border-bottom-color: rgba(189, 195, 199, 0.3) !important; }
.gr-markdown pre code { background-color: rgba(52, 73, 94, 0.95) !important; border-color: rgba(189, 195, 199, 0.3) !important; }
.gr-chatbot { background-color: rgba(44, 62, 80, 0.7) !important; border-color: rgba(189, 195, 199, 0.2) !important; }
.gr-chatbot .message { background-color: rgba(52, 73, 94, 0.9) !important; color: #ecf0f1 !important; border-color: rgba(189, 195, 199, 0.3) !important; }
.gr-chatbot .message.user { background-color: rgba(46, 204, 113, 0.9) !important; color: black !important; }
.gradio-container .gr-accordion { border-color: rgba(189, 195, 199, 0.3) !important; }
.gradio-container .gr-accordion.closed { background-color: rgba(52, 73, 94, 0.9) !important; }
.gradio-container .gr-accordion.open { background-color: rgba(44, 62, 80, 0.8) !important; }

"""

with gr.Blocks(theme=custom_theme, css=custom_css) as demo:
    changeset_state = gr.State([])

    gr.Markdown("# 🤖 AI-Powered Hugging Face Space Commander")
    gr.Markdown("Use an AI assistant to create, modify, build, and manage your Hugging Face Spaces directly from this interface.")
    gr.Markdown("## ❗ This will cause changes to your huggingface spaces if you give it your Huggingface Key")
    gr.Markdown("⚒ Under Development - Use with Caution")


    with gr.Sidebar():
        with gr.Column(scale=1):
            with gr.Accordion("⚙️ Configuration", open=True):
                hf_api_key_input = gr.Textbox(label="Hugging Face Token", type="password", placeholder="hf_... (uses env var HF_TOKEN if empty)")
                owner_name_input = gr.Textbox(label="HF Owner Name", placeholder="e.g., your-username")
                space_name_input = gr.Textbox(label="HF Space Name", value="")
                load_space_button = gr.Button("🔄 Load Existing Space", variant="secondary")
                detect_user_button = gr.Button("👤 Detect User from Token", variant="secondary")


            with gr.Accordion("🤖 AI Model Settings", open=True):
                available_providers = get_available_providers()
                default_provider = 'Groq'
                if default_provider not in available_providers:
                    default_provider = available_providers[0] if available_providers else None
                elif len(available_providers) < 3: # Adjust default if less than 3 providers available
                     default_provider = available_providers[0] if available_providers else None

                initial_models = get_models_for_provider(default_provider) if default_provider else []
                initial_model = get_default_model_for_provider(default_provider) if default_provider else None
                if initial_model not in initial_models:
                    initial_model = initial_models[0] if initial_models else None

                provider_select = gr.Dropdown(
                    label="AI Provider",
                    choices=available_providers,
                    value=default_provider,
                    allow_custom_value=False
                )
                model_select = gr.Dropdown(
                    label="AI Model",
                    choices=initial_models,
                    value=initial_model,
                    allow_custom_value=False
                )
                provider_api_key_input = gr.Textbox(label="Model Provider API Key (Optional)", type="password", placeholder="sk_... (overrides backend settings)")
                system_prompt_input = gr.Textbox(label="System Prompt", lines=10, value=DEFAULT_SYSTEM_PROMPT, elem_id="system-prompt")

            with gr.Accordion("🗄️ Space Management", open=True):
                gr.Markdown("### Manual Actions")
                with gr.Group():
                    gr.Markdown("Duplicate Current Space To:")
                    target_owner_input = gr.Textbox(label="Target Owner Name", placeholder="e.g., new-username")
                    target_space_name_input = gr.Textbox(label="Target Space Name", placeholder="e.g., new-space")
                    target_private_checkbox = gr.Checkbox(label="Make Target Private", value=False)
                    duplicate_space_button = gr.Button("📂 Duplicate Space", variant="secondary")

                gr.Markdown("---")
                gr.Markdown("### List Spaces")
                list_spaces_button = gr.Button("📄 List My Spaces", variant="secondary")
                list_spaces_display = gr.Markdown("*List of spaces will appear here.*")


    with gr.Column(scale=2):
        gr.Markdown("## 💬 AI Assistant Chat")
        chatbot_display = gr.Chatbot(label="AI Chat", height=500, bubble_full_width=False, avatar_images=(None)) # Removed avatar tuple as per doc
        with gr.Row():
            chat_message_input = gr.Textbox(show_label=False, placeholder="Your Message...", scale=7)
            send_chat_button = gr.Button("Send", variant="primary", scale=1)
        status_output = gr.Textbox(label="Last Action Status", interactive=False, value="Ready.")

    with gr.Accordion("📝 Proposed Changes (Pending Confirmation)", open=False, visible=False) as confirm_accordion:
        changeset_display = gr.Markdown("*No changes proposed.*")
        with gr.Row():
            confirm_button = gr.Button("✅ Confirm & Apply Changes", variant="primary", visible=False)
            cancel_button = gr.Button("❌ Cancel", variant="stop", visible=False)

    with gr.Tabs():
        with gr.TabItem("📝 Generated Markdown & Build"):
            with gr.Row():
                with gr.Column(scale=2):
                    formatted_space_output_display = gr.Textbox(label="Current Space Definition (Generated Markdown)", lines=20, interactive=True, value="*Load or create a space to see its definition.*")
                    download_button = gr.DownloadButton(label="Download .md", interactive=False)
                with gr.Column(scale=1):
                    gr.Markdown("### Manual Build & Status")
                    space_sdk_select = gr.Dropdown(label="Space SDK", choices=["gradio", "streamlit", "docker", "static"], value="gradio", interactive=True)
                    space_private_checkbox = gr.Checkbox(label="Make Space Private", value=False, interactive=True)
                    build_space_button = gr.Button("🚀 Build / Update Space from Markdown", variant="primary")
                    build_status_display = gr.Textbox(label="Manual Build/Update Status", interactive=False, value="*Manual build status...*")
                    gr.Markdown("---")
                    refresh_status_button = gr.Button("🔄 Refresh Runtime/Repo Status")
                    space_runtime_status_display = gr.Markdown("*Runtime/Repo status will appear here.*")

        with gr.TabItem("🔍 Files Preview"):
            detected_files_preview = gr.Markdown(value="*A preview of the latest file versions will appear here.*")

        with gr.TabItem("✏️ Live File Editor & Preview"):
             with gr.Row():
                with gr.Column(scale=1):
                    gr.Markdown("### Live Editor")
                    file_browser_dropdown = gr.Dropdown(label="Select File in Space", choices=[], interactive=True)
                    file_content_editor = gr.Code(label="File Content Editor", language="python", lines=15, interactive=True, value="")
                    commit_message_input = gr.Textbox(label="Commit Message", placeholder="e.g., Updated app.py", interactive=True, value="")
                    with gr.Row():
                        update_file_button = gr.Button("Commit Changes", variant="primary", interactive=True)
                        delete_file_button = gr.Button("🗑️ Delete Selected File", variant="stop", interactive=True)
                    edit_status_display = gr.Textbox(label="File Edit/Delete Status", interactive=False, value="")
                with gr.Column(scale=1):
                    gr.Markdown("### Live Space Preview")
                    space_iframe_display = gr.HTML(value="", visible=True)


    provider_select.change(update_models_dropdown, inputs=provider_select, outputs=model_select)

    chat_inputs = [
        chat_message_input, chatbot_display, hf_api_key_input,
        provider_api_key_input, provider_select, model_select, system_prompt_input,
        owner_name_input, space_name_input
    ] # 9 inputs
    chat_outputs = [
        chat_message_input, chatbot_display, status_output,
        detected_files_preview, formatted_space_output_display, download_button,
        changeset_state, changeset_display, confirm_accordion, confirm_button, cancel_button
    ] # 11 outputs

    send_chat_button.click(handle_chat_submit, inputs=chat_inputs, outputs=chat_outputs)
    chat_message_input.submit(handle_chat_submit, inputs=chat_inputs, outputs=chat_outputs)

    confirm_inputs = [hf_api_key_input, owner_name_input, space_name_input, changeset_state] # 4 inputs
    confirm_outputs = [
        status_output, formatted_space_output_display, detected_files_preview, download_button,
        confirm_accordion, confirm_button, cancel_button, changeset_state, changeset_display,
        owner_name_input, space_name_input, file_browser_dropdown, space_iframe_display, space_runtime_status_display
    ] # 14 outputs
    confirm_button.click(handle_confirm_changes, inputs=confirm_inputs, outputs=confirm_outputs)

    cancel_outputs = [
        status_output, changeset_state, changeset_display,
        confirm_accordion, confirm_button, cancel_button
    ] # 6 outputs
    cancel_button.click(handle_cancel_changes, inputs=None, outputs=cancel_outputs)

    load_space_outputs = [
        formatted_space_output_display, detected_files_preview, status_output, file_browser_dropdown,
        owner_name_input, space_name_input, space_iframe_display, download_button, build_status_display,
        edit_status_display, space_runtime_status_display, changeset_state, changeset_display, confirm_accordion,
        confirm_button, cancel_button, list_spaces_display, target_owner_input, target_space_name_input, target_private_checkbox
    ] # 20 outputs
    load_space_button.click(
        fn=handle_load_existing_space,
        inputs=[hf_api_key_input, owner_name_input, space_name_input], # 3 inputs
        outputs=load_space_outputs
    )

    detect_user_outputs = [status_output, owner_name_input, list_spaces_display] # 3 outputs
    # Pass owner_name_input to the detect user function, although it's not strictly needed for the logic,
    # it matches the function signature and allows initial yield to show the value.
    detect_user_button.click(fn=handle_detect_user, inputs=[hf_api_key_input, owner_name_input], outputs=detect_user_outputs) # 2 inputs

    build_outputs = [
        build_status_display, space_iframe_display, file_browser_dropdown,
        owner_name_input, space_name_input,
        changeset_state, changeset_display, confirm_accordion, confirm_button, cancel_button,
        formatted_space_output_display, detected_files_preview, download_button, space_runtime_status_display
    ] # 14 outputs
    build_inputs = [
        hf_api_key_input, space_name_input, owner_name_input, space_sdk_select,
        space_private_checkbox, formatted_space_output_display
    ] # 6 inputs
    build_space_button.click(fn=handle_build_space_button, inputs=build_inputs, outputs=build_outputs)

    file_edit_load_outputs = [file_content_editor, edit_status_display, commit_message_input] # Corrected: 3 outputs
    file_browser_dropdown.change(
        fn=handle_load_file_for_editing,
        inputs=[hf_api_key_input, space_name_input, owner_name_input, file_browser_dropdown], # 4 inputs
        outputs=[file_content_editor, edit_status_display, commit_message_input] # Pass outputs explicitly here
    )

    commit_file_outputs = [edit_status_display, file_browser_dropdown, formatted_space_output_display, detected_files_preview, download_button] # 5 outputs
    update_file_button.click(
        fn=handle_commit_file_changes,
        inputs=[hf_api_key_input, space_name_input, owner_name_input, file_browser_dropdown, file_content_editor, commit_message_input], # 6 inputs
        outputs=commit_file_outputs
    )

    delete_file_outputs = [edit_status_display, file_browser_dropdown, file_content_editor, commit_message_input,
    formatted_space_output_display, detected_files_preview, download_button] # Corrected: 7 outputs
    delete_file_button.click(
        fn=handle_delete_file,
        inputs=[hf_api_key_input, space_name_input, owner_name_input, file_browser_dropdown], # 4 inputs
        outputs=[
            edit_status_display, file_browser_dropdown,
            file_content_editor, commit_message_input, # Clear editor fields
            formatted_space_output_display, detected_files_preview, download_button # Update displays
        ] # Pass outputs explicitly here
    )

    refresh_status_button.click(fn=handle_refresh_space_status, inputs=[hf_api_key_input, owner_name_input, space_name_input], outputs=[space_runtime_status_display]) # 3 inputs, 1 output

    manual_duplicate_inputs = [hf_api_key_input, owner_name_input, space_name_input, target_owner_input, target_space_name_input, target_private_checkbox] # 6 inputs
    manual_duplicate_outputs = [status_output, owner_name_input, space_name_input,
    formatted_space_output_display, detected_files_preview, download_button,
    file_browser_dropdown, space_iframe_display, space_runtime_status_display] # 9 outputs
    duplicate_space_button.click(fn=handle_manual_duplicate_space, inputs=manual_duplicate_inputs, outputs=manual_duplicate_outputs)

    list_spaces_button.click(fn=handle_list_spaces, inputs=[hf_api_key_input, owner_name_input], outputs=[list_spaces_display]) # 2 inputs, 1 output


if __name__ == "__main__":
    demo.launch(debug=True, mcp_server=True) # Set debug=True for more detailed errors