anycoder

.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

@@ -4,359 +4,10 @@ emoji: 🏢
 colorFrom: indigo
 colorTo: indigo
 sdk: gradio
-sdk_version: 5.36.2
+sdk_version: 5.23.3
 app_file: app.py
 pinned: false
 disable_embedding: true
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
-
-# 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 and can generate HTML/CSS/JavaScript code for web applications.
-
-## Features
-
-- **Multi-Model Support**: Choose from various AI models including DeepSeek, ERNIE-4.5-VL, MiniMax, and Qwen
-- **Image-to-Code**: Upload UI design images and get corresponding HTML/CSS code (ERNIE-4.5-VL model)
-- **Image Text Extraction**: Upload images and extract text using OCR for processing
-- **Website Redesign**: Enter a website URL to extract content and redesign it with modern, responsive layouts
-- **Live Preview**: See your generated code in action with the built-in sandbox
-- **Web Search Integration**: Enable real-time web search to get the latest information and best practices
-- **Chat History**: Keep track of your conversations and generated code
-- **Quick Examples**: Pre-built examples to get you started quickly
-- **🚀 One-Click Deployment**: Deploy your generated applications directly to Hugging Face Spaces
-
-## 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 TAVILY_API_KEY="your_tavily_api_key"  # Optional, for web search feature
-```
-
-## 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
-
-4. Optionally:
-   - Upload a UI design image (for ERNIE-4.5-VL model)
-   - Enable web search to get the latest information
-   - Choose a different AI model
-
-5. Click "Generate" to create your code
-
-6. View the generated code in the Code Editor tab or see it in action in the Live Preview tab
-
-7. **Deploy to Space**: Enter a title and click "🚀 Deploy to Space" to publish your application
-
-## 🚀 Deployment Feature
-
-AnyCoder now includes one-click deployment to Hugging Face Spaces! This feature allows you to:
-
-### How to Deploy
-
-1. **Login**: Click the "Sign in with Hugging Face" button in the sidebar
-2. **Authorize Permissions**: When the authorization page appears, make sure to grant ALL the requested permissions:
-   - ✅ **read-repos** - Read access to repositories
-   - ✅ **write-repos** - Write access to create repositories
-   - ✅ **manage-repos** - Manage repository settings
-3. **Complete Authorization**: Click "Authorize" to complete the login
-4. **Generate Code**: Generate some HTML code using the AI
-5. **Enter Title**: In the sidebar, enter a title for your space (e.g., "My Todo App")
-6. **Deploy**: Click the "🚀 Deploy to Space" button
-7. **Share**: Get a shareable URL for your deployed application
-
-**Important**: You must grant ALL three permissions during the OAuth authorization process. If you only grant partial permissions, deployment will fail.
-
-**Note**: You need to be logged in with your Hugging Face account to deploy. This ensures that:
-- Deployments are created under your own account namespace
-- You can manage and update your spaces from your Hugging Face dashboard
-- Each deployment gets a unique URL under your username
-
-**Technical Note**: The deployment uses your personal OAuth token to create spaces under your account, ensuring full security and ownership of your deployed applications.
-
-### Troubleshooting Deployment Issues
-
-If you encounter permission errors during deployment:
-
-1. **Check Permissions**: Make sure you granted all three required permissions during login
-2. **Logout and Login Again**: Click logout and sign in again, ensuring all permissions are granted
-3. **Account Status**: Verify your Hugging Face account allows repository creation
-4. **Network Issues**: Check your internet connection and try again
-5. **Contact Support**: If issues persist, contact Hugging Face support
-
-### What Gets Deployed
-
-- **Complete HTML Application**: Your generated code wrapped in a professional template
-- **Responsive Design**: Mobile-friendly layout with modern styling
-- **Project Documentation**: README with project details and prompts used
-- **Live URL**: Publicly accessible URL that anyone can visit
-
-### Deployment Benefits
-
-- **Instant Publishing**: No need to set up hosting or domains
-- **Shareable**: Get a public URL to share with others
-- **Professional**: Clean, branded presentation of your work
-- **Version Control**: Each deployment creates a new space with timestamp
-- **Free Hosting**: Hosted on Hugging Face's infrastructure
-
-### Example Deployment
-
-```
-Title: "My Weather Dashboard"
-Generated Code: <div>Weather app HTML...</div>
-Result: https://huggingface.co/spaces/my-weather-dashboard-1234567890
-```
-
-The deployed space will include:
-- Your application with professional styling
-- A header with your title and AnyCoder branding
-- A footer with attribution
-- A README documenting the project
-
-## Web Search Feature
-
-The web search feature uses Tavily to provide real-time information when generating code. To enable this feature:
-
-1. Get a free Tavily API key from [Tavily Platform](https://tavily.com/)
-2. Set the `TAVILY_API_KEY` environment variable
-3. Toggle the "🔍 Enable Web Search" checkbox in the sidebar
-
-When enabled, the AI will search the web for the latest information, best practices, and technologies related to your request.
-
-## Image Text Extraction
-
-The application supports extracting text from images using OCR (Optical Character Recognition). This feature allows you to:
-
-1. Upload image files (JPG, PNG, BMP, TIFF, GIF, WebP) through the file input
-2. Automatically extract text from the images using Tesseract OCR
-3. Include the extracted text in your prompts for code generation
-
-### Setting up OCR
-
-To use the image text extraction feature, you need to install Tesseract OCR on your system. See `install_tesseract.md` for detailed installation instructions.
-
-**Example usage:**
-- Upload an image containing text (like a screenshot, document, or handwritten notes)
-- The application will extract the text and include it in your prompt
-- You can then ask the AI to process, summarize, or work with the extracted text
-
-## Website Redesign Feature
-
-The website redesign feature allows you to extract content from existing websites and generate modern, responsive redesigns. This feature:
-
-1. **Extracts Website Content**: Automatically scrapes the target website to extract:
-   - Page title and meta description
-   - Navigation menu structure
-   - Main content sections
-   - Images and their descriptions
-   - Overall page structure and purpose
-
-2. **Generates Modern Redesigns**: Creates improved versions with:
-   - Modern, responsive layouts
-   - Enhanced user experience
-   - Better accessibility
-   - Mobile-first design principles
-   - Current design trends and best practices
-
-### How to Use Website Redesign
-
-1. **Enter a Website URL**: In the "🌐 Website URL (for redesign)" field, enter the URL of the website you want to redesign
-   - Example: `https://example.com`
-   - The URL can be with or without `https://`
-
-2. **Add Custom Requirements**: Optionally describe specific improvements you want:
-   - "Make it more modern and minimalist"
-   - "Add a dark mode toggle"
-   - "Improve the mobile layout"
-   - "Use a different color scheme"
-
-3. **Enable Web Search**: Toggle the web search feature to get the latest design trends and best practices
-
-4. **Generate**: Click "Generate" to create your redesigned website
-
-### Example Usage
-
-```
-URL: https://example.com
-Description: Redesign this website with a modern, minimalist approach. Use a clean typography and improve the mobile experience.
-```
-
-The AI will analyze the original website content and create a completely redesigned version that maintains the core functionality while providing a better user experience.
-
-### Supported Websites
-
-The feature works with most public websites, including:
-- Business websites
-- Portfolio sites
-- Blog platforms
-- E-commerce sites
-- Landing pages
-- Documentation sites
-
-**Note**: Some websites may block automated access or require JavaScript to load content. In such cases, the extraction may be limited.
-
-## Available Models
-
-- **DeepSeek V3**: Advanced code generation model
-- **DeepSeek R1**: Specialized for code generation tasks
-- **ERNIE-4.5-VL**: Multimodal model with image support
-- **MiniMax M1**: General-purpose AI model
-- **Qwen3-235B-A22B**: Large language model for code generation
-
-## Environment Variables
-
-- `HF_TOKEN`: Your Hugging Face API token (required)
-- `TAVILY_API_KEY`: Your Tavily API key (optional, for web search)
-
-## License
-
-[Add your license information here]
-
-## Project Structure
-
-```
-anycoder/
-├── app.py          # Main application (everything included)
-├── app.css         # Basic styling
-├── pyproject.toml  # Dependencies
-└── README.md       # This file
-```
-
-## Setup
-
-1. Set your Hugging Face API token:
-   ```bash
-   export HF_TOKEN="your_huggingface_token"
-   ```
-
-2. Install dependencies:
-   ```bash
-   uv sync
-   ```
-
-3. Run the application:
-   ```bash
-   uv run python app.py
-   ```
-
-## Usage
-
-1. **Sign in with your Hugging Face account** using the login button at the top left.
-2. Enter your application requirements in the text area
-3. Click "send" to generate code
-4. View the generated code in the code drawer
-5. See the live preview in the sandbox area
-6. Use example cards for quick prompts
-
-## Code Example
-
-```python
-import os
-from huggingface_hub import InferenceClient
-
-client = InferenceClient(
-    provider="novita",
-    api_key=os.environ["HF_TOKEN"],
-    bill_to="huggingface"
-)
-
-completion = client.chat.completions.create(
-    model="deepseek-ai/DeepSeek-V3-0324",
-    messages=[
-        {
-            "role": "user",
-            "content": "Create a simple todo app"
-        }
-    ],
-)
-```
-
-## Architecture
-
-The application uses:
-- **Gradio**: For the web interface
-- **Hugging Face Hub**: For model inference
-- **ModelScope Studio**: For UI components
-- **OAuth Login**: Requires users to sign in with Hugging Face for code generation
-- **Streaming**: For real-time code generation
-
-# Hugging Face Coder
-
-A Gradio-based application that uses Hugging Face models to generate code based on user requirements. The app supports both text-only and multimodal (text + image) code generation.
-
-## Features
-
-- **Multiple Model Support**: DeepSeek V3, DeepSeek R1, and ERNIE-4.5-VL
-- **Multimodal Input**: Upload images to help describe your requirements
-- **Real-time Code Generation**: Stream responses from the models
-- **Live Preview**: See your generated code in action with the built-in sandbox
-- **History Management**: Keep track of your previous generations
-- **Example Templates**: Quick-start with predefined application templates
-
-## Setup
-
-1. Install dependencies:
-```bash
-pip install -r requirements.txt
-```
-
-2. Set your Hugging Face API token as an environment variable:
-```bash
-export HF_TOKEN="your_huggingface_token"
-```
-
-3. Run the application:
-```bash
-python app.py
-```
-
-## Usage
-
-1. **Text-only Generation**: Simply type your requirements in the text area
-2. **Multimodal Generation**: Upload an image and describe what you want to create
-3. **Model Selection**: Switch between different models using the model selector
-4. **Examples**: Use the provided example templates to get started quickly
-
-## Supported Models
-
-- **DeepSeek V3**: General code generation
-- **DeepSeek R1**: Advanced code generation
-- **ERNIE-4.5-VL**: Multimodal code generation with image understanding
-
-## Environment Variables
-
-- `HF_TOKEN`: Your Hugging Face API token (required)
-
-## Examples
-
-- Todo App
-- Calculator
-- Weather Dashboard
-- Chat Interface
-- E-commerce Product Card
-- Login Form
-- Dashboard Layout
-- Data Table
-- Image Gallery
-- UI from Image (multimodal)
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -1,1183 +1,54 @@
-import os
-import re
-from http import HTTPStatus
-from typing import Dict, List, Optional, Tuple
-import base64
-import mimetypes
-import PyPDF2
-import docx
-import cv2
-import numpy as np
-from PIL import Image
-import pytesseract
-import requests
-from urllib.parse import urlparse, urljoin
-from bs4 import BeautifulSoup
-import html2text
-import json
-import time
-
+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
-from huggingface_hub import InferenceClient
-from tavily import TavilyClient
-
-# Search/Replace Constants
-SEARCH_START = "<<<<<<< SEARCH"
-DIVIDER = "======="
-REPLACE_END = ">>>>>>> REPLACE"
-
-# Configuration
-SystemPrompt = """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 TAILWINDCSS. Use as much as you can TailwindCSS for the CSS, if you can't do something with TailwindCSS, then use custom CSS (make sure to import <script src="https://cdn.tailwindcss.com"></script> in the head). Also, try to ellaborate as much as you can, to create something unique. ALWAYS GIVE THE RESPONSE INTO A SINGLE HTML FILE
-
-For website redesign tasks:
-- Use the provided original HTML code as the starting point for redesign
-- Preserve all original content, structure, and functionality
-- Keep the same semantic HTML structure but enhance the styling
-- Reuse all original images and their URLs from the HTML code
-- Create a modern, responsive design with improved typography and spacing
-- Use modern CSS frameworks and design patterns
-- Ensure accessibility and mobile responsiveness
-- Maintain the same navigation and user flow
-- Enhance the visual design while keeping the original layout structure
-
-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.
-
-Always output only the HTML code inside a ```html ... ``` code block, and do not include any explanations or extra text."""
-
-# System prompt with search capability
-SystemPromptWithSearch = """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 TAILWINDCSS. Use as much as you can TailwindCSS for the CSS, if you can't do something with TailwindCSS, then use custom CSS (make sure to import <script src="https://cdn.tailwindcss.com"></script> in the head). Also, try to ellaborate as much as you can, to create something unique. ALWAYS GIVE THE RESPONSE INTO A SINGLE HTML FILE
-
-You have access to real-time web search. When needed, use web search to find the latest information, best practices, or specific technologies.
-
-For website redesign tasks:
-- Use the provided original HTML code as the starting point for redesign
-- Preserve all original content, structure, and functionality
-- Keep the same semantic HTML structure but enhance the styling
-- Reuse all original images and their URLs from the HTML code
-- Use web search to find current design trends and best practices for the specific type of website
-- Create a modern, responsive design with improved typography and spacing
-- Use modern CSS frameworks and design patterns
-- Ensure accessibility and mobile responsiveness
-- Maintain the same navigation and user flow
-- Enhance the visual design while keeping the original layout structure
-
-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.
-
-Always output only the HTML code inside a ```html ... ``` code block, and do not include any explanations or extra text."""
-
-# Follow-up system prompt for modifying existing HTML files
-FollowUpSystemPrompt = f"""You are an expert web developer modifying an existing HTML file.
-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.
-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 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 Deleting Code:
-```
-Removing the paragraph...
-{SEARCH_START}
-  <p>This paragraph will be deleted.</p>
-{DIVIDER}
-{REPLACE_END}
-```"""
-
-# Available models
-AVAILABLE_MODELS = [
-    {
-        "name": "Moonshot Kimi-K2",
-        "id": "moonshotai/Kimi-K2-Instruct",
-        "description": "Moonshot AI Kimi-K2-Instruct model for code generation and general tasks"
-    },
-    {
-        "name": "DeepSeek V3",
-        "id": "deepseek-ai/DeepSeek-V3-0324",
-        "description": "DeepSeek V3 model for code generation"
-    },
-    {
-        "name": "DeepSeek R1", 
-        "id": "deepseek-ai/DeepSeek-R1-0528",
-        "description": "DeepSeek R1 model for code generation"
-    },
-    {
-        "name": "ERNIE-4.5-VL",
-        "id": "baidu/ERNIE-4.5-VL-424B-A47B-Base-PT",
-        "description": "ERNIE-4.5-VL model for multimodal code generation with image support"
-    },
-    {
-        "name": "MiniMax M1",
-        "id": "MiniMaxAI/MiniMax-M1-80k",
-        "description": "MiniMax M1 model for code generation and general tasks"
-    },
-    {
-        "name": "Qwen3-235B-A22B",
-        "id": "Qwen/Qwen3-235B-A22B",
-        "description": "Qwen3-235B-A22B model for code generation and general tasks"
-    },
-    {
-        "name": "SmolLM3-3B",
-        "id": "HuggingFaceTB/SmolLM3-3B",
-        "description": "SmolLM3-3B model for code generation and general tasks"
-    },
-    {
-        "name": "GLM-4.1V-9B-Thinking",
-        "id": "THUDM/GLM-4.1V-9B-Thinking",
-        "description": "GLM-4.1V-9B-Thinking model for multimodal code generation with image support"
-    }
-]
-
-DEMO_LIST = [
-    {
-        "title": "Todo App",
-        "description": "Create a simple todo application with add, delete, and mark as complete functionality"
-    },
-    {
-        "title": "Calculator",
-        "description": "Build a basic calculator with addition, subtraction, multiplication, and division"
-    },
-    {
-        "title": "Weather Dashboard",
-        "description": "Create a weather dashboard that displays current weather information"
-    },
-    {
-        "title": "Chat Interface",
-        "description": "Build a chat interface with message history and user input"
-    },
-    {
-        "title": "E-commerce Product Card",
-        "description": "Create a product card component for an e-commerce website"
-    },
-    {
-        "title": "Login Form",
-        "description": "Build a responsive login form with validation"
-    },
-    {
-        "title": "Dashboard Layout",
-        "description": "Create a dashboard layout with sidebar navigation and main content area"
-    },
-    {
-        "title": "Data Table",
-        "description": "Build a data table with sorting and filtering capabilities"
-    },
-    {
-        "title": "Image Gallery",
-        "description": "Create an image gallery with lightbox functionality and responsive grid layout"
-    },
-    {
-        "title": "UI from Image",
-        "description": "Upload an image of a UI design and I'll generate the HTML/CSS code for it"
-    },
-    {
-        "title": "Extract Text from Image",
-        "description": "Upload an image containing text and I'll extract and process the text content"
-    },
-    {
-        "title": "Website Redesign",
-        "description": "Enter a website URL to extract its content and redesign it with a modern, responsive layout"
-    },
-    {
-        "title": "Modify HTML",
-        "description": "After generating HTML, ask me to modify it with specific changes using search/replace format"
-    },
-    {
-        "title": "Search/Replace Example",
-        "description": "Generate HTML first, then ask: 'Change the title to My New Title' or 'Add a blue background to the body'"
-    }
-]
-
-# HF Inference Client
-HF_TOKEN = os.getenv('HF_TOKEN')
-client = InferenceClient(
-    provider="auto",
-    api_key=HF_TOKEN,
-    bill_to="huggingface"
-)
-
-# Type definitions
-History = List[Tuple[str, str]]
-Messages = List[Dict[str, str]]
-
-# Tavily Search Client
-TAVILY_API_KEY = os.getenv('TAVILY_API_KEY')
-tavily_client = None
-if TAVILY_API_KEY:
-    try:
-        tavily_client = TavilyClient(api_key=TAVILY_API_KEY)
-    except Exception as e:
-        print(f"Failed to initialize Tavily client: {e}")
-        tavily_client = None
-
-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 messages_to_history(messages: Messages) -> Tuple[str, History]:
-    assert messages[0]['role'] == 'system'
-    history = []
-    for q, r in zip(messages[1::2], messages[2::2]):
-        # Extract text content from multimodal messages for history
-        user_content = q['content']
-        if isinstance(user_content, list):
-            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)
-        
-        history.append([user_content, r['content']])
-    return history
-
-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 remove_code_block(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()
-            return extracted
-    # If no code block is found, check if the entire text is HTML
-    if text.strip().startswith('<!DOCTYPE html>') or text.strip().startswith('<html') or text.strip().startswith('<'):
-        return text.strip()
-    return text.strip()
-
-def history_render(history: History):
-    return gr.update(visible=True), history
-
-def clear_history():
-    return [], [], None, ""  # Empty lists for both tuple format and chatbot messages, None for file, empty string for website URL
-
-def update_image_input_visibility(model):
-    """Update image input visibility based on selected model"""
-    is_ernie_vl = model.get("id") == "baidu/ERNIE-4.5-VL-424B-A47B-Base-PT"
-    is_glm_vl = model.get("id") == "THUDM/GLM-4.1V-9B-Thinking"
-    return gr.update(visible=is_ernie_vl or is_glm_vl)
-
-def process_image_for_model(image):
-    """Convert image to base64 for model input"""
-    if image is None:
-        return None
-    
-    # Convert numpy array to PIL Image if needed
-    import io
-    import base64
-    import numpy as np
-    from PIL import Image
-    
-    # Handle numpy array from Gradio
-    if isinstance(image, np.ndarray):
-        image = Image.fromarray(image)
-    
-    buffer = io.BytesIO()
-    image.save(buffer, format='PNG')
-    img_str = base64.b64encode(buffer.getvalue()).decode()
-    return f"data:image/png;base64,{img_str}"
-
-def create_multimodal_message(text, image=None):
-    """Create a multimodal message with text and optional image"""
-    if image is None:
-        return {"role": "user", "content": text}
-    
-    content = [
-        {
-            "type": "text",
-            "text": text
-        },
-        {
-            "type": "image_url",
-            "image_url": {
-                "url": process_image_for_model(image)
-            }
-        }
-    ]
-    
-    return {"role": "user", "content": content}
-
-def apply_search_replace_changes(original_html: str, changes_text: str) -> str:
-    """Apply search/replace changes to HTML content"""
-    if not changes_text.strip():
-        return original_html
-    
-    # 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_html = original_html
-    
-    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_html:
-                modified_html = modified_html.replace(search_text, replace_text)
-            else:
-                print(f"Warning: Search text not found in HTML: {search_text[:100]}...")
-    
-    return modified_html
-
-# Updated for faster Tavily search and closer prompt usage
-# Uses 'advanced' search_depth and auto_parameters=True for speed and relevance
-
-def perform_web_search(query: str, max_results: int = 5, include_domains=None, exclude_domains=None) -> str:
-    """Perform web search using Tavily with default parameters"""
-    if not tavily_client:
-        return "Web search is not available. Please set the TAVILY_API_KEY environment variable."
-    
-    try:
-        # Use Tavily defaults with advanced search depth for better results
-        search_params = {
-            "search_depth": "advanced",
-            "max_results": min(max(1, max_results), 20)
-        }
-        if include_domains is not None:
-            search_params["include_domains"] = include_domains
-        if exclude_domains is not None:
-            search_params["exclude_domains"] = exclude_domains
 
-        response = tavily_client.search(query, **search_params)
-        
-        search_results = []
-        for result in response.get('results', []):
-            title = result.get('title', 'No title')
-            url = result.get('url', 'No URL')
-            content = result.get('content', 'No content')
-            search_results.append(f"Title: {title}\nURL: {url}\nContent: {content}\n")
-        
-        if search_results:
-            return "Web Search Results:\n\n" + "\n---\n".join(search_results)
-        else:
-            return "No search results found."
-            
-    except Exception as e:
-        return f"Search error: {str(e)}"
-
-def enhance_query_with_search(query: str, enable_search: bool) -> str:
-    """Enhance the query with web search results if search is enabled"""
-    if not enable_search or not tavily_client:
-        return query
-    
-    # Perform search to get relevant information
-    search_results = perform_web_search(query)
-    
-    # Combine original query with search results
-    enhanced_query = f"""Original Query: {query}
-
-{search_results}
-
-Please use the search results above to help create the requested application with the most up-to-date information and best practices."""
-    
-    return enhanced_query
-
-def send_to_sandbox(code):
-    # Add a wrapper to inject necessary permissions and ensure full HTML
-    wrapped_code = f"""
-    <!DOCTYPE html>
-    <html>
-    <head>
-        <meta charset=\"UTF-8\">
-        <meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\">
-        <script>
-            // Safe localStorage polyfill
-            const safeStorage = {{
-                _data: {{}},
-                getItem: function(key) {{ return this._data[key] || null; }},
-                setItem: function(key, value) {{ this._data[key] = value; }},
-                removeItem: function(key) {{ delete this._data[key]; }},
-                clear: function() {{ this._data = {{}}; }}
-            }};
-            Object.defineProperty(window, 'localStorage', {{
-                value: safeStorage,
-                writable: false
-            }});
-            window.onerror = function(message, source, lineno, colno, error) {{
-                console.error('Error:', message);
-            }};
-        </script>
-    </head>
-    <body>
-        {code}
-    </body>
-    </html>
-    """
-    encoded_html = base64.b64encode(wrapped_code.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 demo_card_click(e: gr.EventData):
-    try:
-        # Get the index from the event data
-        if hasattr(e, '_data') and e._data:
-            # Try different ways to get the index
-            if 'index' in e._data:
-                index = e._data['index']
-            elif 'component' in e._data and 'index' in e._data['component']:
-                index = e._data['component']['index']
-            elif 'target' in e._data and 'index' in e._data['target']:
-                index = e._data['target']['index']
-            else:
-                # If we can't get the index, try to extract it from the card data
-                index = 0
-        else:
-            index = 0
-        
-        # Ensure index is within bounds
-        if index >= len(DEMO_LIST):
-            index = 0
-            
-        return DEMO_LIST[index]['description']
-    except (KeyError, IndexError, AttributeError) as e:
-        # Return the first demo description as fallback
-        return DEMO_LIST[0]['description']
-
-def extract_text_from_image(image_path):
-    """Extract text from image using OCR"""
-    try:
-        # Check if tesseract is available
-        try:
-            pytesseract.get_tesseract_version()
-        except Exception:
-            return "Error: Tesseract OCR is not installed. Please install Tesseract to extract text from images. See install_tesseract.md for instructions."
-        
-        # Read image using OpenCV
-        image = cv2.imread(image_path)
-        if image is None:
-            return "Error: Could not read image file"
-        
-        # Convert to RGB (OpenCV uses BGR)
-        image_rgb = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
-        
-        # Preprocess image for better OCR results
-        # Convert to grayscale
-        gray = cv2.cvtColor(image_rgb, cv2.COLOR_RGB2GRAY)
-        
-        # Apply thresholding to get binary image
-        _, binary = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
-        
-        # Extract text using pytesseract
-        text = pytesseract.image_to_string(binary, config='--psm 6')
-        
-        return text.strip() if text.strip() else "No text found in image"
-        
-    except Exception as e:
-        return f"Error extracting text from image: {e}"
-
-def extract_text_from_file(file_path):
-    if not file_path:
-        return ""
-    mime, _ = mimetypes.guess_type(file_path)
-    ext = os.path.splitext(file_path)[1].lower()
-    try:
-        if ext == ".pdf":
-            with open(file_path, "rb") as f:
-                reader = PyPDF2.PdfReader(f)
-                return "\n".join(page.extract_text() or "" for page in reader.pages)
-        elif ext in [".txt", ".md"]:
-            with open(file_path, "r", encoding="utf-8") as f:
-                return f.read()
-        elif ext == ".csv":
-            with open(file_path, "r", encoding="utf-8") as f:
-                return f.read()
-        elif ext == ".docx":
-            doc = docx.Document(file_path)
-            return "\n".join([para.text for para in doc.paragraphs])
-        elif ext.lower() in [".jpg", ".jpeg", ".png", ".bmp", ".tiff", ".tif", ".gif", ".webp"]:
-            return extract_text_from_image(file_path)
-        else:
-            return ""
-    except Exception as e:
-        return f"Error extracting text: {e}"
-
-def extract_website_content(url: str) -> str:
-    """Extract HTML code and content from a website URL"""
-    try:
-        # Validate URL
-        parsed_url = urlparse(url)
-        if not parsed_url.scheme:
-            url = "https://" + url
-            parsed_url = urlparse(url)
-        
-        if not parsed_url.netloc:
-            return "Error: Invalid URL provided"
-        
-        # Set comprehensive headers to mimic a real browser request
-        headers = {
-            'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
-            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8',
-            'Accept-Language': 'en-US,en;q=0.9',
-            'Accept-Encoding': 'gzip, deflate, br',
-            'DNT': '1',
-            'Connection': 'keep-alive',
-            'Upgrade-Insecure-Requests': '1',
-            'Sec-Fetch-Dest': 'document',
-            'Sec-Fetch-Mode': 'navigate',
-            'Sec-Fetch-Site': 'none',
-            'Sec-Fetch-User': '?1',
-            'Cache-Control': 'max-age=0'
-        }
-        
-        # Create a session to maintain cookies and handle redirects
-        session = requests.Session()
-        session.headers.update(headers)
-        
-        # Make the request with retry logic
-        max_retries = 3
-        for attempt in range(max_retries):
-            try:
-                response = session.get(url, timeout=15, allow_redirects=True)
-                response.raise_for_status()
-                break
-            except requests.exceptions.HTTPError as e:
-                if e.response.status_code == 403 and attempt < max_retries - 1:
-                    # Try with different User-Agent on 403
-                    session.headers['User-Agent'] = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36'
-                    continue
-                else:
-                    raise
-        
-        # Get the raw HTML content with proper encoding
-        try:
-            # Try to get the content with automatic encoding detection
-            response.encoding = response.apparent_encoding
-            raw_html = response.text
-        except:
-            # Fallback to UTF-8 if encoding detection fails
-            raw_html = response.content.decode('utf-8', errors='ignore')
-        
-        # Debug: Check if we got valid HTML
-        if not raw_html.strip().startswith('<!DOCTYPE') and not raw_html.strip().startswith('<html'):
-            print(f"Warning: Response doesn't look like HTML. First 200 chars: {raw_html[:200]}")
-            print(f"Response headers: {dict(response.headers)}")
-            print(f"Response encoding: {response.encoding}")
-            print(f"Apparent encoding: {response.apparent_encoding}")
-            
-            # Try alternative approaches
-            try:
-                raw_html = response.content.decode('latin-1', errors='ignore')
-                print("Tried latin-1 decoding")
-            except:
-                try:
-                    raw_html = response.content.decode('utf-8', errors='ignore')
-                    print("Tried UTF-8 decoding")
-                except:
-                    raw_html = response.content.decode('cp1252', errors='ignore')
-                    print("Tried cp1252 decoding")
-        
-        # Parse HTML content for analysis
-        soup = BeautifulSoup(raw_html, 'html.parser')
-        
-        # Check if this is a JavaScript-heavy site
-        script_tags = soup.find_all('script')
-        if len(script_tags) > 10:
-            print(f"Warning: This site has {len(script_tags)} script tags - it may be a JavaScript-heavy site")
-            print("The content might be loaded dynamically and not available in the initial HTML")
-        
-        # Extract title
-        title = soup.find('title')
-        title_text = title.get_text().strip() if title else "No title found"
-        
-        # Extract meta description
-        meta_desc = soup.find('meta', attrs={'name': 'description'})
-        description = meta_desc.get('content', '') if meta_desc else ""
-        
-        # Extract main content areas for analysis
-        content_sections = []
-        main_selectors = [
-            'main', 'article', '.content', '.main-content', '.post-content',
-            '#content', '#main', '.entry-content', '.post-body'
-        ]
-        
-        for selector in main_selectors:
-            elements = soup.select(selector)
-            for element in elements:
-                text = element.get_text().strip()
-                if len(text) > 100:  # Only include substantial content
-                    content_sections.append(text)
-        
-        # Extract navigation links for analysis
-        nav_links = []
-        nav_elements = soup.find_all(['nav', 'header'])
-        for nav in nav_elements:
-            links = nav.find_all('a')
-            for link in links:
-                link_text = link.get_text().strip()
-                link_href = link.get('href', '')
-                if link_text and link_href:
-                    nav_links.append(f"{link_text}: {link_href}")
-        
-        # Extract and fix image URLs in the HTML
-        img_elements = soup.find_all('img')
-        for img in img_elements:
-            src = img.get('src', '')
-            if src:
-                # Handle different URL formats
-                if src.startswith('//'):
-                    # Protocol-relative URL
-                    absolute_src = 'https:' + src
-                    img['src'] = absolute_src
-                elif src.startswith('/'):
-                    # Root-relative URL
-                    absolute_src = urljoin(url, src)
-                    img['src'] = absolute_src
-                elif not src.startswith(('http://', 'https://')):
-                    # Relative URL
-                    absolute_src = urljoin(url, src)
-                    img['src'] = absolute_src
-                # If it's already absolute, keep it as is
-                
-                # Also check for data-src (lazy loading) and other common attributes
-                data_src = img.get('data-src', '')
-                if data_src and not src:
-                    # Use data-src if src is empty
-                    if data_src.startswith('//'):
-                        absolute_data_src = 'https:' + data_src
-                        img['src'] = absolute_data_src
-                    elif data_src.startswith('/'):
-                        absolute_data_src = urljoin(url, data_src)
-                        img['src'] = absolute_data_src
-                    elif not data_src.startswith(('http://', 'https://')):
-                        absolute_data_src = urljoin(url, data_src)
-                        img['src'] = absolute_data_src
-                    else:
-                        img['src'] = data_src
-        
-        # Also fix background image URLs in style attributes
-        elements_with_style = soup.find_all(attrs={'style': True})
-        for element in elements_with_style:
-            style_attr = element.get('style', '')
-            # Find and replace relative URLs in background-image
-            import re
-            bg_pattern = r'background-image:\s*url\(["\']?([^"\']+)["\']?\)'
-            matches = re.findall(bg_pattern, style_attr, re.IGNORECASE)
-            for match in matches:
-                if match:
-                    if match.startswith('//'):
-                        absolute_bg = 'https:' + match
-                        style_attr = style_attr.replace(match, absolute_bg)
-                    elif match.startswith('/'):
-                        absolute_bg = urljoin(url, match)
-                        style_attr = style_attr.replace(match, absolute_bg)
-                    elif not match.startswith(('http://', 'https://')):
-                        absolute_bg = urljoin(url, match)
-                        style_attr = style_attr.replace(match, absolute_bg)
-            element['style'] = style_attr
-        
-        # Fix background images in <style> tags
-        style_elements = soup.find_all('style')
-        for style in style_elements:
-            if style.string:
-                style_content = style.string
-                # Find and replace relative URLs in background-image
-                bg_pattern = r'background-image:\s*url\(["\']?([^"\']+)["\']?\)'
-                matches = re.findall(bg_pattern, style_content, re.IGNORECASE)
-                for match in matches:
-                    if match:
-                        if match.startswith('//'):
-                            absolute_bg = 'https:' + match
-                            style_content = style_content.replace(match, absolute_bg)
-                        elif match.startswith('/'):
-                            absolute_bg = urljoin(url, match)
-                            style_content = style_content.replace(match, absolute_bg)
-                        elif not match.startswith(('http://', 'https://')):
-                            absolute_bg = urljoin(url, match)
-                            style_content = style_content.replace(match, absolute_bg)
-                style.string = style_content
-        
-        # Extract images for analysis (after fixing URLs)
-        images = []
-        img_elements = soup.find_all('img')
-        for img in img_elements:
-            src = img.get('src', '')
-            alt = img.get('alt', '')
-            if src:
-                images.append({'src': src, 'alt': alt})
-        
-        # Debug: Print some image URLs to see what we're getting
-        print(f"Found {len(images)} images:")
-        for i, img in enumerate(images[:5]):  # Show first 5 images
-            print(f"  {i+1}. {img['alt'] or 'No alt'} - {img['src']}")
-        
-        # Test a few image URLs to see if they're accessible
-        def test_image_url(img_url):
-            try:
-                test_response = requests.head(img_url, timeout=5, allow_redirects=True)
-                return test_response.status_code == 200
-            except:
-                return False
-        
-        # Test first few images
-        working_images = []
-        for img in images[:10]:  # Test first 10 images
-            if test_image_url(img['src']):
-                working_images.append(img)
-            else:
-                print(f"  ❌ Broken image: {img['src']}")
-        
-        print(f"Working images: {len(working_images)} out of {len(images)}")
-        
-        # Get the modified HTML with absolute URLs
-        modified_html = str(soup)
-        
-        # Clean and format the HTML for better readability
-        # Remove unnecessary whitespace and comments
-        import re
-        cleaned_html = re.sub(r'<!--.*?-->', '', modified_html, flags=re.DOTALL)  # Remove HTML comments
-        cleaned_html = re.sub(r'\s+', ' ', cleaned_html)  # Normalize whitespace
-        cleaned_html = re.sub(r'>\s+<', '><', cleaned_html)  # Remove whitespace between tags
-        
-        # Limit HTML size to avoid token limits (keep first 15000 chars)
-        if len(cleaned_html) > 15000:
-            cleaned_html = cleaned_html[:15000] + "\n<!-- ... HTML truncated for length ... -->"
-        
-                # Check if we got any meaningful content
-        if not title_text or title_text == "No title found":
-            title_text = url.split('/')[-1] or url.split('/')[-2] or "Website"
-        
-        # If we couldn't extract any meaningful content, provide a fallback
-        if len(cleaned_html.strip()) < 100:
-            website_content = f"""
-WEBSITE REDESIGN - EXTRACTION FAILED
-====================================
-
-URL: {url}
-Title: {title_text}
-
-ERROR: Could not extract meaningful HTML content from this website. This could be due to:
-1. The website uses heavy JavaScript to load content dynamically
-2. The website has anti-bot protection
-3. The website requires authentication
-4. The website is using advanced compression or encoding
-
-FALLBACK APPROACH:
-Please create a modern, responsive website design for a {title_text.lower()} website. Since I couldn't extract the original content, you can:
-
-1. Create a typical layout for this type of website
-2. Use placeholder content that would be appropriate
-3. Include modern design elements and responsive features
-4. Use a clean, professional design with good typography
-5. Make it mobile-friendly and accessible
-
-The website appears to be: {title_text}
-"""
-            return website_content.strip()
-        
-        # Compile the extracted content with the actual HTML code
-        website_content = f"""
-WEBSITE REDESIGN - ORIGINAL HTML CODE
-=====================================
-
-URL: {url}
-Title: {title_text}
-Description: {description}
-
-PAGE ANALYSIS:
-- This appears to be a {title_text.lower()} website
-- Contains {len(content_sections)} main content sections
-- Has {len(nav_links)} navigation links
-- Includes {len(images)} images
-
-IMAGES FOUND (use these exact URLs in your redesign):
-{chr(10).join([f"• {img['alt'] or 'Image'} - {img['src']}" for img in working_images[:20]]) if working_images else "No working images found"}
-
-ALL IMAGES (including potentially broken ones):
-{chr(10).join([f"• {img['alt'] or 'Image'} - {img['src']}" for img in images[:20]]) if images else "No images found"}
-
-ORIGINAL HTML CODE (use this as the base for redesign):
-```html
-{cleaned_html}
-```
-
-REDESIGN INSTRUCTIONS:
-Please redesign this website with a modern, responsive layout while:
-1. Preserving all the original content and structure
-2. Maintaining the same navigation and functionality
-3. Using the original images and their URLs (listed above)
-4. Creating a modern, clean design with improved typography and spacing
-5. Making it fully responsive for mobile devices
-6. Using modern CSS frameworks and best practices
-7. Keeping the same semantic structure but with enhanced styling
-
-IMPORTANT: All image URLs in the HTML code above have been converted to absolute URLs and are ready to use. Make sure to preserve these exact image URLs in your redesigned version.
-
-The HTML code above contains the complete original website structure with all images properly linked. Use it as your starting point and create a modernized version.
-"""
-        
-        return website_content.strip()
-        
-    except requests.exceptions.HTTPError as e:
-        if e.response.status_code == 403:
-            return f"Error: Website blocked access (403 Forbidden). This website may have anti-bot protection. Try a different website or provide a description of what you want to build instead."
-        elif e.response.status_code == 404:
-            return f"Error: Website not found (404). Please check the URL and try again."
-        elif e.response.status_code >= 500:
-            return f"Error: Website server error ({e.response.status_code}). Please try again later."
-        else:
-            return f"Error accessing website: HTTP {e.response.status_code} - {str(e)}"
-    except requests.exceptions.Timeout:
-        return "Error: Request timed out. The website may be slow or unavailable."
-    except requests.exceptions.ConnectionError:
-        return "Error: Could not connect to the website. Please check your internet connection and the URL."
-    except requests.exceptions.RequestException as e:
-        return f"Error accessing website: {str(e)}"
-    except Exception as e:
-        return f"Error extracting website content: {str(e)}"
-
-def generation_code(query: Optional[str], image: Optional[gr.Image], file: Optional[str], website_url: Optional[str], _setting: Dict[str, str], _history: Optional[History], _current_model: Dict, enable_search: bool = False):
-    if query is None:
-        query = ''
-    if _history is None:
-        _history = []
-    
-    # Check if there's existing HTML content in history to determine if this is a modification request
-    has_existing_html = False
-    if _history:
-        # Check the last assistant message for HTML content
-        last_assistant_msg = _history[-1][1] if len(_history) > 0 else ""
-        if '<!DOCTYPE html>' in last_assistant_msg or '<html' in last_assistant_msg:
-            has_existing_html = True
-    
-    # Choose system prompt based on context
-    if has_existing_html:
-        # Use follow-up prompt for modifying existing HTML
-        system_prompt = FollowUpSystemPrompt
-    else:
-        # Use regular prompt for new generation
-        system_prompt = SystemPromptWithSearch if enable_search else _setting['system']
-    
-    messages = history_to_messages(_history, system_prompt)
-    
-    # Extract file text and append to query if file is present
-    file_text = ""
-    if file:
-        file_text = extract_text_from_file(file)
-        if file_text:
-            file_text = file_text[:5000]  # Limit to 5000 chars for prompt size
-            query = f"{query}\n\n[Reference file content below]\n{file_text}"
-    
-    # Extract website content and append to query if website URL is present
-    website_text = ""
-    if website_url and website_url.strip():
-        website_text = extract_website_content(website_url.strip())
-        if website_text and not website_text.startswith("Error"):
-            website_text = website_text[:8000]  # Limit to 8000 chars for prompt size
-            query = f"{query}\n\n[Website content to redesign below]\n{website_text}"
-        elif website_text.startswith("Error"):
-            # Provide helpful guidance when website extraction fails
-            fallback_guidance = """
-Since I couldn't extract the website content, please provide additional details about what you'd like to build:
-
-1. What type of website is this? (e.g., e-commerce, blog, portfolio, dashboard)
-2. What are the main features you want?
-3. What's the target audience?
-4. Any specific design preferences? (colors, style, layout)
-
-This will help me create a better design for you."""
-            query = f"{query}\n\n[Error extracting website: {website_text}]{fallback_guidance}"
-    
-    # Enhance query with search if enabled
-    enhanced_query = enhance_query_with_search(query, enable_search)
-    
-    if image is not None:
-        messages.append(create_multimodal_message(enhanced_query, image))
-    else:
-        messages.append({'role': 'user', 'content': enhanced_query})
-    try:
-        completion = client.chat.completions.create(
-            model=_current_model["id"],
-            messages=messages,
-            stream=True,
-            max_tokens=5000
-        )
-        content = ""
-        for chunk in completion:
-            if chunk.choices[0].delta.content:
-                content += chunk.choices[0].delta.content
-                clean_code = remove_code_block(content)
-                search_status = " (with web search)" if enable_search and tavily_client else ""
-                yield {
-                    code_output: clean_code,
-                    history_output: history_to_chatbot_messages(_history),
-                }
-        # Handle response based on whether this is a modification or new generation
-        if has_existing_html:
-            # Apply search/replace changes to existing HTML
-            last_html = _history[-1][1] if _history else ""
-            modified_html = apply_search_replace_changes(last_html, remove_code_block(content))
-            clean_html = remove_code_block(modified_html)
-            
-            # Update history with the cleaned HTML
-            _history = messages_to_history(messages + [{
-                'role': 'assistant',
-                'content': clean_html
-            }])
-            
-            yield {
-                code_output: clean_html,
-                history: _history,
-                sandbox: send_to_sandbox(clean_html),
-                history_output: history_to_chatbot_messages(_history),
-            }
-        else:
-            # Regular generation - use the content as is
-            _history = messages_to_history(messages + [{
-                'role': 'assistant',
-                'content': content
-            }])
-            yield {
-                code_output: remove_code_block(content),
-                history: _history,
-                sandbox: send_to_sandbox(remove_code_block(content)),
-                history_output: history_to_chatbot_messages(_history),
-            }
-    except Exception as e:
-        error_message = f"Error: {str(e)}"
-        yield {
-            code_output: error_message,
-            history_output: history_to_chatbot_messages(_history),
-        }
-
-# Main application
-with gr.Blocks(
-    theme=gr.themes.Base(
-        primary_hue="blue",
-        secondary_hue="gray",
-        neutral_hue="gray",
-        font=gr.themes.GoogleFont("Inter"),
-        font_mono=gr.themes.GoogleFont("JetBrains Mono"),
-        text_size=gr.themes.sizes.text_md,
-        spacing_size=gr.themes.sizes.spacing_md,
-        radius_size=gr.themes.sizes.radius_md
-    ),
-    title="AnyCoder - AI Code Generator"
-) as demo:
-    history = gr.State([])
-    setting = gr.State({
-        "system": SystemPrompt,
-    })
-    current_model = gr.State(AVAILABLE_MODELS[1])  # DeepSeek V3
-    open_panel = gr.State(None)
-
-    with gr.Sidebar():
-        gr.Markdown("# AnyCoder")
-        gr.Markdown("*AI-Powered Code Generator*")
-        
-        gr.Markdown("---")  # Separator
-        
-        # Main input section
-        input = gr.Textbox(
-            label="What would you like to build?",
-            placeholder="Describe your application...",
-            lines=3
-        )
-        
-        # URL input for website redesign
-        website_url_input = gr.Textbox(
-            label="Website URL for redesign",
-            placeholder="https://example.com",
-            lines=1,
-            visible=True
-        )
-        
-        # File upload (minimal)
-        file_input = gr.File(
-            label="Reference file",
-            file_types=[".pdf", ".txt", ".md", ".csv", ".docx", ".jpg", ".jpeg", ".png", ".bmp", ".tiff", ".tif", ".gif", ".webp"],
-            visible=True
-        )
-        
-        # Image input (only for ERNIE model)
-        image_input = gr.Image(
-            label="UI design image",
-            visible=False
-        )
-        
-        # Action buttons
-        with gr.Row():
-            btn = gr.Button("Generate", variant="primary", size="lg", scale=2)
-            clear_btn = gr.Button("Clear", variant="secondary", size="sm", scale=1)
-        
-        # Search toggle (minimal)
-        search_toggle = gr.Checkbox(
-            label="🔍 Web search",
-            value=False
-        )
-        
-        # Model selection (minimal)
-        model_dropdown = gr.Dropdown(
-            choices=[model['name'] for model in AVAILABLE_MODELS],
-            value=AVAILABLE_MODELS[1]['name'],  # DeepSeek V3
-            label="Model"
-        )
-        
-        # Quick examples (minimal)
-        gr.Markdown("**Quick start**")
-        with gr.Column():
-            for i, demo_item in enumerate(DEMO_LIST[:3]):
-                demo_card = gr.Button(
-                    value=demo_item['title'], 
-                    variant="secondary",
-                    size="sm"
-                )
-                demo_card.click(
-                    fn=lambda idx=i: gr.update(value=DEMO_LIST[idx]['description']),
-                    outputs=input
-                )
-        
-        # Status indicators (minimal)
-        if not tavily_client:
-            gr.Markdown("⚠️ Web search unavailable")
-        else:
-            gr.Markdown("✅ Web search available")
-        
-        # Hidden elements for functionality
-        model_display = gr.Markdown(f"**Model:** {AVAILABLE_MODELS[1]['name']}", visible=False)  # DeepSeek V3
-        
-        def on_model_change(model_name):
-            for m in AVAILABLE_MODELS:
-                if m['name'] == model_name:
-                    return m, f"**Model:** {m['name']}", update_image_input_visibility(m)
-            return AVAILABLE_MODELS[1], f"**Model:** {AVAILABLE_MODELS[1]['name']}", update_image_input_visibility(AVAILABLE_MODELS[1])  # DeepSeek V3 fallback
-        
-        def save_prompt(input):
-            return {setting: {"system": input}}
-        
-        model_dropdown.change(
-            on_model_change,
-            inputs=model_dropdown,
-            outputs=[current_model, model_display, image_input]
-        )
-        
-        # System prompt (collapsed by default)
-        with gr.Accordion("Advanced", open=False):
-            systemPromptInput = gr.Textbox(
-                value=SystemPrompt,
-                label="System prompt",
-                lines=5
-            )
-            save_prompt_btn = gr.Button("Save", variant="primary", size="sm")
-            save_prompt_btn.click(save_prompt, inputs=systemPromptInput, outputs=setting)
-
-    with gr.Column():
-        with gr.Tabs():
-            with gr.Tab("Code"):
-                code_output = gr.Code(
-                    language="html", 
-                    lines=25, 
-                    interactive=False,
-                    label="Generated code"
-                )
-            with gr.Tab("Preview"):
-                sandbox = gr.HTML(label="Live preview")
-            with gr.Tab("History"):
-                history_output = gr.Chatbot(show_label=False, height=400, type="messages")
-
-    # Event handlers
-    btn.click(
-        generation_code,
-        inputs=[input, image_input, file_input, website_url_input, setting, history, current_model, search_toggle],
-        outputs=[code_output, history, sandbox, history_output]
+# 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,
+}
+
+# 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",
     )
-    clear_btn.click(clear_history, outputs=[history, history_output, file_input, website_url_input])
 
 if __name__ == "__main__":
-    demo.queue(default_concurrency_limit=20).launch(ssr_mode=True, mcp_server=True)
+    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()

app_omini.py

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

app_openai.py

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

app_openai_coder.py

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

app_openai_voice.py

@@ -0,0 +1,23 @@
+import os
+
+import openai_gradio
+
+from utils import get_app
+
+demo = get_app(
+    models=[
+        "gpt-4o-realtime-preview",
+        "gpt-4o-realtime-preview-2024-12-17",
+        "gpt-4o-realtime-preview-2024-10-01",
+        "gpt-4o-mini-realtime-preview",
+        "gpt-4o-mini-realtime-preview-2024-12-17",
+    ],
+    default_model="gpt-4o-mini-realtime-preview-2024-12-17",
+    src=openai_gradio.registry,
+    accept_token=not os.getenv("OPENAI_API_KEY"),
+    twilio_sid=os.getenv("TWILIO_SID_OPENAI"),
+    twilio_token=os.getenv("TWILIO_AUTH_OPENAI"),
+)
+
+if __name__ == "__main__":
+    demo.launch()

app_openrouter.py

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

app_paligemma.py

@@ -0,0 +1,78 @@
+import gradio as gr
+from gradio_client import Client, handle_file
+
+MODELS = {"Paligemma-10B": "akhaliq/paligemma2-10b-ft-docci-448"}
+
+
+def create_chat_fn(client, system_prompt, temperature, max_tokens, top_k, rep_penalty, top_p):
+    def chat(message, history):
+        text = message.get("text", "")
+        files = message.get("files", [])
+        processed_files = [handle_file(f) for f in files]
+
+        response = client.predict(
+            message={"text": text, "files": processed_files},
+            system_prompt=system_prompt,
+            temperature=temperature,
+            max_new_tokens=max_tokens,
+            top_k=top_k,
+            repetition_penalty=rep_penalty,
+            top_p=top_p,
+            api_name="/chat",
+        )
+        return response
+
+    return chat
+
+
+def set_client_for_session(model_name, request: gr.Request):
+    headers = {}
+    if request and hasattr(request, "headers"):
+        x_ip_token = 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, system_prompt, temperature, max_tokens, top_k, rep_penalty, top_p):
+    if client is None:
+        return "Error: Client not initialized. Please refresh the page."
+    try:
+        return create_chat_fn(client, system_prompt, temperature, max_tokens, top_k, rep_penalty, top_p)(
+            message, history
+        )
+    except Exception as e:
+        print(f"Error during chat: {e!s}")
+        return f"Error during chat: {e!s}"
+
+
+with gr.Blocks() as demo:
+    client = gr.State()
+
+    with gr.Accordion("Advanced Settings", open=False):
+        system_prompt = gr.Textbox(value="You are a helpful AI assistant.", label="System Prompt")
+        with gr.Row():
+            temperature = gr.Slider(minimum=0.0, maximum=2.0, value=0.7, label="Temperature")
+            top_p = gr.Slider(minimum=0.0, maximum=1.0, value=0.95, label="Top P")
+        with gr.Row():
+            top_k = gr.Slider(minimum=1, maximum=100, value=40, step=1, label="Top K")
+            rep_penalty = gr.Slider(minimum=1.0, maximum=2.0, value=1.1, label="Repetition Penalty")
+        max_tokens = gr.Slider(minimum=64, maximum=4096, value=1024, step=64, label="Max Tokens")
+
+    chat_interface = gr.ChatInterface(
+        fn=safe_chat_fn,
+        additional_inputs=[client, system_prompt, temperature, max_tokens, top_k, rep_penalty, top_p],
+        multimodal=True,
+    )
+
+    # Initialize client on page load with default model
+    demo.load(fn=set_client_for_session, inputs=[gr.State("Paligemma-10B")], outputs=[client])  # Using default model
+
+# Move the API access check here, after demo is defined
+if hasattr(demo, "fns"):
+    for fn in demo.fns.values():
+        fn.api_name = False
+
+if __name__ == "__main__":
+    demo.launch()

