machine

.gitattributes

@@ -1 +1,35 @@
-Animated_Logo_Video_Ready.gif filter=lfs diff=lfs merge=lfs -text
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -1,3 +1,5 @@
+.gradio/
+
 # Byte-compiled / optimized / DLL files
 __pycache__/
 *.py[cod]
@@ -19,18 +21,16 @@ lib64/
 parts/
 sdist/
 var/
+wheels/
+share/python-wheels/
 *.egg-info/
 .installed.cfg
 *.egg
 MANIFEST
 
-# Virtual environments
-venv/
-env/
-ENV/
-.venv/
-
 # PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
 *.manifest
 *.spec
 
@@ -48,34 +48,115 @@ htmlcov/
 nosetests.xml
 coverage.xml
 *.cover
+*.py,cover
 .hypothesis/
 .pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
 
 # Jupyter Notebook
 .ipynb_checkpoints
 
+# IPython
+profile_default/
+ipython_config.py
+
 # pyenv
-.python-version
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
 
 # mypy
 .mypy_cache/
 .dmypy.json
+dmypy.json
 
 # Pyre type checker
 .pyre/
 
-# Gradio cache
-log/
-logs/
-
-# System files
-.DS_Store
-Thumbs.db
+# pytype static type analyzer
+.pytype/
 
-# Lock files
-uv.lock
-poetry.lock
-Pipfile.lock
+# Cython debug symbols
+cython_debug/
 
-# VSCode
-.vscode/ 
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

.pre-commit-config.yaml

@@ -0,0 +1,32 @@
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v5.0.0
+    hooks:
+      - id: check-executables-have-shebangs
+      - id: check-json
+      - id: check-merge-conflict
+      - id: check-shebang-scripts-are-executable
+      - id: check-toml
+      - id: check-yaml
+      - id: end-of-file-fixer
+      - id: mixed-line-ending
+        args: ["--fix=lf"]
+      - id: requirements-txt-fixer
+      - id: trailing-whitespace
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.8.6
+    hooks:
+      - id: ruff
+        args: ["--fix"]
+  - repo: https://github.com/pre-commit/mirrors-mypy
+    rev: v1.14.1
+    hooks:
+      - id: mypy
+        args: ["--ignore-missing-imports"]
+        additional_dependencies:
+          [
+            "types-python-slugify",
+            "types-requests",
+            "types-PyYAML",
+            "types-pytz",
+          ]

.python-version

@@ -0,0 +1 @@
+3.10

.vscode/extensions.json

@@ -0,0 +1,8 @@
+{
+    "recommendations": [
+        "ms-python.python",
+        "charliermarsh.ruff",
+        "streetsidesoftware.code-spell-checker",
+        "tamasfe.even-better-toml"
+    ]
+}

.vscode/settings.json

@@ -0,0 +1,16 @@
+{
+    "editor.formatOnSave": true,
+    "files.insertFinalNewline": false,
+    "[python]": {
+        "editor.defaultFormatter": "charliermarsh.ruff",
+        "editor.formatOnType": true,
+        "editor.codeActionsOnSave": {
+            "source.fixAll.ruff": "explicit"
+        }
+    },
+    "[jupyter]": {
+        "files.insertFinalNewline": false
+    },
+    "notebook.output.scrolling": true,
+    "notebook.formatOnSave.enabled": true
+}

README.md

@@ -1,143 +1,13 @@
 ---
 title: Anycoder
-emoji: 🔥
+emoji: 🏢
 colorFrom: indigo
 colorTo: indigo
 sdk: gradio
-sdk_version: 5.49.1
+sdk_version: 5.23.3
 app_file: app.py
 pinned: false
 disable_embedding: true
-hf_oauth: true
-hf_oauth_scopes:
-- manage-repos
 ---
 
-# AnyCoder - AI Code Generator
-
-AnyCoder is an AI-powered code generator that helps you create applications by describing them in plain English. It supports multiple AI models, multimodal input, website redesign, and one-click deployment to Hugging Face Spaces. The UI is built with Gradio theming for a minimal, modern experience.
-
-## Features
-
-- **Multi-Model Support**: Choose from Moonshot Kimi-K2, Kimi K2 Turbo (Preview), Kimi K2 Thinking, DeepSeek V3, DeepSeek R1, ERNIE-4.5-VL, MiniMax M2, Qwen3-235B-A22B, Qwen3-30B-A3B-Instruct-2507, Qwen3-30B-A3B-Thinking-2507, SmolLM3-3B, GLM-4.1V-9B-Thinking, Gemini 2.5 Flash and Gemini 2.5 Pro (OpenAI-compatible)
- - Claude-Opus-4.1 (via Poe)
-- **Flexible Input**: Describe your app in text, upload a UI design image (for multimodal models), provide a reference file (PDF, TXT, MD, CSV, DOCX, or image), or enter a website URL for redesign
-- **Web Search Integration**: Enable real-time web search (Tavily, with advanced search depth) to enhance code generation with up-to-date information and best practices
-- **Code Generation**: Generate code in HTML, Python, JS, and more. Special support for transformers.js apps (outputs index.html, index.js, style.css)
-- **Live Preview**: Instantly preview generated HTML in a sandboxed iframe
-- **Modify Existing Code**: Use search/replace block format to update generated HTML
-- **One-Click Deployment**: Deploy your app to Hugging Face Spaces (Gradio, Streamlit, Static HTML, or Transformers.js) with OAuth login
-- **History & Examples**: Chat-like history of all interactions and quick example prompts for fast prototyping
-- **Minimal, Modern UI**: Built with Gradio 5.x, using only built-in theming and styling (no custom CSS)
-
-## Installation
-
-1. Clone the repository:
-```bash
-git clone <repository-url>
-cd anycoder
-```
-2. Install dependencies:
-```bash
-pip install -r requirements.txt
-```
-3. Set up environment variables:
-```bash
-export HF_TOKEN="your_huggingface_token"
-export DASHSCOPE_API_KEY="your_dashscope_api_key"  # Required for Qwen3-30B models via DashScope
-export POE_API_KEY="your_poe_api_key"  # Required for GPT-5, Grok-4, and Grok-Code-Fast-1 via Poe
-export GEMINI_API_KEY="your_gemini_api_key"  # Required for Gemini models
-export MOONSHOT_API_KEY="your_moonshot_api_key"  # Required for Kimi models
-export MINIMAX_API_KEY="your_minimax_api_key"  # Required for MiniMax M2 model
-```
-
-## Usage
-
-1. Run the application:
-```bash
-python app.py
-```
-2. Open your browser and navigate to the provided URL
-3. Describe your application in the text input field, or:
-   - Upload a UI design image (for multimodal models)
-   - Upload a reference file (PDF, TXT, MD, CSV, DOCX, or image)
-   - Enter a website URL for redesign (the app will extract and analyze the HTML and content)
-   - Enable web search for up-to-date information
-   - Choose a different AI model or code language
-4. Click "Generate" to create your code
-5. View the generated code in the Code tab or see it in action in the Preview tab
-6. Use the History tab to review previous generations
-7. **Deploy to Space**: Enter a title and click "🚀 Deploy App" to publish your application (OAuth login required) - the SDK is automatically matched to your selected code language
-
-## Supported Models
-
-- Moonshot Kimi-K2
-- Kimi K2 Turbo (Preview)
-- Kimi K2 Thinking
-- DeepSeek V3
-- DeepSeek V3.1
-- DeepSeek V3.1 Terminus
-- DeepSeek V3.2-Exp
-- DeepSeek R1
-- MiniMax M2
-- Qwen3-235B-A22B
-- Qwen3-4B-Instruct-2507
-- Qwen3-4B-Thinking-2507
-- Qwen3-30B-A3B-Instruct-2507 (via DashScope)
-- Qwen3-30B-A3B-Thinking-2507 (via DashScope)
-- GPT-5 (via Poe)
-- Grok-4 (via Poe)
- - Claude-Opus-4.1 (via Poe)
- - Gemini 2.5 Flash (OpenAI-compatible)
- - Gemini 2.5 Pro (OpenAI-compatible)
-
-## Input Options
-
-- **Text Prompt**: Describe your app or code requirements
-- **Image Upload**: For multimodal models, upload a UI design image to generate code from visuals
-- **File Upload**: Provide a reference file (PDF, TXT, MD, CSV, DOCX, or image) for code generation or text extraction (OCR for images)
-- **Website URL**: Enter a URL to extract and redesign the website (HTML and content are analyzed and modernized)
-
-## Code Generation & Modification
-
-- Generates code in HTML, Python, JS, and more (selectable via dropdown)
-- Special support for transformers.js apps (outputs index.html, index.js, style.css)
-- Svelte apps
-- For HTML, provides a live preview in a sandboxed iframe
-- For modification requests, uses a search/replace block format to update existing HTML
-
-## Deployment
-
-- Deploy generated apps to Hugging Face Spaces directly from the UI
-- Supported SDKs: Gradio (Python), Streamlit (Python), Static (HTML), Transformers.js
-- OAuth login with Hugging Face is required for deployment to user-owned Spaces
-
-## History & Examples
-
-- Maintains a chat-like history of user/assistant interactions
-- Quick example prompts are available in the sidebar for fast prototyping
-
-## UI/UX
-
-- Built with Gradio 5.x, using only Gradio's built-in theming and styling (no custom CSS)
-- Minimal, uncluttered sidebar and interface
-
-## Environment Variables
-
-- `HF_TOKEN`: Your Hugging Face API token (required)
- - `GEMINI_API_KEY`: Your Google Gemini API key (required to use Gemini models)
-- `MOONSHOT_API_KEY`: Your Moonshot AI API key (required to use Kimi models)
-- `MINIMAX_API_KEY`: Your MiniMax API key (required to use MiniMax M2 model)
-
-## Project Structure
-
-```
-anycoder/
-├── app.py          # Main application (all logic and UI)
-├── requirements.txt
-├── README.md       # This file
-```
-
-## License
-
-[Add your license information here]
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

anycoder_app/__init__.py

@@ -1,27 +0,0 @@
-"""
-AnyCoder - AI Code Generator Package
-Modular structure for better code organization and maintainability.
-"""
-
-__version__ = "1.0.0"
-
-from . import config
-from . import prompts
-from . import docs_manager
-from . import models
-from . import parsers
-from . import deploy
-from . import themes
-from . import ui
-
-__all__ = [
-    "config",
-    "prompts", 
-    "docs_manager",
-    "models",
-    "parsers",
-    "deploy",
-    "themes",
-    "ui",
-]
-

anycoder_app/agent.py

@@ -1,234 +0,0 @@
-"""
-Agent functionality for interactive code generation with follow-up questions and task planning.
-"""
-import os
-from typing import Dict, List, Optional, Tuple, Generator
-import gradio as gr
-
-from .models import (
-    get_inference_client, get_real_model_id, history_to_messages,
-    history_to_chatbot_messages, strip_thinking_tags
-)
-from .deploy import generation_code
-
-
-def agent_generate_with_questions(
-    query: Optional[str],
-    setting: Dict[str, str],
-    history: List,
-    current_model: Dict,
-    language: str,
-    provider: str,
-    profile: Optional[gr.OAuthProfile] = None,
-    token: Optional[gr.OAuthToken] = None,
-    max_questions: int = 3
-) -> Generator[Tuple[List, List], None, None]:
-    """
-    Agent that asks follow-up questions, creates a task list, and generates code.
-    
-    Args:
-        query: Initial user request
-        setting: System settings
-        history: Conversation history
-        current_model: Selected model configuration
-        language: Target programming language/framework
-        provider: Model provider
-        profile: User OAuth profile
-        token: User OAuth token
-        max_questions: Maximum number of follow-up questions to ask
-        
-    Yields:
-        Tuples of (history, chatbot_messages) at each step
-    """
-    if not query or not query.strip():
-        return
-    
-    # Initialize history with user's initial query
-    current_history = history + [[query, ""]]
-    
-    # Step 1: Agent analyzes the request and asks follow-up questions
-    agent_system_prompt = """You are a helpful coding assistant that helps users clarify their requirements before generating code.
-
-Your task is to:
-1. Analyze the user's request
-2. Ask 1-3 clarifying questions to better understand their needs
-3. Focus on important details like:
-   - Target audience and use case
-   - Specific features or functionality needed
-   - Design preferences (colors, layout, style)
-   - Data sources or APIs to integrate
-   - Performance or scalability requirements
-
-Output ONLY the questions, numbered 1, 2, 3, etc. Keep questions concise and focused.
-Do not generate code yet - just ask the questions."""
-
-    # Get LLM client
-    client = get_inference_client(current_model.get('model_id', 'Qwen/Qwen2.5-Coder-32B-Instruct'), provider)
-    model_id = get_real_model_id(current_model.get('model_id', 'Qwen/Qwen2.5-Coder-32B-Instruct'))
-    
-    # Prepare messages for follow-up questions
-    messages = [
-        {'role': 'system', 'content': agent_system_prompt},
-        {'role': 'user', 'content': f"User wants to create: {query}\n\nLanguage/Framework: {language}\n\nAsk clarifying questions."}
-    ]
-    
-    # Generate follow-up questions
-    questions_response = ""
-    try:
-        # Try to use the client (works for both InferenceClient and OpenAI-compatible clients)
-        stream = client.chat.completions.create(
-            model=model_id,
-            messages=messages,
-            temperature=0.7,
-            max_tokens=500,
-            stream=True
-        )
-        for chunk in stream:
-            if hasattr(chunk.choices[0].delta, 'content') and chunk.choices[0].delta.content:
-                questions_response += chunk.choices[0].delta.content
-                # Update display in real-time
-                temp_history = current_history[:-1] + [[query, f"🤔 **Analyzing your request...**\n\n{questions_response}"]]
-                yield (temp_history, history_to_chatbot_messages(temp_history))
-    except Exception as e:
-        error_msg = f"❌ Error asking follow-up questions: {str(e)}"
-        temp_history = current_history[:-1] + [[query, error_msg]]
-        yield (temp_history, history_to_chatbot_messages(temp_history))
-        return
-    
-    # Update history with agent's questions
-    current_history[-1][1] = f"🤔 **Let me ask you a few questions to better understand your needs:**\n\n{questions_response}\n\n💬 Please answer these questions in your next message."
-    yield (current_history, history_to_chatbot_messages(current_history))
-    
-    # Wait for user response (this will be handled by the UI)
-    # For now, we'll return and let the user respond, then continue in the next call
-    return
-
-
-def agent_process_answers_and_generate(
-    user_answers: str,
-    original_query: str,
-    questions: str,
-    setting: Dict[str, str],
-    history: List,
-    current_model: Dict,
-    language: str,
-    provider: str,
-    profile: Optional[gr.OAuthProfile] = None,
-    token: Optional[gr.OAuthToken] = None,
-    code_output=None,
-    history_output=None,
-    history_state=None
-) -> Generator:
-    """
-    Process user's answers, create task list, and generate code.
-    
-    Args:
-        user_answers: User's responses to the questions
-        original_query: Original user request
-        questions: Agent's questions
-        setting: System settings
-        history: Conversation history
-        current_model: Selected model configuration
-        language: Target programming language/framework
-        provider: Model provider
-        profile: User OAuth profile
-        token: User OAuth token
-        code_output: Code output component
-        history_output: History output component
-        history_state: History state
-        
-    Yields:
-        Updates to code output and history
-    """
-    # Step 2: Create task list based on answers
-    task_planning_prompt = f"""Based on the user's request and their answers, create a detailed task list for implementing the solution.
-
-Original Request: {original_query}
-
-Questions Asked:
-{questions}
-
-User's Answers:
-{user_answers}
-
-Create a numbered task list with 5-8 specific, actionable tasks. Each task should be clear and focused.
-Start with "📋 **Task List:**" and then list the tasks."""
-
-    client = get_inference_client(current_model.get('model_id', 'Qwen/Qwen2.5-Coder-32B-Instruct'), provider)
-    model_id = get_real_model_id(current_model.get('model_id', 'Qwen/Qwen2.5-Coder-32B-Instruct'))
-    
-    messages = [
-        {'role': 'system', 'content': 'You are a helpful coding assistant creating a task plan.'},
-        {'role': 'user', 'content': task_planning_prompt}
-    ]
-    
-    # Generate task list
-    task_list = ""
-    try:
-        stream = client.chat.completions.create(
-            model=model_id,
-            messages=messages,
-            temperature=0.7,
-            max_tokens=800,
-            stream=True
-        )
-        for chunk in stream:
-            if hasattr(chunk.choices[0].delta, 'content') and chunk.choices[0].delta.content:
-                task_list += chunk.choices[0].delta.content
-                # Update display
-                temp_history = history + [[user_answers, f"📋 **Creating task list...**\n\n{task_list}"]]
-                yield {
-                    history_state: temp_history,
-                    history_output: history_to_chatbot_messages(temp_history)
-                }
-    except Exception as e:
-        error_msg = f"❌ Error creating task list: {str(e)}"
-        temp_history = history + [[user_answers, error_msg]]
-        yield {
-            history_state: temp_history,
-            history_output: history_to_chatbot_messages(temp_history)
-        }
-        return
-    
-    # Update history with task list
-    updated_history = history + [[user_answers, task_list]]
-    yield {
-        history_state: updated_history,
-        history_output: history_to_chatbot_messages(updated_history)
-    }
-    
-    # Step 3: Generate code based on refined requirements
-    refined_query = f"""{original_query}
-
-Additional Requirements (based on follow-up):
-{user_answers}
-
-Task List:
-{task_list}
-
-Please implement the above requirements following the task list."""
-    
-    # Add a message indicating code generation is starting
-    code_gen_start_history = updated_history + [["[System]", "🚀 **Starting code generation based on your requirements...**"]]
-    yield {
-        history_state: code_gen_start_history,
-        history_output: history_to_chatbot_messages(code_gen_start_history)
-    }
-    
-    # Use the existing generation_code function for actual code generation
-    # We need to pass the refined query and updated history
-    for result in generation_code(
-        refined_query,
-        setting,
-        updated_history,
-        current_model,
-        language,
-        provider,
-        profile,
-        token,
-        code_output,
-        history_output,
-        history_state
-    ):
-        yield result
-

anycoder_app/config.py

@@ -1,175 +0,0 @@
-"""
-Configuration constants for AnyCoder application.
-"""
-import os
-from datetime import datetime
-from typing import Optional
-
-# Gradio supported languages for syntax highlighting
-GRADIO_SUPPORTED_LANGUAGES = [
-    "python", "json", "html", "javascript"
-]
-
-# Search/Replace Constants
-SEARCH_START = "<<<<<<< SEARCH"
-DIVIDER = "======="
-REPLACE_END = ">>>>>>> REPLACE"
-
-# Gradio Documentation Auto-Update System
-GRADIO_LLMS_TXT_URL = "https://www.gradio.app/llms.txt"
-GRADIO_DOCS_CACHE_FILE = ".gradio_docs_cache.txt"
-GRADIO_DOCS_LAST_UPDATE_FILE = ".gradio_docs_last_update.txt"
-GRADIO_DOCS_UPDATE_ON_APP_UPDATE = True  # Only update when app is updated, not on a timer
-
-# Global variable to store the current Gradio documentation
-_gradio_docs_content: Optional[str] = None
-_gradio_docs_last_fetched: Optional[datetime] = None
-
-# ComfyUI Documentation Auto-Update System
-COMFYUI_LLMS_TXT_URL = "https://docs.comfy.org/llms.txt"
-COMFYUI_DOCS_CACHE_FILE = ".comfyui_docs_cache.txt"
-COMFYUI_DOCS_LAST_UPDATE_FILE = ".comfyui_docs_last_update.txt"
-COMFYUI_DOCS_UPDATE_ON_APP_UPDATE = True  # Only update when app is updated, not on a timer
-
-# Global variable to store the current ComfyUI documentation
-_comfyui_docs_content: Optional[str] = None
-_comfyui_docs_last_fetched: Optional[datetime] = None
-
-# FastRTC Documentation Auto-Update System
-FASTRTC_LLMS_TXT_URL = "https://fastrtc.org/llms.txt"
-FASTRTC_DOCS_CACHE_FILE = ".fastrtc_docs_cache.txt"
-FASTRTC_DOCS_LAST_UPDATE_FILE = ".fastrtc_docs_last_update.txt"
-FASTRTC_DOCS_UPDATE_ON_APP_UPDATE = True  # Only update when app is updated, not on a timer
-
-# Global variable to store the current FastRTC documentation
-_fastrtc_docs_content: Optional[str] = None
-_fastrtc_docs_last_fetched: Optional[datetime] = None
-
-# Available Models Configuration
-AVAILABLE_MODELS = [
-    {
-        "name": "DeepSeek V3.2-Exp",
-        "id": "deepseek-ai/DeepSeek-V3.2-Exp",
-        "description": "DeepSeek V3.2 Experimental model for cutting-edge code generation and reasoning"
-    },
-    {
-        "name": "DeepSeek R1", 
-        "id": "deepseek-ai/DeepSeek-R1-0528",
-        "description": "DeepSeek R1 model for code generation"
-    },
-    {
-        "name": "GLM-4.6",
-        "id": "zai-org/GLM-4.6",
-        "description": "GLM-4.6 model for advanced code generation and general tasks"
-    },
-    {
-        "name": "Gemini Flash Latest",
-        "id": "gemini-flash-latest",
-        "description": "Google Gemini Flash Latest model via native Gemini API"
-    },
-    {
-        "name": "Gemini Flash Lite Latest",
-        "id": "gemini-flash-lite-latest",
-        "description": "Google Gemini Flash Lite Latest model via OpenAI-compatible API"
-    },
-    {
-        "name": "GPT-5",
-        "id": "gpt-5",
-        "description": "OpenAI GPT-5 model for advanced code generation and general tasks"
-    },
-    {
-        "name": "GPT-5.1",
-        "id": "gpt-5.1",
-        "description": "OpenAI GPT-5.1 model via Poe for advanced code generation and general tasks"
-    },
-    {
-        "name": "GPT-5.1 Instant",
-        "id": "gpt-5.1-instant",
-        "description": "OpenAI GPT-5.1 Instant model via Poe for fast responses"
-    },
-    {
-        "name": "GPT-5.1 Codex",
-        "id": "gpt-5.1-codex",
-        "description": "OpenAI GPT-5.1 Codex model via Poe optimized for code generation"
-    },
-    {
-        "name": "GPT-5.1 Codex Mini",
-        "id": "gpt-5.1-codex-mini",
-        "description": "OpenAI GPT-5.1 Codex Mini model via Poe for lightweight code generation"
-    },
-    {
-        "name": "Grok-4",
-        "id": "grok-4",
-        "description": "Grok-4 model via Poe (OpenAI-compatible) for advanced tasks"
-    },
-    {
-        "name": "Grok-Code-Fast-1",
-        "id": "Grok-Code-Fast-1",
-        "description": "Grok-Code-Fast-1 model via Poe (OpenAI-compatible) for fast code generation"
-    },
-    {
-        "name": "Claude-Opus-4.1",
-        "id": "claude-opus-4.1",
-        "description": "Anthropic Claude Opus 4.1 via Poe (OpenAI-compatible)"
-    },
-    {
-        "name": "Claude-Sonnet-4.5",
-        "id": "claude-sonnet-4.5",
-        "description": "Anthropic Claude Sonnet 4.5 via Poe (OpenAI-compatible)"
-    },
-    {
-        "name": "Claude-Haiku-4.5",
-        "id": "claude-haiku-4.5",
-        "description": "Anthropic Claude Haiku 4.5 via Poe (OpenAI-compatible)"
-    },
-    {
-        "name": "Qwen3 Max Preview",
-        "id": "qwen3-max-preview",
-        "description": "Qwen3 Max Preview model via DashScope International API"
-    },
-    {
-        "name": "MiniMax M2",
-        "id": "MiniMaxAI/MiniMax-M2",
-        "description": "MiniMax M2 model via HuggingFace InferenceClient with Novita provider"
-    },
-    {
-        "name": "Kimi K2 Thinking",
-        "id": "moonshotai/Kimi-K2-Thinking",
-        "description": "Moonshot Kimi K2 Thinking model for advanced reasoning and code generation"
-    }
-]
-
-k2_model_name_tag = "moonshotai/Kimi-K2-Thinking"
-
-# Default model selection
-DEFAULT_MODEL_NAME = "GPT-5.1 Codex"
-DEFAULT_MODEL = None
-for _m in AVAILABLE_MODELS:
-    if _m.get("name") == DEFAULT_MODEL_NAME:
-        DEFAULT_MODEL = _m
-        break
-if DEFAULT_MODEL is None and AVAILABLE_MODELS:
-    DEFAULT_MODEL = AVAILABLE_MODELS[0]
-
-# HF Inference Client
-HF_TOKEN = os.getenv('HF_TOKEN')
-# Note: HF_TOKEN is checked at runtime when needed, not at import time
-
-# Language choices for code generation
-LANGUAGE_CHOICES = [
-    "html", "gradio", "transformers.js", "streamlit", "comfyui", "react"
-]
-
-
-def get_gradio_language(language):
-    """Map composite options to a supported syntax highlighting."""
-    if language == "streamlit":
-        return "python"
-    if language == "gradio":
-        return "python"
-    if language == "comfyui":
-        return "json"
-    if language == "react":
-        return "javascript"
-    return language if language in GRADIO_SUPPORTED_LANGUAGES else None
-

anycoder_app/docs_manager.py