app_perplexity.py

@@ -0,0 +1,23 @@
+import os
+
+import perplexity_gradio
+
+from utils import get_app
+
+demo = get_app(
+    models=[
+        "llama-3.1-sonar-large-128k-online",
+        "llama-3.1-sonar-small-128k-online",
+        "llama-3.1-sonar-huge-128k-online",
+        "llama-3.1-sonar-small-128k-chat",
+        "llama-3.1-sonar-large-128k-chat",
+        "llama-3.1-8b-instruct",
+        "llama-3.1-70b-instruct",
+    ],
+    default_model="llama-3.1-sonar-huge-128k-online",
+    src=perplexity_gradio.registry,
+    accept_token=not os.getenv("PERPLEXITY_API_KEY"),
+)
+
+if __name__ == "__main__":
+    demo.launch()

app_playai.py

@@ -0,0 +1,10 @@
+import gradio as gr
+import playai_gradio
+
+demo = gr.load(
+    name="PlayDialog",
+    src=playai_gradio.registry,
+)
+
+for fn in demo.fns.values():
+    fn.api_name = False

app_qwen.py

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

app_qwen_coder.py

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

app_replicate.py

@@ -0,0 +1,18 @@
+import replicate_gradio
+
+from utils import get_app
+
+demo = get_app(
+    models=[
+        "black-forest-labs/flux-depth-pro",
+        "black-forest-labs/flux-canny-pro",
+        "black-forest-labs/flux-fill-pro",
+        "black-forest-labs/flux-depth-dev",
+        "tencent/hunyuan-video:140176772be3b423d14fdaf5403e6d4e38b85646ccad0c3fd2ed07c211f0cad1",
+    ],
+    default_model="tencent/hunyuan-video:140176772be3b423d14fdaf5403e6d4e38b85646ccad0c3fd2ed07c211f0cad1",
+    src=replicate_gradio.registry,
+)
+
+if __name__ == "__main__":
+    demo.launch()