@@ -1,1484 +0,0 @@
-"""
-Documentation management for Gradio, ComfyUI, and FastRTC.
-Handles fetching, caching, and updating documentation from llms.txt files.
-"""
-import os
-import requests
-import re
-from datetime import datetime, timedelta
-from typing import Optional
-
-from .config import (
-    GRADIO_LLMS_TXT_URL, GRADIO_DOCS_CACHE_FILE, GRADIO_DOCS_LAST_UPDATE_FILE,
-    GRADIO_DOCS_UPDATE_ON_APP_UPDATE, _gradio_docs_content, _gradio_docs_last_fetched,
-    COMFYUI_LLMS_TXT_URL, COMFYUI_DOCS_CACHE_FILE, COMFYUI_DOCS_LAST_UPDATE_FILE,
-    COMFYUI_DOCS_UPDATE_ON_APP_UPDATE, _comfyui_docs_content, _comfyui_docs_last_fetched,
-    FASTRTC_LLMS_TXT_URL, FASTRTC_DOCS_CACHE_FILE, FASTRTC_DOCS_LAST_UPDATE_FILE,
-    FASTRTC_DOCS_UPDATE_ON_APP_UPDATE, _fastrtc_docs_content, _fastrtc_docs_last_fetched
-)
-from . import prompts
-
-def fetch_gradio_docs() -> Optional[str]:
-    """Fetch the latest Gradio documentation from llms.txt"""
-    try:
-        response = requests.get(GRADIO_LLMS_TXT_URL, timeout=10)
-        response.raise_for_status()
-        return response.text
-    except Exception as e:
-        print(f"Warning: Failed to fetch Gradio docs from {GRADIO_LLMS_TXT_URL}: {e}")
-        return None
-
-def fetch_comfyui_docs() -> Optional[str]:
-    """Fetch the latest ComfyUI documentation from llms.txt"""
-    try:
-        response = requests.get(COMFYUI_LLMS_TXT_URL, timeout=10)
-        response.raise_for_status()
-        return response.text
-    except Exception as e:
-        print(f"Warning: Failed to fetch ComfyUI docs from {COMFYUI_LLMS_TXT_URL}: {e}")
-        return None
-
-def fetch_fastrtc_docs() -> Optional[str]:
-    """Fetch the latest FastRTC documentation from llms.txt"""
-    try:
-        response = requests.get(FASTRTC_LLMS_TXT_URL, timeout=10)
-        response.raise_for_status()
-        return response.text
-    except Exception as e:
-        print(f"Warning: Failed to fetch FastRTC docs from {FASTRTC_LLMS_TXT_URL}: {e}")
-        return None
-
-def filter_problematic_instructions(content: str) -> str:
-    """Filter out problematic instructions that cause LLM to stop generation prematurely"""
-    if not content:
-        return content
-    
-    # List of problematic phrases that cause early termination when LLM encounters ``` in user code
-    problematic_patterns = [
-        r"Output ONLY the code inside a ``` code block, and do not include any explanations or extra text",
-        r"output only the code inside a ```.*?``` code block",
-        r"Always output only the.*?code.*?inside.*?```.*?```.*?block",
-        r"Return ONLY the code inside a.*?```.*?``` code block",
-        r"Do NOT add the language name at the top of the code output",
-        r"do not include any explanations or extra text",
-        r"Always output only the.*?code blocks.*?shown above, and do not include any explanations",
-        r"Output.*?ONLY.*?code.*?inside.*?```.*?```",
-        r"Return.*?ONLY.*?code.*?inside.*?```.*?```",
-        r"Generate.*?ONLY.*?code.*?inside.*?```.*?```",
-        r"Provide.*?ONLY.*?code.*?inside.*?```.*?```",
-    ]
-    
-    # Remove problematic patterns
-    filtered_content = content
-    for pattern in problematic_patterns:
-        # Use case-insensitive matching
-        filtered_content = re.sub(pattern, "", filtered_content, flags=re.IGNORECASE | re.DOTALL)
-    
-    # Clean up any double newlines or extra whitespace left by removals
-    filtered_content = re.sub(r'\n\s*\n\s*\n', '\n\n', filtered_content)
-    filtered_content = re.sub(r'^\s+', '', filtered_content, flags=re.MULTILINE)
-    
-    return filtered_content
-
-def load_cached_gradio_docs() -> Optional[str]:
-    """Load cached Gradio documentation from file"""
-    try:
-        if os.path.exists(GRADIO_DOCS_CACHE_FILE):
-            with open(GRADIO_DOCS_CACHE_FILE, 'r', encoding='utf-8') as f:
-                return f.read()
-    except Exception as e:
-        print(f"Warning: Failed to load cached Gradio docs: {e}")
-    return None
-
-def save_gradio_docs_cache(content: str):
-    """Save Gradio documentation to cache file"""
-    try:
-        with open(GRADIO_DOCS_CACHE_FILE, 'w', encoding='utf-8') as f:
-            f.write(content)
-        with open(GRADIO_DOCS_LAST_UPDATE_FILE, 'w', encoding='utf-8') as f:
-            f.write(datetime.now().isoformat())
-    except Exception as e:
-        print(f"Warning: Failed to save Gradio docs cache: {e}")
-
-def load_comfyui_docs_cache() -> Optional[str]:
-    """Load ComfyUI documentation from cache file"""
-    try:
-        if os.path.exists(COMFYUI_DOCS_CACHE_FILE):
-            with open(COMFYUI_DOCS_CACHE_FILE, 'r', encoding='utf-8') as f:
-                return f.read()
-    except Exception as e:
-        print(f"Warning: Failed to load cached ComfyUI docs: {e}")
-    return None
-
-def save_comfyui_docs_cache(content: str):
-    """Save ComfyUI documentation to cache file"""
-    try:
-        with open(COMFYUI_DOCS_CACHE_FILE, 'w', encoding='utf-8') as f:
-            f.write(content)
-        with open(COMFYUI_DOCS_LAST_UPDATE_FILE, 'w', encoding='utf-8') as f:
-            f.write(datetime.now().isoformat())
-    except Exception as e:
-        print(f"Warning: Failed to save ComfyUI docs cache: {e}")
-
-def load_fastrtc_docs_cache() -> Optional[str]:
-    """Load FastRTC documentation from cache file"""
-    try:
-        if os.path.exists(FASTRTC_DOCS_CACHE_FILE):
-            with open(FASTRTC_DOCS_CACHE_FILE, 'r', encoding='utf-8') as f:
-                return f.read()
-    except Exception as e:
-        print(f"Warning: Failed to load cached FastRTC docs: {e}")
-    return None
-
-def save_fastrtc_docs_cache(content: str):
-    """Save FastRTC documentation to cache file"""
-    try:
-        with open(FASTRTC_DOCS_CACHE_FILE, 'w', encoding='utf-8') as f:
-            f.write(content)
-        with open(FASTRTC_DOCS_LAST_UPDATE_FILE, 'w', encoding='utf-8') as f:
-            f.write(datetime.now().isoformat())
-    except Exception as e:
-        print(f"Warning: Failed to save FastRTC docs cache: {e}")
-
-def get_last_update_time() -> Optional[datetime]:
-    """Get the last update time from file"""
-    try:
-        if os.path.exists(GRADIO_DOCS_LAST_UPDATE_FILE):
-            with open(GRADIO_DOCS_LAST_UPDATE_FILE, 'r', encoding='utf-8') as f:
-                return datetime.fromisoformat(f.read().strip())
-    except Exception as e:
-        print(f"Warning: Failed to read last update time: {e}")
-    return None
-
-def should_update_gradio_docs() -> bool:
-    """Check if Gradio documentation should be updated"""
-    # Only update if we don't have cached content (first run or cache deleted)
-    return not os.path.exists(GRADIO_DOCS_CACHE_FILE)
-
-def should_update_comfyui_docs() -> bool:
-    """Check if ComfyUI documentation should be updated"""
-    # Only update if we don't have cached content (first run or cache deleted)
-    return not os.path.exists(COMFYUI_DOCS_CACHE_FILE)
-
-def should_update_fastrtc_docs() -> bool:
-    """Check if FastRTC documentation should be updated"""
-    # Only update if we don't have cached content (first run or cache deleted)
-    return not os.path.exists(FASTRTC_DOCS_CACHE_FILE)
-
-def force_update_gradio_docs():
-    """
-    Force an update of Gradio documentation (useful when app is updated).
-    
-    To manually refresh docs, you can call this function or simply delete the cache file:
-    rm .gradio_docs_cache.txt && restart the app
-    """
-    global _gradio_docs_content, _gradio_docs_last_fetched
-    
-    print("🔄 Forcing Gradio documentation update...")
-    latest_content = fetch_gradio_docs()
-    
-    if latest_content:
-        # Filter out problematic instructions that cause early termination
-        filtered_content = filter_problematic_instructions(latest_content)
-        _gradio_docs_content = filtered_content
-        _gradio_docs_last_fetched = datetime.now()
-        save_gradio_docs_cache(filtered_content)
-        update_gradio_system_prompts()
-        print("✅ Gradio documentation updated successfully")
-        return True
-    else:
-        print("❌ Failed to update Gradio documentation")
-        return False
-
-def force_update_comfyui_docs():
-    """
-    Force an update of ComfyUI documentation (useful when app is updated).
-    
-    To manually refresh docs, you can call this function or simply delete the cache file:
-    rm .comfyui_docs_cache.txt && restart the app
-    """
-    global _comfyui_docs_content, _comfyui_docs_last_fetched
-    
-    print("🔄 Forcing ComfyUI documentation update...")
-    latest_content = fetch_comfyui_docs()
-    
-    if latest_content:
-        # Filter out problematic instructions that cause early termination
-        filtered_content = filter_problematic_instructions(latest_content)
-        _comfyui_docs_content = filtered_content
-        _comfyui_docs_last_fetched = datetime.now()
-        save_comfyui_docs_cache(filtered_content)
-        update_json_system_prompts()
-        print("✅ ComfyUI documentation updated successfully")
-        return True
-    else:
-        print("❌ Failed to update ComfyUI documentation")
-        return False
-
-def force_update_fastrtc_docs():
-    """
-    Force an update of FastRTC documentation (useful when app is updated).
-    
-    To manually refresh docs, you can call this function or simply delete the cache file:
-    rm .fastrtc_docs_cache.txt && restart the app
-    """
-    global _fastrtc_docs_content, _fastrtc_docs_last_fetched
-    
-    print("🔄 Forcing FastRTC documentation update...")
-    latest_content = fetch_fastrtc_docs()
-    
-    if latest_content:
-        # Filter out problematic instructions that cause early termination
-        filtered_content = filter_problematic_instructions(latest_content)
-        _fastrtc_docs_content = filtered_content
-        _fastrtc_docs_last_fetched = datetime.now()
-        save_fastrtc_docs_cache(filtered_content)
-        update_gradio_system_prompts()
-        print("✅ FastRTC documentation updated successfully")
-        return True
-    else:
-        print("❌ Failed to update FastRTC documentation")
-        return False
-
-def get_gradio_docs_content() -> str:
-    """Get the current Gradio documentation content, updating if necessary"""
-    global _gradio_docs_content, _gradio_docs_last_fetched
-    
-    # Check if we need to update
-    if (_gradio_docs_content is None or 
-        _gradio_docs_last_fetched is None or 
-        should_update_gradio_docs()):
-        
-        print("Updating Gradio documentation...")
-        
-        # Try to fetch latest content
-        latest_content = fetch_gradio_docs()
-        
-        if latest_content:
-            # Filter out problematic instructions that cause early termination
-            filtered_content = filter_problematic_instructions(latest_content)
-            _gradio_docs_content = filtered_content
-            _gradio_docs_last_fetched = datetime.now()
-            save_gradio_docs_cache(filtered_content)
-            print("✅ Gradio documentation updated successfully")
-        else:
-            # Fallback to cached content
-            cached_content = load_cached_gradio_docs()
-            if cached_content:
-                _gradio_docs_content = cached_content
-                _gradio_docs_last_fetched = datetime.now()
-                print("⚠️ Using cached Gradio documentation (network fetch failed)")
-            else:
-                # Fallback to minimal content
-                _gradio_docs_content = """
-                # Gradio API Reference (Offline Fallback)
-                
-                This is a minimal fallback when documentation cannot be fetched.
-                Please check your internet connection for the latest API reference.
-                
-                Basic Gradio components: Button, Textbox, Slider, Image, Audio, Video, File, etc.
-                Use gr.Blocks() for custom layouts and gr.Interface() for simple apps.
-                """
-                print("❌ Using minimal fallback documentation")
-    
-    return _gradio_docs_content or ""
-
-def get_comfyui_docs_content() -> str:
-    """Get the current ComfyUI documentation content, updating if necessary"""
-    global _comfyui_docs_content, _comfyui_docs_last_fetched
-    
-    # Check if we need to update
-    if (_comfyui_docs_content is None or 
-        _comfyui_docs_last_fetched is None or 
-        should_update_comfyui_docs()):
-        
-        print("Updating ComfyUI documentation...")
-        
-        # Try to fetch latest content
-        latest_content = fetch_comfyui_docs()
-        
-        if latest_content:
-            # Filter out problematic instructions that cause early termination
-            filtered_content = filter_problematic_instructions(latest_content)
-            _comfyui_docs_content = filtered_content
-            _comfyui_docs_last_fetched = datetime.now()
-            save_comfyui_docs_cache(filtered_content)
-            print("✅ ComfyUI documentation updated successfully")
-        else:
-            # Fallback to cached content
-            cached_content = load_comfyui_docs_cache()
-            if cached_content:
-                _comfyui_docs_content = cached_content
-                _comfyui_docs_last_fetched = datetime.now()
-                print("⚠️ Using cached ComfyUI documentation (network fetch failed)")
-            else:
-                # Fallback to minimal content
-                _comfyui_docs_content = """
-                # ComfyUI API Reference (Offline Fallback)
-                
-                This is a minimal fallback when documentation cannot be fetched.
-                Please check your internet connection for the latest API reference.
-                
-                Basic ComfyUI workflow structure: nodes, connections, inputs, outputs.
-                Use CheckpointLoaderSimple, CLIPTextEncode, KSampler for basic workflows.
-                """
-                print("❌ Using minimal fallback documentation")
-    
-    return _comfyui_docs_content or ""
-
-def get_fastrtc_docs_content() -> str:
-    """Get the current FastRTC documentation content, updating if necessary"""
-    global _fastrtc_docs_content, _fastrtc_docs_last_fetched
-    
-    # Check if we need to update
-    if (_fastrtc_docs_content is None or 
-        _fastrtc_docs_last_fetched is None or 
-        should_update_fastrtc_docs()):
-        
-        print("Updating FastRTC documentation...")
-        
-        # Try to fetch latest content
-        latest_content = fetch_fastrtc_docs()
-        
-        if latest_content:
-            # Filter out problematic instructions that cause early termination
-            filtered_content = filter_problematic_instructions(latest_content)
-            _fastrtc_docs_content = filtered_content
-            _fastrtc_docs_last_fetched = datetime.now()
-            save_fastrtc_docs_cache(filtered_content)
-            print("✅ FastRTC documentation updated successfully")
-        else:
-            # Fallback to cached content
-            cached_content = load_fastrtc_docs_cache()
-            if cached_content:
-                _fastrtc_docs_content = cached_content
-                _fastrtc_docs_last_fetched = datetime.now()
-                print("⚠️ Using cached FastRTC documentation (network fetch failed)")
-            else:
-                # Fallback to minimal content
-                _fastrtc_docs_content = """
-                # FastRTC API Reference (Offline Fallback)
-                
-                This is a minimal fallback when documentation cannot be fetched.
-                Please check your internet connection for the latest API reference.
-                
-                Basic FastRTC usage: Stream class, handlers, real-time audio/video processing.
-                Use Stream(handler, modality, mode) for real-time communication apps.
-                """
-                print("❌ Using minimal fallback documentation")
-    
-    return _fastrtc_docs_content or ""
-
-def update_gradio_system_prompts():
-    """Update the global Gradio system prompts with latest documentation"""
-    docs_content = get_gradio_docs_content()
-    fastrtc_content = get_fastrtc_docs_content()
-    
-    # Base system prompt
-    base_prompt = """You are an expert Gradio developer. Create a complete, working Gradio application based on the user's request. Generate all necessary code to make the application functional and runnable.
-
-🚨 CRITICAL OUTPUT RULES:
-- DO NOT use <think> tags or thinking blocks in your output
-- DO NOT use [TOOL_CALL] or any tool call markers
-- Generate ONLY the requested code files and requirements.txt
-- No explanatory text outside the code blocks
-
-## 🎯 Working with Imported Model Code
-
-**CRITICAL: If the user has imported model code in the conversation history (InferenceClient, transformers, diffusers), you MUST integrate it into your Gradio application!**
-
-**For InferenceClient Code (HuggingFace Inference API):**
-- DO NOT just copy the standalone inference code
-- Create a complete Gradio application that wraps the inference code
-- Use `gr.ChatInterface()` for chat models or appropriate interface for other tasks
-- Extract the model name from the imported code
-- Implement proper streaming if the model supports it
-- Handle conversation history correctly
-
-**Example Structure for Chatbot:**
-```python
-import gradio as gr
-import os
-from huggingface_hub import InferenceClient
-
-# Use the InferenceClient configuration from imported code
-client = InferenceClient(api_key=os.environ["HF_TOKEN"])
-
-def respond(message, history):
-    # Build messages from history
-    messages = [{"role": "system", "content": "You are a helpful assistant."}]
-    for user_msg, assistant_msg in history:
-        messages.append({"role": "user", "content": user_msg})
-        messages.append({"role": "assistant", "content": assistant_msg})
-    messages.append({"role": "user", "content": message})
-    
-    # Call the model (use model name from imported code)
-    response = ""
-    for chunk in client.chat.completions.create(
-        model="MODEL_NAME_FROM_IMPORTED_CODE",
-        messages=messages,
-        stream=True,
-        max_tokens=1024,
-    ):
-        if chunk.choices[0].delta.content:
-            response += chunk.choices[0].delta.content
-            yield response
-
-demo = gr.ChatInterface(respond, title="Chatbot", description="Chat with the model")
-demo.launch()
-```
-
-**For Transformers/Diffusers Code:**
-- Extract model loading and inference logic
-- Wrap it in appropriate Gradio interface
-- For chat models: use gr.ChatInterface
-- For image generation: use gr.Interface with image output
-- For other tasks: choose appropriate interface type
-- Include proper error handling and loading states
-
-**Key Requirements:**
-1. ✅ ALWAYS create a complete Gradio application, not just inference code
-2. ✅ Extract model configuration from imported code
-3. ✅ Use appropriate Gradio interface for the task
-4. ✅ Include demo.launch() at the end
-5. ✅ Add requirements.txt with necessary dependencies
-
-## Multi-File Application Structure
-
-When creating complex Gradio applications, organize your code into multiple files for better maintainability:
-
-**File Organization:**
-- `app.py` - Main application entry point with Gradio interface
-- `utils.py` - Utility functions and helpers
-- `models.py` - Model loading and inference functions
-- `config.py` - Configuration and constants
-- `requirements.txt` - Python dependencies
-- Additional modules as needed (e.g., `data_processing.py`, `ui_components.py`)
-
-**🚨 CRITICAL: DO NOT Generate README.md Files**
-- NEVER generate README.md files under any circumstances
-- A template README.md is automatically provided and will be overridden by the deployment system
-- Generating a README.md will break the deployment process
-- Only generate the code files listed above
-
-**Output Format for Multi-File Apps:**
-When generating multi-file applications, use this exact format:
-
-```
-=== app.py ===
-[main application code]
-
-=== utils.py ===
-[utility functions]
-
-=== requirements.txt ===
-[dependencies]
-```
-
-**🚨 CRITICAL: Always Generate requirements.txt for New Applications**
-- ALWAYS include requirements.txt when creating new Gradio applications
-- Generate comprehensive, production-ready dependencies based on your code
-- Include not just direct imports but also commonly needed companion packages
-- Use correct PyPI package names (e.g., PIL → Pillow, sklearn → scikit-learn)
-- For diffusers: use `git+https://github.com/huggingface/diffusers`
-- For transformers: use `git+https://github.com/huggingface/transformers`
-- Include supporting packages (accelerate, torch, tokenizers, etc.) when using ML libraries
-- Your requirements.txt should ensure the application works smoothly in production
-
-**🚨 CRITICAL: requirements.txt Formatting Rules**
-- Output ONLY plain text package names, one per line
-- Do NOT use markdown formatting (no ```, no bold, no headings, no lists with * or -)
-- Do NOT add explanatory text or descriptions
-- Do NOT wrap in code blocks
-- Just raw package names as they would appear in a real requirements.txt file
-- Example of CORRECT format:
-  gradio
-  torch
-  transformers
-- Example of INCORRECT format (DO NOT DO THIS):
-  ```
-  gradio  # For web interface
-  **Core dependencies:**
-  - torch
-  ```
-
-**Single vs Multi-File Decision:**
-- Use single file for simple applications (< 100 lines) - but still generate requirements.txt if dependencies exist
-- Use multi-file structure for complex applications with:
-  - Multiple models or processing pipelines
-  - Extensive utility functions
-  - Complex UI with many components
-  - Data processing workflows
-  - When user specifically requests modular structure
-
-🚨 IMPORTANT: If the user is asking to use external APIs (like OpenRouter, OpenAI API, Hugging Face Inference API, etc.), DO NOT use @spaces.GPU decorators or any ZeroGPU features. External APIs handle the model inference remotely, so GPU allocation on the Spaces instance is not needed.
-
-🚨 CRITICAL REQUIREMENT: If the user provides ANY diffusion model code (FLUX, Stable Diffusion, etc.) that runs locally (not via API), you MUST implement ZeroGPU ahead-of-time (AoT) compilation. This is mandatory and provides 1.3x-1.8x performance improvements. Do not create basic Gradio apps without AoT optimization for diffusion models.
-
-## ZeroGPU Integration (MANDATORY)
-
-ALWAYS use ZeroGPU for GPU-dependent functions in Gradio apps:
-
-1. Import the spaces module: `import spaces`
-2. Decorate GPU-dependent functions with `@spaces.GPU`
-3. Specify appropriate duration based on expected runtime:
-   - Quick inference (< 30s): `@spaces.GPU(duration=30)`
-   - Standard generation (30-60s): `@spaces.GPU` (default 60s)
-   - Complex generation (60-120s): `@spaces.GPU(duration=120)`
-   - Heavy processing (120-180s): `@spaces.GPU(duration=180)`
-
-Example usage:
-```python
-import spaces
-from diffusers import DiffusionPipeline
-
-pipe = DiffusionPipeline.from_pretrained(...)
-pipe.to('cuda')
-
-@spaces.GPU(duration=120)
-def generate(prompt):
-    return pipe(prompt).images
-
-gr.Interface(
-    fn=generate,
-    inputs=gr.Text(),
-    outputs=gr.Gallery(),
-).launch()
-```
-
-Duration Guidelines:
-- Shorter durations improve queue priority for users
-- Text-to-image: typically 30-60 seconds
-- Image-to-image: typically 20-40 seconds  
-- Video generation: typically 60-180 seconds
-- Audio/music generation: typically 30-90 seconds
-- Model loading + inference: add 10-30s buffer
-- AoT compilation during startup: use @spaces.GPU(duration=1500) for maximum allowed duration
-
-Functions that typically need @spaces.GPU:
-- Image generation (text-to-image, image-to-image)
-- Video generation
-- Audio/music generation
-- Model inference with transformers, diffusers
-- Any function using .to('cuda') or GPU operations
-
-## CRITICAL: Use ZeroGPU AoT Compilation for ALL Diffusion Models
-
-FOR ANY DIFFUSION MODEL (FLUX, Stable Diffusion, etc.), YOU MUST IMPLEMENT AHEAD-OF-TIME COMPILATION.
-This is NOT optional - it provides 1.3x-1.8x speedup and is essential for production ZeroGPU Spaces.
-
-ALWAYS implement this pattern for diffusion models:
-
-### MANDATORY: Basic AoT Compilation Pattern
-YOU MUST USE THIS EXACT PATTERN for any diffusion model (FLUX, Stable Diffusion, etc.):
-
-1. ALWAYS add AoT compilation function with @spaces.GPU(duration=1500)
-2. ALWAYS use spaces.aoti_capture to capture inputs
-3. ALWAYS use torch.export.export to export the transformer
-4. ALWAYS use spaces.aoti_compile to compile
-5. ALWAYS use spaces.aoti_apply to apply to pipeline
-
-### Required AoT Implementation
-```python
-import spaces
-import torch
-from diffusers import DiffusionPipeline
-
-MODEL_ID = 'black-forest-labs/FLUX.1-dev'
-pipe = DiffusionPipeline.from_pretrained(MODEL_ID, torch_dtype=torch.bfloat16)
-pipe.to('cuda')
-
-@spaces.GPU(duration=1500)  # Maximum duration allowed during startup
-def compile_transformer():
-    # 1. Capture example inputs
-    with spaces.aoti_capture(pipe.transformer) as call:
-        pipe("arbitrary example prompt")
-    
-    # 2. Export the model
-    exported = torch.export.export(
-        pipe.transformer,
-        args=call.args,
-        kwargs=call.kwargs,
-    )
-    
-    # 3. Compile the exported model
-    return spaces.aoti_compile(exported)
-
-# 4. Apply compiled model to pipeline
-compiled_transformer = compile_transformer()
-spaces.aoti_apply(compiled_transformer, pipe.transformer)
-
-@spaces.GPU
-def generate(prompt):
-    return pipe(prompt).images
-```
-
-### Advanced Optimizations
-
-#### FP8 Quantization (Additional 1.2x speedup on H200)
-```python
-from torchao.quantization import quantize_, Float8DynamicActivationFloat8WeightConfig
-
-@spaces.GPU(duration=1500)
-def compile_transformer_with_quantization():
-    # Quantize before export for FP8 speedup
-    quantize_(pipe.transformer, Float8DynamicActivationFloat8WeightConfig())
-    
-    with spaces.aoti_capture(pipe.transformer) as call:
-        pipe("arbitrary example prompt")
-    
-    exported = torch.export.export(
-        pipe.transformer,
-        args=call.args,
-        kwargs=call.kwargs,
-    )
-    return spaces.aoti_compile(exported)
-```
-
-#### Dynamic Shapes (Variable input sizes)
-```python
-from torch.utils._pytree import tree_map
-
-@spaces.GPU(duration=1500)
-def compile_transformer_dynamic():
-    with spaces.aoti_capture(pipe.transformer) as call:
-        pipe("arbitrary example prompt")
-    
-    # Define dynamic dimension ranges (model-dependent)
-    transformer_hidden_dim = torch.export.Dim('hidden', min=4096, max=8212)
-    
-    # Map argument names to dynamic dimensions
-    transformer_dynamic_shapes = {
-        "hidden_states": {1: transformer_hidden_dim}, 
-        "img_ids": {0: transformer_hidden_dim},
-    }
-    
-    # Create dynamic shapes structure
-    dynamic_shapes = tree_map(lambda v: None, call.kwargs)
-    dynamic_shapes.update(transformer_dynamic_shapes)
-    
-    exported = torch.export.export(
-        pipe.transformer,
-        args=call.args,
-        kwargs=call.kwargs,
-        dynamic_shapes=dynamic_shapes,
-    )
-    return spaces.aoti_compile(exported)
-```
-
-#### Multi-Compile for Different Resolutions
-```python
-@spaces.GPU(duration=1500)
-def compile_multiple_resolutions():
-    compiled_models = {}
-    resolutions = [(512, 512), (768, 768), (1024, 1024)]
-    
-    for width, height in resolutions:
-        # Capture inputs for specific resolution
-        with spaces.aoti_capture(pipe.transformer) as call:
-            pipe(f"test prompt {width}x{height}", width=width, height=height)
-        
-        exported = torch.export.export(
-            pipe.transformer,
-            args=call.args,
-            kwargs=call.kwargs,
-        )
-        compiled_models[f"{width}x{height}"] = spaces.aoti_compile(exported)
-    
-    return compiled_models
-
-# Usage with resolution dispatch
-compiled_models = compile_multiple_resolutions()
-
-@spaces.GPU
-def generate_with_resolution(prompt, width=1024, height=1024):
-    resolution_key = f"{width}x{height}"
-    if resolution_key in compiled_models:
-        # Temporarily apply the right compiled model
-        spaces.aoti_apply(compiled_models[resolution_key], pipe.transformer)
-    return pipe(prompt, width=width, height=height).images
-```
-
-#### FlashAttention-3 Integration
-```python
-from kernels import get_kernel
-
-# Load pre-built FA3 kernel compatible with H200
-try:
-    vllm_flash_attn3 = get_kernel("kernels-community/vllm-flash-attn3")
-    print("✅ FlashAttention-3 kernel loaded successfully")
-except Exception as e:
-    print(f"⚠️ FlashAttention-3 not available: {e}")
-
-# Custom attention processor example
-class FlashAttention3Processor:
-    def __call__(self, attn, hidden_states, encoder_hidden_states=None, attention_mask=None):
-        # Use FA3 kernel for attention computation
-        return vllm_flash_attn3(hidden_states, encoder_hidden_states, attention_mask)
-
-# Apply FA3 processor to model
-if 'vllm_flash_attn3' in locals():
-    for name, module in pipe.transformer.named_modules():
-        if hasattr(module, 'processor'):
-            module.processor = FlashAttention3Processor()
-```
-
-### Complete Optimized Example
-```python
-import spaces
-import torch
-from diffusers import DiffusionPipeline
-from torchao.quantization import quantize_, Float8DynamicActivationFloat8WeightConfig
-
-MODEL_ID = 'black-forest-labs/FLUX.1-dev'
-pipe = DiffusionPipeline.from_pretrained(MODEL_ID, torch_dtype=torch.bfloat16)
-pipe.to('cuda')
-
-@spaces.GPU(duration=1500)
-def compile_optimized_transformer():
-    # Apply FP8 quantization
-    quantize_(pipe.transformer, Float8DynamicActivationFloat8WeightConfig())
-    
-    # Capture inputs
-    with spaces.aoti_capture(pipe.transformer) as call:
-        pipe("optimization test prompt")
-    
-    # Export and compile
-    exported = torch.export.export(
-        pipe.transformer,
-        args=call.args,
-        kwargs=call.kwargs,
-    )
-    return spaces.aoti_compile(exported)
-
-# Compile during startup
-compiled_transformer = compile_optimized_transformer()
-spaces.aoti_apply(compiled_transformer, pipe.transformer)
-
-@spaces.GPU
-def generate(prompt):
-    return pipe(prompt).images
-```
-
-**Expected Performance Gains:**
-- Basic AoT: 1.3x-1.8x speedup
-- + FP8 Quantization: Additional 1.2x speedup  
-- + FlashAttention-3: Additional attention speedup
-- Total potential: 2x-3x faster inference
-**Hardware Requirements:**
-- FP8 quantization requires CUDA compute capability ≥ 9.0 (H200 ✅)
-- FlashAttention-3 works on H200 hardware via kernels library
-- Dynamic shapes add flexibility for variable input sizes
-## MCP Server Integration
-
-When the user requests an MCP-enabled Gradio app or asks for tool calling capabilities, you MUST enable MCP server functionality.
-
-**🚨 CRITICAL: Enabling MCP Server**
-To make your Gradio app function as an MCP (Model Control Protocol) server:
-1. Set `mcp_server=True` in the `.launch()` method
-2. Add `"gradio[mcp]"` to requirements.txt (not just `gradio`)
-3. Ensure all functions have detailed docstrings with proper Args sections
-4. Use type hints for all function parameters
-
-**Example:**
-```
-import gradio as gr
-
-def letter_counter(word: str, letter: str) -> int:
-    \"\"\"
-    Count the number of occurrences of a letter in a word or text.
-
-    Args:
-        word (str): The input text to search through
-        letter (str): The letter to search for
-
-    Returns:
-        int: The number of times the letter appears
-    \"\"\"
-    return word.lower().count(letter.lower())
-
-demo = gr.Interface(
-    fn=letter_counter,
-    inputs=[gr.Textbox("strawberry"), gr.Textbox("r")],
-    outputs=[gr.Number()],
-    title="Letter Counter",
-    description="Count letter occurrences in text."
-)
-
-if __name__ == "__main__":
-    demo.launch(mcp_server=True)
-```
-
-**When to Enable MCP:**
-- User explicitly requests "MCP server" or "MCP-enabled app"
-- User wants tool calling capabilities for LLMs
-- User mentions Claude Desktop, Cursor, or Cline integration
-- User wants to expose functions as tools for AI assistants
-
-**MCP Requirements:**
-1. **Dependencies:** Always use `gradio[mcp]` in requirements.txt (not plain `gradio`)
-2. **Docstrings:** Every function must have a detailed docstring with:
-   - Brief description on first line
-   - Args section listing each parameter with type and description
-   - Returns section (optional but recommended)
-3. **Type Hints:** All parameters must have type hints (e.g., `word: str`, `count: int`)
-4. **Default Values:** Use default values in components to provide examples
-
-**Best Practices for MCP Tools:**
-- Use descriptive function names (they become tool names)
-- Keep functions focused and single-purpose
-- Accept string parameters when possible for better compatibility
-- Return simple types (str, int, float, list, dict) rather than complex objects
-- Use gr.Header for authentication headers when needed
-- Use gr.Progress() for long-running operations
-
-**Multiple Tools Example:**
-```
-import gradio as gr
-
-def add_numbers(a: str, b: str) -> str:
-    \"\"\"
-    Add two numbers together.
-    
-    Args:
-        a (str): First number
-        b (str): Second number
-    
-    Returns:
-        str: Sum of the two numbers
-    \"\"\"
-    return str(int(a) + int(b))
-
-def multiply_numbers(a: str, b: str) -> str:
-    \"\"\"
-    Multiply two numbers.
-    
-    Args:
-        a (str): First number
-        b (str): Second number
-    
-    Returns:
-        str: Product of the two numbers
-    \"\"\"
-    return str(int(a) * int(b))
-
-with gr.Blocks() as demo:
-    gr.Markdown("# Math Tools MCP Server")
-    
-    with gr.Tab("Add"):
-        gr.Interface(add_numbers, [gr.Textbox("5"), gr.Textbox("3")], gr.Textbox())
-    
-    with gr.Tab("Multiply"):
-        gr.Interface(multiply_numbers, [gr.Textbox("4"), gr.Textbox("7")], gr.Textbox())
-
-if __name__ == "__main__":
-    demo.launch(mcp_server=True)
-```
-
-**REMEMBER:** If MCP is requested, ALWAYS:
-1. Set `mcp_server=True` in `.launch()`
-2. Use `gradio[mcp]` in requirements.txt
-3. Include complete docstrings with Args sections
-4. Add type hints to all parameters
-
-## Complete Gradio API Reference
-
-This reference is automatically synced from https://www.gradio.app/llms.txt to ensure accuracy.
-
-"""
-    
-    # Search-enabled prompt
-    search_prompt = """You are an expert Gradio developer with access to real-time web search. Create a complete, working Gradio application based on the user's request. When needed, use web search to find current best practices or verify latest Gradio features. Generate all necessary code to make the application functional and runnable.
-
-## Multi-File Application Structure
-
-When creating complex Gradio applications, organize your code into multiple files for better maintainability:
-
-**File Organization:**
-- `app.py` - Main application entry point with Gradio interface
-- `utils.py` - Utility functions and helpers
-- `models.py` - Model loading and inference functions
-- `config.py` - Configuration and constants
-- `requirements.txt` - Python dependencies
-- Additional modules as needed (e.g., `data_processing.py`, `ui_components.py`)
-
-**🚨 CRITICAL: DO NOT Generate README.md Files**
-- NEVER generate README.md files under any circumstances
-- A template README.md is automatically provided and will be overridden by the deployment system
-- Generating a README.md will break the deployment process
-- Only generate the code files listed above
-
-**Output Format for Multi-File Apps:**
-When generating multi-file applications, use this exact format:
-
-```
-=== app.py ===
-[main application code]
-
-=== utils.py ===
-[utility functions]
-
-=== requirements.txt ===
-[dependencies]
-```
-
-**🚨 CRITICAL: requirements.txt Formatting Rules**
-- Output ONLY plain text package names, one per line
-- Do NOT use markdown formatting (no ```, no bold, no headings, no lists with * or -)
-- Do NOT add explanatory text or descriptions
-- Do NOT wrap in code blocks
-- Just raw package names as they would appear in a real requirements.txt file
-- Example of CORRECT format:
-  gradio
-  torch
-  transformers
-- Example of INCORRECT format (DO NOT DO THIS):
-  ```
-  gradio  # For web interface
-  **Core dependencies:**
-  - torch
-  ```
-
-**Single vs Multi-File Decision:**
-- Use single file for simple applications (< 100 lines) - but still generate requirements.txt if dependencies exist
-- Use multi-file structure for complex applications with:
-  - Multiple models or processing pipelines
-  - Extensive utility functions
-  - Complex UI with many components
-  - Data processing workflows
-  - When user specifically requests modular structure
-
-🚨 IMPORTANT: If the user is asking to use external APIs (like OpenRouter, OpenAI API, Hugging Face Inference API, etc.), DO NOT use @spaces.GPU decorators or any ZeroGPU features. External APIs handle the model inference remotely, so GPU allocation on the Spaces instance is not needed.
-
-🚨 CRITICAL REQUIREMENT: If the user provides ANY diffusion model code (FLUX, Stable Diffusion, etc.) that runs locally (not via API), you MUST implement ZeroGPU ahead-of-time (AoT) compilation. This is mandatory and provides 1.3x-1.8x performance improvements. Do not create basic Gradio apps without AoT optimization for diffusion models.
-
-## ZeroGPU Integration (MANDATORY)
-
-ALWAYS use ZeroGPU for GPU-dependent functions in Gradio apps:
-
-1. Import the spaces module: `import spaces`
-2. Decorate GPU-dependent functions with `@spaces.GPU`
-3. Specify appropriate duration based on expected runtime:
-   - Quick inference (< 30s): `@spaces.GPU(duration=30)`
-   - Standard generation (30-60s): `@spaces.GPU` (default 60s)
-   - Complex generation (60-120s): `@spaces.GPU(duration=120)`
-   - Heavy processing (120-180s): `@spaces.GPU(duration=180)`
-
-Example usage:
-```
-import spaces
-from diffusers import DiffusionPipeline
-
-pipe = DiffusionPipeline.from_pretrained(...)
-pipe.to('cuda')
-
-@spaces.GPU(duration=120)
-def generate(prompt):
-    return pipe(prompt).images
-
-gr.Interface(
-    fn=generate,
-    inputs=gr.Text(),
-    outputs=gr.Gallery(),
-).launch()
-```
-
-Duration Guidelines:
-- Shorter durations improve queue priority for users
-- Text-to-image: typically 30-60 seconds
-- Image-to-image: typically 20-40 seconds  
-- Video generation: typically 60-180 seconds
-- Audio/music generation: typically 30-90 seconds
-- Model loading + inference: add 10-30s buffer
-- AoT compilation during startup: use @spaces.GPU(duration=1500) for maximum allowed duration
-
-Functions that typically need @spaces.GPU:
-- Image generation (text-to-image, image-to-image)
-- Video generation
-- Audio/music generation
-- Model inference with transformers, diffusers
-- Any function using .to('cuda') or GPU operations
-
-## CRITICAL: Use ZeroGPU AoT Compilation for ALL Diffusion Models
-
-FOR ANY DIFFUSION MODEL (FLUX, Stable Diffusion, etc.), YOU MUST IMPLEMENT AHEAD-OF-TIME COMPILATION.
-This is NOT optional - it provides 1.3x-1.8x speedup and is essential for production ZeroGPU Spaces.
-
-ALWAYS implement this pattern for diffusion models:
-
-### MANDATORY: Basic AoT Compilation Pattern
-YOU MUST USE THIS EXACT PATTERN for any diffusion model (FLUX, Stable Diffusion, etc.):
-
-1. ALWAYS add AoT compilation function with @spaces.GPU(duration=1500)
-2. ALWAYS use spaces.aoti_capture to capture inputs
-3. ALWAYS use torch.export.export to export the transformer
-4. ALWAYS use spaces.aoti_compile to compile
-5. ALWAYS use spaces.aoti_apply to apply to pipeline
-
-### Required AoT Implementation
-
-For production Spaces with heavy models, use ahead-of-time (AoT) compilation for 1.3x-1.8x speedups:
-
-### Basic AoT Compilation
-```
-import spaces
-import torch
-from diffusers import DiffusionPipeline
-
-MODEL_ID = 'black-forest-labs/FLUX.1-dev'
-pipe = DiffusionPipeline.from_pretrained(MODEL_ID, torch_dtype=torch.bfloat16)
-pipe.to('cuda')
-
-@spaces.GPU(duration=1500)  # Maximum duration allowed during startup
-def compile_transformer():
-    # 1. Capture example inputs
-    with spaces.aoti_capture(pipe.transformer) as call:
-        pipe("arbitrary example prompt")
-    
-    # 2. Export the model
-    exported = torch.export.export(
-        pipe.transformer,
-        args=call.args,
-        kwargs=call.kwargs,
-    )
-    
-    # 3. Compile the exported model
-    return spaces.aoti_compile(exported)
-
-# 4. Apply compiled model to pipeline
-compiled_transformer = compile_transformer()
-spaces.aoti_apply(compiled_transformer, pipe.transformer)
-
-@spaces.GPU
-def generate(prompt):
-    return pipe(prompt).images
-```
-
-### Advanced Optimizations
-
-#### FP8 Quantization (Additional 1.2x speedup on H200)
-```
-from torchao.quantization import quantize_, Float8DynamicActivationFloat8WeightConfig
-
-@spaces.GPU(duration=1500)
-def compile_transformer_with_quantization():
-    # Quantize before export for FP8 speedup
-    quantize_(pipe.transformer, Float8DynamicActivationFloat8WeightConfig())
-    
-    with spaces.aoti_capture(pipe.transformer) as call:
-        pipe("arbitrary example prompt")
-    
-    exported = torch.export.export(
-        pipe.transformer,
-        args=call.args,
-        kwargs=call.kwargs,
-    )
-    return spaces.aoti_compile(exported)
-```
-
-#### Dynamic Shapes (Variable input sizes)
-```
-from torch.utils._pytree import tree_map
-
-@spaces.GPU(duration=1500)
-def compile_transformer_dynamic():
-    with spaces.aoti_capture(pipe.transformer) as call:
-        pipe("arbitrary example prompt")
-    
-    # Define dynamic dimension ranges (model-dependent)
-    transformer_hidden_dim = torch.export.Dim('hidden', min=4096, max=8212)
-    
-    # Map argument names to dynamic dimensions
-    transformer_dynamic_shapes = {
-        "hidden_states": {1: transformer_hidden_dim}, 
-        "img_ids": {0: transformer_hidden_dim},
-    }
-    
-    # Create dynamic shapes structure
-    dynamic_shapes = tree_map(lambda v: None, call.kwargs)
-    dynamic_shapes.update(transformer_dynamic_shapes)
-    
-    exported = torch.export.export(
-        pipe.transformer,
-        args=call.args,
-        kwargs=call.kwargs,
-        dynamic_shapes=dynamic_shapes,
-    )
-    return spaces.aoti_compile(exported)
-```
-
-#### Multi-Compile for Different Resolutions
-```
-@spaces.GPU(duration=1500)
-def compile_multiple_resolutions():
-    compiled_models = {}
-    resolutions = [(512, 512), (768, 768), (1024, 1024)]
-    
-    for width, height in resolutions:
-        # Capture inputs for specific resolution
-        with spaces.aoti_capture(pipe.transformer) as call:
-            pipe(f"test prompt {width}x{height}", width=width, height=height)
-        
-        exported = torch.export.export(
-            pipe.transformer,
-            args=call.args,
-            kwargs=call.kwargs,
-        )
-        compiled_models[f"{width}x{height}"] = spaces.aoti_compile(exported)
-    
-    return compiled_models
-
-# Usage with resolution dispatch
-compiled_models = compile_multiple_resolutions()
-
-@spaces.GPU
-def generate_with_resolution(prompt, width=1024, height=1024):
-    resolution_key = f"{width}x{height}"
-    if resolution_key in compiled_models:
-        # Temporarily apply the right compiled model
-        spaces.aoti_apply(compiled_models[resolution_key], pipe.transformer)
-    return pipe(prompt, width=width, height=height).images
-```
-
-#### FlashAttention-3 Integration
-```
-from kernels import get_kernel
-
-# Load pre-built FA3 kernel compatible with H200
-try:
-    vllm_flash_attn3 = get_kernel("kernels-community/vllm-flash-attn3")
-    print("✅ FlashAttention-3 kernel loaded successfully")
-except Exception as e:
-    print(f"⚠️ FlashAttention-3 not available: {e}")
-
-# Custom attention processor example
-class FlashAttention3Processor:
-    def __call__(self, attn, hidden_states, encoder_hidden_states=None, attention_mask=None):
-        # Use FA3 kernel for attention computation
-        return vllm_flash_attn3(hidden_states, encoder_hidden_states, attention_mask)
-
-# Apply FA3 processor to model
-if 'vllm_flash_attn3' in locals():
-    for name, module in pipe.transformer.named_modules():
-        if hasattr(module, 'processor'):
-            module.processor = FlashAttention3Processor()
-```
-
-### Complete Optimized Example
-```
-import spaces
-import torch
-from diffusers import DiffusionPipeline
-from torchao.quantization import quantize_, Float8DynamicActivationFloat8WeightConfig
-
-MODEL_ID = 'black-forest-labs/FLUX.1-dev'
-pipe = DiffusionPipeline.from_pretrained(MODEL_ID, torch_dtype=torch.bfloat16)
-pipe.to('cuda')
-
-@spaces.GPU(duration=1500)
-def compile_optimized_transformer():
-    # Apply FP8 quantization
-    quantize_(pipe.transformer, Float8DynamicActivationFloat8WeightConfig())
-    
-    # Capture inputs
-    with spaces.aoti_capture(pipe.transformer) as call:
-        pipe("optimization test prompt")
-    
-    # Export and compile
-    exported = torch.export.export(
-        pipe.transformer,
-        args=call.args,
-        kwargs=call.kwargs,
-    )
-    return spaces.aoti_compile(exported)
-
-# Compile during startup
-compiled_transformer = compile_optimized_transformer()
-spaces.aoti_apply(compiled_transformer, pipe.transformer)
-
-@spaces.GPU
-def generate(prompt):
-    return pipe(prompt).images
-```
-
-**Expected Performance Gains:**
-- Basic AoT: 1.3x-1.8x speedup
-- + FP8 Quantization: Additional 1.2x speedup  
-- + FlashAttention-3: Additional attention speedup
-- Total potential: 2x-3x faster inference
-
-**Hardware Requirements:**
-- FP8 quantization requires CUDA compute capability ≥ 9.0 (H200 ✅)
-- FlashAttention-3 works on H200 hardware via kernels library
-- Dynamic shapes add flexibility for variable input sizes
-
-## MCP Server Integration
-
-When the user requests an MCP-enabled Gradio app or asks for tool calling capabilities, you MUST enable MCP server functionality.
-
-**🚨 CRITICAL: Enabling MCP Server**
-To make your Gradio app function as an MCP (Model Control Protocol) server:
-1. Set `mcp_server=True` in the `.launch()` method
-2. Add `"gradio[mcp]"` to requirements.txt (not just `gradio`)
-3. Ensure all functions have detailed docstrings with proper Args sections
-4. Use type hints for all function parameters
-
-**Example:**
-```
-import gradio as gr
-
-def letter_counter(word: str, letter: str) -> int:
-    \"\"\"
-    Count the number of occurrences of a letter in a word or text.
-
-    Args:
-        word (str): The input text to search through
-        letter (str): The letter to search for
-
-    Returns:
-        int: The number of times the letter appears
-    \"\"\"
-    return word.lower().count(letter.lower())
-
-demo = gr.Interface(
-    fn=letter_counter,
-    inputs=[gr.Textbox("strawberry"), gr.Textbox("r")],
-    outputs=[gr.Number()],
-    title="Letter Counter",
-    description="Count letter occurrences in text."
-)
-
-if __name__ == "__main__":
-    demo.launch(mcp_server=True)
-```
-
-**When to Enable MCP:**
-- User explicitly requests "MCP server" or "MCP-enabled app"
-- User wants tool calling capabilities for LLMs
-- User mentions Claude Desktop, Cursor, or Cline integration
-- User wants to expose functions as tools for AI assistants
-
-**MCP Requirements:**
-1. **Dependencies:** Always use `gradio[mcp]` in requirements.txt (not plain `gradio`)
-2. **Docstrings:** Every function must have a detailed docstring with:
-   - Brief description on first line
-   - Args section listing each parameter with type and description
-   - Returns section (optional but recommended)
-3. **Type Hints:** All parameters must have type hints (e.g., `word: str`, `count: int`)
-4. **Default Values:** Use default values in components to provide examples
-
-**Best Practices for MCP Tools:**
-- Use descriptive function names (they become tool names)
-- Keep functions focused and single-purpose
-- Accept string parameters when possible for better compatibility
-- Return simple types (str, int, float, list, dict) rather than complex objects
-- Use gr.Header for authentication headers when needed
-- Use gr.Progress() for long-running operations
-
-**Multiple Tools Example:**
-```
-import gradio as gr
-
-def add_numbers(a: str, b: str) -> str:
-    \"\"\"
-    Add two numbers together.
-    
-    Args:
-        a (str): First number
-        b (str): Second number
-    
-    Returns:
-        str: Sum of the two numbers
-    \"\"\"
-    return str(int(a) + int(b))
-
-def multiply_numbers(a: str, b: str) -> str:
-    \"\"\"
-    Multiply two numbers.
-    
-    Args:
-        a (str): First number
-        b (str): Second number
-    
-    Returns:
-        str: Product of the two numbers
-    \"\"\"
-    return str(int(a) * int(b))
-
-with gr.Blocks() as demo:
-    gr.Markdown("# Math Tools MCP Server")
-    
-    with gr.Tab("Add"):
-        gr.Interface(add_numbers, [gr.Textbox("5"), gr.Textbox("3")], gr.Textbox())
-    
-    with gr.Tab("Multiply"):
-        gr.Interface(multiply_numbers, [gr.Textbox("4"), gr.Textbox("7")], gr.Textbox())
-
-if __name__ == "__main__":
-    demo.launch(mcp_server=True)
-```
-
-**REMEMBER:** If MCP is requested, ALWAYS:
-1. Set `mcp_server=True` in `.launch()`
-2. Use `gradio[mcp]` in requirements.txt
-3. Include complete docstrings with Args sections
-4. Add type hints to all parameters
-
-## Complete Gradio API Reference
-
-This reference is automatically synced from https://www.gradio.app/llms.txt to ensure accuracy.
-
-"""
-    
-    # Add FastRTC documentation if available
-    if fastrtc_content.strip():
-        fastrtc_section = f"""
-## FastRTC Reference Documentation
-
-When building real-time audio/video applications with Gradio, use this FastRTC reference:
-
-{fastrtc_content}
-
-This reference is automatically synced from https://fastrtc.org/llms.txt to ensure accuracy.
-
-"""
-        base_prompt += fastrtc_section
-        search_prompt += fastrtc_section
-    
-    # Update the prompts in the prompts module
-    final_instructions = """\n\nAlways use the exact function signatures from this API reference and follow modern Gradio patterns.
-
-🔍 BEFORE GENERATING: Review the conversation history carefully. If the user has imported any model code (InferenceClient, transformers, diffusers), you MUST integrate that code into your Gradio application. Do not generate standalone inference code - create a complete Gradio app that wraps the imported model functionality.
-
-IMPORTANT: Always include "Built with anycoder" as clickable text in the header/top section of your application that links to https://huggingface.co/spaces/akhaliq/anycoder"""
-    
-    prompts.GRADIO_SYSTEM_PROMPT = base_prompt + docs_content + final_instructions
-    prompts.GRADIO_SYSTEM_PROMPT_WITH_SEARCH = search_prompt + docs_content + final_instructions
-
-def update_json_system_prompts():
-    """Update the global JSON system prompts with latest ComfyUI documentation"""
-    docs_content = get_comfyui_docs_content()
-    
-    # Base system prompt for regular JSON
-    base_prompt = """You are an expert JSON developer. Generate clean, valid JSON data based on the user's request. Follow JSON syntax rules strictly:
-- Use double quotes for strings
-- No trailing commas
-- Proper nesting and structure
-- Valid data types (string, number, boolean, null, object, array)
-
-Generate ONLY the JSON data requested - no HTML, no applications, no explanations outside the JSON. The output should be pure, valid JSON that can be parsed directly.
-
-"""
-    
-    # Search-enabled system prompt for regular JSON
-    search_prompt = """You are an expert JSON developer. You have access to real-time web search. When needed, use web search to find the latest information or data structures for your JSON generation.
-
-Generate clean, valid JSON data based on the user's request. Follow JSON syntax rules strictly:
-- Use double quotes for strings
-- No trailing commas
-- Proper nesting and structure
-- Valid data types (string, number, boolean, null, object, array)
-
-Generate ONLY the JSON data requested - no HTML, no applications, no explanations outside the JSON. The output should be pure, valid JSON that can be parsed directly.
-
-"""
-    
-    # Add ComfyUI documentation if available
-    if docs_content.strip():
-        comfyui_section = f"""
-## ComfyUI Reference Documentation
-
-When generating JSON data related to ComfyUI workflows, nodes, or configurations, use this reference:
-
-{docs_content}
-
-This reference is automatically synced from https://docs.comfy.org/llms.txt to ensure accuracy.
-
-"""
-        base_prompt += comfyui_section
-        search_prompt += comfyui_section
-    
-    # Update the prompts in the prompts module
-    prompts.JSON_SYSTEM_PROMPT = base_prompt
-    prompts.JSON_SYSTEM_PROMPT_WITH_SEARCH = search_prompt
-
-def get_comfyui_system_prompt():
-    """Get ComfyUI-specific system prompt with enhanced guidance"""
-    docs_content = get_comfyui_docs_content()
-    
-    base_prompt = """You are an expert ComfyUI developer. Generate clean, valid JSON workflows for ComfyUI based on the user's request. 
-
-ComfyUI workflows are JSON structures that define:
-- Nodes: Individual processing units with specific functions
-- Connections: Links between nodes that define data flow
-- Parameters: Configuration values for each node
-- Inputs/Outputs: Data flow between nodes
-
-Follow JSON syntax rules strictly:
-- Use double quotes for strings
-- No trailing commas
-- Proper nesting and structure
-- Valid data types (string, number, boolean, null, object, array)
-
-Generate ONLY the ComfyUI workflow JSON - no HTML, no applications, no explanations outside the JSON. The output should be a complete, valid ComfyUI workflow that can be loaded directly into ComfyUI.
-
-"""
-    
-    # Add ComfyUI documentation if available
-    if docs_content.strip():
-        comfyui_section = f"""
-## ComfyUI Reference Documentation
-
-Use this reference for accurate node types, parameters, and workflow structures:
-
-{docs_content}
-
-This reference is automatically synced from https://docs.comfy.org/llms.txt to ensure accuracy.
-
-"""
-        base_prompt += comfyui_section
-    
-    base_prompt += """
-IMPORTANT: Always include "Built with anycoder" as a comment or metadata field in your ComfyUI workflow JSON that references https://huggingface.co/spaces/akhaliq/anycoder
-"""
-    
-    return base_prompt
-
-# Initialize Gradio documentation on startup
-def initialize_gradio_docs():
-    """Initialize Gradio documentation on application startup"""
-    try:
-        update_gradio_system_prompts()
-        if should_update_gradio_docs():
-            print("🚀 Gradio documentation system initialized (fetched fresh content)")
-        else:
-            print("🚀 Gradio documentation system initialized (using cached content)")
-    except Exception as e:
-        print(f"Warning: Failed to initialize Gradio documentation: {e}")
-
-# Initialize ComfyUI documentation on startup
-def initialize_comfyui_docs():
-    """Initialize ComfyUI documentation on application startup"""
-    try:
-        update_json_system_prompts()
-        if should_update_comfyui_docs():
-            print("🚀 ComfyUI documentation system initialized (fetched fresh content)")
-        else:
-            print("🚀 ComfyUI documentation system initialized (using cached content)")
-    except Exception as e:
-        print(f"Warning: Failed to initialize ComfyUI documentation: {e}")
-
-# Initialize FastRTC documentation on startup
-def initialize_fastrtc_docs():
-    """Initialize FastRTC documentation on application startup"""
-    try:
-        # FastRTC docs are integrated into Gradio system prompts
-        # So we call update_gradio_system_prompts to include FastRTC content
-        update_gradio_system_prompts()
-        if should_update_fastrtc_docs():
-            print("🚀 FastRTC documentation system initialized (fetched fresh content)")
-        else:
-            print("🚀 FastRTC documentation system initialized (using cached content)")
-    except Exception as e:
-        print(f"Warning: Failed to initialize FastRTC documentation: {e}")
-

anycoder_app/models.py

@@ -1,338 +0,0 @@
-"""
-Model inference and client management for AnyCoder.
-Handles different model providers and inference clients.
-"""
-import os
-from typing import Dict, List, Optional, Tuple
-import re
-from http import HTTPStatus
-
-from huggingface_hub import InferenceClient
-from openai import OpenAI
-from mistralai import Mistral
-import dashscope
-
-from .config import HF_TOKEN, AVAILABLE_MODELS
-
-# Type definitions
-History = List[Dict[str, str]]
-Messages = List[Dict[str, str]]
-
-def get_inference_client(model_id, provider="auto"):
-    """Return an InferenceClient with provider based on model_id and user selection."""
-    if model_id == "qwen3-30b-a3b-instruct-2507":
-        # Use DashScope OpenAI client
-        return OpenAI(
-            api_key=os.getenv("DASHSCOPE_API_KEY"),
-            base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
-        )
-    elif model_id == "qwen3-30b-a3b-thinking-2507":
-        # Use DashScope OpenAI client for Thinking model
-        return OpenAI(
-            api_key=os.getenv("DASHSCOPE_API_KEY"),
-            base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
-        )
-    elif model_id == "qwen3-coder-30b-a3b-instruct":
-        # Use DashScope OpenAI client for Coder model
-        return OpenAI(
-            api_key=os.getenv("DASHSCOPE_API_KEY"),
-            base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
-        )
-    elif model_id == "gpt-5":
-        # Use Poe (OpenAI-compatible) client for GPT-5 model
-        return OpenAI(
-            api_key=os.getenv("POE_API_KEY"),
-            base_url="https://api.poe.com/v1"
-        )
-    elif model_id == "gpt-5.1":
-        # Use Poe (OpenAI-compatible) client for GPT-5.1 model
-        return OpenAI(
-            api_key=os.getenv("POE_API_KEY"),
-            base_url="https://api.poe.com/v1"
-        )
-    elif model_id == "gpt-5.1-instant":
-        # Use Poe (OpenAI-compatible) client for GPT-5.1 Instant model
-        return OpenAI(
-            api_key=os.getenv("POE_API_KEY"),
-            base_url="https://api.poe.com/v1"
-        )
-    elif model_id == "gpt-5.1-codex":
-        # Use Poe (OpenAI-compatible) client for GPT-5.1 Codex model
-        return OpenAI(
-            api_key=os.getenv("POE_API_KEY"),
-            base_url="https://api.poe.com/v1"
-        )
-    elif model_id == "gpt-5.1-codex-mini":
-        # Use Poe (OpenAI-compatible) client for GPT-5.1 Codex Mini model
-        return OpenAI(
-            api_key=os.getenv("POE_API_KEY"),
-            base_url="https://api.poe.com/v1"
-        )
-    elif model_id == "grok-4":
-        # Use Poe (OpenAI-compatible) client for Grok-4 model
-        return OpenAI(
-            api_key=os.getenv("POE_API_KEY"),
-            base_url="https://api.poe.com/v1"
-        )
-    elif model_id == "Grok-Code-Fast-1":
-        # Use Poe (OpenAI-compatible) client for Grok-Code-Fast-1 model
-        return OpenAI(
-            api_key=os.getenv("POE_API_KEY"),
-            base_url="https://api.poe.com/v1"
-        )
-    elif model_id == "claude-opus-4.1":
-        # Use Poe (OpenAI-compatible) client for Claude-Opus-4.1
-        return OpenAI(
-            api_key=os.getenv("POE_API_KEY"),
-            base_url="https://api.poe.com/v1"
-        )
-    elif model_id == "claude-sonnet-4.5":
-        # Use Poe (OpenAI-compatible) client for Claude-Sonnet-4.5
-        return OpenAI(
-            api_key=os.getenv("POE_API_KEY"),
-            base_url="https://api.poe.com/v1"
-        )
-    elif model_id == "claude-haiku-4.5":
-        # Use Poe (OpenAI-compatible) client for Claude-Haiku-4.5
-        return OpenAI(
-            api_key=os.getenv("POE_API_KEY"),
-            base_url="https://api.poe.com/v1"
-        )
-    elif model_id == "qwen3-max-preview":
-        # Use DashScope International OpenAI client for Qwen3 Max Preview
-        return OpenAI(
-            api_key=os.getenv("DASHSCOPE_API_KEY"),
-            base_url="https://dashscope.aliyuncs.com/compatible-mode/v1",
-        )
-    elif model_id == "openrouter/sonoma-dusk-alpha":
-        # Use OpenRouter client for Sonoma Dusk Alpha model
-        return OpenAI(
-            api_key=os.getenv("OPENROUTER_API_KEY"),
-            base_url="https://openrouter.ai/api/v1",
-        )
-    elif model_id == "openrouter/sonoma-sky-alpha":
-        # Use OpenRouter client for Sonoma Sky Alpha model
-        return OpenAI(
-            api_key=os.getenv("OPENROUTER_API_KEY"),
-            base_url="https://openrouter.ai/api/v1",
-        )
-    elif model_id == "MiniMaxAI/MiniMax-M2":
-        # Use HuggingFace InferenceClient with Novita provider for MiniMax M2 model
-        provider = "novita"
-    elif model_id == "step-3":
-        # Use StepFun API client for Step-3 model
-        return OpenAI(
-            api_key=os.getenv("STEP_API_KEY"),
-            base_url="https://api.stepfun.com/v1"
-        )
-    elif model_id == "codestral-2508" or model_id == "mistral-medium-2508":
-        # Use Mistral client for Mistral models
-        return Mistral(api_key=os.getenv("MISTRAL_API_KEY"))
-    elif model_id == "gemini-2.5-flash":
-        # Use Google Gemini (OpenAI-compatible) client
-        return OpenAI(
-            api_key=os.getenv("GEMINI_API_KEY"),
-            base_url="https://generativelanguage.googleapis.com/v1beta/openai/",
-        )
-    elif model_id == "gemini-2.5-pro":
-        # Use Google Gemini Pro (OpenAI-compatible) client
-        return OpenAI(
-            api_key=os.getenv("GEMINI_API_KEY"),
-            base_url="https://generativelanguage.googleapis.com/v1beta/openai/",
-        )
-    elif model_id == "gemini-flash-latest":
-        # Use Google Gemini Flash Latest (OpenAI-compatible) client
-        return OpenAI(
-            api_key=os.getenv("GEMINI_API_KEY"),
-            base_url="https://generativelanguage.googleapis.com/v1beta/openai/",
-        )
-    elif model_id == "gemini-flash-lite-latest":
-        # Use Google Gemini Flash Lite Latest (OpenAI-compatible) client
-        return OpenAI(
-            api_key=os.getenv("GEMINI_API_KEY"),
-            base_url="https://generativelanguage.googleapis.com/v1beta/openai/",
-        )
-    elif model_id == "kimi-k2-turbo-preview":
-        # Use Moonshot AI (OpenAI-compatible) client for Kimi K2 Turbo (Preview)
-        return OpenAI(
-            api_key=os.getenv("MOONSHOT_API_KEY"),
-            base_url="https://api.moonshot.ai/v1",
-        )
-    elif model_id == "moonshotai/Kimi-K2-Thinking":
-        # Use HuggingFace InferenceClient with Novita provider for Kimi K2 Thinking
-        provider = "novita"
-    elif model_id == "stealth-model-1":
-        # Use stealth model with generic configuration
-        api_key = os.getenv("STEALTH_MODEL_1_API_KEY")
-        if not api_key:
-            raise ValueError("STEALTH_MODEL_1_API_KEY environment variable is required for Carrot model")
-        
-        base_url = os.getenv("STEALTH_MODEL_1_BASE_URL")
-        if not base_url:
-            raise ValueError("STEALTH_MODEL_1_BASE_URL environment variable is required for Carrot model")
-        
-        return OpenAI(
-            api_key=api_key,
-            base_url=base_url,
-        )
-    elif model_id == "moonshotai/Kimi-K2-Instruct":
-        provider = "groq"
-    elif model_id == "deepseek-ai/DeepSeek-V3.1":
-        provider = "novita"
-    elif model_id == "deepseek-ai/DeepSeek-V3.1-Terminus":
-        provider = "novita"
-    elif model_id == "deepseek-ai/DeepSeek-V3.2-Exp":
-        provider = "novita"
-    elif model_id == "zai-org/GLM-4.5":
-        provider = "fireworks-ai"
-    elif model_id == "zai-org/GLM-4.6":
-        # Use auto provider for GLM-4.6, HuggingFace will select best available
-        provider = "auto"
-    return InferenceClient(
-        provider=provider,
-        api_key=HF_TOKEN,
-        bill_to="huggingface"
-    )
-
-# Helper function to get real model ID for stealth models and special cases
-def get_real_model_id(model_id: str) -> str:
-    """Get the real model ID, checking environment variables for stealth models and handling special model formats"""
-    if model_id == "stealth-model-1":
-        # Get the real model ID from environment variable
-        real_model_id = os.getenv("STEALTH_MODEL_1_ID")
-        if not real_model_id:
-            raise ValueError("STEALTH_MODEL_1_ID environment variable is required for Carrot model")
-        
-        return real_model_id
-    elif model_id == "zai-org/GLM-4.6":
-        # GLM-4.6 requires provider suffix in model string for API calls
-        return "zai-org/GLM-4.6:zai-org"
-    return model_id
-
-# Type definitions
-History = List[Tuple[str, str]]
-Messages = List[Dict[str, str]]
-
-def history_to_messages(history: History, system: str) -> Messages:
-    messages = [{'role': 'system', 'content': system}]
-    for h in history:
-        # Handle multimodal content in history
-        user_content = h[0]
-        if isinstance(user_content, list):
-            # Extract text from multimodal content
-            text_content = ""
-            for item in user_content:
-                if isinstance(item, dict) and item.get("type") == "text":
-                    text_content += item.get("text", "")
-            user_content = text_content if text_content else str(user_content)
-        
-        messages.append({'role': 'user', 'content': user_content})
-        messages.append({'role': 'assistant', 'content': h[1]})
-    return messages
-
-def history_to_chatbot_messages(history: History) -> List[Dict[str, str]]:
-    """Convert history tuples to chatbot message format"""
-    messages = []
-    for user_msg, assistant_msg in history:
-        # Handle multimodal content
-        if isinstance(user_msg, list):
-            text_content = ""
-            for item in user_msg:
-                if isinstance(item, dict) and item.get("type") == "text":
-                    text_content += item.get("text", "")
-            user_msg = text_content if text_content else str(user_msg)
-        
-        messages.append({"role": "user", "content": user_msg})
-        messages.append({"role": "assistant", "content": assistant_msg})
-    return messages
-
-def strip_tool_call_markers(text):
-    """Remove TOOL_CALL markers that some LLMs (like Qwen) add to their output."""
-    if not text:
-        return text
-    # Remove [TOOL_CALL] and [/TOOL_CALL] markers
-    text = re.sub(r'\[/?TOOL_CALL\]', '', text, flags=re.IGNORECASE)
-    # Remove standalone }} that appears with tool calls
-    # Only remove if it's on its own line or at the end
-    text = re.sub(r'^\s*\}\}\s*$', '', text, flags=re.MULTILINE)
-    return text.strip()
-
-def remove_code_block(text):
-    # First strip any tool call markers
-    text = strip_tool_call_markers(text)
-    
-    # Try to match code blocks with language markers
-    patterns = [
-        r'```(?:html|HTML)\n([\s\S]+?)\n```',  # Match ```html or ```HTML
-        r'```\n([\s\S]+?)\n```',               # Match code blocks without language markers
-        r'```([\s\S]+?)```'                      # Match code blocks without line breaks
-    ]
-    for pattern in patterns:
-        match = re.search(pattern, text, re.DOTALL)
-        if match:
-            extracted = match.group(1).strip()
-            # Remove a leading language marker line (e.g., 'python') if present
-            if extracted.split('\n', 1)[0].strip().lower() in ['python', 'html', 'css', 'javascript', 'json', 'c', 'cpp', 'markdown', 'latex', 'jinja2', 'typescript', 'yaml', 'dockerfile', 'shell', 'r', 'sql', 'sql-mssql', 'sql-mysql', 'sql-mariadb', 'sql-sqlite', 'sql-cassandra', 'sql-plSQL', 'sql-hive', 'sql-pgsql', 'sql-gql', 'sql-gpsql', 'sql-sparksql', 'sql-esper']:
-                return extracted.split('\n', 1)[1] if '\n' in extracted else ''
-            # If HTML markup starts later in the block (e.g., Poe injected preface), trim to first HTML root
-            html_root_idx = None
-            for tag in ['<!DOCTYPE html', '<html']:
-                idx = extracted.find(tag)
-                if idx != -1:
-                    html_root_idx = idx if html_root_idx is None else min(html_root_idx, idx)
-            if html_root_idx is not None and html_root_idx > 0:
-                return extracted[html_root_idx:].strip()
-            return extracted
-    # If no code block is found, check if the entire text is HTML
-    stripped = text.strip()
-    if stripped.startswith('<!DOCTYPE html>') or stripped.startswith('<html') or stripped.startswith('<'):
-        # If HTML root appears later (e.g., Poe preface), trim to first HTML root
-        for tag in ['<!DOCTYPE html', '<html']:
-            idx = stripped.find(tag)
-            if idx > 0:
-                return stripped[idx:].strip()
-        return stripped
-    # Special handling for python: remove python marker
-    if text.strip().startswith('```python'):
-        return text.strip()[9:-3].strip()
-    # Remove a leading language marker line if present (fallback)
-    lines = text.strip().split('\n', 1)
-    if lines[0].strip().lower() in ['python', 'html', 'css', 'javascript', 'json', 'c', 'cpp', 'markdown', 'latex', 'jinja2', 'typescript', 'yaml', 'dockerfile', 'shell', 'r', 'sql', 'sql-mssql', 'sql-mysql', 'sql-mariadb', 'sql-sqlite', 'sql-cassandra', 'sql-plSQL', 'sql-hive', 'sql-pgsql', 'sql-gql', 'sql-gpsql', 'sql-sparksql', 'sql-esper']:
-        return lines[1] if len(lines) > 1 else ''
-    return text.strip()
-
-## React CDN compatibility fixer removed per user preference
-
-def strip_thinking_tags(text: str) -> str:
-    """Strip <think> tags and [TOOL_CALL] markers from streaming output."""
-    if not text:
-        return text
-    # Remove <think> opening tags
-    text = re.sub(r'<think>', '', text, flags=re.IGNORECASE)
-    # Remove </think> closing tags
-    text = re.sub(r'</think>', '', text, flags=re.IGNORECASE)
-    # Remove [TOOL_CALL] markers
-    text = re.sub(r'\[/?TOOL_CALL\]', '', text, flags=re.IGNORECASE)
-    return text
-
-def strip_placeholder_thinking(text: str) -> str:
-    """Remove placeholder 'Thinking...' status lines from streamed text."""
-    if not text:
-        return text
-    # Matches lines like: "Thinking..." or "Thinking... (12s elapsed)"
-    return re.sub(r"(?mi)^[\t ]*Thinking\.\.\.(?:\s*\(\d+s elapsed\))?[\t ]*$\n?", "", text)
-
-def is_placeholder_thinking_only(text: str) -> bool:
-    """Return True if text contains only 'Thinking...' placeholder lines (with optional elapsed)."""
-    if not text:
-        return False
-    stripped = text.strip()
-    if not stripped:
-        return False
-    return re.fullmatch(r"(?s)(?:\s*Thinking\.\.\.(?:\s*\(\d+s elapsed\))?\s*)+", stripped) is not None
-
-def extract_last_thinking_line(text: str) -> str:
-    """Extract the last 'Thinking...' line to display as status."""
-    matches = list(re.finditer(r"Thinking\.\.\.(?:\s*\(\d+s elapsed\))?", text))
-    return matches[-1].group(0) if matches else "Thinking..."
-

anycoder_app/parsers.py

@@ -1,1111 +0,0 @@
-"""
-Code parsing and formatting utilities for different frameworks.
-Handles parsing of transformers.js, React, multi-file HTML, Streamlit, and Gradio code.
-"""
-import re
-import os
-import json
-import base64
-from typing import Dict, List, Optional, Tuple
-from bs4 import BeautifulSoup
-import html
-
-from .config import SEARCH_START, DIVIDER, REPLACE_END
-
-# Type definitions
-History = List[Dict[str, str]]
-
-def strip_tool_call_markers(text):
-    """Remove TOOL_CALL markers and thinking tags that some LLMs add to their output."""
-    if not text:
-        return text
-    # Remove [TOOL_CALL] and [/TOOL_CALL] markers
-    text = re.sub(r'\[/?TOOL_CALL\]', '', text, flags=re.IGNORECASE)
-    # Remove <think> and </think> tags and their content
-    text = re.sub(r'<think>[\s\S]*?</think>', '', text, flags=re.IGNORECASE)
-    # Remove any remaining unclosed <think> tags at the start
-    text = re.sub(r'^<think>[\s\S]*?(?=\n|$)', '', text, flags=re.IGNORECASE | re.MULTILINE)
-    # Remove any remaining </think> tags
-    text = re.sub(r'</think>', '', text, flags=re.IGNORECASE)
-    # Remove standalone }} that appears with tool calls
-    # Only remove if it's on its own line or at the end
-    text = re.sub(r'^\s*\}\}\s*$', '', text, flags=re.MULTILINE)
-    return text.strip()
-
-def remove_code_block(text):
-    # First strip any tool call markers
-    text = strip_tool_call_markers(text)
-    
-    # Try to match code blocks with language markers
-    patterns = [
-        r'```(?:html|HTML)\n([\s\S]+?)\n```',  # Match ```html or ```HTML
-        r'```\n([\s\S]+?)\n```',               # Match code blocks without language markers
-        r'```([\s\S]+?)```'                      # Match code blocks without line breaks
-    ]
-    for pattern in patterns:
-        match = re.search(pattern, text, re.DOTALL)
-        if match:
-            extracted = match.group(1).strip()
-            # Remove a leading language marker line (e.g., 'python') if present
-            if extracted.split('\n', 1)[0].strip().lower() in ['python', 'html', 'css', 'javascript', 'json', 'c', 'cpp', 'markdown', 'latex', 'jinja2', 'typescript', 'yaml', 'dockerfile', 'shell', 'r', 'sql', 'sql-mssql', 'sql-mysql', 'sql-mariadb', 'sql-sqlite', 'sql-cassandra', 'sql-plSQL', 'sql-hive', 'sql-pgsql', 'sql-gql', 'sql-gpsql', 'sql-sparksql', 'sql-esper']:
-                return extracted.split('\n', 1)[1] if '\n' in extracted else ''
-            # If HTML markup starts later in the block (e.g., Poe injected preface), trim to first HTML root
-            html_root_idx = None
-            for tag in ['<!DOCTYPE html', '<html']:
-                idx = extracted.find(tag)
-                if idx != -1:
-                    html_root_idx = idx if html_root_idx is None else min(html_root_idx, idx)
-            if html_root_idx is not None and html_root_idx > 0:
-                return extracted[html_root_idx:].strip()
-            return extracted
-    # If no code block is found, check if the entire text is HTML
-    stripped = text.strip()
-    if stripped.startswith('<!DOCTYPE html>') or stripped.startswith('<html') or stripped.startswith('<'):
-        # If HTML root appears later (e.g., Poe preface), trim to first HTML root
-        for tag in ['<!DOCTYPE html', '<html']:
-            idx = stripped.find(tag)
-            if idx > 0:
-                return stripped[idx:].strip()
-        return stripped
-    # Special handling for python: remove python marker
-    if text.strip().startswith('```python'):
-        return text.strip()[9:-3].strip()
-    # Remove a leading language marker line if present (fallback)
-    lines = text.strip().split('\n', 1)
-    if lines[0].strip().lower() in ['python', 'html', 'css', 'javascript', 'json', 'c', 'cpp', 'markdown', 'latex', 'jinja2', 'typescript', 'yaml', 'dockerfile', 'shell', 'r', 'sql', 'sql-mssql', 'sql-mysql', 'sql-mariadb', 'sql-sqlite', 'sql-cassandra', 'sql-plSQL', 'sql-hive', 'sql-pgsql', 'sql-gql', 'sql-gpsql', 'sql-sparksql', 'sql-esper']:
-        return lines[1] if len(lines) > 1 else ''
-    return text.strip()
-
-## React CDN compatibility fixer removed per user preference
-
-def strip_placeholder_thinking(text: str) -> str:
-    """Remove placeholder 'Thinking...' status lines from streamed text."""
-    if not text:
-        return text
-    # Matches lines like: "Thinking..." or "Thinking... (12s elapsed)"
-    return re.sub(r"(?mi)^[\t ]*Thinking\.\.\.(?:\s*\(\d+s elapsed\))?[\t ]*$\n?", "", text)
-
-def is_placeholder_thinking_only(text: str) -> bool:
-    """Return True if text contains only 'Thinking...' placeholder lines (with optional elapsed)."""
-    if not text:
-        return False
-    stripped = text.strip()
-    if not stripped:
-        return False
-    return re.fullmatch(r"(?s)(?:\s*Thinking\.\.\.(?:\s*\(\d+s elapsed\))?\s*)+", stripped) is not None
-
-def extract_last_thinking_line(text: str) -> str:
-    """Extract the last 'Thinking...' line to display as status."""
-    matches = list(re.finditer(r"Thinking\.\.\.(?:\s*\(\d+s elapsed\))?", text))
-    return matches[-1].group(0) if matches else "Thinking..."
-
-def parse_transformers_js_output(text):
-    """Parse transformers.js output and extract the three files (index.html, index.js, style.css)"""
-    files = {
-        'index.html': '',
-        'index.js': '',
-        'style.css': ''
-    }
-    
-    # Multiple patterns to match the three code blocks with different variations
-    html_patterns = [
-        r'```html\s*\n([\s\S]*?)(?:```|\Z)',
-        r'```htm\s*\n([\s\S]*?)(?:```|\Z)',
-        r'```\s*(?:index\.html|html)\s*\n([\s\S]*?)(?:```|\Z)'
-    ]
-    
-    js_patterns = [
-        r'```javascript\s*\n([\s\S]*?)(?:```|\Z)',
-        r'```js\s*\n([\s\S]*?)(?:```|\Z)',
-        r'```\s*(?:index\.js|javascript|js)\s*\n([\s\S]*?)(?:```|\Z)'
-    ]
-    
-    css_patterns = [
-        r'```css\s*\n([\s\S]*?)(?:```|\Z)',
-        r'```\s*(?:style\.css|css)\s*\n([\s\S]*?)(?:```|\Z)'
-    ]
-    
-    # Extract HTML content
-    for pattern in html_patterns:
-        html_match = re.search(pattern, text, re.IGNORECASE)
-        if html_match:
-            files['index.html'] = html_match.group(1).strip()
-            break
-    
-    # Extract JavaScript content
-    for pattern in js_patterns:
-        js_match = re.search(pattern, text, re.IGNORECASE)
-        if js_match:
-            files['index.js'] = js_match.group(1).strip()
-            break
-    
-    # Extract CSS content
-    for pattern in css_patterns:
-        css_match = re.search(pattern, text, re.IGNORECASE)
-        if css_match:
-            files['style.css'] = css_match.group(1).strip()
-            break
-    
-    # Fallback: support === index.html === format if any file is missing
-    if not (files['index.html'] and files['index.js'] and files['style.css']):
-        # Use regex to extract sections
-        html_fallback = re.search(r'===\s*index\.html\s*===\s*\n([\s\S]+?)(?=\n===|$)', text, re.IGNORECASE)
-        js_fallback = re.search(r'===\s*index\.js\s*===\s*\n([\s\S]+?)(?=\n===|$)', text, re.IGNORECASE)
-        css_fallback = re.search(r'===\s*style\.css\s*===\s*\n([\s\S]+?)(?=\n===|$)', text, re.IGNORECASE)
-        
-        if html_fallback:
-            files['index.html'] = html_fallback.group(1).strip()
-        if js_fallback:
-            files['index.js'] = js_fallback.group(1).strip()
-        if css_fallback:
-            files['style.css'] = css_fallback.group(1).strip()
-    
-    # Additional fallback: extract from numbered sections or file headers
-    if not (files['index.html'] and files['index.js'] and files['style.css']):
-        # Try patterns like "1. index.html:" or "**index.html**"
-        patterns = [
-            (r'(?:^\d+\.\s*|^##\s*|^\*\*\s*)index\.html(?:\s*:|\*\*:?)\s*\n([\s\S]+?)(?=\n(?:\d+\.|##|\*\*|===)|$)', 'index.html'),
-            (r'(?:^\d+\.\s*|^##\s*|^\*\*\s*)index\.js(?:\s*:|\*\*:?)\s*\n([\s\S]+?)(?=\n(?:\d+\.|##|\*\*|===)|$)', 'index.js'),
-            (r'(?:^\d+\.\s*|^##\s*|^\*\*\s*)style\.css(?:\s*:|\*\*:?)\s*\n([\s\S]+?)(?=\n(?:\d+\.|##|\*\*|===)|$)', 'style.css')
-        ]
-        
-        for pattern, file_key in patterns:
-            if not files[file_key]:
-                match = re.search(pattern, text, re.IGNORECASE | re.MULTILINE)
-                if match:
-                    # Clean up the content by removing any code block markers
-                    content = match.group(1).strip()
-                    content = re.sub(r'^```\w*\s*\n', '', content)
-                    content = re.sub(r'\n```\s*$', '', content)
-                    files[file_key] = content.strip()
-    
-    return files
-
-def format_transformers_js_output(files):
-    """Format the three files into a single display string"""
-    output = []
-    output.append("=== index.html ===")
-    output.append(files['index.html'])
-    output.append("\n=== index.js ===")
-    output.append(files['index.js'])
-    output.append("\n=== style.css ===")
-    output.append(files['style.css'])
-    return '\n'.join(output)
-
-def build_transformers_inline_html(files: dict) -> str:
-    """Merge transformers.js three-file output into a single self-contained HTML document.
-
-    - Inlines style.css into a <style> tag
-    - Inlines index.js into a <script type="module"> tag
-    - Rewrites ESM imports for transformers.js to a stable CDN URL so it works in data: iframes
-    """
-    import re as _re
-
-    html = files.get('index.html') or ''
-    js = files.get('index.js') or ''
-    css = files.get('style.css') or ''
-
-    # Normalize JS imports to CDN (handle both @huggingface/transformers and legacy @xenova/transformers)
-    cdn_url = "https://cdn.jsdelivr.net/npm/@huggingface/[email protected]"
-
-    def _normalize_imports(_code: str) -> str:
-        if not _code:
-            return _code or ""
-        _code = _re.sub(r"from\s+['\"]@huggingface/transformers['\"]", f"from '{cdn_url}'", _code)
-        _code = _re.sub(r"from\s+['\"]@xenova/transformers['\"]", f"from '{cdn_url}'", _code)
-        _code = _re.sub(r"from\s+['\"]https://cdn.jsdelivr.net/npm/@huggingface/transformers@[^'\"]+['\"]", f"from '{cdn_url}'", _code)
-        _code = _re.sub(r"from\s+['\"]https://cdn.jsdelivr.net/npm/@xenova/transformers@[^'\"]+['\"]", f"from '{cdn_url}'", _code)
-        return _code
-
-    # Extract inline module scripts from index.html, then merge into JS so we control imports
-    inline_modules = []
-    try:
-        for _m in _re.finditer(r"<script\\b[^>]*type=[\"\']module[\"\'][^>]*>([\s\S]*?)</script>", html, flags=_re.IGNORECASE):
-            inline_modules.append(_m.group(1))
-        if inline_modules:
-            html = _re.sub(r"<script\\b[^>]*type=[\"\']module[\"\'][^>]*>[\s\S]*?</script>\\s*", "", html, flags=_re.IGNORECASE)
-        # Normalize any external module script URLs that load transformers to a single CDN version (keep the tag)
-        html = _re.sub(r"https://cdn\.jsdelivr\.net/npm/@huggingface/transformers@[^'\"<>\s]+", cdn_url, html)
-        html = _re.sub(r"https://cdn\.jsdelivr\.net/npm/@xenova/transformers@[^'\"<>\s]+", cdn_url, html)
-    except Exception:
-        # Best-effort; continue
-        pass
-
-    # Merge inline module code with provided index.js, then normalize imports
-    combined_js_parts = []
-    if inline_modules:
-        combined_js_parts.append("\n\n".join(inline_modules))
-    if js:
-        combined_js_parts.append(js)
-    js = "\n\n".join([p for p in combined_js_parts if (p and p.strip())])
-    js = _normalize_imports(js)
-
-    # Prepend a small prelude to reduce persistent caching during preview
-    # Also ensure a global `transformers` namespace exists for apps relying on it
-    # Note: importing env alongside user's own imports is fine in ESM
-    if js.strip():
-        prelude = (
-            f"import {{ env }} from '{cdn_url}';\n"
-            "try { env.useBrowserCache = false; } catch (e) {}\n"
-            "try { if (env && env.backends && env.backends.onnx && env.backends.onnx.wasm) { env.backends.onnx.wasm.numThreads = 1; env.backends.onnx.wasm.proxy = false; } } catch (e) {}\n"
-            f"(async () => {{ try {{ if (typeof globalThis.transformers === 'undefined') {{ const m = await import('{cdn_url}'); globalThis.transformers = m; }} }} catch (e) {{}} }})();\n"
-        )
-        js = prelude + js
-
-    # If index.html missing or doesn't look like a full document, create a minimal shell
-    doc = html.strip()
-    if not doc or ('<html' not in doc.lower()):
-        doc = (
-            "<!DOCTYPE html>\n"
-            "<html>\n<head>\n<meta charset=\"UTF-8\">\n<meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\">\n<title>Transformers.js App</title>\n</head>\n"
-            "<body>\n<div id=\"app\"></div>\n</body>\n</html>"
-        )
-
-    # Remove local references to style.css and index.js to avoid duplicates when inlining
-    doc = _re.sub(r"<link[^>]+href=\"[^\"]*style\.css\"[^>]*>\s*", "", doc, flags=_re.IGNORECASE)
-    doc = _re.sub(r"<script[^>]+src=\"[^\"]*index\.js\"[^>]*>\s*</script>\s*", "", doc, flags=_re.IGNORECASE)
-
-    # Inline CSS: insert before </head> or create a <head>
-    style_tag = f"<style>\n{css}\n</style>" if css else ""
-    if style_tag:
-        if '</head>' in doc.lower():
-            # Preserve original casing by finding closing head case-insensitively
-            match = _re.search(r"</head>", doc, flags=_re.IGNORECASE)
-            if match:
-                idx = match.start()
-                doc = doc[:idx] + style_tag + doc[idx:]
-        else:
-            # No head; insert at top of body
-            match = _re.search(r"<body[^>]*>", doc, flags=_re.IGNORECASE)
-            if match:
-                idx = match.end()
-                doc = doc[:idx] + "\n" + style_tag + doc[idx:]
-            else:
-                # Append at beginning
-                doc = style_tag + doc
-
-    # Inline JS: insert before </body>
-    script_tag = f"<script type=\"module\">\n{js}\n</script>" if js else ""
-    # Lightweight debug console overlay to surface runtime errors inside the iframe
-    debug_overlay = (
-        "<style>\n"
-        "#anycoder-debug{position:fixed;left:0;right:0;bottom:0;max-height:45%;overflow:auto;"
-        "background:rgba(0,0,0,.85);color:#9eff9e;padding:.5em;font:12px/1.4 monospace;z-index:2147483647;display:none}"
-        "#anycoder-debug pre{margin:0;white-space:pre-wrap;word-break:break-word}"
-        "</style>\n"
-        "<div id=\"anycoder-debug\"></div>\n"
-        "<script>\n"
-        "(function(){\n"
-        "  const el = document.getElementById('anycoder-debug');\n"
-        "  function show(){ if(el && el.style.display!=='block'){ el.style.display='block'; } }\n"
-        "  function log(msg){ try{ show(); const pre=document.createElement('pre'); pre.textContent=msg; el.appendChild(pre);}catch(e){} }\n"
-        "  const origError = console.error.bind(console);\n"
-        "  console.error = function(){ origError.apply(console, arguments); try{ log('console.error: ' + Array.from(arguments).map(a=>{try{return (typeof a==='string')?a:JSON.stringify(a);}catch(e){return String(a);}}).join(' ')); }catch(e){} };\n"
-        "  window.addEventListener('error', e => { log('window.onerror: ' + (e && e.message ? e.message : 'Unknown error')); });\n"
-        "  window.addEventListener('unhandledrejection', e => { try{ const r=e && e.reason; log('unhandledrejection: ' + (r && (r.message || JSON.stringify(r)))); }catch(err){ log('unhandledrejection'); } });\n"
-        "})();\n"
-        "</script>"
-    )
-    # Cleanup script to clear Cache Storage and IndexedDB on unload to free model weights
-    cleanup_tag = (
-        "<script>\n"
-        "(function(){\n"
-        "  function cleanup(){\n"
-        "    try { if (window.caches && caches.keys) { caches.keys().then(keys => keys.forEach(k => caches.delete(k))); } } catch(e){}\n"
-        "    try { if (window.indexedDB && indexedDB.databases) { indexedDB.databases().then(dbs => dbs.forEach(db => db && db.name && indexedDB.deleteDatabase(db.name))); } } catch(e){}\n"
-        "  }\n"
-        "  window.addEventListener('pagehide', cleanup, { once: true });\n"
-        "  window.addEventListener('beforeunload', cleanup, { once: true });\n"
-        "})();\n"
-        "</script>"
-    )
-    if script_tag:
-        match = _re.search(r"</body>", doc, flags=_re.IGNORECASE)
-        if match:
-            idx = match.start()
-            doc = doc[:idx] + debug_overlay + script_tag + cleanup_tag + doc[idx:]
-        else:
-            # Append at end
-            doc = doc + debug_overlay + script_tag + cleanup_tag
-
-    return doc
-
-def send_transformers_to_sandbox(files: dict) -> str:
-    """Build a self-contained HTML document from transformers.js files and return an iframe preview."""
-    merged_html = build_transformers_inline_html(files)
-    return send_to_sandbox(merged_html)
-
-def parse_multipage_html_output(text: str) -> Dict[str, str]:
-    """Parse multi-page HTML output formatted as repeated "=== filename ===" sections.
-
-    Returns a mapping of filename → file content. Supports nested paths like assets/css/styles.css.
-    If HTML content appears before the first === marker, it's treated as index.html.
-    """
-    if not text:
-        return {}
-    # First, strip any markdown fences
-    cleaned = remove_code_block(text)
-    files: Dict[str, str] = {}
-    import re as _re
-    
-    # Check if there's content before the first === marker
-    first_marker_match = _re.search(r"^===\s*([^=\n]+?)\s*===", cleaned, _re.MULTILINE)
-    if first_marker_match:
-        # There's content before the first marker
-        first_marker_pos = first_marker_match.start()
-        if first_marker_pos > 0:
-            leading_content = cleaned[:first_marker_pos].strip()
-            # Check if it looks like HTML content
-            if leading_content and ('<!DOCTYPE' in leading_content or '<html' in leading_content or leading_content.startswith('<')):
-                files['index.html'] = leading_content
-        
-        # Now parse the rest with === markers
-        remaining_text = cleaned[first_marker_pos:] if first_marker_pos > 0 else cleaned
-        pattern = _re.compile(r"^===\s*([^=\n]+?)\s*===\s*\n([\s\S]*?)(?=\n===\s*[^=\n]+?\s*===|\Z)", _re.MULTILINE)
-        for m in pattern.finditer(remaining_text):
-            name = m.group(1).strip()
-            content = m.group(2).strip()
-            # Remove accidental trailing fences if present
-            content = _re.sub(r"^```\w*\s*\n|\n```\s*$", "", content)
-            files[name] = content
-    else:
-        # No === markers found, try standard pattern matching
-        pattern = _re.compile(r"^===\s*([^=\n]+?)\s*===\s*\n([\s\S]*?)(?=\n===\s*[^=\n]+?\s*===|\Z)", _re.MULTILINE)
-        for m in pattern.finditer(cleaned):
-            name = m.group(1).strip()
-            content = m.group(2).strip()
-            # Remove accidental trailing fences if present
-            content = _re.sub(r"^```\w*\s*\n|\n```\s*$", "", content)
-            files[name] = content
-    
-    return files
-
-def format_multipage_output(files: Dict[str, str]) -> str:
-    """Format a dict of files back into === filename === sections.
-
-    Ensures `index.html` appears first if present; others follow sorted by path.
-    """
-    if not isinstance(files, dict) or not files:
-        return ""
-    ordered_paths = []
-    if 'index.html' in files:
-        ordered_paths.append('index.html')
-    for path in sorted(files.keys()):
-        if path == 'index.html':
-            continue
-        ordered_paths.append(path)
-    parts: list[str] = []
-    for path in ordered_paths:
-        parts.append(f"=== {path} ===")
-        # Avoid trailing extra newlines to keep blocks compact
-        parts.append((files.get(path) or '').rstrip())
-    return "\n".join(parts)
-
-def validate_and_autofix_files(files: Dict[str, str]) -> Dict[str, str]:
-    """Ensure minimal contract for multi-file sites; auto-fix missing pieces.
-
-    Rules:
-    - Ensure at least one HTML entrypoint (index.html). If none, synthesize a simple index.html linking discovered pages.
-    - For each HTML file, ensure referenced local assets exist in files; if missing, add minimal stubs.
-    - Normalize relative paths (strip leading '/').
-    """
-    if not isinstance(files, dict) or not files:
-        return files or {}
-    import re as _re
-
-    normalized: Dict[str, str] = {}
-    for k, v in files.items():
-        safe_key = k.strip().lstrip('/')
-        normalized[safe_key] = v
-
-    html_files = [p for p in normalized.keys() if p.lower().endswith('.html')]
-    has_index = 'index.html' in normalized
-
-    # If no index.html but some HTML pages exist, create a simple hub index linking to them
-    if not has_index and html_files:
-        links = '\n'.join([f"<li><a href=\"{p}\">{p}</a></li>" for p in html_files])
-        normalized['index.html'] = (
-            "<!DOCTYPE html>\n<html lang=\"en\">\n<head>\n<meta charset=\"utf-8\"/>\n"
-            "<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\"/>\n"
-            "<title>Site Index</title>\n</head>\n<body>\n<h1>Site</h1>\n<ul>\n"
-            + links + "\n</ul>\n</body>\n</html>"
-        )
-
-    # Collect references from HTML files
-    asset_refs: set[str] = set()
-    link_href = _re.compile(r"<link[^>]+href=\"([^\"]+)\"")
-    script_src = _re.compile(r"<script[^>]+src=\"([^\"]+)\"")
-    img_src = _re.compile(r"<img[^>]+src=\"([^\"]+)\"")
-    a_href = _re.compile(r"<a[^>]+href=\"([^\"]+)\"")
-
-    for path, content in list(normalized.items()):
-        if not path.lower().endswith('.html'):
-            continue
-        for patt in (link_href, script_src, img_src, a_href):
-            for m in patt.finditer(content or ""):
-                ref = (m.group(1) or "").strip()
-                if not ref or ref.startswith('http://') or ref.startswith('https://') or ref.startswith('data:') or '#' in ref:
-                    continue
-                asset_refs.add(ref.lstrip('/'))
-
-    # Add minimal stubs for missing local references (CSS/JS/pages only, not images)
-    for ref in list(asset_refs):
-        if ref not in normalized:
-            if ref.lower().endswith('.css'):
-                normalized[ref] = "/* generated stub */\n"
-            elif ref.lower().endswith('.js'):
-                normalized[ref] = "// generated stub\n"
-            elif ref.lower().endswith('.html'):
-                normalized[ref] = (
-                    "<!DOCTYPE html>\n<html lang=\"en\">\n<head><meta charset=\"utf-8\"/><meta name=\"viewport\" content=\"width=device-width, initial-scale=1\"/><title>Page</title></head>\n"
-                    "<body><main><h1>Placeholder page</h1><p>This page was auto-created to satisfy an internal link.</p></main></body>\n</html>"
-                )
-            # Note: We no longer create placeholder image files automatically
-            # This prevents unwanted SVG stub files from being generated during image generation
-
-    return normalized
-def inline_multipage_into_single_preview(files: Dict[str, str]) -> str:
-    """Inline local CSS/JS referenced by index.html for preview inside a data: iframe.
-
-    - Uses index.html as the base document
-    - Inlines <link href="..."> if the target exists in files
-    - Inlines <script src="..."> if the target exists in files
-    - Leaves other links (e.g., about.html) untouched; preview covers the home page
-    """
-    import re as _re
-    html = files.get('index.html', '')
-    if not html:
-        return ""
-    doc = html
-    # Inline CSS links that point to known files
-    def _inline_css(match):
-        href = match.group(1)
-        if href in files:
-            return f"<style>\n{files[href]}\n</style>"
-        return match.group(0)
-    doc = _re.sub(r"<link[^>]+href=\"([^\"]+)\"[^>]*/?>", _inline_css, doc, flags=_re.IGNORECASE)
-
-    # Inline JS scripts that point to known files
-    def _inline_js(match):
-        src = match.group(1)
-        if src in files:
-            return f"<script>\n{files[src]}\n</script>"
-        return match.group(0)
-    doc = _re.sub(r"<script[^>]+src=\"([^\"]+)\"[^>]*>\s*</script>", _inline_js, doc, flags=_re.IGNORECASE)
-
-    # Inject a lightweight in-iframe client-side navigator to load other HTML files
-    try:
-        import json as _json
-        import base64 as _b64
-        import re as _re
-        html_pages = {k: v for k, v in files.items() if k.lower().endswith('.html')}
-        # Ensure index.html entry restores the current body's HTML
-        _m_body = _re.search(r"<body[^>]*>([\s\S]*?)</body>", doc, flags=_re.IGNORECASE)
-        _index_body = _m_body.group(1) if _m_body else doc
-        html_pages['index.html'] = _index_body
-        encoded = _b64.b64encode(_json.dumps(html_pages).encode('utf-8')).decode('ascii')
-        nav_script = (
-            "<script>\n"  # Simple client-side loader for internal links
-            "(function(){\n"
-            f"  const MP_FILES = JSON.parse(atob('{encoded}'));\n"
-            "  function extractBody(html){\n"
-            "    try {\n"
-            "      const doc = new DOMParser().parseFromString(html, 'text/html');\n"
-            "      const title = doc.querySelector('title'); if (title) document.title = title.textContent || document.title;\n"
-            "      return doc.body ? doc.body.innerHTML : html;\n"
-            "    } catch(e){ return html; }\n"
-            "  }\n"
-            "  function loadPage(path){\n"
-            "    if (!MP_FILES[path]) return false;\n"
-            "    const bodyHTML = extractBody(MP_FILES[path]);\n"
-            "    document.body.innerHTML = bodyHTML;\n"
-            "    attach();\n"
-            "    try { history.replaceState({}, '', '#'+path); } catch(e){}\n"
-            "    return true;\n"
-            "  }\n"
-            "  function clickHandler(e){\n"
-            "    const a = e.target && e.target.closest ? e.target.closest('a') : null;\n"
-            "    if (!a) return;\n"
-            "    const href = a.getAttribute('href') || '';\n"
-            "    if (!href || href.startsWith('#') || /^https?:/i.test(href) || href.startsWith('mailto:') || href.startsWith('tel:')) return;\n"
-            "    const clean = href.split('#')[0].split('?')[0];\n"
-            "    if (MP_FILES[clean]) { e.preventDefault(); loadPage(clean); }\n"
-            "  }\n"
-            "  function attach(){ document.removeEventListener('click', clickHandler, true); document.addEventListener('click', clickHandler, true); }\n"
-            "  document.addEventListener('DOMContentLoaded', function(){ attach(); const initial = (location.hash||'').slice(1); if (initial && MP_FILES[initial]) loadPage(initial); }, { once:true });\n"
-            "})();\n"
-            "</script>"
-        )
-        m = _re.search(r"</body>", doc, flags=_re.IGNORECASE)
-        if m:
-            i = m.start()
-            doc = doc[:i] + nav_script + doc[i:]
-        else:
-            doc = doc + nav_script
-    except Exception:
-        # Non-fatal in preview
-        pass
-
-    return doc
-
-def extract_html_document(text: str) -> str:
-    """Return substring starting from the first <!DOCTYPE html> or <html> if present, else original text.
-
-    This ignores prose or planning notes before the actual HTML so previews don't break.
-    """
-    if not text:
-        return text
-    lower = text.lower()
-    idx = lower.find("<!doctype html")
-    if idx == -1:
-        idx = lower.find("<html")
-    return text[idx:] if idx != -1 else text
-
-
-def parse_react_output(text):
-    """Parse React/Next.js output to extract individual files.
-
-    Supports multi-file sections using === filename === sections.
-    """
-    if not text:
-        return {}
-
-    # Use the generic multipage parser
-    try:
-        files = parse_multipage_html_output(text) or {}
-    except Exception:
-        files = {}
-
-    return files if isinstance(files, dict) and files else {}
-
-
-def history_render(history: History):
-    return gr.update(visible=True), history
-
-def clear_history():
-    return [], [], []  # Empty lists for history, history_output, and chat_history
-
-def create_multimodal_message(text, image=None):
-    """Create a chat message. For broad provider compatibility, always return content as a string.
-
-    Some providers (e.g., Hugging Face router endpoints like Cerebras) expect `content` to be a string,
-    not a list of typed parts. To avoid 422 validation errors, we inline a brief note when an image is provided.
-    """
-    if image is None:
-        return {"role": "user", "content": text}
-    # Keep providers happy: avoid structured multimodal payloads; add a short note instead
-    # If needed, this can be enhanced per-model with proper multimodal schemas.
-    return {"role": "user", "content": f"{text}\n\n[An image was provided as reference.]"}
-def apply_search_replace_changes(original_content: str, changes_text: str) -> str:
-    """Apply search/replace changes to content (HTML, Python, etc.)"""
-    if not changes_text.strip():
-        return original_content
-    
-    # If the model didn't use the block markers, try a CSS-rule fallback where
-    # provided blocks like `.selector { ... }` replace matching CSS rules.
-    if (SEARCH_START not in changes_text) and (DIVIDER not in changes_text) and (REPLACE_END not in changes_text):
-        try:
-            import re  # Local import to avoid global side effects
-            updated_content = original_content
-            replaced_any_rule = False
-            # Find CSS-like rule blocks in the changes_text
-            # This is a conservative matcher that looks for `selector { ... }`
-            css_blocks = re.findall(r"([^{]+)\{([\s\S]*?)\}", changes_text, flags=re.MULTILINE)
-            for selector_raw, body_raw in css_blocks:
-                selector = selector_raw.strip()
-                body = body_raw.strip()
-                if not selector:
-                    continue
-                # Build a regex to find the existing rule for this selector
-                # Capture opening `{` and closing `}` to preserve them; replace inner body.
-                pattern = re.compile(rf"({re.escape(selector)}\s*\{{)([\s\S]*?)(\}})")
-                def _replace_rule(match):
-                    nonlocal replaced_any_rule
-                    replaced_any_rule = True
-                    prefix, existing_body, suffix = match.groups()
-                    # Preserve indentation of the existing first body line if present
-                    first_line_indent = ""
-                    for line in existing_body.splitlines():
-                        stripped = line.lstrip(" \t")
-                        if stripped:
-                            first_line_indent = line[: len(line) - len(stripped)]
-                            break
-                    # Re-indent provided body with the detected indent
-                    if body:
-                        new_body_lines = [first_line_indent + line if line.strip() else line for line in body.splitlines()]
-                        new_body_text = "\n" + "\n".join(new_body_lines) + "\n"
-                    else:
-                        new_body_text = existing_body  # If empty body provided, keep existing
-                    return f"{prefix}{new_body_text}{suffix}"
-                updated_content, num_subs = pattern.subn(_replace_rule, updated_content, count=1)
-            if replaced_any_rule:
-                return updated_content
-        except Exception:
-            # Fallback silently to the standard block-based application
-            pass
-
-    # Split the changes text into individual search/replace blocks
-    blocks = []
-    current_block = ""
-    lines = changes_text.split('\n')
-    
-    for line in lines:
-        if line.strip() == SEARCH_START:
-            if current_block.strip():
-                blocks.append(current_block.strip())
-            current_block = line + '\n'
-        elif line.strip() == REPLACE_END:
-            current_block += line + '\n'
-            blocks.append(current_block.strip())
-            current_block = ""
-        else:
-            current_block += line + '\n'
-    
-    if current_block.strip():
-        blocks.append(current_block.strip())
-    
-    modified_content = original_content
-    
-    for block in blocks:
-        if not block.strip():
-            continue
-            
-        # Parse the search/replace block
-        lines = block.split('\n')
-        search_lines = []
-        replace_lines = []
-        in_search = False
-        in_replace = False
-        
-        for line in lines:
-            if line.strip() == SEARCH_START:
-                in_search = True
-                in_replace = False
-            elif line.strip() == DIVIDER:
-                in_search = False
-                in_replace = True
-            elif line.strip() == REPLACE_END:
-                in_replace = False
-            elif in_search:
-                search_lines.append(line)
-            elif in_replace:
-                replace_lines.append(line)
-        
-        # Apply the search/replace
-        if search_lines:
-            search_text = '\n'.join(search_lines).strip()
-            replace_text = '\n'.join(replace_lines).strip()
-            
-            if search_text in modified_content:
-                modified_content = modified_content.replace(search_text, replace_text)
-            else:
-                # If exact block match fails, attempt a CSS-rule fallback using the replace_text
-                try:
-                    import re
-                    updated_content = modified_content
-                    replaced_any_rule = False
-                    css_blocks = re.findall(r"([^{]+)\{([\s\S]*?)\}", replace_text, flags=re.MULTILINE)
-                    for selector_raw, body_raw in css_blocks:
-                        selector = selector_raw.strip()
-                        body = body_raw.strip()
-                        if not selector:
-                            continue
-                        pattern = re.compile(rf"({re.escape(selector)}\s*\{{)([\s\S]*?)(\}})")
-                        def _replace_rule(match):
-                            nonlocal replaced_any_rule
-                            replaced_any_rule = True
-                            prefix, existing_body, suffix = match.groups()
-                            first_line_indent = ""
-                            for line in existing_body.splitlines():
-                                stripped = line.lstrip(" \t")
-                                if stripped:
-                                    first_line_indent = line[: len(line) - len(stripped)]
-                                    break
-                            if body:
-                                new_body_lines = [first_line_indent + line if line.strip() else line for line in body.splitlines()]
-                                new_body_text = "\n" + "\n".join(new_body_lines) + "\n"
-                            else:
-                                new_body_text = existing_body
-                            return f"{prefix}{new_body_text}{suffix}"
-                        updated_content, num_subs = pattern.subn(_replace_rule, updated_content, count=1)
-                    if replaced_any_rule:
-                        modified_content = updated_content
-                    else:
-                        print(f"Warning: Search text not found in content: {search_text[:100]}...")
-                except Exception:
-                    print(f"Warning: Search text not found in content: {search_text[:100]}...")
-    
-    return modified_content
-
-def apply_transformers_js_search_replace_changes(original_formatted_content: str, changes_text: str) -> str:
-    """Apply search/replace changes to transformers.js formatted content (three files)"""
-    if not changes_text.strip():
-        return original_formatted_content
-    
-    # Parse the original formatted content to get the three files
-    files = parse_transformers_js_output(original_formatted_content)
-    
-    # Split the changes text into individual search/replace blocks
-    blocks = []
-    current_block = ""
-    lines = changes_text.split('\n')
-    
-    for line in lines:
-        if line.strip() == SEARCH_START:
-            if current_block.strip():
-                blocks.append(current_block.strip())
-            current_block = line + '\n'
-        elif line.strip() == REPLACE_END:
-            current_block += line + '\n'
-            blocks.append(current_block.strip())
-            current_block = ""
-        else:
-            current_block += line + '\n'
-    
-    if current_block.strip():
-        blocks.append(current_block.strip())
-    
-    # Process each block and apply changes to the appropriate file
-    for block in blocks:
-        if not block.strip():
-            continue
-            
-        # Parse the search/replace block
-        lines = block.split('\n')
-        search_lines = []
-        replace_lines = []
-        in_search = False
-        in_replace = False
-        target_file = None
-        
-        for line in lines:
-            if line.strip() == SEARCH_START:
-                in_search = True
-                in_replace = False
-            elif line.strip() == DIVIDER:
-                in_search = False
-                in_replace = True
-            elif line.strip() == REPLACE_END:
-                in_replace = False
-            elif in_search:
-                search_lines.append(line)
-            elif in_replace:
-                replace_lines.append(line)
-        
-        # Determine which file this change targets based on the search content
-        if search_lines:
-            search_text = '\n'.join(search_lines).strip()
-            replace_text = '\n'.join(replace_lines).strip()
-            
-            # Check which file contains the search text
-            if search_text in files['index.html']:
-                target_file = 'index.html'
-            elif search_text in files['index.js']:
-                target_file = 'index.js'
-            elif search_text in files['style.css']:
-                target_file = 'style.css'
-            
-            # Apply the change to the target file
-            if target_file and search_text in files[target_file]:
-                files[target_file] = files[target_file].replace(search_text, replace_text)
-            else:
-                print(f"Warning: Search text not found in any transformers.js file: {search_text[:100]}...")
-    
-    # Reformat the modified files
-    return format_transformers_js_output(files)
-
-def send_to_sandbox(code):
-    """Render HTML in a sandboxed iframe. Assumes full HTML is provided by prompts."""
-    html_doc = (code or "").strip()
-    # For preview only: inline local file URLs as data URIs so the
-    # data: iframe can load them. The original code (shown to the user) still contains file URLs.
-    try:
-        import re
-        import base64 as _b64
-        import mimetypes as _mtypes
-        import urllib.parse as _uparse
-        def _file_url_to_data_uri(file_url: str) -> Optional[str]:
-            try:
-                parsed = _uparse.urlparse(file_url)
-                path = _uparse.unquote(parsed.path)
-                if not path:
-                    return None
-                with open(path, 'rb') as _f:
-                    raw = _f.read()
-                mime = _mtypes.guess_type(path)[0] or 'application/octet-stream'
-                
-                b64 = _b64.b64encode(raw).decode()
-                return f"data:{mime};base64,{b64}"
-            except Exception as e:
-                print(f"[Sandbox] Failed to convert file URL to data URI: {str(e)}")
-                return None
-        def _repl_double(m):
-            url = m.group(1)
-            data_uri = _file_url_to_data_uri(url)
-            return f'src="{data_uri}"' if data_uri else m.group(0)
-        def _repl_single(m):
-            url = m.group(1)
-            data_uri = _file_url_to_data_uri(url)
-            return f"src='{data_uri}'" if data_uri else m.group(0)
-        html_doc = re.sub(r'src="(file:[^"]+)"', _repl_double, html_doc)
-        html_doc = re.sub(r"src='(file:[^']+)'", _repl_single, html_doc)
-                
-    except Exception:
-        # Best-effort; continue without inlining
-        pass
-    encoded_html = base64.b64encode(html_doc.encode('utf-8')).decode('utf-8')
-    data_uri = f"data:text/html;charset=utf-8;base64,{encoded_html}"
-    iframe = f'<iframe src="{data_uri}" width="100%" height="920px" sandbox="allow-scripts allow-same-origin allow-forms allow-popups allow-modals allow-presentation" allow="display-capture"></iframe>'
-    return iframe
-
-def is_streamlit_code(code: str) -> bool:
-    """Heuristic check to determine if Python code is a Streamlit app."""
-    if not code:
-        return False
-    lowered = code.lower()
-    return ("import streamlit" in lowered) or ("from streamlit" in lowered) or ("st." in code and "streamlit" in lowered)
-
-def clean_requirements_txt_content(content: str) -> str:
-    """
-    Clean up requirements.txt content to remove markdown formatting.
-    This function removes code blocks, markdown lists, headers, and other formatting
-    that might be mistakenly included by LLMs.
-    """
-    if not content:
-        return content
-    
-    # First, remove code blocks if present
-    if '```' in content:
-        content = remove_code_block(content)
-    
-    # Process line by line to remove markdown formatting
-    lines = content.split('\n')
-    clean_lines = []
-    
-    for line in lines:
-        stripped_line = line.strip()
-        
-        # Skip empty lines
-        if not stripped_line:
-            continue
-        
-        # Skip lines that are markdown formatting
-        if (stripped_line == '```' or 
-            stripped_line.startswith('```') or
-            # Skip markdown headers (## Header) but keep comments (# comment)
-            (stripped_line.startswith('#') and len(stripped_line) > 1 and stripped_line[1] != ' ') or
-            stripped_line.startswith('**') or  # Skip bold text
-            stripped_line.startswith('===') or  # Skip section dividers
-            stripped_line.startswith('---') or  # Skip horizontal rules
-            # Skip common explanatory text patterns
-            stripped_line.lower().startswith('here') or
-            stripped_line.lower().startswith('this') or
-            stripped_line.lower().startswith('the ') or
-            stripped_line.lower().startswith('based on') or
-            stripped_line.lower().startswith('dependencies') or
-            stripped_line.lower().startswith('requirements')):
-            continue
-        
-        # Handle markdown list items (- item or * item)
-        if (stripped_line.startswith('- ') or stripped_line.startswith('* ')):
-            # Extract the package name after the list marker
-            stripped_line = stripped_line[2:].strip()
-            if not stripped_line:
-                continue
-        
-        # Keep lines that look like valid package specifications
-        # Valid lines: package names, git+https://, comments starting with "# "
-        if (stripped_line.startswith('# ') or  # Valid comments
-            stripped_line.startswith('git+') or  # Git dependencies
-            stripped_line[0].isalnum() or  # Package names start with alphanumeric
-            '==' in stripped_line or  # Version specifications
-            '>=' in stripped_line or  # Version specifications
-            '<=' in stripped_line or  # Version specifications
-            '~=' in stripped_line):  # Version specifications
-            clean_lines.append(stripped_line)
-    
-    result = '\n'.join(clean_lines)
-    
-    # Ensure it ends with a newline
-    if result and not result.endswith('\n'):
-        result += '\n'
-    
-    return result if result else "# No additional dependencies required\n"
-
-def parse_multi_file_python_output(code: str) -> dict:
-    """Parse multi-file Python output (Gradio/Streamlit) into separate files"""
-    files = {}
-    if not code:
-        return files
-    
-    # Look for file separators like === filename.py ===
-    import re
-    file_pattern = r'=== ([^=]+) ==='
-    parts = re.split(file_pattern, code)
-    
-    if len(parts) > 1:
-        # Multi-file format detected
-        for i in range(1, len(parts), 2):
-            if i + 1 < len(parts):
-                filename = parts[i].strip()
-                content = parts[i + 1].strip()
-                
-                # Clean up requirements.txt to remove markdown formatting
-                if filename == 'requirements.txt':
-                    content = clean_requirements_txt_content(content)
-                
-                files[filename] = content
-    else:
-        # Single file - check if it's a space import or regular code
-        if "IMPORTED PROJECT FROM HUGGING FACE SPACE" in code:
-            # This is already a multi-file import, try to parse it
-            lines = code.split('\n')
-            current_file = None
-            current_content = []
-            
-            for line in lines:
-                if line.startswith('=== ') and line.endswith(' ==='):
-                    # Save previous file
-                    if current_file and current_content:
-                        content = '\n'.join(current_content)
-                        # Clean up requirements.txt to remove markdown formatting
-                        if current_file == 'requirements.txt':
-                            content = clean_requirements_txt_content(content)
-                        files[current_file] = content
-                    # Start new file
-                    current_file = line[4:-4].strip()
-                    current_content = []
-                elif current_file:
-                    current_content.append(line)
-            
-            # Save last file
-            if current_file and current_content:
-                content = '\n'.join(current_content)
-                # Clean up requirements.txt to remove markdown formatting
-                if current_file == 'requirements.txt':
-                    content = clean_requirements_txt_content(content)
-                files[current_file] = content
-        else:
-            # Single file code - determine appropriate filename
-            if is_streamlit_code(code):
-                files['streamlit_app.py'] = code
-            elif 'import gradio' in code.lower() or 'from gradio' in code.lower():
-                files['app.py'] = code
-            else:
-                files['app.py'] = code
-    
-    return files
-
-def format_multi_file_python_output(files: dict) -> str:
-    """Format multiple Python files into the standard multi-file format"""
-    if not files:
-        return ""
-    
-    if len(files) == 1:
-        # Single file - return as is
-        return list(files.values())[0]
-    
-    # Multi-file format
-    output = []
-    
-    # Order files: main app first, then utils, models, config, requirements
-    file_order = ['app.py', 'streamlit_app.py', 'main.py', 'utils.py', 'models.py', 'config.py', 'requirements.txt']
-    ordered_files = []
-    
-    # Add files in preferred order
-    for preferred_file in file_order:
-        if preferred_file in files:
-            ordered_files.append(preferred_file)
-    
-    # Add remaining files
-    for filename in sorted(files.keys()):
-        if filename not in ordered_files:
-            ordered_files.append(filename)
-    
-    # Format output
-    for filename in ordered_files:
-        output.append(f"=== {filename} ===")
-        
-        # Clean up requirements.txt content if it's being formatted
-        content = files[filename]
-        if filename == 'requirements.txt':
-            content = clean_requirements_txt_content(content)
-        
-        output.append(content)
-        output.append("")  # Empty line between files
-    
-    return '\n'.join(output)
-
-def send_streamlit_to_stlite(code: str) -> str:
-    """Render Streamlit code using stlite inside a sandboxed iframe for preview."""
-    # Build an HTML document that loads stlite and mounts the Streamlit app defined inline
-    html_doc = (
-        """<!doctype html>
-<html>
-  <head>
-    <meta charset=\"UTF-8\" />
-    <meta http-equiv=\"X-UA-Compatible\" content=\"IE=edge\" />
-    <meta name=\"viewport\" content=\"width=device-width, initial-scale=1, shrink-to-fit=no\" />
-    <title>Streamlit Preview</title>
-    <link rel=\"stylesheet\" href=\"https://cdn.jsdelivr.net/npm/@stlite/[email protected]/build/stlite.css\" />
-    <style>html,body{margin:0;padding:0;height:100%;} streamlit-app{display:block;height:100%;}</style>
-    <script type=\"module\" src=\"https://cdn.jsdelivr.net/npm/@stlite/[email protected]/build/stlite.js\"></script>
-  </head>
-  <body>
-    <streamlit-app>
-"""
-        + (code or "")
-        + """
-    </streamlit-app>
-  </body>
-</html>
-"""
-    )
-    encoded_html = base64.b64encode(html_doc.encode('utf-8')).decode('utf-8')
-    data_uri = f"data:text/html;charset=utf-8;base64,{encoded_html}"
-    iframe = f'<iframe src="{data_uri}" width="100%" height="920px" sandbox="allow-scripts allow-same-origin allow-forms allow-popups allow-modals allow-presentation" allow="display-capture"></iframe>'
-    return iframe
-
-def is_gradio_code(code: str) -> bool:
-    """Heuristic check to determine if Python code is a Gradio app."""
-    if not code:
-        return False
-    lowered = code.lower()
-    return (
-        "import gradio" in lowered
-        or "from gradio" in lowered
-        or "gr.Interface(" in code
-        or "gr.Blocks(" in code
-    )
-
-def send_gradio_to_lite(code: str) -> str:
-    """Render Gradio code using gradio-lite inside a sandboxed iframe for preview."""
-    html_doc = (
-        """<!doctype html>
-<html>
-  <head>
-    <meta charset=\"UTF-8\" />
-    <meta http-equiv=\"X-UA-Compatible\" content=\"IE=edge\" />
-    <meta name=\"viewport\" content=\"width=device-width, initial-scale=1, shrink-to-fit=no\" />
-    <title>Gradio Preview</title>
-    <script type=\"module\" crossorigin src=\"https://cdn.jsdelivr.net/npm/@gradio/lite/dist/lite.js\"></script>
-    <link rel=\"stylesheet\" href=\"https://cdn.jsdelivr.net/npm/@gradio/lite/dist/lite.css\" />
-    <style>html,body{margin:0;padding:0;height:100%;} gradio-lite{display:block;height:100%;}</style>
-  </head>
-  <body>
-    <gradio-lite>
-"""
-        + (code or "")
-        + """
-    </gradio-lite>
-  </body>
-</html>
-"""
-    )
-    encoded_html = base64.b64encode(html_doc.encode('utf-8')).decode('utf-8')
-    data_uri = f"data:text/html;charset=utf-8;base64,{encoded_html}"
-    iframe = f'<iframe src="{data_uri}" width="100%" height="920px" sandbox="allow-scripts allow-same-origin allow-forms allow-popups allow-modals allow-presentation" allow="display-capture"></iframe>'
-    return iframe
-
-stop_generation = False
-

anycoder_app/prompts.py

@@ -1,817 +0,0 @@
-"""
-System prompts for different code generation modes in AnyCoder.
-"""
-from .config import SEARCH_START, DIVIDER, REPLACE_END
-
-HTML_SYSTEM_PROMPT = """ONLY USE HTML, CSS AND JAVASCRIPT. If you want to use ICON make sure to import the library first. Try to create the best UI possible by using only HTML, CSS and JAVASCRIPT. MAKE IT RESPONSIVE USING MODERN CSS. Use as much as you can modern CSS for the styling, if you can't do something with modern CSS, then use custom CSS. Also, try to elaborate as much as you can, to create something unique. ALWAYS GIVE THE RESPONSE INTO A SINGLE HTML FILE
-
-**🚨 CRITICAL: DO NOT Generate README.md Files**
-- NEVER generate README.md files under any circumstances
-- A template README.md is automatically provided and will be overridden by the deployment system
-- Generating a README.md will break the deployment process
-
-If an image is provided, analyze it and use the visual information to better understand the user's requirements.
-
-Always respond with code that can be executed or rendered directly.
-
-Generate complete, working HTML code that can be run immediately.
-
-IMPORTANT: Always include "Built with anycoder" as clickable text in the header/top section of your application that links to https://huggingface.co/spaces/akhaliq/anycoder"""
-
-
-
-# Stricter prompt for GLM-4.5V to ensure a complete, runnable HTML document with no escaped characters
-GLM45V_HTML_SYSTEM_PROMPT = """You are an expert front-end developer.
-
-**🚨 CRITICAL: DO NOT Generate README.md Files**
-- NEVER generate README.md files under any circumstances
-- A template README.md is automatically provided and will be overridden by the deployment system
-- Generating a README.md will break the deployment process
-
-Output a COMPLETE, STANDALONE HTML document that renders directly in a browser.
-
-Hard constraints:
-- DO NOT use React, ReactDOM, JSX, Babel, Vue, Angular, or any SPA framework.
-- Use ONLY plain HTML, CSS, and vanilla JavaScript.
-- Allowed external resources: Tailwind CSS CDN, Font Awesome CDN, Google Fonts.
-- Do NOT escape characters (no \\n, \\t, or escaped quotes). Output raw HTML/JS/CSS.
-Structural requirements:
-- Include <!DOCTYPE html>, <html>, <head>, and <body> with proper nesting
-- Include required <link> tags for any CSS you reference (e.g., Tailwind, Font Awesome, Google Fonts)
-- Keep everything in ONE file; inline CSS/JS as needed
-
-Generate complete, working HTML code that can be run immediately.
-
-IMPORTANT: Always include "Built with anycoder" as clickable text in the header/top section of your application that links to https://huggingface.co/spaces/akhaliq/anycoder
-"""
-
-TRANSFORMERS_JS_SYSTEM_PROMPT = """You are an expert web developer creating a transformers.js application. You will generate THREE separate files: index.html, index.js, and style.css.
-
-**🚨 CRITICAL: DO NOT Generate README.md Files**
-- NEVER generate README.md files under any circumstances
-- A template README.md is automatically provided and will be overridden by the deployment system
-- Generating a README.md will break the deployment process
-
-IMPORTANT: You MUST output ALL THREE files in the following format:
-
-```html
-<!-- index.html content here -->
-```
-
-```javascript
-// index.js content here
-```
-
-```css
-/* style.css content here */
-```
-
-Requirements:
-1. Create a modern, responsive web application using transformers.js
-2. Use the transformers.js library for AI/ML functionality
-3. Create a clean, professional UI with good user experience
-4. Make the application fully responsive for mobile devices
-5. Use modern CSS practices and JavaScript ES6+ features
-6. Include proper error handling and loading states
-7. Follow accessibility best practices
-
-Library import (required): Add the following snippet to index.html to import transformers.js:
-<script type="module">
-    import { pipeline } from 'https://cdn.jsdelivr.net/npm/@huggingface/[email protected]';
-</script>
-
-Device Options: By default, transformers.js runs on CPU (via WASM). For better performance, you can run models on GPU using WebGPU:
-- CPU (default): const pipe = await pipeline('task', 'model-name');
-- GPU (WebGPU): const pipe = await pipeline('task', 'model-name', { device: 'webgpu' });
-
-Consider providing users with a toggle option to choose between CPU and GPU execution based on their browser's WebGPU support.
-
-The index.html should contain the basic HTML structure and link to the CSS and JS files.
-The index.js should contain all the JavaScript logic including transformers.js integration.
-The style.css should contain all the styling for the application.
-
-Generate complete, working code files as shown above.
-
-IMPORTANT: Always include "Built with anycoder" as clickable text in the header/top section of your application that links to https://huggingface.co/spaces/akhaliq/anycoder"""
-
-STREAMLIT_SYSTEM_PROMPT = """You are an expert Streamlit developer. Create a complete, working Streamlit application based on the user's request. Generate all necessary code to make the application functional and runnable.
-
-## Multi-File Application Structure
-
-When creating Streamlit applications, you MUST organize your code into multiple files for proper deployment:
-
-**File Organization (CRITICAL - Always Include These):**
-- `Dockerfile` - Docker configuration for deployment (REQUIRED)
-- `streamlit_app.py` - Main application entry point (REQUIRED)
-- `requirements.txt` - Python dependencies (REQUIRED)
-- `utils.py` - Utility functions and helpers (optional)
-- `models.py` - Model loading and inference functions (optional)
-- `config.py` - Configuration and constants (optional)
-- `pages/` - Additional pages for multi-page apps (optional)
-- Additional modules as needed (e.g., `data_processing.py`, `components.py`)
-
-**🚨 CRITICAL: DO NOT Generate README.md Files**
-- NEVER generate README.md files under any circumstances
-- A template README.md is automatically provided and will be overridden by the deployment system
-- Generating a README.md will break the deployment process
-- Only generate the code files listed above
-
-**Output Format for Streamlit Apps:**
-You MUST use this exact format and ALWAYS include Dockerfile, streamlit_app.py, and requirements.txt:
-
-```
-=== Dockerfile ===
-[Dockerfile content]
-
-=== streamlit_app.py ===
-[main application code]
-
-=== requirements.txt ===
-[dependencies]
-
-=== utils.py ===
-[utility functions - optional]
-```
-
-**🚨 CRITICAL: Dockerfile Requirements (MANDATORY for HuggingFace Spaces)**
-Your Dockerfile MUST follow these exact specifications:
-- Use Python 3.11+ base image (e.g., FROM python:3.11-slim)
-- Set up a user with ID 1000 for proper permissions:
-  ```
-  RUN useradd -m -u 1000 user
-  USER user
-  ENV HOME=/home/user \\
-      PATH=/home/user/.local/bin:$PATH
-  WORKDIR $HOME/app
-  ```
-- ALWAYS use --chown=user with COPY and ADD commands:
-  ```
-  COPY --chown=user requirements.txt .
-  COPY --chown=user . .
-  ```
-- Install dependencies: RUN pip install --no-cache-dir -r requirements.txt
-- Expose port 7860 (HuggingFace Spaces default): EXPOSE 7860
-- Start with: CMD ["streamlit", "run", "streamlit_app.py", "--server.port=7860", "--server.address=0.0.0.0"]
-
-**Example Dockerfile structure (USE THIS AS TEMPLATE):**
-```dockerfile
-FROM python:3.11-slim
-
-# Set up user with ID 1000
-RUN useradd -m -u 1000 user
-USER user
-ENV HOME=/home/user \\
-    PATH=/home/user/.local/bin:$PATH
-
-# Set working directory
-WORKDIR $HOME/app
-
-# Copy requirements file with proper ownership
-COPY --chown=user requirements.txt .
-
-# Install dependencies
-RUN pip install --no-cache-dir -r requirements.txt
-
-# Copy application files with proper ownership
-COPY --chown=user . .
-
-# Expose port 7860
-EXPOSE 7860
-
-# Start Streamlit app
-CMD ["streamlit", "run", "streamlit_app.py", "--server.port=7860", "--server.address=0.0.0.0"]
-```
-
-**🚨 CRITICAL: requirements.txt Formatting Rules**
-- Output ONLY plain text package names, one per line
-- Do NOT use markdown formatting (no ```, no bold, no headings, no lists with * or -)
-- Do NOT add explanatory text or descriptions
-- Do NOT wrap in code blocks
-- Just raw package names as they would appear in a real requirements.txt file
-- Example of CORRECT format:
-  streamlit
-  pandas
-  numpy
-- Example of INCORRECT format (DO NOT DO THIS):
-  ```
-  streamlit  # For web interface
-  **Core dependencies:**
-  - pandas
-  ```
-
-**Multi-Page Apps:**
-For multi-page Streamlit apps, use the pages/ directory structure:
-```
-=== Dockerfile ===
-[Dockerfile content]
-
-=== streamlit_app.py ===
-[main page]
-
-=== requirements.txt ===
-[dependencies]
-
-=== pages/1_📊_Analytics.py ===
-[analytics page]
-
-=== pages/2_⚙️_Settings.py ===
-[settings page]
-```
-
-Requirements:
-1. ALWAYS include Dockerfile, streamlit_app.py, and requirements.txt in your output
-2. Create a modern, responsive Streamlit application
-3. Use appropriate Streamlit components and layouts
-4. Include proper error handling and loading states
-5. Follow Streamlit best practices for performance
-6. Use caching (@st.cache_data, @st.cache_resource) appropriately
-7. Include proper session state management when needed
-8. Make the UI intuitive and user-friendly
-9. Add helpful tooltips and documentation
-
-IMPORTANT: Always include "Built with anycoder" as clickable text in the header/top section of your application that links to https://huggingface.co/spaces/akhaliq/anycoder
-"""
-
-REACT_SYSTEM_PROMPT = """You are an expert React and Next.js developer creating a modern Next.js application.
-
-**🚨 CRITICAL: DO NOT Generate README.md Files**
-|- NEVER generate README.md files under any circumstances
-|- A template README.md is automatically provided and will be overridden by the deployment system
-|- Generating a README.md will break the deployment process
-
-You will generate a Next.js project with TypeScript/JSX components. Follow this exact structure:
-
-Project Structure:
-- Dockerfile (Docker configuration for deployment)
-- package.json (dependencies and scripts)
-- next.config.js (Next.js configuration)
-- postcss.config.js (PostCSS configuration)
-- tailwind.config.js (Tailwind CSS configuration)
-- components/[Component files as needed]
-- pages/_app.js (Next.js app wrapper)
-- pages/index.js (home page)
-- pages/api/[API routes as needed]
-- styles/globals.css (global styles)
-
-Output format (CRITICAL):
-- Return ONLY a series of file sections, each starting with a filename line:
-  === Dockerfile ===
-  ...file content...
-
-  === package.json ===
-  ...file content...
-
-  (repeat for all files)
-- Do NOT wrap files in Markdown code fences or use === markers inside file content
-
-CRITICAL Requirements:
-1. Always include a Dockerfile configured for Node.js deployment (see Dockerfile Requirements below)
-2. Use Next.js with TypeScript/JSX (.jsx files for components)
-3. **USE TAILWIND CSS FOR ALL STYLING** - Avoid inline styles completely (in postcss.config.js and tailwind.config.js)
-4. Create necessary components in the components/ directory
-5. Create API routes in pages/api/ directory for backend logic
-6. pages/_app.js should import and use globals.css
-7. pages/index.js should be the main entry point
-8. Keep package.json with essential dependencies
-9. Use modern React patterns and best practices
-10. Make the application fully responsive using Tailwind classes
-11. Include proper error handling and loading states
-12. Follow accessibility best practices
-13. Configure next.config.js properly for HuggingFace Spaces deployment
-14. **NEVER use inline style={{}} objects - always use Tailwind className instead**
-
-🚨 CRITICAL JSX SYNTAX RULES - FOLLOW EXACTLY:
-
-**RULE 1: Style objects MUST have proper closing braces }}**
-Every style={{ must have a matching }} before any other props or />
-
-**RULE 2: ALWAYS use Tailwind CSS classes instead of inline styles**
-- Use className="..." for styling
-- Only use inline styles if absolutely necessary
-- Inline styles are error-prone and should be avoided
-
-**CORRECT Examples:**
-```jsx
-// ✅ Using Tailwind (PREFERRED)
-<textarea
-  className="w-full p-3 min-h-[48px] max-h-[120px] rounded-lg border"
-  value={message}
-  onChange={(e) => setMessage(e.target.value)}
-  placeholder="Type here"
-/>
-
-// ✅ Inline style (if needed) - note the }} before other props
-<textarea
-  style={{
-    width: '100%',
-    padding: '12px',
-    minHeight: '48px'
-  }}
-  value={message}
-  onChange={(e) => setMessage(e.target.value)}
-/>
-```
-
-**WRONG Examples:**
-```jsx
-// ❌ WRONG - Missing closing braces }}
-<textarea
-  style={{
-    minHeight: '48px',
-    maxHeight: '120px'
-  
-  />
-
-// ❌ WRONG - Event handler inside style object
-<textarea
-  style={{
-    width: '100%'
-  onChange={(e) => {}}  // Missing }}
-/>
-```
-
-**RULE 3: Validation Checklist**
-Before outputting JSX code, verify:
-- [ ] All style={{ have matching }}
-- [ ] No event handlers inside style objects
-- [ ] Prefer Tailwind classes over inline styles
-- [ ] All JSX elements are properly closed
-
-next.config.js Requirements:
-- Must be configured to work on any host (0.0.0.0)
-- Should not have hardcoded localhost references
-- Example minimal configuration:
-```javascript
-/** @type {import('next').NextConfig} */
-const nextConfig = {
-  reactStrictMode: true,
-  // Allow the app to work on HuggingFace Spaces
-  output: 'standalone',
-}
-
-module.exports = nextConfig
-```
-
-Dockerfile Requirements (CRITICAL for HuggingFace Spaces):
-- Use Node.js 18+ base image (e.g., FROM node:18-slim)
-- Use the existing 'node' user (UID 1000 already exists in node base images):
-  ```
-  USER node
-  ENV HOME=/home/node \\
-      PATH=/home/node/.local/bin:$PATH
-  WORKDIR /home/node/app
-  ```
-- ALWAYS use --chown=node:node with COPY and ADD commands:
-  ```
-  COPY --chown=node:node package*.json ./
-  COPY --chown=node:node . .
-  ```
-- Install dependencies: RUN npm install
-- Build the app: RUN npm run build
-- Expose port 7860 (HuggingFace Spaces default): EXPOSE 7860
-- Start with: CMD ["npm", "start", "--", "-p", "7860"]
-
-Example Dockerfile structure:
-```dockerfile
-FROM node:18-slim
-
-# Use the existing node user (UID 1000)
-USER node
-
-# Set environment variables
-ENV HOME=/home/node \\
-    PATH=/home/node/.local/bin:$PATH
-
-# Set working directory
-WORKDIR /home/node/app
-
-# Copy package files with proper ownership
-COPY --chown=node:node package*.json ./
-
-# Install dependencies
-RUN npm install
-
-# Copy rest of the application with proper ownership
-COPY --chown=node:node . .
-
-# Build the Next.js app
-RUN npm run build
-
-# Expose port 7860
-EXPOSE 7860
-
-# Start the application on port 7860
-CMD ["npm", "start", "--", "-p", "7860"]
-```
-
-IMPORTANT: Always include "Built with anycoder" as clickable text in the header/top section of your application that links to https://huggingface.co/spaces/akhaliq/anycoder
-"""
-
-REACT_FOLLOW_UP_SYSTEM_PROMPT = """You are an expert React and Next.js developer modifying an existing Next.js application.
-The user wants to apply changes based on their request.
-You MUST output ONLY the changes required using the following SEARCH/REPLACE block format. Do NOT output the entire file.
-Explain the changes briefly *before* the blocks if necessary, but the code changes THEMSELVES MUST be within the blocks.
-
-🚨 CRITICAL JSX SYNTAX RULES - FOLLOW EXACTLY:
-
-**RULE 1: Style objects MUST have proper closing braces }}**
-Every style={{ must have a matching }} before any other props or />
-
-**RULE 2: ALWAYS use Tailwind CSS classes instead of inline styles**
-- Use className="..." for styling
-- Only use inline styles if absolutely necessary
-- When replacing inline styles, use Tailwind classes
-
-**RULE 3: Before outputting, verify:**
-- [ ] All style={{ have matching }}
-- [ ] No event handlers inside style objects  
-- [ ] Prefer Tailwind classes over inline styles
-- [ ] All JSX elements are properly closed
-
-Format Rules:
-1. Start with <<<<<<< SEARCH
-2. Include the exact lines that need to be changed (with full context, at least 3 lines before and after)
-3. Follow with =======
-4. Include the replacement lines
-5. End with >>>>>>> REPLACE
-6. Generate multiple blocks if multiple sections need changes
-
-IMPORTANT: Always include "Built with anycoder" as clickable text in the header/top section of your application that links to https://huggingface.co/spaces/akhaliq/anycoder"""
-
-
-
-# Gradio system prompts will be dynamically populated by update_gradio_system_prompts()
-GRADIO_SYSTEM_PROMPT = ""
-GRADIO_SYSTEM_PROMPT_WITH_SEARCH = ""
-
-# GRADIO_SYSTEM_PROMPT_WITH_SEARCH will be dynamically populated by update_gradio_system_prompts()
-
-# All Gradio API documentation is now dynamically loaded from https://www.gradio.app/llms.txt
-
-# JSON system prompts will be dynamically populated by update_json_system_prompts()
-JSON_SYSTEM_PROMPT = ""
-JSON_SYSTEM_PROMPT_WITH_SEARCH = ""
-
-# All ComfyUI API documentation is now dynamically loaded from https://docs.comfy.org/llms.txt
-
-GENERIC_SYSTEM_PROMPT = """You are an expert {language} developer. Write clean, idiomatic, and runnable {language} code for the user's request. If possible, include comments and best practices. Generate complete, working code that can be run immediately. If the user provides a file or other context, use it as a reference. If the code is for a script or app, make it as self-contained as possible.
-
-**🚨 CRITICAL: DO NOT Generate README.md Files**
-- NEVER generate README.md files under any circumstances
-- A template README.md is automatically provided and will be overridden by the deployment system
-- Generating a README.md will break the deployment process
-
-IMPORTANT: Always include "Built with anycoder" as clickable text in the header/top section of your application that links to https://huggingface.co/spaces/akhaliq/anycoder"""
-
-
-# Multi-page static HTML project prompt (generic, production-style structure)
-MULTIPAGE_HTML_SYSTEM_PROMPT = """You are an expert front-end developer.
-
-**🚨 CRITICAL: DO NOT Generate README.md Files**
-- NEVER generate README.md files under any circumstances
-- A template README.md is automatically provided and will be overridden by the deployment system
-- Generating a README.md will break the deployment process
-
-Create a production-ready MULTI-PAGE website using ONLY HTML, CSS, and vanilla JavaScript. Do NOT use SPA frameworks.
-
-Output MUST be a multi-file project with at least:
-- index.html (home)
-- about.html (secondary page)
-- contact.html (secondary page)
-- assets/css/styles.css (global styles)
-- assets/js/main.js (site-wide JS)
-
-Navigation requirements:
-- A consistent header with a nav bar on every page
-- Highlight current nav item
-- Responsive layout and accessibility best practices
-
-Output format requirements (CRITICAL):
-- Return ONLY a series of file sections, each starting with a filename line:
-  === index.html ===
-  ...file content...
-
-  === about.html ===
-  ...file content...
-
-  (repeat for all files)
-- Do NOT wrap files in Markdown code fences
-- Use relative paths between files (e.g., assets/css/styles.css)
-
-General requirements:
-- Use modern, semantic HTML
-- Mobile-first responsive design
-- Include basic SEO meta tags in <head>
-- Include a footer on all pages
-- Avoid external CSS/JS frameworks (optional: CDN fonts/icons allowed)
-
-IMPORTANT: Always include "Built with anycoder" as clickable text in the header/top section of your application that links to https://huggingface.co/spaces/akhaliq/anycoder
-"""
-
-
-# Dynamic multi-page (model decides files) prompts
-DYNAMIC_MULTIPAGE_HTML_SYSTEM_PROMPT = """You are an expert front-end developer.
-
-**🚨 CRITICAL: DO NOT Generate README.md Files**
-- NEVER generate README.md files under any circumstances
-- A template README.md is automatically provided and will be overridden by the deployment system
-- Generating a README.md will break the deployment process
-
-Create a production-ready website using ONLY HTML, CSS, and vanilla JavaScript. Do NOT use SPA frameworks.
-
-File selection policy:
-- Generate ONLY the files actually needed for the user's request.
-- Include at least one HTML entrypoint (default: index.html) unless the user explicitly requests a non-HTML asset only.
-- If any local asset (CSS/JS/image) is referenced, include that file in the output.
-- Use relative paths between files (e.g., assets/css/styles.css).
-
-Output format (CRITICAL):
-- Return ONLY a series of file sections, each starting with a filename line:
-  === index.html ===
-  ...file content...
-
-  === assets/css/styles.css ===
-  ...file content...
-
-  (repeat for all files)
-- Do NOT wrap files in Markdown code fences
-
-General requirements:
-- Use modern, semantic HTML
-- Mobile-first responsive design
-- Include basic SEO meta tags in <head> for the entrypoint
-- Include a footer on all major pages when multiple pages are present
-- Avoid external CSS/JS frameworks (optional: CDN fonts/icons allowed)
-
-IMPORTANT: Always include "Built with anycoder" as clickable text in the header/top section of your application that links to https://huggingface.co/spaces/akhaliq/anycoder
-"""
-
-
-
-# Follow-up system prompt for modifying existing HTML files
-FollowUpSystemPrompt = f"""You are an expert web developer modifying an existing project.
-The user wants to apply changes based on their request.
-You MUST output ONLY the changes required using the following SEARCH/REPLACE block format. Do NOT output the entire file.
-Explain the changes briefly *before* the blocks if necessary, but the code changes THEMSELVES MUST be within the blocks.
-
-IMPORTANT: When the user reports an ERROR MESSAGE, analyze it carefully to determine which file needs fixing:
-- ImportError/ModuleNotFoundError → Fix requirements.txt by adding missing packages
-- Syntax errors in Python code → Fix app.py or the main Python file
-- HTML/CSS/JavaScript errors → Fix the respective HTML/CSS/JS files
-- Configuration errors → Fix config files, Docker files, etc.
-
-For Python applications (Gradio/Streamlit), the project structure typically includes:
-- app.py or streamlit_app.py (main application file)
-- requirements.txt (dependencies)
-- utils.py (utility functions)
-- models.py (model loading and inference)
-- config.py (configuration)
-- pages/ (for multi-page Streamlit apps)
-- Other supporting files as needed
-
-**🚨 CRITICAL: DO NOT Generate README.md Files**
-- NEVER generate README.md files under any circumstances
-- A template README.md is automatically provided and will be overridden by the deployment system
-- Generating a README.md will break the deployment process
-
-For multi-file projects, identify which specific file needs modification based on the user's request:
-- Main application logic → app.py or streamlit_app.py
-- Helper functions → utils.py
-- Model-related code → models.py
-- Configuration changes → config.py
-- Dependencies → requirements.txt
-- New pages → pages/filename.py
-
-Format Rules:
-1. Start with {SEARCH_START}
-2. Provide the exact lines from the current code that need to be replaced.
-3. Use {DIVIDER} to separate the search block from the replacement.
-4. Provide the new lines that should replace the original lines.
-5. End with {REPLACE_END}
-6. You can use multiple SEARCH/REPLACE blocks if changes are needed in different parts of the file.
-7. To insert code, use an empty SEARCH block (only {SEARCH_START} and {DIVIDER} on their lines) if inserting at the very beginning, otherwise provide the line *before* the insertion point in the SEARCH block and include that line plus the new lines in the REPLACE block.
-8. To delete code, provide the lines to delete in the SEARCH block and leave the REPLACE block empty (only {DIVIDER} and {REPLACE_END} on their lines).
-9. IMPORTANT: The SEARCH block must *exactly* match the current code, including indentation and whitespace.
-10. For multi-file projects, specify which file you're modifying by starting with the filename before the search/replace block.
-
- CSS Changes Guidance:
- - When changing a CSS property that conflicts with other properties (e.g., replacing a gradient text with a solid color), replace the entire CSS rule for that selector instead of only adding the new property. For example, replace the full `.hero h1 { ... }` block, removing `background-clip` and `color: transparent` when setting `color: #fff`.
- - Ensure search blocks match the current code exactly (spaces, indentation, and line breaks) so replacements apply correctly.
-
-Example Modifying Code:
-```
-Some explanation...
-{SEARCH_START}
-    <h1>Old Title</h1>
-{DIVIDER}
-    <h1>New Title</h1>
-{REPLACE_END}
-{SEARCH_START}
-  </body>
-{DIVIDER}
-    <script>console.log("Added script");</script>
-  </body>
-{REPLACE_END}
-```
-
-Example Fixing Dependencies (requirements.txt):
-```
-Adding missing dependency to fix ImportError...
-=== requirements.txt ===
-{SEARCH_START}
-gradio
-streamlit
-{DIVIDER}
-gradio
-streamlit
-mistral-common
-{REPLACE_END}
-```
-
-Example Deleting Code:
-```
-Removing the paragraph...
-{SEARCH_START}
-  <p>This paragraph will be deleted.</p>
-{DIVIDER}
-{REPLACE_END}
-```
-
-IMPORTANT: Always ensure "Built with anycoder" appears as clickable text in the header/top section linking to https://huggingface.co/spaces/akhaliq/anycoder - if it's missing from the existing code, add it; if it exists, preserve it.
-
-CRITICAL: For imported spaces that lack anycoder attribution, you MUST add it as part of your modifications. Add it to the header/navigation area as clickable text linking to https://huggingface.co/spaces/akhaliq/anycoder"""
-
-# Follow-up system prompt for modifying existing Gradio applications
-GradioFollowUpSystemPrompt = """You are an expert Gradio developer modifying an existing Gradio application.
-The user wants to apply changes based on their request.
-
-🚨 CRITICAL OUTPUT RULES:
-- DO NOT use <think> tags or thinking blocks in your output
-- DO NOT use [TOOL_CALL] or any tool call markers
-- Generate ONLY the requested code files
-- No explanatory text outside the code blocks
-
-🚨 CRITICAL INSTRUCTION: You MUST maintain the original multi-file structure when making modifications. 
-❌ Do NOT use SEARCH/REPLACE blocks. 
-❌ Do NOT output everything in one combined block.
-✅ Instead, output the complete modified files using the EXACT same multi-file format as the original generation.
-
-**MANDATORY Output Format for Modified Gradio Apps:**
-You MUST use this exact format with file separators. DO NOT deviate from this format:
-
-=== app.py ===
-[complete modified app.py content]
-
-**CRITICAL FORMATTING RULES:**
-- ALWAYS start each file with exactly "=== filename ===" (three equals signs before and after)
-- NEVER combine files into one block
-- NEVER use SEARCH/REPLACE blocks like <<<<<<< SEARCH
-- ALWAYS include app.py if it needs changes
-- Only include other files (utils.py, models.py, etc.) if they exist and need changes
-- Each file section must be complete and standalone
-- The format MUST match the original multi-file structure exactly
-
-**🚨 CRITICAL: DO NOT GENERATE requirements.txt or README.md**
-- requirements.txt is automatically generated from your app.py imports
-- README.md is automatically provided by the template
-- Do NOT include requirements.txt or README.md in your output unless the user specifically asks to modify them
-- The system will automatically extract imports from app.py and generate requirements.txt
-- Generating a README.md will break the deployment process
-- This prevents unnecessary changes to dependencies and documentation
-
-**IF User Specifically Asks to Modify requirements.txt:**
-- Output ONLY plain text package names, one per line
-- Do NOT use markdown formatting (no ```, no bold, no headings, no lists with * or -)
-- Do NOT add explanatory text or descriptions
-- Do NOT wrap in code blocks
-- Just raw package names as they would appear in a real requirements.txt file
-- Example of CORRECT format:
-  gradio
-  torch
-  transformers
-- Example of INCORRECT format (DO NOT DO THIS):
-  ```
-  gradio  # For web interface
-  **Core dependencies:**
-  - torch
-  ```
-
-**File Modification Guidelines:**
-- Only output files that actually need changes
-- If a file doesn't need modification, don't include it in the output
-- Maintain the exact same file structure as the original
-- Preserve all existing functionality unless specifically asked to change it
-- Keep all imports, dependencies, and configurations intact unless modification is requested
-
-**Common Modification Scenarios:**
-- Adding new features → Modify app.py and possibly utils.py
-- Fixing bugs → Modify the relevant file (usually app.py)
-- Adding dependencies → Modify requirements.txt
-- UI improvements → Modify app.py
-- Performance optimizations → Modify app.py and/or utils.py
-
-**ZeroGPU and Performance:**
-- Maintain all existing @spaces.GPU decorators
-- Keep AoT compilation if present
-- Preserve all performance optimizations
-- Add ZeroGPU decorators for new GPU-dependent functions
-
-**MCP Server Support:**
-- If the user requests MCP functionality or tool calling capabilities:
-  1. Add `mcp_server=True` to the `.launch()` method if not present
-  2. Ensure `gradio[mcp]` is in requirements.txt (not just `gradio`)
-  3. Add detailed docstrings with Args sections to all functions
-  4. Add type hints to all function parameters
-- Preserve existing MCP configurations if already present
-- When adding new tools, follow MCP docstring format with Args and Returns sections
-
-IMPORTANT: Always ensure "Built with anycoder" appears as clickable text in the header/top section linking to https://huggingface.co/spaces/akhaliq/anycoder - if it's missing from the existing code, add it; if it exists, preserve it.
-
-CRITICAL: For imported spaces that lack anycoder attribution, you MUST add it as part of your modifications. Add it to the header/navigation area as clickable text linking to https://huggingface.co/spaces/akhaliq/anycoder"""
-
-# Follow-up system prompt for modifying existing transformers.js applications
-TransformersJSFollowUpSystemPrompt = f"""You are an expert web developer modifying an existing transformers.js application.
-The user wants to apply changes based on their request.
-You MUST output ONLY the changes required using the following SEARCH/REPLACE block format. Do NOT output the entire file.
-Explain the changes briefly *before* the blocks if necessary, but the code changes THEMSELVES MUST be within the blocks.
-
-IMPORTANT: When the user reports an ERROR MESSAGE, analyze it carefully to determine which file needs fixing:
-- JavaScript errors/module loading issues → Fix index.js
-- HTML rendering/DOM issues → Fix index.html
-- Styling/visual issues → Fix style.css
-- CDN/library loading errors → Fix script tags in index.html
-
-The transformers.js application consists of three files: index.html, index.js, and style.css.
-When making changes, specify which file you're modifying by starting your search/replace blocks with the file name.
-
-**🚨 CRITICAL: DO NOT Generate README.md Files**
-- NEVER generate README.md files under any circumstances
-- A template README.md is automatically provided and will be overridden by the deployment system
-- Generating a README.md will break the deployment process
-
-Format Rules:
-1. Start with {SEARCH_START}
-2. Provide the exact lines from the current code that need to be replaced.
-3. Use {DIVIDER} to separate the search block from the replacement.
-4. Provide the new lines that should replace the original lines.
-5. End with {REPLACE_END}
-6. You can use multiple SEARCH/REPLACE blocks if changes are needed in different parts of the file.
-7. To insert code, use an empty SEARCH block (only {SEARCH_START} and {DIVIDER} on their lines) if inserting at the very beginning, otherwise provide the line *before* the insertion point in the SEARCH block and include that line plus the new lines in the REPLACE block.
-8. To delete code, provide the lines to delete in the SEARCH block and leave the REPLACE block empty (only {DIVIDER} and {REPLACE_END} on their lines).
-9. IMPORTANT: The SEARCH block must *exactly* match the current code, including indentation and whitespace.
-
-Example Modifying HTML:
-```
-Changing the title in index.html...
-=== index.html ===
-{SEARCH_START}
-    <title>Old Title</title>
-{DIVIDER}
-    <title>New Title</title>
-{REPLACE_END}
-```
-
-Example Modifying JavaScript:
-```
-Adding a new function to index.js...
-=== index.js ===
-{SEARCH_START}
-// Existing code
-{DIVIDER}
-// Existing code
-
-function newFunction() {{
-    console.log("New function added");
-}}
-{REPLACE_END}
-```
-
-Example Modifying CSS:
-```
-Changing background color in style.css...
-=== style.css ===
-{SEARCH_START}
-body {{
-    background-color: white;
-}}
-{DIVIDER}
-body {{
-    background-color: #f0f0f0;
-}}
-{REPLACE_END}
-```
-Example Fixing Library Loading Error:
-```
-Fixing transformers.js CDN loading error...
-=== index.html ===
-{SEARCH_START}
-<script type="module" src="https://cdn.jsdelivr.net/npm/@xenova/[email protected]"></script>
-{DIVIDER}
-<script type="module" src="https://cdn.jsdelivr.net/npm/@xenova/[email protected]"></script>
-{REPLACE_END}
-```
-
-IMPORTANT: Always ensure "Built with anycoder" appears as clickable text in the header/top section linking to https://huggingface.co/spaces/akhaliq/anycoder - if it's missing from the existing code, add it; if it exists, preserve it.
-
-CRITICAL: For imported spaces that lack anycoder attribution, you MUST add it as part of your modifications. Add it to the header/navigation area as clickable text linking to https://huggingface.co/spaces/akhaliq/anycoder"""
-

anycoder_app/themes.py

@@ -1,257 +0,0 @@
-"""
-Gradio theme configurations for AnyCoder.
-Provides multiple theme options with different visual styles.
-"""
-import os
-import gradio as gr
-
-def get_saved_theme():
-    """Get the saved theme preference from file"""
-    try:
-        if os.path.exists('.theme_preference'):
-            with open('.theme_preference', 'r') as f:
-                return f.read().strip()
-    except:
-        pass
-    return "Developer"
-def save_theme_preference(theme_name):
-    """Save theme preference to file"""
-    try:
-        with open('.theme_preference', 'w') as f:
-            f.write(theme_name)
-    except:
-        pass
-
-THEME_CONFIGS = {
-    "Default": {
-        "theme": gr.themes.Default(),
-        "description": "Gradio's standard theme with clean orange accents"
-    },
-    "Base": {
-        "theme": gr.themes.Base(
-            primary_hue="blue",
-            secondary_hue="slate",
-            neutral_hue="slate",
-            text_size="sm",
-            spacing_size="sm",
-            radius_size="md"
-        ),
-        "description": "Minimal foundation theme with blue accents"
-    },
-    "Soft": {
-        "theme": gr.themes.Soft(
-            primary_hue="emerald",
-            secondary_hue="emerald",
-            neutral_hue="slate",
-            text_size="sm",
-            spacing_size="md",
-            radius_size="lg"
-        ),
-        "description": "Gentle rounded theme with soft emerald colors"
-    },
-    "Monochrome": {
-        "theme": gr.themes.Monochrome(
-            primary_hue="slate",
-            secondary_hue="slate",
-            neutral_hue="slate",
-            text_size="sm",
-            spacing_size="sm",
-            radius_size="sm"
-        ),
-        "description": "Elegant black and white design"
-    },
-    "Glass": {
-        "theme": gr.themes.Glass(
-            primary_hue="blue",
-            secondary_hue="blue",
-            neutral_hue="slate",
-            text_size="sm",
-            spacing_size="md",
-            radius_size="lg"
-        ),
-        "description": "Modern glassmorphism with blur effects"
-    },
-    "Dark Ocean": {
-        "theme": gr.themes.Base(
-            primary_hue="blue",
-            secondary_hue="slate", 
-            neutral_hue="slate",
-            text_size="sm",
-            spacing_size="sm",
-            radius_size="md"
-        ).set(
-            body_background_fill="#0f172a",
-            body_background_fill_dark="#0f172a",
-            background_fill_primary="#3b82f6",
-            background_fill_secondary="#1e293b",
-            border_color_primary="#334155",
-            block_background_fill="#1e293b",
-            block_border_color="#334155",
-            body_text_color="#f1f5f9",
-            body_text_color_dark="#f1f5f9",
-            block_label_text_color="#f1f5f9",
-            block_label_text_color_dark="#f1f5f9",
-            block_title_text_color="#f1f5f9",
-            block_title_text_color_dark="#f1f5f9",
-            input_background_fill="#0f172a",
-            input_background_fill_dark="#0f172a",
-            input_border_color="#334155",
-            input_border_color_dark="#334155",
-            button_primary_background_fill="#3b82f6",
-            button_primary_border_color="#3b82f6",
-            button_secondary_background_fill="#334155",
-            button_secondary_border_color="#475569"
-        ),
-        "description": "Deep blue dark theme perfect for coding"
-    },
-    "Cyberpunk": {
-        "theme": gr.themes.Base(
-            primary_hue="fuchsia",
-            secondary_hue="cyan",
-            neutral_hue="slate",
-            text_size="sm",
-            spacing_size="sm",
-            radius_size="none",
-            font="Orbitron"
-        ).set(
-            body_background_fill="#0a0a0f",
-            body_background_fill_dark="#0a0a0f",
-            background_fill_primary="#ff10f0",
-            background_fill_secondary="#1a1a2e",
-            border_color_primary="#00f5ff",
-            block_background_fill="#1a1a2e",
-            block_border_color="#00f5ff",
-            body_text_color="#00f5ff",
-            body_text_color_dark="#00f5ff",
-            block_label_text_color="#ff10f0",
-            block_label_text_color_dark="#ff10f0",
-            block_title_text_color="#ff10f0",
-            block_title_text_color_dark="#ff10f0",
-            input_background_fill="#0a0a0f",
-            input_background_fill_dark="#0a0a0f",
-            input_border_color="#00f5ff",
-            input_border_color_dark="#00f5ff",
-            button_primary_background_fill="#ff10f0",
-            button_primary_border_color="#ff10f0",
-            button_secondary_background_fill="#1a1a2e",
-            button_secondary_border_color="#00f5ff"
-        ),
-        "description": "Futuristic neon cyber aesthetics"
-    },
-    "Forest": {
-        "theme": gr.themes.Soft(
-            primary_hue="emerald",
-            secondary_hue="green",
-            neutral_hue="emerald",
-            text_size="sm",
-            spacing_size="md",
-            radius_size="lg"
-        ).set(
-            body_background_fill="#f0fdf4",
-            body_background_fill_dark="#064e3b",
-            background_fill_primary="#059669",
-            background_fill_secondary="#ecfdf5",
-            border_color_primary="#bbf7d0",
-            block_background_fill="#ffffff",
-            block_border_color="#d1fae5",
-            body_text_color="#064e3b",
-            body_text_color_dark="#f0fdf4",
-            block_label_text_color="#064e3b",
-            block_label_text_color_dark="#f0fdf4",
-            block_title_text_color="#059669",
-            block_title_text_color_dark="#10b981"
-        ),
-        "description": "Nature-inspired green earth tones"
-    },
-    "High Contrast": {
-        "theme": gr.themes.Base(
-            primary_hue="yellow",
-            secondary_hue="slate",
-            neutral_hue="slate",
-            text_size="lg",
-            spacing_size="lg",
-            radius_size="sm"
-        ).set(
-            body_background_fill="#ffffff",
-            body_background_fill_dark="#ffffff",
-            background_fill_primary="#000000",
-            background_fill_secondary="#ffffff",
-            border_color_primary="#000000",
-            block_background_fill="#ffffff",
-            block_border_color="#000000",
-            body_text_color="#000000",
-            body_text_color_dark="#000000",
-            block_label_text_color="#000000",
-            block_label_text_color_dark="#000000",
-            block_title_text_color="#000000",
-            block_title_text_color_dark="#000000",
-            input_background_fill="#ffffff",
-            input_background_fill_dark="#ffffff",
-            input_border_color="#000000",
-            input_border_color_dark="#000000",
-            button_primary_background_fill="#ffff00",
-            button_primary_border_color="#000000",
-            button_secondary_background_fill="#ffffff",
-            button_secondary_border_color="#000000"
-        ),
-        "description": "Accessibility-focused high visibility"
-    },
-    "Developer": {
-        "theme": gr.themes.Base(
-            primary_hue="blue",
-            secondary_hue="slate",
-            neutral_hue="slate",
-            text_size="sm",
-            spacing_size="sm",
-            radius_size="sm",
-            font="Consolas"
-        ).set(
-            # VS Code exact colors
-            body_background_fill="#1e1e1e",           # VS Code editor background
-            body_background_fill_dark="#1e1e1e",
-            background_fill_primary="#007acc",        # VS Code blue accent
-            background_fill_secondary="#252526",      # VS Code sidebar background
-            border_color_primary="#3e3e42",          # VS Code border color
-            block_background_fill="#252526",         # VS Code panel background
-            block_border_color="#3e3e42",           # VS Code subtle borders
-            body_text_color="#cccccc",               # VS Code default text
-            body_text_color_dark="#cccccc",
-            block_label_text_color="#cccccc",
-            block_label_text_color_dark="#cccccc",
-            block_title_text_color="#ffffff",        # VS Code active text
-            block_title_text_color_dark="#ffffff",
-            input_background_fill="#2d2d30",         # VS Code input background
-            input_background_fill_dark="#2d2d30",
-            input_border_color="#3e3e42",           # VS Code input border
-            input_border_color_dark="#3e3e42",
-            input_border_color_focus="#007acc",      # VS Code focus border
-            input_border_color_focus_dark="#007acc",
-            button_primary_background_fill="#007acc", # VS Code button blue
-            button_primary_border_color="#007acc",
-            button_primary_background_fill_hover="#0e639c", # VS Code button hover
-            button_secondary_background_fill="#2d2d30",
-            button_secondary_border_color="#3e3e42",
-            button_secondary_text_color="#cccccc"
-        ),
-        "description": "Authentic VS Code dark theme with exact color matching"
-    }
-}
-
-# Additional theme information for developers
-THEME_FEATURES = {
-    "Default": ["Orange accents", "Clean layout", "Standard Gradio look"],
-    "Base": ["Blue accents", "Minimal styling", "Clean foundation"],
-    "Soft": ["Rounded corners", "Emerald colors", "Comfortable viewing"],
-    "Monochrome": ["Black & white", "High elegance", "Timeless design"],
-    "Glass": ["Glassmorphism", "Blur effects", "Translucent elements"],
-    "Dark Ocean": ["Deep blue palette", "Dark theme", "Easy on eyes"],
-    "Cyberpunk": ["Neon cyan/magenta", "Futuristic fonts", "Cyber vibes"],
-    "Forest": ["Nature inspired", "Green tones", "Organic rounded"],
-    "High Contrast": ["Black/white/yellow", "High visibility", "Accessibility"],
-    "Developer": ["Authentic VS Code colors", "Consolas/Monaco fonts", "Exact theme matching"]
-}
-
-# Load saved theme and apply it
-current_theme_name = get_saved_theme()
-current_theme = THEME_CONFIGS[current_theme_name]["theme"]
-

app.py

@@ -1,31 +1,54 @@
-"""
-AnyCoder - AI Code Generator
-Main application entry point - now with modular architecture!
-"""
+from app_huggingface import demo as demo_huggingface
+from app_gemini_coder import demo as demo_gemini
+from utils import get_app
+import gradio as gr
 
-# Import initialization functions from modules
-from anycoder_app.docs_manager import (
-    initialize_gradio_docs,
-    initialize_comfyui_docs,
-    initialize_fastrtc_docs
-)
-from anycoder_app.ui import demo
+# Create mapping of providers to their code snippets
+PROVIDER_SNIPPETS = {
+    "Hugging Face": """
+import gradio as gr
+import ai_gradio
+gr.load(
+    name='huggingface:deepseek-ai/DeepSeek-R1',
+    src=ai_gradio.registry,
+    coder=True,
+    provider="together"
+).launch()""",
+    "Gemini Coder": """
+import gradio as gr
+import ai_gradio
+gr.load(
+    name='gemini:gemini-2.5-pro-exp-03-25',
+    src=ai_gradio.registry,
+    coder=True,
+    provider="together"
+).launch()
+    """,
+}
+# Create mapping of providers to their demos
+PROVIDERS = {
+    "Hugging Face": demo_huggingface,
+    "Gemini Coder": demo_gemini,
+}
 
-if __name__ == "__main__":
-    # Initialize documentation systems
-    print("Initializing Gradio documentation...")
-    initialize_gradio_docs()
-    
-    print("Initializing ComfyUI documentation...")
-    initialize_comfyui_docs()
-    
-    print("Initializing FastRTC documentation...")
-    initialize_fastrtc_docs()
-    
-    # Launch the application
-    print("Launching AnyCoder application...")
-    demo.queue(api_open=False, default_concurrency_limit=20).launch(
-        show_api=False, 
-        ssr_mode=True, 
-        mcp_server=False
+# Modified get_app implementation
+demo = gr.Blocks()
+with demo:
+
+    provider_dropdown = gr.Dropdown(choices=list(PROVIDERS.keys()), value="Hugging Face", label="Select code snippet")
+    code_display = gr.Code(label="Provider Code Snippet", language="python", value=PROVIDER_SNIPPETS["Hugging Face"])
+
+    def update_code(provider):
+        return PROVIDER_SNIPPETS.get(provider, "Code snippet not available")
+
+    provider_dropdown.change(fn=update_code, inputs=[provider_dropdown], outputs=[code_display])
+
+    selected_demo = get_app(
+        models=list(PROVIDERS.keys()),
+        default_model="Hugging Face",
+        src=PROVIDERS,
+        dropdown_label="Select Provider",
     )
+
+if __name__ == "__main__":
+    demo.queue(api_open=False).launch(show_api=False)

app_allenai.py

@@ -0,0 +1,67 @@
+import gradio as gr
+from gradio_client import Client
+
+MODELS = {"OLMo-2-1124-13B-Instruct": "akhaliq/olmo-anychat", "Llama-3.1-Tulu-3-8B": "akhaliq/allen-test"}
+
+
+def create_chat_fn(client):
+    def chat(message, history):
+        response = client.predict(
+            message=message,
+            system_prompt="You are a helpful AI assistant.",
+            temperature=0.7,
+            max_new_tokens=1024,
+            top_k=40,
+            repetition_penalty=1.1,
+            top_p=0.95,
+            api_name="/chat",
+        )
+        return response
+
+    return chat
+
+
+def set_client_for_session(model_name, request: gr.Request):
+    headers = {}
+    if request and hasattr(request, "request") and hasattr(request.request, "headers"):
+        x_ip_token = request.request.headers.get("x-ip-token")
+        if x_ip_token:
+            headers["X-IP-Token"] = x_ip_token
+
+    return Client(MODELS[model_name], headers=headers)
+
+
+def safe_chat_fn(message, history, client):
+    if client is None:
+        return "Error: Client not initialized. Please refresh the page."
+    return create_chat_fn(client)(message, history)
+
+
+with gr.Blocks() as demo:
+    client = gr.State()
+
+    model_dropdown = gr.Dropdown(
+        choices=list(MODELS.keys()), value="OLMo-2-1124-13B-Instruct", label="Select Model", interactive=True
+    )
+
+    chat_interface = gr.ChatInterface(fn=safe_chat_fn, additional_inputs=[client])
+
+    # Update client when model changes
+    def update_model(model_name, request):
+        return set_client_for_session(model_name, request)
+
+    model_dropdown.change(
+        fn=update_model,
+        inputs=[model_dropdown],
+        outputs=[client],
+    )
+
+    # Initialize client on page load
+    demo.load(
+        fn=set_client_for_session,
+        inputs=gr.State("OLMo-2-1124-13B-Instruct"),
+        outputs=client,
+    )
+
+if __name__ == "__main__":
+    demo.launch()

app_cerebras.py

@@ -0,0 +1,19 @@
+import os
+
+import cerebras_gradio
+
+from utils import get_app
+
+demo = get_app(
+    models=[
+        "llama3.1-8b",
+        "llama3.1-70b",
+        "llama3.1-405b",
+    ],
+    default_model="llama3.1-70b",
+    src=cerebras_gradio.registry,
+    accept_token=not os.getenv("CEREBRAS_API_KEY"),
+)
+
+if __name__ == "__main__":
+    demo.launch()

app_claude.py

@@ -0,0 +1,21 @@
+import os
+
+import anthropic_gradio
+
+from utils import get_app
+
+demo = get_app(
+    models=[
+        "claude-3-5-sonnet-20241022",
+        "claude-3-5-haiku-20241022",
+        "claude-3-opus-20240229",
+        "claude-3-sonnet-20240229",
+        "claude-3-haiku-20240307",
+    ],
+    default_model="claude-3-5-sonnet-20241022",
+    src=anthropic_gradio.registry,
+    accept_token=not os.getenv("ANTHROPIC_API_KEY"),
+)
+
+if __name__ == "__main__":
+    demo.launch()

app_cohere.py

@@ -0,0 +1,21 @@
+import os
+
+import cohere_gradio
+
+from utils import get_app
+
+demo = get_app(
+    models=[
+        "command-r",
+        "command-r-08-2024",
+        "command-r-plus",
+        "command-r-plus-08-2024",
+        "command-r7b-12-2024",
+    ],
+    default_model="command-r7b-12-2024",
+    src=cohere_gradio.registry,
+    accept_token=not os.getenv("COHERE_API_KEY"),
+)
+
+if __name__ == "__main__":
+    demo.launch()

app_compare.py

@@ -0,0 +1,210 @@
+import os
+
+import google.generativeai as genai
+import gradio as gr
+import openai
+from anthropic import Anthropic
+from openai import OpenAI  # Add explicit OpenAI import
+
+
+def get_all_models():
+    """Get all available models from the registries."""
+    return [
+        "SambaNova: Meta-Llama-3.2-1B-Instruct",
+        "SambaNova: Meta-Llama-3.2-3B-Instruct",
+        "SambaNova: Llama-3.2-11B-Vision-Instruct",
+        "SambaNova: Llama-3.2-90B-Vision-Instruct",
+        "SambaNova: Meta-Llama-3.1-8B-Instruct",
+        "SambaNova: Meta-Llama-3.1-70B-Instruct",
+        "SambaNova: Meta-Llama-3.1-405B-Instruct",
+        "Hyperbolic: Qwen/Qwen2.5-Coder-32B-Instruct",
+        "Hyperbolic: meta-llama/Llama-3.2-3B-Instruct",
+        "Hyperbolic: meta-llama/Meta-Llama-3.1-8B-Instruct",
+        "Hyperbolic: meta-llama/Meta-Llama-3.1-70B-Instruct",
+        "Hyperbolic: meta-llama/Meta-Llama-3-70B-Instruct",
+        "Hyperbolic: NousResearch/Hermes-3-Llama-3.1-70B",
+        "Hyperbolic: Qwen/Qwen2.5-72B-Instruct",
+        "Hyperbolic: deepseek-ai/DeepSeek-V2.5",
+        "Hyperbolic: meta-llama/Meta-Llama-3.1-405B-Instruct",
+    ]
+
+
+def generate_discussion_prompt(original_question: str, previous_responses: list[str]) -> str:
+    """Generate a prompt for models to discuss and build upon previous
+    responses.
+    """
+    prompt = f"""You are participating in a multi-AI discussion about this question: "{original_question}"
+
+Previous responses from other AI models:
+{chr(10).join(f"- {response}" for response in previous_responses)}
+
+Please provide your perspective while:
+1. Acknowledging key insights from previous responses
+2. Adding any missing important points
+3. Respectfully noting if you disagree with anything and explaining why
+4. Building towards a complete answer
+
+Keep your response focused and concise (max 3-4 paragraphs)."""
+    return prompt
+
+
+def generate_consensus_prompt(original_question: str, discussion_history: list[str]) -> str:
+    """Generate a prompt for final consensus building."""
+    return f"""Review this multi-AI discussion about: "{original_question}"
+
+Discussion history:
+{chr(10).join(discussion_history)}
+
+As a final synthesizer, please:
+1. Identify the key points where all models agreed
+2. Explain how any disagreements were resolved
+3. Present a clear, unified answer that represents our collective best understanding
+4. Note any remaining uncertainties or caveats
+
+Keep the final consensus concise but complete."""
+
+
+def chat_with_openai(model: str, messages: list[dict], api_key: str | None) -> str:
+    import openai
+
+    client = openai.OpenAI(api_key=api_key)
+    response = client.chat.completions.create(model=model, messages=messages)
+    return response.choices[0].message.content
+
+
+def chat_with_anthropic(messages: list[dict], api_key: str | None) -> str:
+    """Chat with Anthropic's Claude model."""
+    client = Anthropic(api_key=api_key)
+    response = client.messages.create(model="claude-3-sonnet-20240229", messages=messages, max_tokens=1024)
+    return response.content[0].text
+
+
+def chat_with_gemini(messages: list[dict], api_key: str | None) -> str:
+    """Chat with Gemini Pro model."""
+    genai.configure(api_key=api_key)
+    model = genai.GenerativeModel("gemini-pro")
+
+    # Convert messages to Gemini format
+    gemini_messages = []
+    for msg in messages:
+        role = "user" if msg["role"] == "user" else "model"
+        gemini_messages.append({"role": role, "parts": [msg["content"]]})
+
+    response = model.generate_content([m["parts"][0] for m in gemini_messages])
+    return response.text
+
+
+def chat_with_sambanova(
+    messages: list[dict], api_key: str | None, model_name: str = "Llama-3.2-90B-Vision-Instruct"
+) -> str:
+    """Chat with SambaNova's models using their OpenAI-compatible API."""
+    client = openai.OpenAI(
+        api_key=api_key,
+        base_url="https://api.sambanova.ai/v1",
+    )
+
+    response = client.chat.completions.create(
+        model=model_name,
+        messages=messages,
+        temperature=0.1,
+        top_p=0.1,  # Use the specific model name passed in
+    )
+    return response.choices[0].message.content
+
+
+def chat_with_hyperbolic(
+    messages: list[dict], api_key: str | None, model_name: str = "Qwen/Qwen2.5-Coder-32B-Instruct"
+) -> str:
+    """Chat with Hyperbolic's models using their OpenAI-compatible API."""
+    client = OpenAI(api_key=api_key, base_url="https://api.hyperbolic.xyz/v1")
+
+    # Add system message to the start of the messages list
+    full_messages = [
+        {"role": "system", "content": "You are a helpful assistant. Be descriptive and clear."},
+        *messages,
+    ]
+
+    response = client.chat.completions.create(
+        model=model_name,  # Use the specific model name passed in
+        messages=full_messages,
+        temperature=0.7,
+        max_tokens=1024,
+    )
+    return response.choices[0].message.content
+
+
+def multi_model_consensus(
+    question: str, selected_models: list[str], rounds: int = 3, progress: gr.Progress = gr.Progress()
+) -> list[tuple[str, str]]:
+    if not selected_models:
+        raise gr.Error("Please select at least one model to chat with.")
+
+    chat_history = []
+    progress(0, desc="Getting responses from all models...")
+
+    # Get responses from all models in parallel
+    for i, model in enumerate(selected_models):
+        provider, model_name = model.split(": ", 1)
+        progress((i + 1) / len(selected_models), desc=f"Getting response from {model}...")
+
+        try:
+            if provider == "Anthropic":
+                api_key = os.getenv("ANTHROPIC_API_KEY")
+                response = chat_with_anthropic(messages=[{"role": "user", "content": question}], api_key=api_key)
+            elif provider == "SambaNova":
+                api_key = os.getenv("SAMBANOVA_API_KEY")
+                response = chat_with_sambanova(
+                    messages=[
+                        {"role": "system", "content": "You are a helpful assistant"},
+                        {"role": "user", "content": question},
+                    ],
+                    api_key=api_key,
+                    model_name=model_name,
+                )
+            elif provider == "Hyperbolic":
+                api_key = os.getenv("HYPERBOLIC_API_KEY")
+                response = chat_with_hyperbolic(
+                    messages=[{"role": "user", "content": question}],
+                    api_key=api_key,
+                    model_name=model_name,
+                )
+            else:  # Gemini
+                api_key = os.getenv("GEMINI_API_KEY")
+                response = chat_with_gemini(messages=[{"role": "user", "content": question}], api_key=api_key)
+
+            chat_history.append((model, response))
+        except Exception as e:
+            chat_history.append((model, f"Error: {e!s}"))
+
+    progress(1.0, desc="Done!")
+    return chat_history
+
+
+with gr.Blocks() as demo:
+    gr.Markdown("# Model Response Comparison")
+    gr.Markdown("""Select multiple models to compare their responses""")
+
+    with gr.Row():
+        with gr.Column():
+            model_selector = gr.Dropdown(
+                choices=get_all_models(),
+                multiselect=True,
+                label="Select Models",
+                info="Choose models to compare",
+                value=["SambaNova: Llama-3.2-90B-Vision-Instruct", "Hyperbolic: Qwen/Qwen2.5-Coder-32B-Instruct"],
+            )
+
+    chatbot = gr.Chatbot(height=600, label="Model Responses")
+    msg = gr.Textbox(label="Prompt", placeholder="Ask a question to compare model responses...")
+
+    def respond(message, selected_models):
+        chat_history = multi_model_consensus(message, selected_models, rounds=1)
+        return chat_history
+
+    msg.submit(respond, [msg, model_selector], [chatbot])
+
+for fn in demo.fns.values():
+    fn.api_name = False
+
+if __name__ == "__main__":
+    demo.launch()

app_crew.py

@@ -0,0 +1,8 @@
+import ai_gradio
+import gradio as gr
+
+demo = gr.load(
+    name="crewai:gpt-4-turbo",
+    crew_type="article",  # or 'support'
+    src=ai_gradio.registry,
+)

app_deepseek.py

@@ -0,0 +1,23 @@
+import ai_gradio
+
+from utils_ai_gradio import get_app
+
+# Get the hyperbolic models but keep their full names for loading
+DEEPSEEK_MODELS_FULL = [k for k in ai_gradio.registry.keys() if k.startswith("deepseek:")]
+
+# Create display names without the prefix
+DEEPSEEK_MODELS_DISPLAY = [k.replace("deepseek:", "") for k in DEEPSEEK_MODELS_FULL]
+
+
+# Create and launch the interface using get_app utility
+demo = get_app(
+    models=DEEPSEEK_MODELS_FULL,  # Use the full names with prefix
+    default_model=DEEPSEEK_MODELS_FULL[-1],
+    dropdown_label="Select DeepSeek Model",
+    choices=DEEPSEEK_MODELS_DISPLAY,  # Display names without prefix
+    fill_height=True,
+    coder=True,
+)
+
+if __name__ == "__main__":
+    demo.launch()

app_experimental.py

@@ -0,0 +1,300 @@
+import os
+import random
+
+import google.generativeai as genai
+import gradio as gr
+import openai
+from anthropic import Anthropic
+from openai import OpenAI  # Add explicit OpenAI import
+
+
+def get_all_models():
+    """Get all available models from the registries."""
+    return [
+        "SambaNova: Meta-Llama-3.2-1B-Instruct",
+        "SambaNova: Meta-Llama-3.2-3B-Instruct",
+        "SambaNova: Llama-3.2-11B-Vision-Instruct",
+        "SambaNova: Llama-3.2-90B-Vision-Instruct",
+        "SambaNova: Meta-Llama-3.1-8B-Instruct",
+        "SambaNova: Meta-Llama-3.1-70B-Instruct",
+        "SambaNova: Meta-Llama-3.1-405B-Instruct",
+        "Hyperbolic: Qwen/Qwen2.5-Coder-32B-Instruct",
+        "Hyperbolic: meta-llama/Llama-3.2-3B-Instruct",
+        "Hyperbolic: meta-llama/Meta-Llama-3.1-8B-Instruct",
+        "Hyperbolic: meta-llama/Meta-Llama-3.1-70B-Instruct",
+        "Hyperbolic: meta-llama/Meta-Llama-3-70B-Instruct",
+        "Hyperbolic: NousResearch/Hermes-3-Llama-3.1-70B",
+        "Hyperbolic: Qwen/Qwen2.5-72B-Instruct",
+        "Hyperbolic: deepseek-ai/DeepSeek-V2.5",
+        "Hyperbolic: meta-llama/Meta-Llama-3.1-405B-Instruct",
+    ]
+
+
+def generate_discussion_prompt(original_question: str, previous_responses: list[str]) -> str:
+    """Generate a prompt for models to discuss and build upon previous
+    responses.
+    """
+    prompt = f"""You are participating in a multi-AI discussion about this question: "{original_question}"
+
+Previous responses from other AI models:
+{chr(10).join(f"- {response}" for response in previous_responses)}
+
+Please provide your perspective while:
+1. Acknowledging key insights from previous responses
+2. Adding any missing important points
+3. Respectfully noting if you disagree with anything and explaining why
+4. Building towards a complete answer
+
+Keep your response focused and concise (max 3-4 paragraphs)."""
+    return prompt
+
+
+def generate_consensus_prompt(original_question: str, discussion_history: list[str]) -> str:
+    """Generate a prompt for final consensus building."""
+    return f"""Review this multi-AI discussion about: "{original_question}"
+
+Discussion history:
+{chr(10).join(discussion_history)}
+
+As a final synthesizer, please:
+1. Identify the key points where all models agreed
+2. Explain how any disagreements were resolved
+3. Present a clear, unified answer that represents our collective best understanding
+4. Note any remaining uncertainties or caveats
+
+Keep the final consensus concise but complete."""
+
+
+def chat_with_openai(model: str, messages: list[dict], api_key: str | None) -> str:
+    import openai
+
+    client = openai.OpenAI(api_key=api_key)
+    response = client.chat.completions.create(model=model, messages=messages)
+    return response.choices[0].message.content
+
+
+def chat_with_anthropic(messages: list[dict], api_key: str | None) -> str:
+    """Chat with Anthropic's Claude model."""
+    client = Anthropic(api_key=api_key)
+    response = client.messages.create(model="claude-3-sonnet-20240229", messages=messages, max_tokens=1024)
+    return response.content[0].text
+
+
+def chat_with_gemini(messages: list[dict], api_key: str | None) -> str:
+    """Chat with Gemini Pro model."""
+    genai.configure(api_key=api_key)
+    model = genai.GenerativeModel("gemini-pro")
+
+    # Convert messages to Gemini format
+    gemini_messages = []
+    for msg in messages:
+        role = "user" if msg["role"] == "user" else "model"
+        gemini_messages.append({"role": role, "parts": [msg["content"]]})
+
+    response = model.generate_content([m["parts"][0] for m in gemini_messages])
+    return response.text
+
+
+def chat_with_sambanova(
+    messages: list[dict], api_key: str | None, model_name: str = "Llama-3.2-90B-Vision-Instruct"
+) -> str:
+    """Chat with SambaNova's models using their OpenAI-compatible API."""
+    client = openai.OpenAI(
+        api_key=api_key,
+        base_url="https://api.sambanova.ai/v1",
+    )
+
+    response = client.chat.completions.create(
+        model=model_name,
+        messages=messages,
+        temperature=0.1,
+        top_p=0.1,  # Use the specific model name passed in
+    )
+    return response.choices[0].message.content
+
+
+def chat_with_hyperbolic(
+    messages: list[dict], api_key: str | None, model_name: str = "Qwen/Qwen2.5-Coder-32B-Instruct"
+) -> str:
+    """Chat with Hyperbolic's models using their OpenAI-compatible API."""
+    client = OpenAI(api_key=api_key, base_url="https://api.hyperbolic.xyz/v1")
+
+    # Add system message to the start of the messages list
+    full_messages = [
+        {"role": "system", "content": "You are a helpful assistant. Be descriptive and clear."},
+        *messages,
+    ]
+
+    response = client.chat.completions.create(
+        model=model_name,  # Use the specific model name passed in
+        messages=full_messages,
+        temperature=0.7,
+        max_tokens=1024,
+    )
+    return response.choices[0].message.content
+
+
+def multi_model_consensus(
+    question: str, selected_models: list[str], rounds: int = 3, progress: gr.Progress = gr.Progress()
+) -> list[tuple[str, str]]:
+    if not selected_models:
+        raise gr.Error("Please select at least one model to chat with.")
+
+    chat_history = []
+    discussion_history = []
+
+    # Initial responses
+    progress(0, desc="Getting initial responses...")
+    initial_responses = []
+    for i, model in enumerate(selected_models):
+        provider, model_name = model.split(": ", 1)
+
+        try:
+            if provider == "Anthropic":
+                api_key = os.getenv("ANTHROPIC_API_KEY")
+                response = chat_with_anthropic(messages=[{"role": "user", "content": question}], api_key=api_key)
+            elif provider == "SambaNova":
+                api_key = os.getenv("SAMBANOVA_API_KEY")
+                response = chat_with_sambanova(
+                    messages=[
+                        {"role": "system", "content": "You are a helpful assistant"},
+                        {"role": "user", "content": question},
+                    ],
+                    api_key=api_key,
+                )
+            elif provider == "Hyperbolic":  # Add Hyperbolic case
+                api_key = os.getenv("HYPERBOLIC_API_KEY")
+                response = chat_with_hyperbolic(messages=[{"role": "user", "content": question}], api_key=api_key)
+            else:  # Gemini
+                api_key = os.getenv("GEMINI_API_KEY")
+                response = chat_with_gemini(messages=[{"role": "user", "content": question}], api_key=api_key)
+
+            initial_responses.append(f"{model}: {response}")
+            discussion_history.append(f"Initial response from {model}:\n{response}")
+            chat_history.append((f"Initial response from {model}", response))
+        except Exception as e:
+            chat_history.append((f"Error from {model}", str(e)))
+
+    # Discussion rounds
+    for round_num in range(rounds):
+        progress((round_num + 1) / (rounds + 2), desc=f"Discussion round {round_num + 1}...")
+        round_responses = []
+
+        random.shuffle(selected_models)  # Randomize order each round
+        for model in selected_models:
+            provider, model_name = model.split(": ", 1)
+
+            try:
+                discussion_prompt = generate_discussion_prompt(question, discussion_history)
+                if provider == "Anthropic":
+                    api_key = os.getenv("ANTHROPIC_API_KEY")
+                    response = chat_with_anthropic(
+                        messages=[{"role": "user", "content": discussion_prompt}], api_key=api_key
+                    )
+                elif provider == "SambaNova":
+                    api_key = os.getenv("SAMBANOVA_API_KEY")
+                    response = chat_with_sambanova(
+                        messages=[
+                            {"role": "system", "content": "You are a helpful assistant"},
+                            {"role": "user", "content": discussion_prompt},
+                        ],
+                        api_key=api_key,
+                    )
+                elif provider == "Hyperbolic":  # Add Hyperbolic case
+                    api_key = os.getenv("HYPERBOLIC_API_KEY")
+                    response = chat_with_hyperbolic(
+                        messages=[{"role": "user", "content": discussion_prompt}], api_key=api_key
+                    )
+                else:  # Gemini
+                    api_key = os.getenv("GEMINI_API_KEY")
+                    response = chat_with_gemini(
+                        messages=[{"role": "user", "content": discussion_prompt}], api_key=api_key
+                    )
+
+                round_responses.append(f"{model}: {response}")
+                discussion_history.append(f"Round {round_num + 1} - {model}:\n{response}")
+                chat_history.append((f"Round {round_num + 1} - {model}", response))
+            except Exception as e:
+                chat_history.append((f"Error from {model} in round {round_num + 1}", str(e)))
+
+    # Final consensus
+    progress(0.9, desc="Building final consensus...")
+    model = selected_models[0]
+    provider, model_name = model.split(": ", 1)
+
+    try:
+        consensus_prompt = generate_consensus_prompt(question, discussion_history)
+        if provider == "Anthropic":
+            api_key = os.getenv("ANTHROPIC_API_KEY")
+            final_consensus = chat_with_anthropic(
+                messages=[{"role": "user", "content": consensus_prompt}], api_key=api_key
+            )
+        elif provider == "SambaNova":
+            api_key = os.getenv("SAMBANOVA_API_KEY")
+            final_consensus = chat_with_sambanova(
+                messages=[
+                    {"role": "system", "content": "You are a helpful assistant"},
+                    {"role": "user", "content": consensus_prompt},
+                ],
+                api_key=api_key,
+            )
+        elif provider == "Hyperbolic":  # Add Hyperbolic case
+            api_key = os.getenv("HYPERBOLIC_API_KEY")
+            final_consensus = chat_with_hyperbolic(
+                messages=[{"role": "user", "content": consensus_prompt}], api_key=api_key
+            )
+        else:  # Gemini
+            api_key = os.getenv("GEMINI_API_KEY")
+            final_consensus = chat_with_gemini(
+                messages=[{"role": "user", "content": consensus_prompt}], api_key=api_key
+            )
+    except Exception as e:
+        final_consensus = f"Error getting consensus from {model}: {e!s}"
+
+    chat_history.append(("Final Consensus", final_consensus))
+
+    progress(1.0, desc="Done!")
+    return chat_history
+
+
+with gr.Blocks() as demo:
+    gr.Markdown("# Experimental Multi-Model Consensus Chat")
+    gr.Markdown(
+        """Select multiple models to collaborate on answering your question.
+                The models will discuss with each other and attempt to reach a consensus.
+                Maximum 3 models can be selected at once."""
+    )
+
+    with gr.Row():
+        with gr.Column():
+            model_selector = gr.Dropdown(
+                choices=get_all_models(),
+                multiselect=True,
+                label="Select Models (max 3)",
+                info="Choose up to 3 models to participate in the discussion",
+                value=["SambaNova: Llama-3.2-90B-Vision-Instruct", "Hyperbolic: Qwen/Qwen2.5-Coder-32B-Instruct"],
+                max_choices=3,
+            )
+            rounds_slider = gr.Slider(
+                minimum=1,
+                maximum=2,
+                value=1,
+                step=1,
+                label="Discussion Rounds",
+                info="Number of rounds of discussion between models",
+            )
+
+    chatbot = gr.Chatbot(height=600, label="Multi-Model Discussion")
+    msg = gr.Textbox(label="Your Question", placeholder="Ask a question for the models to discuss...")
+
+    def respond(message, selected_models, rounds):
+        chat_history = multi_model_consensus(message, selected_models, rounds)
+        return chat_history
+
+    msg.submit(respond, [msg, model_selector, rounds_slider], [chatbot], api_name="consensus_chat")
+
+for fn in demo.fns.values():
+    fn.api_name = False
+
+if __name__ == "__main__":
+    demo.launch()

app_fal.py

@@ -0,0 +1,16 @@
+import fal_gradio
+
+from utils import get_app
+
+demo = get_app(
+    models=[
+        "fal-ai/ltx-video",
+        "fal-ai/ltx-video/image-to-video",
+        "fal-ai/luma-photon",
+    ],
+    default_model="fal-ai/luma-photon",
+    src=fal_gradio.registry,
+)
+
+if __name__ == "__main__":
+    demo.launch()

app_fireworks.py

@@ -0,0 +1,19 @@
+import os
+
+import fireworks_gradio
+
+from utils import get_app
+
+demo = get_app(
+    models=[
+        "f1-preview",
+        "f1-mini-preview",
+        "llama-v3p3-70b-instruct",
+    ],
+    default_model="llama-v3p3-70b-instruct",
+    src=fireworks_gradio.registry,
+    accept_token=not os.getenv("FIREWORKS_API_KEY"),
+)
+
+if __name__ == "__main__":
+    demo.launch()

app_gemini.py

@@ -0,0 +1,22 @@
+import ai_gradio
+
+from utils_ai_gradio import get_app
+
+# Get the Gemini models but keep their full names for loading
+GEMINI_MODELS_FULL = [k for k in ai_gradio.registry if k.startswith("gemini:")]
+
+# Create display names without the prefix
+GEMINI_MODELS_DISPLAY = [k.replace("gemini:", "") for k in GEMINI_MODELS_FULL]
+
+# Create and launch the interface using get_app utility
+demo = get_app(
+    models=GEMINI_MODELS_FULL,  # Use the full names with prefix
+    default_model=GEMINI_MODELS_FULL[-1],
+    dropdown_label="Select Gemini Model",
+    choices=GEMINI_MODELS_DISPLAY,  # Display names without prefix
+    src=ai_gradio.registry,
+    fill_height=True,
+)
+
+if __name__ == "__main__":
+    demo.launch()

app_gemini_camera.py

@@ -0,0 +1,23 @@
+import ai_gradio
+
+from utils_ai_gradio import get_app
+
+# Get the Gemini models but keep their full names for loading
+GEMINI_MODELS_FULL = [k for k in ai_gradio.registry if k.startswith("gemini:")]
+
+# Create display names without the prefix
+GEMINI_MODELS_DISPLAY = [k.replace("gemini:", "") for k in GEMINI_MODELS_FULL]
+
+# Create and launch the interface using get_app utility
+demo = get_app(
+    models=GEMINI_MODELS_FULL,  # Use the full names with prefix
+    default_model=GEMINI_MODELS_FULL[-2],
+    dropdown_label="Select Gemini Model",
+    choices=GEMINI_MODELS_DISPLAY,  # Display names without prefix
+    src=ai_gradio.registry,
+    camera=True,
+    fill_height=True,
+)
+
+if __name__ == "__main__":
+    demo.launch()

app_gemini_coder.py

@@ -0,0 +1,23 @@
+import ai_gradio
+
+from utils_ai_gradio import get_app
+
+# Get the Gemini models but keep their full names for loading
+GEMINI_MODELS_FULL = [k for k in ai_gradio.registry if k.startswith("gemini:")]
+
+# Create display names without the prefix
+GEMINI_MODELS_DISPLAY = [k.replace("gemini:", "") for k in GEMINI_MODELS_FULL]
+
+# Create and launch the interface using get_app utility
+demo = get_app(
+    models=GEMINI_MODELS_FULL,  # Use the full names with prefix
+    default_model=GEMINI_MODELS_FULL[0],
+    dropdown_label="Select Gemini Model",
+    choices=GEMINI_MODELS_DISPLAY,  # Display names without prefix
+    src=ai_gradio.registry,
+    fill_height=True,
+    coder=True,
+)
+
+if __name__ == "__main__":
+    demo.launch()

app_gemini_voice.py

@@ -0,0 +1,23 @@
+import ai_gradio
+
+from utils_ai_gradio import get_app
+
+# Get the Gemini models but keep their full names for loading
+GEMINI_MODELS_FULL = [k for k in ai_gradio.registry if k.startswith("gemini:")]
+
+# Create display names without the prefix
+GEMINI_MODELS_DISPLAY = [k.replace("gemini:", "") for k in GEMINI_MODELS_FULL]
+
+# Create and launch the interface using get_app utility
+demo = get_app(
+    models=GEMINI_MODELS_FULL,  # Use the full names with prefix
+    default_model=GEMINI_MODELS_FULL[-2],
+    dropdown_label="Select Gemini Model",
+    choices=GEMINI_MODELS_DISPLAY,  # Display names without prefix
+    src=ai_gradio.registry,
+    enable_voice=True,
+    fill_height=True,
+)
+
+if __name__ == "__main__":
+    demo.launch()

app_groq.py

@@ -0,0 +1,21 @@
+import ai_gradio
+
+from utils_ai_gradio import get_app
+
+# Get the Groq models from the registry
+GROQ_MODELS_FULL = [k for k in ai_gradio.registry.keys() if k.startswith("groq:")]
+
+# Create display names without the prefix
+GROQ_MODELS_DISPLAY = [k.replace("groq:", "") for k in GROQ_MODELS_FULL]
+
+demo = get_app(
+    models=GROQ_MODELS_FULL,
+    default_model=GROQ_MODELS_FULL[-2],
+    src=ai_gradio.registry,
+    dropdown_label="Select Groq Model",
+    choices=GROQ_MODELS_DISPLAY,
+    fill_height=True,
+)
+
+if __name__ == "__main__":
+    demo.launch()

app_groq_coder.py

@@ -0,0 +1,23 @@
+import ai_gradio
+
+from utils_ai_gradio import get_app
+
+# Get the Groq models but keep their full names for loading
+GROQ_MODELS_FULL = [k for k in ai_gradio.registry.keys() if k.startswith("groq:")]
+
+# Create display names without the prefix
+GROQ_MODELS_DISPLAY = [k.replace("groq:", "") for k in GROQ_MODELS_FULL]
+
+# Create and launch the interface using get_app utility
+demo = get_app(
+    models=GROQ_MODELS_FULL,  # Use the full names with prefix
+    default_model=GROQ_MODELS_FULL[-1],
+    dropdown_label="Select Groq Model",
+    choices=GROQ_MODELS_DISPLAY,  # Display names without prefix
+    fill_height=True,
+    coder=True,
+)
+
+
+if __name__ == "__main__":
+    demo.launch()

app_hf.py

@@ -0,0 +1,17 @@
+from utils import get_app
+
+demo = get_app(
+    models=[
+        "microsoft/Phi-3.5-mini-instruct",
+        "HuggingFaceTB/SmolLM2-1.7B-Instruct",
+        "google/gemma-2-2b-it",
+        "openai-community/gpt2",
+        "microsoft/phi-2",
+        "TinyLlama/TinyLlama-1.1B-Chat-v1.0",
+    ],
+    default_model="HuggingFaceTB/SmolLM2-1.7B-Instruct",
+    src="models",
+)
+
+if __name__ == "__main__":
+    demo.launch()

app_huggingface.py

@@ -0,0 +1,22 @@
+import ai_gradio
+
+from utils_ai_gradio import get_app
+
+# Get the hyperbolic models but keep their full names for loading
+HUGGINGFACE_MODELS_FULL = [k for k in ai_gradio.registry.keys() if k.startswith("huggingface:")]
+
+# Create display names without the prefix
+HUGGINGFACE_MODELS_DISPLAY = [k.replace("huggingface:", "") for k in HUGGINGFACE_MODELS_FULL]
+
+
+# Create and launch the interface using get_app utility
+demo = get_app(
+    models=HUGGINGFACE_MODELS_FULL,  # Use the full names with prefix
+    default_model=HUGGINGFACE_MODELS_FULL[0],
+    dropdown_label="Select Huggingface Model",
+    choices=HUGGINGFACE_MODELS_DISPLAY,  # Display names without prefix
+    fill_height=True,
+    coder=True,
+    provider="fireworks-ai",
+    bill_to="huggingface"
+)

app_hyperbolic.py

@@ -0,0 +1,19 @@
+import ai_gradio
+
+from utils_ai_gradio import get_app
+
+# Get the hyperbolic models but keep their full names for loading
+HYPERBOLIC_MODELS_FULL = [k for k in ai_gradio.registry.keys() if k.startswith("hyperbolic:")]
+
+# Create display names without the prefix
+HYPERBOLIC_MODELS_DISPLAY = [k.replace("hyperbolic:", "") for k in HYPERBOLIC_MODELS_FULL]
+
+
+# Create and launch the interface using get_app utility
+demo = get_app(
+    models=HYPERBOLIC_MODELS_FULL,  # Use the full names with prefix
+    default_model=HYPERBOLIC_MODELS_FULL[-2],
+    dropdown_label="Select Hyperbolic Model",
+    choices=HYPERBOLIC_MODELS_DISPLAY,  # Display names without prefix
+    fill_height=True,
+)

app_hyperbolic_coder.py

@@ -0,0 +1,20 @@
+import ai_gradio
+
+from utils_ai_gradio import get_app
+
+# Get the hyperbolic models but keep their full names for loading
+HYPERBOLIC_MODELS_FULL = [k for k in ai_gradio.registry.keys() if k.startswith("hyperbolic:")]
+
+# Create display names without the prefix
+HYPERBOLIC_MODELS_DISPLAY = [k.replace("hyperbolic:", "") for k in HYPERBOLIC_MODELS_FULL]
+
+
+# Create and launch the interface using get_app utility
+demo = get_app(
+    models=HYPERBOLIC_MODELS_FULL,  # Use the full names with prefix
+    default_model=HYPERBOLIC_MODELS_FULL[-2],
+    dropdown_label="Select Hyperbolic Model",
+    choices=HYPERBOLIC_MODELS_DISPLAY,  # Display names without prefix
+    fill_height=True,
+    coder=True,
+)

app_langchain.py

@@ -0,0 +1,23 @@
+import ai_gradio
+
+from utils_ai_gradio import get_app
+
+# Get the hyperbolic models but keep their full names for loading
+LANGCHAIN_MODELS_FULL = [k for k in ai_gradio.registry.keys() if k.startswith("langchain:")]
+
+# Create display names without the prefix
+LANGCHAIN_MODELS_DISPLAY = [k.replace("langchain:", "") for k in LANGCHAIN_MODELS_FULL]
+
+
+# Create and launch the interface using get_app utility
+demo = get_app(
+    models=LANGCHAIN_MODELS_FULL,  # Use the full names with prefix
+    default_model=LANGCHAIN_MODELS_FULL[0],
+    dropdown_label="Select Langchain Model",
+    choices=LANGCHAIN_MODELS_DISPLAY,  # Display names without prefix
+    fill_height=True,
+)
+
+if __name__ == "__main__":
+    demo.launch()
+

app_lumaai.py

@@ -0,0 +1,7 @@
+import gradio as gr
+import lumaai_gradio
+
+demo = gr.load(
+    name="dream-machine",
+    src=lumaai_gradio.registry,
+)

app_marco_o1.py

@@ -0,0 +1,12 @@
+import gradio as gr
+import spaces
+import transformers_gradio
+
+demo = gr.load(name="AIDC-AI/Marco-o1", src=transformers_gradio.registry)
+demo.fn = spaces.GPU()(demo.fn)
+
+for fn in demo.fns.values():
+    fn.api_name = False
+
+if __name__ == "__main__":
+    demo.launch()

app_meta.py

@@ -0,0 +1,6 @@
+import gradio as gr
+
+demo = gr.load("models/meta-llama/Llama-3.3-70B-Instruct")
+
+if __name__ == "__main__":
+    demo.launch()

app_mindsearch.py

@@ -0,0 +1,12 @@
+import gradio as gr
+
+# Load the Gradio space
+demo = gr.load(name="internlm/MindSearch", src="spaces")
+
+# Disable API access for all functions
+if hasattr(demo, "fns"):
+    for fn in demo.fns.values():
+        fn.api_name = False
+
+if __name__ == "__main__":
+    demo.launch()

app_minimax.py

@@ -0,0 +1,22 @@
+import ai_gradio
+
+from utils_ai_gradio import get_app
+
+# Get the hyperbolic models but keep their full names for loading
+MINIMAX_MODELS_FULL = [k for k in ai_gradio.registry.keys() if k.startswith("minimax:")]
+
+# Create display names without the prefix
+MINIMAX_MODELS_DISPLAY = [k.replace("minimax:", "") for k in MINIMAX_MODELS_FULL]
+
+
+# Create and launch the interface using get_app utility
+demo = get_app(
+    models=MINIMAX_MODELS_FULL,  # Use the full names with prefix
+    default_model=MINIMAX_MODELS_FULL[0],
+    dropdown_label="Select Minimax Model",
+    choices=MINIMAX_MODELS_DISPLAY,  # Display names without prefix
+    fill_height=True,
+)
+
+if __name__ == "__main__":
+    demo.launch()

app_minimax_coder.py

@@ -0,0 +1,23 @@
+import ai_gradio
+
+from utils_ai_gradio import get_app
+
+# Get the hyperbolic models but keep their full names for loading
+MINIMAX_MODELS_FULL = [k for k in ai_gradio.registry.keys() if k.startswith("minimax:")]
+
+# Create display names without the prefix
+MINIMAX_MODELS_DISPLAY = [k.replace("minimax:", "") for k in MINIMAX_MODELS_FULL]
+
+
+# Create and launch the interface using get_app utility
+demo = get_app(
+    models=MINIMAX_MODELS_FULL,  # Use the full names with prefix
+    default_model=MINIMAX_MODELS_FULL[0],
+    dropdown_label="Select Minimax Model",
+    choices=MINIMAX_MODELS_DISPLAY,  # Display names without prefix
+    fill_height=True,
+    coder=True
+)
+
+if __name__ == "__main__":
+    demo.launch()

app_mistral.py

@@ -0,0 +1,23 @@
+import ai_gradio
+
+from utils_ai_gradio import get_app
+
+# Get the mistral models but keep their full names for loading
+MISTRAL_MODELS_FULL = [k for k in ai_gradio.registry.keys() if k.startswith("mistral:")]
+
+# Create display names without the prefix
+MISTRAL_MODELS_DISPLAY = [k.replace("mistral:", "") for k in MISTRAL_MODELS_FULL]
+
+
+# Create and launch the interface using get_app utility
+demo = get_app(
+    models=MISTRAL_MODELS_FULL,  # Use the full names with prefix
+    default_model=MISTRAL_MODELS_FULL[5],
+    dropdown_label="Select Mistral Model",
+    choices=MISTRAL_MODELS_DISPLAY,  # Display names without prefix
+    fill_height=True,
+    coder=True
+)
+
+if __name__ == "__main__":
+    demo.launch()

app_moondream.py

@@ -0,0 +1,13 @@
+import gradio as gr
+
+# Load the Gradio space
+demo = gr.load(name="akhaliq/moondream", src="spaces")
+
+
+# Disable API access for all functions
+if hasattr(demo, "fns"):
+    for fn in demo.fns.values():
+        fn.api_name = False
+
+if __name__ == "__main__":
+    demo.launch()

app_nvidia.py

@@ -0,0 +1,22 @@
+import ai_gradio
+
+from utils_ai_gradio import get_app
+
+# Get the nvidia models but keep their full names for loading
+NVIDIA_MODELS_FULL = [k for k in ai_gradio.registry.keys() if k.startswith("nvidia:")]
+
+# Create display names without the prefix
+NVIDIA_MODELS_DISPLAY = [k.replace("nvidia:", "") for k in NVIDIA_MODELS_FULL]
+
+
+# Create and launch the interface using get_app utility
+demo = get_app(
+    models=NVIDIA_MODELS_FULL,  # Use the full names with prefix
+    default_model=NVIDIA_MODELS_FULL[0],
+    dropdown_label="Select Nvidia Model",
+    choices=NVIDIA_MODELS_DISPLAY,  # Display names without prefix
+    fill_height=True,
+)
+
+if __name__ == "__main__":
+    demo.launch()

app_nvidia_coder.py

@@ -0,0 +1,23 @@
+import ai_gradio
+
+from utils_ai_gradio import get_app
+
+# Get the nvidia models but keep their full names for loading
+NVIDIA_MODELS_FULL = [k for k in ai_gradio.registry.keys() if k.startswith("nvidia:")]
+
+# Create display names without the prefix
+NVIDIA_MODELS_DISPLAY = [k.replace("nvidia:", "") for k in NVIDIA_MODELS_FULL]
+
+
+# Create and launch the interface using get_app utility
+demo = get_app(
+    models=NVIDIA_MODELS_FULL,  # Use the full names with prefix
+    default_model=NVIDIA_MODELS_FULL[-1],
+    dropdown_label="Select Nvidia Model",
+    choices=NVIDIA_MODELS_DISPLAY,  # Display names without prefix
+    fill_height=True,
+    coder=True
+)
+
+if __name__ == "__main__":
+    demo.launch()