Added coding and testing agents

- Added `GradioCodingAgent` for implementing applications based on planning results.
- Introduced `GradioTestingAgent` for validating application functionality and performance.
- Updated `app.py` to integrate both coding and testing agents, allowing for a seamless development workflow.
- Enhanced `.env.example` with new settings for coding and testing agents.
- Improved project structure and dependencies in `pyproject.toml`.
- Added utility functions in `utils.py` for file handling.
- Created tests for coding and testing agents to ensure functionality and reliability.
- Updated README with new features and setup instructions.

.env.example

@@ -10,3 +10,13 @@ GRADIO_DEBUG=true
 # Planning Agent Settings
 PLANNING_VERBOSITY=1
 MAX_PLANNING_STEPS=10
+
+# Coding Agent Settings
+CODING_VERBOSITY=2
+MAX_CODING_STEPS=20
+CODE_MODEL_ID=Qwen/Qwen2.5-Coder-32B-Instruct
+
+# Testing Agent Settings
+TESTING_VERBOSITY=2
+MAX_TESTING_STEPS=15
+TEST_MODEL_ID=Qwen/Qwen2.5-Coder-32B-Instruct

.gitignore

@@ -279,3 +279,5 @@ screenshots/
 *.bak
 *.backup
 *.old
+
+sandbox/

README.md

@@ -1,121 +1,227 @@
 # 💗 Likable
 
-A Gradio application builder powered by Smolagents CodeAgent for intelligent planning.
+**AI-powered Gradio app builder that plans and implements complete applications**
 
-## Features
+Likable is an intelligent development assistant that takes natural language descriptions of applications and turns them into fully functional Gradio apps with proper project structure, dependencies, and documentation.
 
-- **AI-Powered Planning**: Uses Smolagents CodeAgent to create comprehensive plans for Gradio applications
-- **Interactive Chat Interface**: Describe what you want to build in natural language
-- **Structured Planning Output**: Get detailed action plans, implementation strategies, and testing approaches
-- **Component Analysis**: Automatically identifies required Gradio components and dependencies
-- **Preview & Code Views**: Switch between live preview and generated code
-- **Environment-based Configuration**: Flexible configuration via environment variables
+## ✨ Features
 
-## Setup
+- **🎯 Intelligent Planning**: Uses AI to create comprehensive application plans
+- **⚡ Automated Implementation**: Converts plans into working code with proper structure
+- **📦 Project Management**: Sets up proper Python projects with `uv` package management
+- **🔄 Iterative Development**: Refines implementations until completion
+- **🎨 Live Preview**: Real-time preview of generated applications
+- **📝 Code Editor**: Built-in code editor for manual adjustments
+- **🛠️ Complete Setup**: Handles dependencies, README, and project structure
 
-1. **Install dependencies:**
+## 🚀 Quick Start
+
+### Prerequisites
+
+- Python 3.12+
+- `uv` package manager
+- API key for LLM service (HuggingFace, OpenAI, etc.)
+
+### Installation
+
+1. **Clone the repository**:
    ```bash
-   uv install
+   git clone https://github.com/yourusername/likable.git
+   cd likable
    ```
 
-2. **Configure environment variables:**
+2. **Install dependencies**:
    ```bash
-   # Copy the example environment file
-   cp .env.example .env
-
-   # Edit .env with your configuration
-   # At minimum, set your API_KEY
+   uv sync
    ```
 
-3. **Set up your API_KEY:**
-
-   Add it to your `.env` file:
-   ```
-   API_KEY=your_actual_key_here
+3. **Set up environment variables**:
+   ```bash
+   cp .env.example .env
+   # Edit .env with your API keys and configuration
    ```
 
-4. **Run the application:**
+4. **Run the application**:
    ```bash
-   python app.py
+   uv run python app.py
    ```
 
-## Configuration
+5. **Open your browser** to `http://localhost:7860`
+
+## 📋 Environment Variables
+
+Create a `.env` file with the following variables:
+
+```env
+# API Configuration for LLM Services
+API_KEY=your_api_key_here
+API_BASE_URL=  # Optional: for custom LLM services
+MODEL_ID=Qwen/Qwen2.5-Coder-32B-Instruct
+CODE_MODEL_ID=Qwen/Qwen2.5-Coder-32B-Instruct  # Can be different from planning model
+
+# Gradio Configuration
+GRADIO_HOST=127.0.0.1
+GRADIO_PORT=7860
+GRADIO_DEBUG=false
 
-The application uses environment variables for configuration. See `.env.example` for all available options:
+# Agent Settings
+PLANNING_VERBOSITY=1
+MAX_PLANNING_STEPS=10
+CODING_VERBOSITY=2
+MAX_CODING_STEPS=20
+```
+
+## 🏗️ Architecture
+
+Likable uses a two-agent system:
+
+### 1. Planning Agent (`planning_agent.py`)
+- **Purpose**: Analyzes user requirements and creates comprehensive plans
+- **Technology**: Smolagents with LiteLLM integration
+- **Output**: Structured planning results with:
+  - Action plans
+  - Implementation strategies
+  - Testing approaches
+  - Required Gradio components
+  - Dependencies list
+  - Complexity estimation
+
+### 2. Coding Agent (`coding_agent.py`)
+- **Purpose**: Implements the planned application with proper project structure
+- **Technology**: Smolagents CodeAgent with file operations
+- **Features**:
+  - Sets up `uv` project structure
+  - Installs dependencies automatically
+  - Creates comprehensive README files
+  - Implements all planned features
+  - Performs iterative refinement
+
+## 🎯 How It Works
+
+1. **User Input**: Describe your desired application in natural language
+2. **Planning Phase**: AI analyzes requirements and creates detailed plans
+3. **Implementation Phase**: Coding agent creates complete project structure
+4. **Quality Assurance**: Iterative refinement ensures completeness
+5. **Deployment Ready**: Generated apps are immediately runnable
+
+## 📁 Project Structure
 
-### Core Configuration
-- `API_KEY`: Your API key (required)
-- `MODEL_ID`: Model to use for planning (default: Qwen/Qwen2.5-Coder-32B-Instruct)
+```
+likable/
+├── app.py                    # Main Gradio interface
+├── planning_agent.py         # AI planning agent
+├── coding_agent.py           # AI coding agent
+├── settings.py               # Configuration management
+├── test_planning_agent.py    # Planning agent tests
+├── test_coding_agent.py      # Coding agent tests
+├── pyproject.toml           # Project dependencies
+├── .env.example             # Environment template
+└── sandbox/                 # Generated applications
+    └── gradio_app/          # Latest generated app
+        ├── app.py           # Main application
+        ├── README.md        # Documentation
+        └── pyproject.toml   # App dependencies
+```
 
-### Application Settings
-- `GRADIO_HOST`: Host to bind Gradio server (default: 127.0.0.1)
-- `GRADIO_PORT`: Port for Gradio server (default: 7860)
-- `GRADIO_DEBUG`: Enable debug mode (default: true)
+## 🧪 Testing
 
-### Planning Agent Settings
-- `PLANNING_VERBOSITY`: Agent verbosity level 0-2 (default: 1)
-- `MAX_PLANNING_STEPS`: Maximum planning steps (default: 10)
+Run tests to verify functionality:
 
-### Test Your Configuration
 ```bash
-# View current configuration
-python settings.py
+# Test planning agent
+uv run python test_planning_agent.py
 
-# Test the planning agent
-python test_planning_agent.py
+# Test coding agent
+uv run python test_coding_agent.py
 
-# Interactive demo
-python test_planning_agent.py demo
+# Test settings
+uv run python settings.py
 ```
 
-## Planning Agent
+## 🔧 Development
 
-The core of Likable is the `GradioPlanningAgent` which uses Smolagents to:
+### Adding New Features
 
-- Analyze your application requirements
-- Create detailed action plans
-- Suggest appropriate Gradio components
-- Plan implementation strategies
-- Design testing approaches
-- Estimate complexity and dependencies
+1. **Planning Agent Extensions**: Modify `planning_agent.py` to enhance planning capabilities
+2. **Coding Agent Tools**: Add new tools to `coding_agent.py` for specialized functionality
+3. **UI Improvements**: Update `app.py` for better user experience
 
-### Using the Planning Agent Directly
+### Code Quality
 
-```python
-from planning_agent import GradioPlanningAgent
+The project uses:
+- **Ruff**: Linting and formatting
+- **Pre-commit**: Git hooks for quality assurance
+- **Type hints**: For better code documentation
+- **Docstrings**: Comprehensive documentation
 
-# Uses configuration from settings.py (loads from .env)
-agent = GradioPlanningAgent()
-result = agent.plan_application("Create a simple calculator app")
+```bash
+# Run linting
+uv run ruff check
+
+# Format code
+uv run ruff format
 
-print(agent.format_plan_as_markdown(result))
+# Install pre-commit hooks
+uv run pre-commit install
 ```
 
-## Project Structure
+## 🎨 Example Applications
 
-```
-likable/
-├── app.py                 # Main Gradio application
-├── planning_agent.py      # Smolagents CodeAgent for planning
-├── settings.py            # Configuration management
-├── test_planning_agent.py # Test script and examples
-├── .env.example           # Environment variables template
-├── pyproject.toml         # Project dependencies
-└── README.md              # This file
-```
+Likable can create various types of Gradio applications:
 
-## Environment Requirements
+- **Text Processing**: Translation, summarization, analysis
+- **Image Tools**: Generation, editing, classification
+- **Data Applications**: Visualization, analysis, dashboards
+- **AI Interfaces**: Chatbots, question-answering systems
+- **Utility Apps**: Converters, calculators, tools
 
-- Python 3.12+
-- Inference API key
-- Internet connection for model inference
+## 🤝 Contributing
+
+1. Fork the repository
+2. Create a feature branch: `git checkout -b feature-name`
+3. Make your changes and add tests
+4. Run the test suite: `uv run python -m pytest`
+5. Submit a pull request
+
+## 📄 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## 🙏 Acknowledgments
+
+- **Smolagents**: For the excellent agent framework
+- **Gradio**: For the amazing UI framework
+- **LiteLLM**: For seamless LLM integration
+- **UV**: For fast Python package management
+
+## 🐛 Troubleshooting
+
+### Common Issues
+
+1. **API Key Errors**:
+   - Ensure your API key is set in `.env`
+   - Check API rate limits and quotas
+
+2. **UV Not Found**:
+   ```bash
+   # Install uv
+   curl -LsSf https://astral.sh/uv/install.sh | sh
+   ```
+
+3. **Project Setup Failures**:
+   - Ensure you have write permissions in the project directory
+   - Check that `uv` is properly installed and accessible
+
+4. **Agent Initialization Issues**:
+   - Verify your model ID is correct
+   - Check network connectivity for API calls
 
-## Dependencies
+### Getting Help
 
-- `gradio` - Web UI framework
-- `smolagents` - AI agent framework
-- `python-dotenv` - Environment variable management
+- Open an issue on GitHub
+- Check the examples in `test_*.py` files
+- Review the agent documentation in source code
 
 ---
 
-*Built with ❤️ using Gradio and Smolagents*
+**Happy Building! 🚀**

app.py

@@ -4,13 +4,16 @@ import sys
 
 import gradio as gr
 
+from coding_agent import GradioCodingAgent
 from planning_agent import GradioPlanningAgent
 from settings import settings
+from utils import load_file
 
 gr.NO_RELOAD = False
 
-# Initialize the planning agent globally
+# Initialize the agents globally
 planning_agent = None
+coding_agent = None
 
 
 def get_planning_agent():
@@ -25,14 +28,28 @@ def get_planning_agent():
     return planning_agent
 
 
-# Enhanced AI response using the planning agent
-def ai_response_with_planning(message, history):
-    """Generate AI response using the planning agent for actual planning."""
+def get_coding_agent():
+    """Get or initialize the coding agent (lazy loading)."""
+    global coding_agent
+    if coding_agent is None:
+        try:
+            coding_agent = GradioCodingAgent()
+        except Exception as e:
+            print(f"Error initializing coding agent: {e}")
+            return None
+    return coding_agent
+
+
+# Enhanced AI response using both planning and coding agents
+def ai_response_with_planning_and_coding(message, history):
+    """Generate AI response using the planning agent for planning and \
+coding agent for implementation."""
 
-    agent = get_planning_agent()
+    planning_agent_instance = get_planning_agent()
+    coding_agent_instance = get_coding_agent()
 
-    if agent is None:
-        # Fallback to mock response if agent fails to initialize
+    if planning_agent_instance is None:
+        # Fallback to mock response if planning agent fails to initialize
         response = (
             "Sorry, the planning agent is not available. "
             "Please check your API_KEY environment variable."
@@ -41,11 +58,26 @@ def ai_response_with_planning(message, history):
         history.append({"role": "assistant", "content": response})
         return history, ""
 
+    if coding_agent_instance is None:
+        # Fallback if coding agent fails to initialize
+        response = (
+            "Sorry, the coding agent is not available. "
+            "Planning is available but implementation will be limited."
+        )
+        history.append({"role": "user", "content": message})
+        history.append({"role": "assistant", "content": response})
+        return history, ""
+
     try:
-        # Use the planning agent for actual planning
-        planning_result = agent.plan_application(message)
+        # Step 1: Use the planning agent for planning
+        history.append({"role": "user", "content": message})
+        history.append(
+            {"role": "assistant", "content": "🎯 Starting to plan your application..."}
+        )
+
+        planning_result = planning_agent_instance.plan_application(message)
 
-        # Format the response with key insights
+        # Format the planning response
         action_summary = (
             planning_result.action_plan[:300] + "..."
             if len(planning_result.action_plan) > 300
@@ -59,7 +91,7 @@ def ai_response_with_planning(message, history):
             [f"• {dep}" for dep in planning_result.dependencies[:5]]
         )
 
-        response = f"""I'll help you plan that application! Here's what I've analyzed:
+        planning_response = f"""✅ **Planning Complete!**
 
 **Complexity**: {planning_result.estimated_complexity}
 
@@ -72,31 +104,70 @@ def ai_response_with_planning(message, history):
 **High-Level Action Plan**:
 {action_summary}
 
-I've created a comprehensive plan including implementation details and testing \
-strategy. Check the detailed view for the complete plan!"""
+🚀 **Now starting implementation...**"""
+
+        history.append({"role": "assistant", "content": planning_response})
+
+        # Step 2: Use the coding agent for implementation
+        history.append(
+            {
+                "role": "assistant",
+                "content": "⚡ Implementing your application with proper \
+project structure...",
+            }
+        )
+
+        coding_result = coding_agent_instance.iterative_implementation(planning_result)
 
-        # Store the full planning result for later use
-        # You could save this to a session state or database
+        # Format the implementation response
+        if coding_result.success:
+            implementation_response = f"""✅ **Implementation Complete!**
+
+**Project Created**: `{coding_result.project_path}`
+**Features Implemented**: {len(coding_result.implemented_features)} components
+**Status**: Ready to run!
+
+Your Gradio application has been created with:
+- Proper `uv` project structure
+- All required dependencies installed
+- Complete README.md with usage instructions
+- Functional app.py with all requested features
+
+You can view and test your app in the **Preview** tab, or check the code in \
+the **Code** tab.
+
+To run locally: `cd {coding_result.project_path} && uv run python app.py`"""
+
+            if coding_result.remaining_tasks:
+                implementation_response += f"\n\n**Remaining Tasks**: \
+{chr(10).join([f'• {task}' for task in coding_result.remaining_tasks])}"
+
+        else:
+            implementation_response = f"""⚠️ **Implementation Partially Complete**
+
+**Project Path**: `{coding_result.project_path}`
+**Issues Encountered**: {len(coding_result.error_messages)} errors
+
+**Error Messages**:
+{chr(10).join([f'• {error}' for error in coding_result.error_messages])}
+
+**Remaining Tasks**:
+{chr(10).join([f'• {task}' for task in coding_result.remaining_tasks])}
+
+The project structure has been set up, but some features may need manual completion."""
+
+        history.append({"role": "assistant", "content": implementation_response})
 
     except Exception as e:
-        response = (
-            f"I encountered an error while planning: {str(e)}. "
+        error_response = (
+            f"I encountered an error during planning and implementation: {str(e)}. "
             "Let me try a simpler approach..."
         )
+        history.append({"role": "assistant", "content": error_response})
 
-    history.append({"role": "user", "content": message})
-    history.append({"role": "assistant", "content": response})
     return history, ""
 
 
-def load_file(path):
-    if path is None:
-        return ""
-    # path is a string like "subdir/example.py"
-    with open(path, encoding="utf-8") as f:
-        return f.read()
-
-
 def save_file(path, new_text):
     if path is None:
         gr.Warning("⚠️ No file selected.")
@@ -109,13 +180,15 @@ def save_file(path, new_text):
 
 
 def load_and_render_app():
-    """Load and render the Gradio app from sandbox/app.py"""
-    app_path = "sandbox/app.py"
+    """Load and render the Gradio app from sandbox/gradio_app/app.py"""
+    app_path = "sandbox/gradio_app/app.py"
 
     if not os.path.exists(app_path):
         return gr.HTML(
-            "<div style='padding: 20px; color: red;'>❌ No app.py found in \
-sandbox directory</div>"
+            """<div style='padding: 20px; color: red;'>
+    ❌ No app.py found in sandbox/gradio_app directory.
+    Create an application first using the chat interface.
+</div>"""
         )
 
     try:
@@ -127,9 +200,10 @@ sandbox directory</div>"
         spec = importlib.util.spec_from_loader("dynamic_app", loader=None)
         module = importlib.util.module_from_spec(spec)
 
-        # Add current directory to sys.path if not already there
-        if os.getcwd() not in sys.path:
-            sys.path.insert(0, os.getcwd())
+        # Add sandbox directory to sys.path if not already there
+        sandbox_path = os.path.abspath("sandbox/gradio_app")
+        if sandbox_path not in sys.path:
+            sys.path.insert(0, sandbox_path)
 
         # Execute the code in the module's namespace
         exec(app_code, module.__dict__)
@@ -153,8 +227,10 @@ sandbox directory</div>"
 
         if app_instance is None:
             return gr.HTML(
-                "<div style='padding: 20px; color: orange;'>⚠️ No Gradio app found. \
-Make sure your app.py creates a Gradio Blocks or Interface object.</div>"
+                """<div style='padding: 20px; color: orange;'>
+⚠️ No Gradio app found. Make sure your app.py creates a Gradio Blocks or \
+Interface object.
+</div>"""
             )
 
         # Return the app instance to be rendered
@@ -162,17 +238,17 @@ Make sure your app.py creates a Gradio Blocks or Interface object.</div>"
 
     except Exception as e:
         error_html = f"""
-        <div style='padding: 20px; color: red; font-family: monospace;'>
-            ❌ Error loading app:<br>
-            <pre style='background: #f5f5f5; padding: 10px; margin-top: 10px; \
+<div style='padding: 20px; color: red; font-family: monospace;'>
+    ❌ Error loading app:<br>
+    <pre style='background: #f5f5f5; padding: 10px; margin-top: 10px; \
 border-radius: 4px;'>{str(e)}</pre>
-        </div>
-        """
+</div>
+"""
         return gr.HTML(error_html)
 
 
-# Create the main Lovable-style UI
-def create_lovable_ui():
+# Create the main Likable UI
+def create_likable_ui():
     with gr.Blocks(
         title="💗Likable",
         theme=gr.themes.Soft(),
@@ -180,9 +256,10 @@ def create_lovable_ui():
         fill_width=True,
     ) as demo:
         gr.Markdown("# 💗Likable")
-        # gr.Markdown(
-        #     "*It's almost Lovable - Build Gradio apps using only a chat interface*"
-        # )
+        gr.Markdown(
+            "*AI-powered Gradio app builder - Plans and implements \
+complete applications*"
+        )
 
         with gr.Row(elem_classes="main-container"):
             # Left side - Chat Interface
@@ -190,17 +267,17 @@ def create_lovable_ui():
                 chatbot = gr.Chatbot(
                     show_copy_button=True,
                     avatar_images=(None, "🤖"),
-                    bubble_full_width=False,
+                    type="messages",
                     height="75vh",
                 )
 
                 with gr.Row():
                     msg_input = gr.Textbox(
-                        placeholder="Describe what you want to build...",
+                        placeholder="Describe the Gradio app you want to build...",
                         scale=4,
                         container=False,
                     )
-                    send_btn = gr.Button("Send", scale=1, variant="primary")
+                    send_btn = gr.Button("Build App", scale=1, variant="primary")
 
             # Right side - Preview/Code Toggle
             with gr.Column(scale=4, elem_classes="preview-container"):
@@ -225,12 +302,12 @@ def create_lovable_ui():
                         )
                         code_editor = gr.Code(
                             scale=3,
-                            value=load_file("sandbox/app.py"),
+                            value=load_file("sandbox/gradio_app/app.py")
+                            if os.path.exists("sandbox/gradio_app/app.py")
+                            else "# No app created yet - use the chat to create one!",
                             language="python",
                             visible=True,
                             interactive=True,
-                            # lines=27,
-                            # max_lines=27,
                             autocomplete=True,
                         )
 
@@ -248,15 +325,16 @@ def create_lovable_ui():
             outputs=[refresh_trigger],
         )
 
-        # Event handlers for chat
+        # Event handlers for chat - updated to use the combined planning and
+        # coding function
         msg_input.submit(
-            ai_response_with_planning,
+            ai_response_with_planning_and_coding,
             inputs=[msg_input, chatbot],
             outputs=[chatbot, msg_input],
         )
 
         send_btn.click(
-            ai_response_with_planning,
+            ai_response_with_planning_and_coding,
             inputs=[msg_input, chatbot],
             outputs=[chatbot, msg_input],
         )
@@ -265,6 +343,6 @@ def create_lovable_ui():
 
 
 if __name__ == "__main__":
-    demo = create_lovable_ui()
+    demo = create_likable_ui()
     gradio_config = settings.get_gradio_config()
     demo.launch(**gradio_config)

coding_agent.py

@@ -0,0 +1,394 @@
+"""
+Smolagents CodeAgent for implementing Gradio applications.
+
+This module provides a specialized coding agent that can:
+- Take a planning result from the planning agent
+- Set up a proper Python Gradio project structure in the sandbox folder
+- Use uv for package management
+- Implement the full plan with proper error handling and iterative development
+- Only exit when the full plan is implemented
+"""
+
+import os
+import shutil
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+
+from mcp import StdioServerParameters
+from smolagents import LiteLLMModel, MCPClient, ToolCallingAgent
+
+from planning_agent import PlanningResult
+from settings import settings
+from utils import load_file
+
+
+@dataclass
+class CodingResult:
+    """Result of the coding agent containing implementation details."""
+
+    success: bool
+    project_path: str
+    implemented_features: list[str]
+    remaining_tasks: list[str]
+    error_messages: list[str]
+    final_app_code: str
+
+
+class GradioCodingAgent:
+    """
+    A specialized CodeAgent for implementing Gradio applications.
+
+    This agent takes planning results and creates complete, working
+    Gradio applications with proper project structure and dependencies.
+    """
+
+    def __init__(
+        self,
+        model_id: str | None = None,
+        api_base_url: str | None = None,
+        api_key: str | None = None,
+        verbosity_level: int | None = None,
+        max_steps: int | None = None,
+    ):
+        """
+        Initialize the Gradio Coding Agent.
+
+        Args:
+            model_id: Model ID to use for coding (uses settings if None)
+            api_base_url: API base URL (uses settings if None)
+            api_key: API key (uses settings if None)
+            verbosity_level: Level of verbosity for agent output (uses settings if None)
+            max_steps: Maximum number of coding steps (uses settings if None)
+        """
+        # Use settings as defaults, but allow override
+        self.model_id = model_id or settings.code_model_id
+        self.api_base_url = api_base_url or settings.api_base_url
+        self.api_key = api_key or settings.api_key
+        verbosity_level = verbosity_level or settings.coding_verbosity
+        max_steps = max_steps or settings.max_coding_steps
+
+        # Initialize the language model for the CodeAgent
+        self.model = LiteLLMModel(
+            model_id=self.model_id,
+            api_base=self.api_base_url,
+            api_key=self.api_key,
+        )
+
+        server_parameters = StdioServerParameters(
+            command="npx",
+            args=[
+                "-y",
+                "@modelcontextprotocol/server-filesystem",
+                "sandbox",
+            ],
+        )
+
+        self.mcp_client = MCPClient(server_parameters)
+
+        tool_collection = self.mcp_client.get_tools()
+
+        # Initialize the CodeAgent with tools for file operations and project setup
+        self.agent = ToolCallingAgent(
+            model=self.model,
+            tools=tool_collection,
+            verbosity_level=verbosity_level,
+            max_steps=max_steps,
+        )
+
+        self.sandbox_path = Path("sandbox")
+
+        # Store the original working directory for cleanup
+        self.original_cwd = os.getcwd()
+
+    def __del__(self):
+        """
+        Cleanup method called when the instance is about to be destroyed.
+
+        This method ensures:
+        - Working directory is restored to original location
+        - Any open resources are properly closed
+        - Temporary files are cleaned up if needed
+        """
+        try:
+            # Restore original working directory
+            if hasattr(self, "original_cwd") and os.path.exists(self.original_cwd):
+                os.chdir(self.original_cwd)
+
+            if hasattr(self, "mcp_client") and self.mcp_client:
+                self.mcp_client.disconnect()
+
+        except Exception:
+            pass
+
+    def setup_project_structure(self, project_name: str = "gradio_app") -> bool:
+        """
+        Set up the initial project structure using uv.
+
+        Args:
+            project_name: Name of the project
+
+        Returns:
+            bool: True if setup was successful
+        """
+        try:
+            # Ensure sandbox directory exists and is clean
+            if self.sandbox_path.exists():
+                shutil.rmtree(self.sandbox_path)
+            self.sandbox_path.mkdir(exist_ok=True)
+
+            # Change to sandbox directory
+            os.chdir(self.sandbox_path)
+
+            # Initialize with uv
+            subprocess.run(
+                ["uv", "init", project_name],
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+
+            # Change to project directory
+            os.chdir(project_name)
+
+            # Add gradio as a dependency
+            subprocess.run(
+                ["uv", "add", "gradio"],
+                capture_output=True,
+                text=True,
+                check=True,
+            )
+
+            # Change back to workspace root
+            os.chdir("../..")
+
+            return True
+
+        except subprocess.CalledProcessError as e:
+            print(f"Error setting up project structure: {e}")
+            print(f"stdout: {e.stdout}")
+            print(f"stderr: {e.stderr}")
+            return False
+        except Exception as e:
+            print(f"Unexpected error setting up project: {e}")
+            return False
+
+    def implement_application(self, planning_result: PlanningResult) -> CodingResult:
+        """
+        Implement the full Gradio application based on the planning result.
+
+        Args:
+            planning_result: The planning result from the planning agent
+
+        Returns:
+            CodingResult containing implementation details
+        """
+        # Set up project structure
+        project_name = "gradio_app"
+        if not self.setup_project_structure(project_name):
+            return CodingResult(
+                success=False,
+                project_path="",
+                implemented_features=[],
+                remaining_tasks=["Failed to set up project structure"],
+                error_messages=["Could not initialize uv project"],
+                final_app_code="",
+            )
+
+        project_path = str(self.sandbox_path / project_name)
+
+        # Create comprehensive prompt for implementation
+        gradio_components = chr(10).join(
+            [f"- {comp}" for comp in planning_result.gradio_components]
+        )
+        dependencies = chr(10).join(
+            [f"- {dep}" for dep in planning_result.dependencies if dep != "gradio"]
+        )
+
+        # Create the user prompt for the specific implementation
+        user_prompt = f"""You are an expert Python developer and Gradio \
+application architect.
+
+Your task is to implement a complete, working Gradio application based on \
+the provided plan.
+
+PROJECT SETUP:
+- You are working in the directory: {project_path}
+- The project has been initialized with `uv` and `gradio` is already installed
+- Use proper Python project structure with a main app.py file
+- Add any additional dependencies needed using `uv add package_name`
+
+IMPLEMENTATION REQUIREMENTS:
+1. Create a complete, functional Gradio application in app.py
+2. Follow the provided action plan and implementation plan exactly
+3. Implement ALL gradio components mentioned in the plan
+4. Add proper error handling and user feedback
+5. Create a comprehensive README.md with usage instructions
+6. Add all required dependencies to the project using `uv add`
+7. Make sure the app can be run with `uv run python app.py`
+8. Test the implementation and fix any issues
+
+QUALITY STANDARDS:
+- Write clean, well-documented code
+- Use proper type hints where appropriate
+- Follow Python best practices
+- Add docstrings to functions and classes
+- Handle edge cases and errors gracefully
+- Make the UI intuitive and user-friendly
+- When using multiline strings within multiline strings, properly escape them \
+using triple quotes
+  Example: Instead of using f\"\"\"...\"\"\", use f'''...''' or escape inner quotes \
+like f\"\"\"...\\\"\\\"\\\"...\\\"\\\"\\\"...\"\"\"
+
+GRADIO COMPONENTS TO IMPLEMENT:
+{gradio_components}
+
+DEPENDENCIES TO ADD:
+{dependencies}
+
+ACTION PLAN TO FOLLOW:
+{planning_result.action_plan}
+
+IMPLEMENTATION PLAN TO FOLLOW:
+{planning_result.implementation_plan}
+
+TESTING PLAN TO CONSIDER:
+{planning_result.testing_plan}
+
+You must implement the complete application and ensure it works properly.
+Use subprocess to run `uv add` commands to install any needed packages.
+Create all necessary files and make sure the application runs without errors.
+
+Please implement the complete Gradio application based on the planning result.
+
+The application should be fully functional and implement all the features
+described in the plans.
+
+Working directory: {project_path}
+
+Please:
+1. Start by creating/updating the README.md file with project description
+   and usage instructions
+2. Add any additional dependencies needed using `uv add package_name`
+3. Create the complete app.py file with all the Gradio components and
+   functionality
+4. Test the implementation to ensure it works
+5. Fix any issues that arise during testing
+
+Make sure the final application is complete and functional.
+/no_think
+"""
+
+        try:
+            # Run the coding agent to implement the application
+            self.agent.run(
+                user_prompt,
+                additional_args={
+                    "current_app_py": load_file(str(Path(project_path) / "app.py")),
+                },
+            )
+
+            # Check if the implementation was successful
+            app_file = Path(project_path) / "app.py"
+            if app_file.exists():
+                with open(app_file, encoding="utf-8") as f:
+                    final_app_code = f.read()
+
+                return CodingResult(
+                    success=True,
+                    project_path=project_path,
+                    implemented_features=planning_result.gradio_components,
+                    remaining_tasks=[],
+                    error_messages=[],
+                    final_app_code=final_app_code,
+                )
+            else:
+                return CodingResult(
+                    success=False,
+                    project_path=project_path,
+                    implemented_features=[],
+                    remaining_tasks=["Main app.py file was not created"],
+                    error_messages=["Implementation failed to create app.py"],
+                    final_app_code="",
+                )
+
+        except Exception as e:
+            return CodingResult(
+                success=False,
+                project_path=project_path,
+                implemented_features=[],
+                remaining_tasks=["Complete implementation"],
+                error_messages=[f"Coding agent error: {str(e)}"],
+                final_app_code="",
+            )
+
+    def iterative_implementation(
+        self, planning_result: PlanningResult, max_iterations: int = 3
+    ) -> CodingResult:
+        """
+        Implement the application with iterative refinement.
+
+        Args:
+            planning_result: The planning result from the planning agent
+            max_iterations: Maximum number of implementation iterations
+
+        Returns:
+            CodingResult containing final implementation details
+        """
+        last_result = None
+
+        for iteration in range(max_iterations):
+            print(f"🔄 Implementation iteration {iteration + 1}/{max_iterations}")
+
+            # Implement or refine the application
+            result = self.implement_application(planning_result)
+
+            if result.success and not result.remaining_tasks:
+                print(f"✅ Implementation successful in {iteration + 1} iteration(s)")
+                return result
+
+            last_result = result
+
+            if iteration < max_iterations - 1:
+                print(f"⚠️ Iteration {iteration + 1} incomplete. Refining...")
+                # For subsequent iterations, we could modify the prompt to focus
+                # on remaining tasks. This is a simplified version - in practice,
+                # you'd want more sophisticated iteration logic
+
+        print(f"⚠️ Implementation completed with {max_iterations} iterations")
+        return last_result or CodingResult(
+            success=False,
+            project_path="",
+            implemented_features=[],
+            remaining_tasks=["Complete implementation failed"],
+            error_messages=["Maximum iterations reached without completion"],
+            final_app_code="",
+        )
+
+
+# Convenience function for the main app
+def create_gradio_coding_agent() -> GradioCodingAgent:
+    """Create a GradioCodingAgent with default settings."""
+    return GradioCodingAgent()
+
+
+if __name__ == "__main__":
+    # Example usage
+    from planning_agent import GradioPlanningAgent
+
+    # Test with a simple planning result
+    planning_agent = GradioPlanningAgent()
+    planning_result = planning_agent.plan_application(
+        "Create a simple text-to-text translator app"
+    )
+
+    # Create coding agent and implement
+    coding_agent = create_gradio_coding_agent()
+    coding_result = coding_agent.iterative_implementation(planning_result)
+
+    print("Coding Result:")
+    print(f"Success: {coding_result.success}")
+    print(f"Project Path: {coding_result.project_path}")
+    print(f"Implemented Features: {coding_result.implemented_features}")
+    print(f"Remaining Tasks: {coding_result.remaining_tasks}")
+    print(f"Error Messages: {coding_result.error_messages}")

pyproject.toml

@@ -5,8 +5,12 @@ description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.12"
 dependencies = [
+    "duckduckgo-search>=8.0.2",
     "gradio>=5.32.0",
-    "smolagents[litellm]>=1.17.0",
+    "mcp>=1.9.2",
+    "smolagents[litellm,mcp]>=1.17.0",
+    "selenium>=4.25.0",
+    "requests>=2.32.0",
 ]
 
 [dependency-groups]
@@ -36,3 +40,10 @@ quote-style = "double"
 indent-style = "space"
 skip-magic-trailing-comma = false
 line-ending = "auto"
+
+[tool.uv.workspace]
+members = [
+    "sandbox/gradio_app",
+    "sandbox/sandbox/gradio_app",
+    "test_sandbox/test_project",
+]

sandbox/app.py

@@ -1,69 +0,0 @@
-import gradio as gr
-
-# Global list to store tasks
-tasks = []
-
-
-def add_task(task_text):
-    """Add a new task to the list"""
-    if task_text.strip():
-        tasks.append({"text": task_text.strip(), "completed": False})
-    return update_task_display(), ""
-
-
-def toggle_task(task_index):
-    """Toggle completion status of a task"""
-    if 0 <= task_index < len(tasks):
-        tasks[task_index]["completed"] = not tasks[task_index]["completed"]
-    return update_task_display()
-
-
-def delete_task(task_index):
-    """Delete a task from the list"""
-    if 0 <= task_index < len(tasks):
-        tasks.pop(task_index)
-    return update_task_display()
-
-
-def update_task_display():
-    """Update the task display"""
-    if not tasks:
-        return "No tasks yet!"
-
-    display_text = ""
-    for i, task in enumerate(tasks):
-        status = "✓" if task["completed"] else "○"
-        display_text += f"{i}: {status} {task['text']}\n"
-    return display_text
-
-
-# Create Gradio interface
-with gr.Blocks(title="Simple To-Do List", theme=gr.themes.Monochrome()) as app:
-    gr.Markdown("# Simple To-Do List")
-
-    with gr.Row():
-        task_input = gr.Textbox(
-            placeholder="Enter a new task...", label="New Task", scale=3
-        )
-        add_btn = gr.Button("Add Task", scale=1)
-
-    task_display = gr.Textbox(
-        value="No tasks yet!", label="Tasks", lines=10, interactive=False
-    )
-
-    with gr.Row():
-        task_index = gr.Number(label="Task Number", value=0, precision=0)
-        toggle_btn = gr.Button("Toggle Complete")
-        delete_btn = gr.Button("Delete Task")
-
-    # Event handlers
-    add_btn.click(add_task, inputs=[task_input], outputs=[task_display, task_input])
-
-    task_input.submit(add_task, inputs=[task_input], outputs=[task_display, task_input])
-
-    toggle_btn.click(toggle_task, inputs=[task_index], outputs=[task_display])
-
-    delete_btn.click(delete_task, inputs=[task_index], outputs=[task_display])
-
-if __name__ == "__main__":
-    app.launch()

settings.py

@@ -23,6 +23,16 @@ class Settings:
         self.api_base_url: str | None = os.getenv("API_BASE_URL")
         self.api_key: str | None = os.getenv("API_KEY")
 
+        # Coding Agent Settings
+        self.code_model_id: str = os.getenv("CODE_MODEL_ID", self.model_id)
+        self.coding_verbosity: int = int(os.getenv("CODING_VERBOSITY", "2"))
+        self.max_coding_steps: int = int(os.getenv("MAX_CODING_STEPS", "20"))
+
+        # Testing Agent Settings
+        self.test_model_id: str = os.getenv("TEST_MODEL_ID", self.model_id)
+        self.testing_verbosity: int = int(os.getenv("TESTING_VERBOSITY", "2"))
+        self.max_testing_steps: int = int(os.getenv("MAX_TESTING_STEPS", "15"))
+
         # Application Settings
         self.gradio_host: str = os.getenv("GRADIO_HOST", "127.0.0.1")
         self.gradio_port: int = int(os.getenv("GRADIO_PORT", "7860"))
@@ -40,7 +50,10 @@ class Settings:
 
         if not self.api_key:
             print("⚠️  Warning: API_KEY not set in environment variables.")
-            print("   The planning agent may not work without a valid API key.")
+            print(
+                "   The planning and coding agents may not work \
+without a valid API key."
+            )
             print("   Set it in your .env file or as an environment variable.")
             print()
 
@@ -52,6 +65,22 @@ in valid range [0, 1, 2]"
             print("   Using default value of 1")
             self.planning_verbosity = 1
 
+        if self.coding_verbosity not in [0, 1, 2]:
+            print(
+                f"⚠️  Warning: CODING_VERBOSITY={self.coding_verbosity} is not \
+in valid range [0, 1, 2]"
+            )
+            print("   Using default value of 2")
+            self.coding_verbosity = 2
+
+        if self.testing_verbosity not in [0, 1, 2]:
+            print(
+                f"⚠️  Warning: TESTING_VERBOSITY={self.testing_verbosity} is not \
+in valid range [0, 1, 2]"
+            )
+            print("   Using default value of 2")
+            self.testing_verbosity = 2
+
     def get_model_config(self) -> dict:
         """Get model configuration for the planning agent."""
         config = {"model_id": self.model_id, "api_key": self.api_key}
@@ -63,6 +92,17 @@ in valid range [0, 1, 2]"
 
         return config
 
+    def get_code_model_config(self) -> dict:
+        """Get model configuration for the coding agent."""
+        config = {"model_id": self.code_model_id, "api_key": self.api_key}
+
+        if self.api_base_url:
+            config["api_base_url"] = self.api_base_url
+        if self.api_key:
+            config["api_key"] = self.api_key
+
+        return config
+
     def get_gradio_config(self) -> dict:
         """Get Gradio launch configuration."""
         return {
@@ -78,17 +118,48 @@ in valid range [0, 1, 2]"
             "max_steps": self.max_planning_steps,
         }
 
+    def get_coding_config(self) -> dict:
+        """Get coding agent configuration."""
+        return {
+            "verbosity_level": self.coding_verbosity,
+            "max_steps": self.max_coding_steps,
+        }
+
+    def get_test_model_config(self) -> dict:
+        """Get model configuration for the testing agent."""
+        config = {"model_id": self.test_model_id, "api_key": self.api_key}
+
+        if self.api_base_url:
+            config["api_base_url"] = self.api_base_url
+        if self.api_key:
+            config["api_key"] = self.api_key
+
+        return config
+
+    def get_testing_config(self) -> dict:
+        """Get testing agent configuration."""
+        return {
+            "verbosity_level": self.testing_verbosity,
+            "max_steps": self.max_testing_steps,
+        }
+
     def __repr__(self) -> str:
         """String representation of settings (excluding sensitive data)."""
         return f"""Settings(
     model_id='{self.model_id}',
+    code_model_id='{self.code_model_id}',
+    test_model_id='{self.test_model_id}',
     api_key={'***' if self.api_key else 'None'},
     api_base_url='{self.api_base_url}',
     gradio_host='{self.gradio_host}',
     gradio_port={self.gradio_port},
     gradio_debug={self.gradio_debug},
     planning_verbosity={self.planning_verbosity},
-    max_planning_steps={self.max_planning_steps}
+    max_planning_steps={self.max_planning_steps},
+    coding_verbosity={self.coding_verbosity},
+    max_coding_steps={self.max_coding_steps},
+    testing_verbosity={self.testing_verbosity},
+    max_testing_steps={self.max_testing_steps}
 )"""
 
 
@@ -115,8 +186,17 @@ if __name__ == "__main__":
     print("Model Config:")
     print(settings.get_model_config())
     print()
+    print("Code Model Config:")
+    print(settings.get_code_model_config())
+    print()
     print("Gradio Config:")
     print(settings.get_gradio_config())
     print()
     print("Planning Config:")
     print(settings.get_planning_config())
+    print()
+    print("Coding Config:")
+    print(settings.get_coding_config())
+    print()
+    print("Testing Config:")
+    print(settings.get_testing_config())

test_coding_agent.py

@@ -0,0 +1,123 @@
+"""
+Test module for the Gradio Coding Agent.
+
+This module provides tests to verify that the coding agent can:
+- Set up proper project structure with uv
+- Integrate with the planning agent
+- Create functional Gradio applications
+"""
+
+import os
+import shutil
+from pathlib import Path
+
+from coding_agent import GradioCodingAgent
+from planning_agent import PlanningResult
+
+
+def test_setup_project_structure():
+    """Test that the project structure setup works correctly."""
+    agent = GradioCodingAgent()
+
+    # Clean up any existing test directory
+    test_sandbox = Path("test_sandbox")
+    if test_sandbox.exists():
+        shutil.rmtree(test_sandbox)
+
+    # Temporarily change the sandbox path for testing
+    original_sandbox = agent.sandbox_path
+    agent.sandbox_path = test_sandbox
+
+    try:
+        # Test project setup
+        success = agent.setup_project_structure("test_project")
+
+        # Verify the structure was created
+        project_path = test_sandbox / "test_project"
+        assert project_path.exists(), "Project directory should exist"
+        assert (project_path / "pyproject.toml").exists(), "pyproject.toml should exist"
+        assert (project_path / "README.md").exists(), "README.md should exist"
+
+        print("✅ Project structure setup test passed")
+        return success
+
+    finally:
+        # Restore original sandbox path
+        agent.sandbox_path = original_sandbox
+
+        # Clean up test directory
+        if test_sandbox.exists():
+            shutil.rmtree(test_sandbox)
+
+
+def test_mock_implementation():
+    """Test implementation with a mock planning result."""
+
+    # Create a simple mock planning result
+    mock_planning = PlanningResult(
+        action_plan="Create a simple text input and output application",
+        implementation_plan="Use gr.Textbox for input and output",
+        testing_plan="Test with sample text input",
+        gradio_components=["gr.Textbox", "gr.Button"],
+        estimated_complexity="Simple",
+        dependencies=["gradio"],
+    )
+
+    agent = GradioCodingAgent()
+
+    # Note: This test requires API access and will only work with valid credentials
+    try:
+        print("🧪 Testing mock implementation (requires API access)...")
+        result = agent.implement_application(mock_planning)
+
+        print(f"Implementation result: Success={result.success}")
+        print(f"Project path: {result.project_path}")
+        print(f"Error messages: {result.error_messages}")
+
+        return result
+
+    except Exception as e:
+        print(f"⚠️ Mock implementation test failed (expected without API): {e}")
+        return None
+
+
+def test_agent_initialization():
+    """Test that the coding agent initializes correctly."""
+    try:
+        agent = GradioCodingAgent()
+        assert agent is not None, "Agent should initialize"
+        assert agent.model is not None, "Model should be initialized"
+        assert agent.agent is not None, "CodeAgent should be initialized"
+
+        print("✅ Agent initialization test passed")
+        return True
+
+    except Exception as e:
+        print(f"❌ Agent initialization test failed: {e}")
+        return False
+
+
+def main():
+    """Run all tests."""
+    print("🚀 Running Coding Agent Tests")
+    print("=" * 50)
+
+    # Test 1: Agent initialization
+    test_agent_initialization()
+    print()
+
+    # Test 2: Project structure setup
+    test_setup_project_structure()
+    print()
+
+    # Test 3: Mock implementation (optional, requires API)
+    if os.getenv("API_KEY"):
+        test_mock_implementation()
+    else:
+        print("⚠️ Skipping implementation test (no API_KEY set)")
+
+    print("\n✅ All available tests completed!")
+
+
+if __name__ == "__main__":
+    main()

test_testing_agent.py

@@ -0,0 +1,284 @@
+"""
+Test cases for the Gradio Testing Agent.
+
+This module contains unit tests and integration tests for the testing agent
+functionality, including tool validation and agent behavior testing.
+"""
+
+import os
+import tempfile
+import unittest
+from pathlib import Path
+from unittest.mock import Mock, patch
+
+from coding_agent import CodingResult
+from testing_agent import (
+    GradioTestingAgent,
+    TestingResult,
+    check_app_health,
+    create_gradio_testing_agent,
+    run_gradio_app,
+    setup_venv_with_uv,
+    stop_gradio_processes,
+    test_gradio_ui_basic,
+)
+
+
+class TestTestingAgentTools(unittest.TestCase):
+    """Test the individual tools used by the testing agent."""
+
+    def setUp(self):
+        """Set up test fixtures."""
+        self.temp_dir = tempfile.mkdtemp()
+        self.project_path = str(Path(self.temp_dir) / "test_project")
+        os.makedirs(self.project_path, exist_ok=True)
+
+    def tearDown(self):
+        """Clean up test fixtures."""
+        import shutil
+
+        shutil.rmtree(self.temp_dir, ignore_errors=True)
+
+    def test_setup_venv_with_uv_missing_directory(self):
+        """Test setup_venv_with_uv with non-existent directory."""
+        result = setup_venv_with_uv("/non/existent/path")
+        self.assertIn("Error: Project directory", result)
+        self.assertIn("does not exist", result)
+
+    @patch("subprocess.run")
+    def test_setup_venv_with_uv_success(self, mock_run):
+        """Test successful virtual environment setup."""
+        mock_run.return_value = Mock(returncode=0)
+
+        result = setup_venv_with_uv(self.project_path)
+
+        self.assertIn("Successfully set up virtual environment", result)
+        mock_run.assert_called_once()
+
+    @patch("subprocess.run")
+    def test_setup_venv_with_uv_failure(self, mock_run):
+        """Test failed virtual environment setup."""
+        mock_run.return_value = Mock(returncode=1, stderr="uv error")
+
+        result = setup_venv_with_uv(self.project_path)
+
+        self.assertIn("Error setting up venv", result)
+        self.assertIn("uv error", result)
+
+    def test_run_gradio_app_missing_file(self):
+        """Test run_gradio_app with missing app.py file."""
+        result = run_gradio_app(self.project_path)
+        self.assertIn("Error: app.py not found", result)
+
+    @patch("subprocess.Popen")
+    def test_run_gradio_app_success(self, mock_popen):
+        """Test successful Gradio app launch."""
+        # Create app.py file
+        app_file = Path(self.project_path) / "app.py"
+        app_file.write_text("import gradio as gr\nprint('test')")
+
+        # Mock the process
+        mock_process = Mock()
+        mock_process.poll.return_value = None  # Process is running
+        mock_process.pid = 12345
+        mock_popen.return_value = mock_process
+
+        result = run_gradio_app(self.project_path, timeout=1)
+
+        self.assertIn("Successfully started Gradio app", result)
+        mock_popen.assert_called_once()
+
+    @patch("requests.get")
+    def test_check_app_health_success(self, mock_get):
+        """Test successful health check."""
+        mock_response = Mock()
+        mock_response.status_code = 200
+        mock_response.elapsed.total_seconds.return_value = 0.5
+        mock_get.return_value = mock_response
+
+        result = check_app_health()
+
+        self.assertIn("Application is healthy", result)
+        self.assertIn("0.50s", result)
+
+    @patch("requests.get")
+    def test_check_app_health_connection_error(self, mock_get):
+        """Test health check with connection error."""
+        mock_get.side_effect = Exception("Connection failed")
+
+        result = check_app_health()
+
+        self.assertIn("Error checking application health", result)
+
+    def test_test_gradio_ui_basic_selenium_not_installed(self):
+        """Test UI testing when Selenium is not available."""
+        with patch(
+            "builtins.__import__", side_effect=ImportError("No module named 'selenium'")
+        ):
+            result = test_gradio_ui_basic()
+            self.assertIn("Error: Selenium not installed", result)
+
+    @patch("subprocess.run")
+    def test_stop_gradio_processes(self, mock_run):
+        """Test stopping Gradio processes."""
+        # Mock subprocess calls
+        mock_run.side_effect = [
+            Mock(returncode=0),  # pkill successful
+            Mock(stdout="12345\n67890", returncode=0),  # lsof
+            Mock(returncode=0),  # kill first process
+            Mock(returncode=0),  # kill second process
+        ]
+
+        result = stop_gradio_processes()
+
+        self.assertIn("Stopped Gradio processes by name", result)
+        self.assertIn("Killed process 12345", result)
+        self.assertIn("Killed process 67890", result)
+
+
+class TestGradioTestingAgent(unittest.TestCase):
+    """Test the main GradioTestingAgent class."""
+
+    @patch("testing_agent.settings")
+    def setUp(self, mock_settings):
+        """Set up test fixtures."""
+        mock_settings.test_model_id = "test-model"
+        mock_settings.api_base_url = "http://test.api"
+        mock_settings.api_key = "test-key"
+        mock_settings.testing_verbosity = 1
+        mock_settings.max_testing_steps = 10
+
+    @patch("testing_agent.LiteLLMModel")
+    @patch("testing_agent.ToolCallingAgent")
+    def test_agent_initialization(self, mock_agent, mock_model):
+        """Test agent initialization with default settings."""
+        agent = GradioTestingAgent()
+
+        self.assertIsInstance(agent, GradioTestingAgent)
+        mock_model.assert_called_once()
+        mock_agent.assert_called_once()
+
+    def test_test_application_with_failed_coding_result(self):
+        """Test testing application when coding agent failed."""
+        agent = GradioTestingAgent()
+        failed_coding_result = CodingResult(
+            success=False,
+            project_path="/test/path",
+            implemented_features=[],
+            remaining_tasks=["Setup failed"],
+            error_messages=["Setup error"],
+            final_app_code="",
+        )
+
+        result = agent.test_application(failed_coding_result)
+
+        self.assertFalse(result.success)
+        self.assertEqual(result.project_path, "/test/path")
+        self.assertIn(
+            "Coding agent failed to create application", result.test_cases_failed
+        )
+
+    @patch("testing_agent.ToolCallingAgent")
+    def test_test_application_agent_error(self, mock_agent_class):
+        """Test testing application when agent execution fails."""
+        mock_agent = Mock()
+        mock_agent.run.side_effect = Exception("Agent error")
+        mock_agent_class.return_value = mock_agent
+
+        agent = GradioTestingAgent()
+        successful_coding_result = CodingResult(
+            success=True,
+            project_path="/test/path",
+            implemented_features=["Basic UI"],
+            remaining_tasks=[],
+            error_messages=[],
+            final_app_code="import gradio as gr",
+        )
+
+        result = agent.test_application(successful_coding_result)
+
+        self.assertFalse(result.success)
+        self.assertIn("Testing agent execution failed", result.test_cases_failed)
+
+    def test_parse_testing_response_success(self):
+        """Test parsing a successful testing response."""
+        agent = GradioTestingAgent()
+        response = """
+        Successfully set up virtual environment for /test/path
+        Successfully started Gradio app: Server running
+        Application is healthy. Status: 200, Response time: 0.25s
+        ✓ Page loaded successfully; ✓ Gradio container found
+        Screenshot saved to /tmp/test.png
+        """
+
+        result = agent._parse_testing_response(response, "/test/path")
+
+        self.assertTrue(result.success)
+        self.assertTrue(result.setup_successful)
+        self.assertTrue(result.server_launched)
+        self.assertTrue(result.ui_accessible)
+        self.assertIn("Virtual environment setup", result.test_cases_passed)
+        self.assertIn("UI component testing", result.test_cases_passed)
+        self.assertEqual(result.performance_metrics["response_time_seconds"], 0.25)
+
+    def test_parse_testing_response_failure(self):
+        """Test parsing a failed testing response."""
+        agent = GradioTestingAgent()
+        response = """
+        Error setting up venv: Command failed
+        Error running gradio app: File not found
+        Cannot connect to http://127.0.0.1:7860
+        Error during UI testing: Browser error
+        """
+
+        result = agent._parse_testing_response(response, "/test/path")
+
+        self.assertFalse(result.success)
+        self.assertFalse(result.setup_successful)
+        self.assertFalse(result.server_launched)
+        self.assertFalse(result.ui_accessible)
+
+    def test_generate_test_report(self):
+        """Test generating a test report."""
+        agent = GradioTestingAgent()
+        test_result = TestingResult(
+            success=True,
+            project_path="/test/path",
+            setup_successful=True,
+            server_launched=True,
+            ui_accessible=True,
+            test_cases_passed=["Setup", "Launch", "UI"],
+            test_cases_failed=[],
+            error_messages=[],
+            screenshots=["/tmp/test.png"],
+            performance_metrics={"response_time": 0.5},
+            logs="Test completed successfully",
+        )
+
+        report = agent.generate_test_report(test_result)
+
+        self.assertIn("# Gradio Application Test Report ✅", report)
+        self.assertIn("**Project Path**: `/test/path`", report)
+        self.assertIn("✅ Setup", report)
+        self.assertIn("✅ Launch", report)
+        self.assertIn("✅ UI", report)
+        self.assertIn("/tmp/test.png", report)
+
+
+class TestTestingAgentFactory(unittest.TestCase):
+    """Test the factory function for creating testing agents."""
+
+    @patch("testing_agent.GradioTestingAgent")
+    def test_create_gradio_testing_agent(self, mock_agent_class):
+        """Test creating a testing agent with factory function."""
+        mock_agent = Mock()
+        mock_agent_class.return_value = mock_agent
+
+        agent = create_gradio_testing_agent()
+
+        self.assertEqual(agent, mock_agent)
+        mock_agent_class.assert_called_once_with()
+
+
+if __name__ == "__main__":
+    unittest.main()

testing_agent.py

@@ -0,0 +1,615 @@
+"""
+Smolagents ToolCallingAgent for testing Gradio applications.
+
+This module provides a specialized testing agent that can:
+- Set up virtual environments using uv
+- Run Gradio applications in the sandbox folder
+- Perform basic UI testing using browser automation
+- Validate that the application is functional and responsive
+- Generate test reports with screenshots and logs
+"""
+
+import os
+import subprocess
+import time
+from dataclasses import dataclass
+from pathlib import Path
+
+from smolagents import LiteLLMModel, ToolCallingAgent, tool
+
+from coding_agent import CodingResult
+from settings import settings
+
+
+@dataclass
+class TestingResult:
+    """Result of the testing agent containing validation details."""
+
+    success: bool
+    project_path: str
+    setup_successful: bool
+    server_launched: bool
+    ui_accessible: bool
+    test_cases_passed: list[str]
+    test_cases_failed: list[str]
+    error_messages: list[str]
+    screenshots: list[str]
+    performance_metrics: dict[str, float]
+    logs: str
+
+
+@tool
+def setup_venv_with_uv(project_path: str) -> str:
+    """
+    Set up a virtual environment using uv for the Gradio project.
+
+    Args:
+        project_path: Path to the Gradio project directory
+
+    Returns:
+        Status message indicating success or failure
+    """
+    try:
+        # Change to project directory
+        original_cwd = os.getcwd()
+        project_dir = Path(project_path)
+
+        if not project_dir.exists():
+            return f"Error: Project directory {project_path} does not exist"
+
+        os.chdir(project_dir)
+
+        # Install dependencies using uv
+        result = subprocess.run(
+            ["uv", "sync"],
+            capture_output=True,
+            text=True,
+            timeout=300,  # 5 minutes timeout
+        )
+
+        os.chdir(original_cwd)
+
+        if result.returncode == 0:
+            return f"Successfully set up virtual environment for {project_path}"
+        else:
+            return f"Error setting up venv: {result.stderr}"
+
+    except subprocess.TimeoutExpired:
+        os.chdir(original_cwd)
+        return "Error: uv sync timed out after 5 minutes"
+    except FileNotFoundError:
+        os.chdir(original_cwd)
+        return "Error: uv command not found. Please install uv first."
+    except Exception as e:
+        os.chdir(original_cwd)
+        return f"Unexpected error: {str(e)}"
+
+
+@tool
+def run_gradio_app(project_path: str, timeout: int = 30) -> str:
+    """
+    Run the Gradio application and check if it starts successfully.
+
+    Args:
+        project_path: Path to the Gradio project directory
+        timeout: Maximum time to wait for the app to start (in seconds)
+
+    Returns:
+        Status message with server information or error details
+    """
+    try:
+        project_dir = Path(project_path)
+        app_file = project_dir / "app.py"
+
+        if not app_file.exists():
+            return f"Error: app.py not found in {project_path}"
+
+        # Start the Gradio app in background
+        process = subprocess.Popen(
+            ["uv", "run", "python", "app.py"],
+            cwd=project_dir,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+        )
+
+        # Wait for the server to start (look for "Running on" in output)
+        start_time = time.time()
+        server_info = ""
+
+        while time.time() - start_time < timeout:
+            if process.poll() is not None:
+                # Process has terminated
+                stdout, stderr = process.communicate()
+                return (
+                    f"Error: App terminated early. STDOUT: {stdout}, STDERR: {stderr}"
+                )
+
+            time.sleep(1)
+
+            # Try to read some output to see if server started
+            try:
+                # Non-blocking read attempt
+                import select
+
+                if select.select([process.stdout], [], [], 0.1)[0]:
+                    line = process.stdout.readline()
+                    if line and "Running on" in line:
+                        server_info = line.strip()
+                        break
+            except Exception as e:
+                print(f"Error: {e}")
+                time.sleep(2)
+                break
+
+        if not server_info:
+            server_info = (
+                f"Server started (PID: {process.pid}), accessible at "
+                "http://127.0.0.1:7860"
+            )
+
+        return f"Successfully started Gradio app: {server_info}"
+
+    except Exception as e:
+        return f"Error running Gradio app: {str(e)}"
+
+
+@tool
+def check_app_health(url: str = "http://127.0.0.1:7860") -> str:
+    """
+    Check if the Gradio application is responding to HTTP requests.
+
+    Args:
+        url: URL of the Gradio application
+
+    Returns:
+        Health check status message
+    """
+    try:
+        import requests
+
+        response = requests.get(url, timeout=10)
+
+        if response.status_code == 200:
+            return (
+                f"Application is healthy. Status: {response.status_code}, "
+                f"Response time: {response.elapsed.total_seconds():.2f}s"
+            )
+        else:
+            return f"Application returned status {response.status_code}"
+
+    except requests.exceptions.ConnectionError:
+        return f"Error: Cannot connect to {url}. Application may not be running."
+    except requests.exceptions.Timeout:
+        return f"Error: Request to {url} timed out."
+    except Exception as e:
+        return f"Error checking application health: {str(e)}"
+
+
+@tool
+def test_gradio_ui_basic(url: str = "http://127.0.0.1:7860") -> str:
+    """
+    Perform basic UI testing of the Gradio application.
+
+    Args:
+        url: URL of the Gradio application
+
+    Returns:
+        Test results summary
+    """
+    try:
+        from selenium import webdriver
+        from selenium.webdriver.chrome.options import Options
+        from selenium.webdriver.common.by import By
+        from selenium.webdriver.support import expected_conditions as EC
+        from selenium.webdriver.support.ui import WebDriverWait
+
+        # Setup Chrome options for headless mode
+        chrome_options = Options()
+        chrome_options.add_argument("--headless")
+        chrome_options.add_argument("--no-sandbox")
+        chrome_options.add_argument("--disable-dev-shm-usage")
+
+        driver = webdriver.Chrome(options=chrome_options)
+
+        try:
+            # Navigate to the Gradio app
+            driver.get(url)
+
+            # Wait for the page to load
+            WebDriverWait(driver, 10).until(
+                EC.presence_of_element_located((By.TAG_NAME, "body"))
+            )
+
+            # Check for Gradio-specific elements
+            gradio_app = driver.find_elements(
+                By.CSS_SELECTOR, ".gradio-container, #gradio-app, .app"
+            )
+
+            if not gradio_app:
+                return "Warning: No Gradio app container found on the page"
+
+            # Check for interactive elements (buttons, inputs)
+            inputs = driver.find_elements(By.CSS_SELECTOR, "input, textarea, button")
+
+            test_results = []
+            test_results.append("✓ Page loaded successfully")
+            test_results.append("✓ Gradio container found")
+            test_results.append(f"✓ Found {len(inputs)} interactive elements")
+
+            # Take a screenshot
+            screenshot_path = "/tmp/gradio_test_screenshot.png"
+            driver.save_screenshot(screenshot_path)
+            test_results.append(f"✓ Screenshot saved to {screenshot_path}")
+
+            return "; ".join(test_results)
+
+        finally:
+            driver.quit()
+
+    except ImportError:
+        return "Error: Selenium not installed. Install with: pip install selenium"
+    except Exception as e:
+        return f"Error during UI testing: {str(e)}"
+
+
+@tool
+def stop_gradio_processes() -> str:
+    """
+    Stop any running Gradio processes to clean up after testing.
+
+    Returns:
+        Status message about process cleanup
+    """
+    try:
+        stopped_processes = []
+
+        # Find processes running Gradio apps by name
+        result1 = subprocess.run(
+            ["pkill", "-f", "gradio"], capture_output=True, text=True
+        )
+
+        if result1.returncode == 0:
+            stopped_processes.append("Stopped Gradio processes by name")
+
+        # Also try to kill processes on port 7860
+        result2 = subprocess.run(["lsof", "-ti:7860"], capture_output=True, text=True)
+
+        if result2.stdout.strip():
+            pids = result2.stdout.strip().split("\n")
+            for pid in pids:
+                kill_result = subprocess.run(["kill", "-9", pid], capture_output=True)
+                if kill_result.returncode == 0:
+                    stopped_processes.append(f"Killed process {pid}")
+
+        if stopped_processes:
+            return "; ".join(stopped_processes)
+        else:
+            return "No Gradio processes found to stop"
+
+    except Exception as e:
+        return f"Error stopping processes: {str(e)}"
+
+
+class GradioTestingAgent:
+    """
+    A specialized ToolCallingAgent for testing Gradio applications.
+
+    This agent validates and tests Gradio applications created by the coding agent,
+    ensuring they are properly set up, runnable, and functional.
+    """
+
+    def __init__(
+        self,
+        model_id: str | None = None,
+        api_base_url: str | None = None,
+        api_key: str | None = None,
+        verbosity_level: int | None = None,
+        max_steps: int | None = None,
+    ):
+        """
+        Initialize the Gradio Testing Agent.
+
+        Args:
+            model_id: Model ID to use for testing (uses settings if None)
+            api_base_url: API base URL (uses settings if None)
+            api_key: API key (uses settings if None)
+            verbosity_level: Level of verbosity for agent output (uses settings if None)
+            max_steps: Maximum number of testing steps (uses settings if None)
+        """
+        # Use settings as defaults, but allow override
+        self.model_id = model_id or settings.test_model_id
+        self.api_base_url = api_base_url or settings.api_base_url
+        self.api_key = api_key or settings.api_key
+        verbosity_level = verbosity_level or settings.testing_verbosity
+        max_steps = max_steps or settings.max_testing_steps
+
+        # Initialize the language model for the ToolCallingAgent
+        self.model = LiteLLMModel(
+            model_id=self.model_id,
+            api_base=self.api_base_url,
+            api_key=self.api_key,
+        )
+
+        # Define the tools for testing
+        testing_tools = [
+            setup_venv_with_uv,
+            run_gradio_app,
+            check_app_health,
+            test_gradio_ui_basic,
+            stop_gradio_processes,
+        ]
+
+        # Initialize the ToolCallingAgent
+        self.agent = ToolCallingAgent(
+            model=self.model,
+            tools=testing_tools,
+            verbosity_level=verbosity_level,
+            max_steps=max_steps,
+        )
+
+        self.sandbox_path = Path("sandbox")
+
+    def test_application(self, coding_result: CodingResult) -> TestingResult:
+        """
+        Test the Gradio application created by the coding agent.
+
+        Args:
+            coding_result: The result from the coding agent
+
+        Returns:
+            TestingResult containing comprehensive test information
+        """
+        if not coding_result.success:
+            return TestingResult(
+                success=False,
+                project_path=coding_result.project_path,
+                setup_successful=False,
+                server_launched=False,
+                ui_accessible=False,
+                test_cases_passed=[],
+                test_cases_failed=["Coding agent failed to create application"],
+                error_messages=coding_result.error_messages,
+                screenshots=[],
+                performance_metrics={},
+                logs="Testing skipped due to coding failure",
+            )
+
+        project_path = coding_result.project_path
+
+        # Create comprehensive test prompt
+        test_prompt = f"""
+You are a specialized testing agent for Gradio applications. Your task is to \
+thoroughly test the Gradio application located at: {project_path}
+
+Please perform the following testing steps in order:
+
+1. **Environment Setup**: Use setup_venv_with_uv to ensure the virtual environment \
+is properly configured
+2. **Application Launch**: Use run_gradio_app to start the Gradio application
+3. **Health Check**: Use check_app_health to verify the application is responding
+4. **UI Testing**: Use test_gradio_ui_basic to test the user interface components
+5. **Cleanup**: Use stop_gradio_processes to clean up after testing
+
+For each step, report:
+- Whether the step succeeded or failed
+- Any error messages encountered
+- Performance observations (loading times, responsiveness)
+- Screenshots taken (if any)
+
+If any critical step fails, still attempt the remaining steps where possible to \
+gather maximum diagnostic information.
+
+The application should be a functional Gradio app with interactive components. Test for:
+- Proper page loading
+- Presence of Gradio components
+- Interactive elements (buttons, inputs, etc.)
+- Basic functionality
+
+Provide a comprehensive summary of all test results at the end.
+        """
+
+        try:
+            # Run the testing workflow
+            result = self.agent.run(test_prompt)
+
+            # Parse the agent's response to create structured result
+            return self._parse_testing_response(result, project_path)
+
+        except Exception as e:
+            return TestingResult(
+                success=False,
+                project_path=project_path,
+                setup_successful=False,
+                server_launched=False,
+                ui_accessible=False,
+                test_cases_passed=[],
+                test_cases_failed=["Testing agent execution failed"],
+                error_messages=[str(e)],
+                screenshots=[],
+                performance_metrics={},
+                logs=f"Testing agent error: {str(e)}",
+            )
+
+    def _parse_testing_response(
+        self, response: str, project_path: str
+    ) -> TestingResult:
+        """
+        Parse the agent's testing response into a structured TestingResult.
+
+        Args:
+            response: Raw response from the testing agent
+            project_path: Path to the tested project
+
+        Returns:
+            Structured TestingResult
+        """
+        # Initialize default values
+        setup_successful = False
+        server_launched = False
+        ui_accessible = False
+        test_cases_passed = []
+        test_cases_failed = []
+        error_messages = []
+        screenshots = []
+        performance_metrics = {}
+
+        # Simple parsing logic based on common success/failure indicators
+        response_lower = response.lower()
+
+        # Check for setup success
+        if "successfully set up virtual environment" in response_lower:
+            setup_successful = True
+            test_cases_passed.append("Virtual environment setup")
+        elif "error setting up venv" in response_lower:
+            test_cases_failed.append("Virtual environment setup")
+
+        # Check for server launch
+        if "successfully started gradio app" in response_lower:
+            server_launched = True
+            test_cases_passed.append("Gradio application launch")
+        elif "error running gradio app" in response_lower:
+            test_cases_failed.append("Gradio application launch")
+
+        # Check for health status
+        if "application is healthy" in response_lower:
+            ui_accessible = True
+            test_cases_passed.append("Application health check")
+        elif "cannot connect to" in response_lower:
+            test_cases_failed.append("Application health check")
+
+        # Check for UI testing
+        if (
+            "page loaded successfully" in response_lower
+            and "gradio container found" in response_lower
+        ):
+            test_cases_passed.append("UI component testing")
+        elif "error during ui testing" in response_lower:
+            test_cases_failed.append("UI component testing")
+
+        # Look for screenshots
+        if "screenshot saved" in response_lower:
+            screenshots.append("/tmp/gradio_test_screenshot.png")
+
+        # Extract performance metrics if mentioned
+        if "response time:" in response_lower:
+            # Simple regex to extract response time
+            import re
+
+            time_match = re.search(r"response time: ([\d.]+)s", response_lower)
+            if time_match:
+                performance_metrics["response_time_seconds"] = float(
+                    time_match.group(1)
+                )
+
+        # Determine overall success
+        success = (
+            setup_successful
+            and server_launched
+            and ui_accessible
+            and len(test_cases_failed) == 0
+        )
+
+        return TestingResult(
+            success=success,
+            project_path=project_path,
+            setup_successful=setup_successful,
+            server_launched=server_launched,
+            ui_accessible=ui_accessible,
+            test_cases_passed=test_cases_passed,
+            test_cases_failed=test_cases_failed,
+            error_messages=error_messages,
+            screenshots=screenshots,
+            performance_metrics=performance_metrics,
+            logs=response,
+        )
+
+    def generate_test_report(self, testing_result: TestingResult) -> str:
+        """
+        Generate a comprehensive test report in markdown format.
+
+        Args:
+            testing_result: The result from testing the application
+
+        Returns:
+            Markdown-formatted test report
+        """
+        status_emoji = "✅" if testing_result.success else "❌"
+
+        report = f"""
+# Gradio Application Test Report {status_emoji}
+
+## Summary
+- **Project Path**: `{testing_result.project_path}`
+- **Overall Success**: {testing_result.success}
+- **Environment Setup**: {"✅" if testing_result.setup_successful else "❌"}
+- **Server Launch**: {"✅" if testing_result.server_launched else "❌"}
+- **UI Accessibility**: {"✅" if testing_result.ui_accessible else "❌"}
+
+## Test Cases
+
+### Passed ({len(testing_result.test_cases_passed)})
+{chr(10).join(f"- ✅ {case}" for case in testing_result.test_cases_passed)}
+
+### Failed ({len(testing_result.test_cases_failed)})
+{chr(10).join(f"- ❌ {case}" for case in testing_result.test_cases_failed)}
+
+## Performance Metrics
+{chr(10).join(f"- **{key}**: {value}" for key, value in \
+testing_result.performance_metrics.items()) if testing_result.performance_metrics else \
+"No performance metrics collected"}
+
+## Screenshots
+{chr(10).join(f"- {screenshot}" for screenshot in testing_result.screenshots) \
+if testing_result.screenshots else "No screenshots captured"}
+
+## Error Messages
+{chr(10).join(f"- {error}" for error in testing_result.error_messages) \
+if testing_result.error_messages else "No errors reported"}
+
+## Detailed Logs
+```
+{testing_result.logs}
+```
+
+---
+*Report generated by GradioTestingAgent*
+        """
+
+        return report.strip()
+
+
+def create_gradio_testing_agent() -> GradioTestingAgent:
+    """
+    Create a Gradio testing agent with default settings.
+
+    Returns:
+        Configured GradioTestingAgent instance
+    """
+    return GradioTestingAgent()
+
+
+if __name__ == "__main__":
+    # Example usage
+    from coding_agent import create_gradio_coding_agent
+    from planning_agent import GradioPlanningAgent
+
+    # Create agents
+    planning_agent = GradioPlanningAgent()
+    coding_agent = create_gradio_coding_agent()
+    testing_agent = create_gradio_testing_agent()
+
+    # Example workflow
+    print("Planning a simple calculator app...")
+    plan = planning_agent.plan_application(
+        "Create a simple calculator with basic arithmetic operations"
+    )
+
+    print("Implementing the application...")
+    implementation = coding_agent.implement_application(plan)
+
+    print("Testing the application...")
+    test_results = testing_agent.test_application(implementation)
+
+    print("Test Report:")
+    print(testing_agent.generate_test_report(test_results))

utils.py

@@ -0,0 +1,29 @@
+"""
+Utility functions shared across the Likable project.
+"""
+
+import os
+
+
+def load_file(path):
+    """Load the contents of a file and return as string.
+
+    Args:
+        path: Path to the file to load
+
+    Returns:
+        str: File contents, or empty string if path is None or file doesn't exist
+    """
+    if path is None:
+        return ""
+
+    # Check if file exists first
+    if not os.path.exists(path):
+        return ""
+
+    # path is a string like "subdir/example.py"
+    try:
+        with open(path, encoding="utf-8") as f:
+            return f.read()
+    except OSError:
+        return ""

uv.lock

@@ -6,6 +6,12 @@ resolution-markers = [
     "python_full_version < '3.13'",
 ]
 
+[manifest]
+members = [
+    "gradio-app",
+    "likable",
+]
+
 [[package]]
 name = "aiofiles"
 version = "24.1.0"
@@ -168,6 +174,21 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/4a/7e/3db2bd1b1f9e95f7cddca6d6e75e2f2bd9f51b1246e546d88addca0106bd/certifi-2025.4.26-py3-none-any.whl", hash = "sha256:30350364dfe371162649852c63336a15c70c6510c2ad5015b21c2345311805f3", size = 159618, upload-time = "2025-04-26T02:12:27.662Z" },
 ]
 
+[[package]]
+name = "cffi"
+version = "1.17.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pycparser" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/fc/97/c783634659c2920c3fc70419e3af40972dbaf758daa229a7d6ea6135c90d/cffi-1.17.1.tar.gz", hash = "sha256:1c39c6016c32bc48dd54561950ebd6836e1670f2ae46128f67cf49e789c52824", size = 516621, upload-time = "2024-09-04T20:45:21.852Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/86/c5/28b2d6f799ec0bdecf44dced2ec5ed43e0eb63097b0f58c293583b406582/cffi-1.17.1-cp312-cp312-win32.whl", hash = "sha256:a08d7e755f8ed21095a310a693525137cfe756ce62d066e53f502a83dc550f65", size = 172448, upload-time = "2024-09-04T20:44:26.208Z" },
+    { url = "https://files.pythonhosted.org/packages/50/b9/db34c4755a7bd1cb2d1603ac3863f22bcecbd1ba29e5ee841a4bc510b294/cffi-1.17.1-cp312-cp312-win_amd64.whl", hash = "sha256:51392eae71afec0d0c8fb1a53b204dbb3bcabcb3c9b807eedf3e1e6ccf2de903", size = 181976, upload-time = "2024-09-04T20:44:27.578Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/ee/f94057fa6426481d663b88637a9a10e859e492c73d0384514a17d78ee205/cffi-1.17.1-cp313-cp313-win32.whl", hash = "sha256:e03eab0a8677fa80d646b5ddece1cbeaf556c313dcfac435ba11f107ba117b5d", size = 172475, upload-time = "2024-09-04T20:44:43.733Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/fc/6a8cb64e5f0324877d503c854da15d76c1e50eb722e320b15345c4d0c6de/cffi-1.17.1-cp313-cp313-win_amd64.whl", hash = "sha256:f6a16c31041f09ead72d69f583767292f750d24913dadacf5756b966aacb3f1a", size = 182009, upload-time = "2024-09-04T20:44:45.309Z" },
+]
+
 [[package]]
 name = "cfgv"
 version = "3.4.0"
@@ -251,6 +272,20 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/12/b3/231ffd4ab1fc9d679809f356cebee130ac7daa00d6d6f3206dd4fd137e9e/distro-1.9.0-py3-none-any.whl", hash = "sha256:7bffd925d65168f85027d8da9af6bddab658135b840670a223589bc0c8ef02b2", size = 20277, upload-time = "2023-12-24T09:54:30.421Z" },
 ]
 
+[[package]]
+name = "duckduckgo-search"
+version = "8.0.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "click" },
+    { name = "lxml" },
+    { name = "primp" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ad/c0/e18c2148d33a9d87f6a0cc00acba30b4e547be0f8cb85ccb313a6e8fbac7/duckduckgo_search-8.0.2.tar.gz", hash = "sha256:3109a99967b29cab8862823bbe320d140d5c792415de851b9d6288de2311b3ec", size = 21807, upload-time = "2025-05-15T08:43:25.311Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/bf/6c/e36d22e76f4aa4e1ea7ea9b443bd49b5ffd2f13d430840f47e35284f797a/duckduckgo_search-8.0.2-py3-none-any.whl", hash = "sha256:b5ff8b6b8f169b8e1b15a788a5749aa900ebcefd6e1ab485787582f8d5b4f1ef", size = 18184, upload-time = "2025-05-15T08:43:23.713Z" },
+]
+
 [[package]]
 name = "fastapi"
 version = "0.115.12"
@@ -392,6 +427,17 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/e2/4d/52a719a5e9a70022438d38238f2a9a3297b864c8ceaa61d77e3f1c1b472a/gradio-5.32.0-py3-none-any.whl", hash = "sha256:45fdb15784f4be19eca2beb1d45d107238ca614c177b20b0e3d4f2d6aee81bae", size = 54201078, upload-time = "2025-05-30T13:59:40.764Z" },
 ]
 
+[[package]]
+name = "gradio-app"
+version = "0.1.0"
+source = { virtual = "sandbox/gradio_app" }
+dependencies = [
+    { name = "gradio" },
+]
+
+[package.metadata]
+requires-dist = [{ name = "gradio", specifier = ">=5.32.0" }]
+
 [[package]]
 name = "gradio-client"
 version = "1.10.2"
@@ -470,6 +516,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" },
 ]
 
+[[package]]
+name = "httpx-sse"
+version = "0.4.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/4c/60/8f4281fa9bbf3c8034fd54c0e7412e66edbab6bc74c4996bd616f8d0406e/httpx-sse-0.4.0.tar.gz", hash = "sha256:1e81a3a3070ce322add1d3529ed42eb5f70817f45ed6ec915ab753f961139721", size = 12624, upload-time = "2023-12-22T08:01:21.083Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e1/9b/a181f281f65d776426002f330c31849b86b31fc9d848db62e16f03ff739f/httpx_sse-0.4.0-py3-none-any.whl", hash = "sha256:f329af6eae57eaa2bdfd962b42524764af68075ea87370a2de920af5341e318f", size = 7819, upload-time = "2023-12-22T08:01:19.89Z" },
+]
+
 [[package]]
 name = "huggingface-hub"
 version = "0.32.3"
@@ -579,6 +634,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/b3/4a/4175a563579e884192ba6e81725fc0448b042024419be8d83aa8a80a3f44/jiter-0.10.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3aa96f2abba33dc77f79b4cf791840230375f9534e5fac927ccceb58c5e604a5", size = 354213, upload-time = "2025-05-18T19:04:41.894Z" },
 ]
 
+[[package]]
+name = "jsonref"
+version = "1.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/aa/0d/c1f3277e90ccdb50d33ed5ba1ec5b3f0a242ed8c1b1a85d3afeb68464dca/jsonref-1.1.0.tar.gz", hash = "sha256:32fe8e1d85af0fdefbebce950af85590b22b60f9e95443176adbde4e1ecea552", size = 8814, upload-time = "2023-01-16T16:10:04.455Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0c/ec/e1db9922bceb168197a558a2b8c03a7963f1afe93517ddd3cf99f202f996/jsonref-1.1.0-py3-none-any.whl", hash = "sha256:590dc7773df6c21cbf948b5dac07a72a251db28b0238ceecce0a2abfa8ec30a9", size = 9425, upload-time = "2023-01-16T16:10:02.255Z" },
+]
+
 [[package]]
 name = "jsonschema"
 version = "4.24.0"
@@ -611,8 +675,12 @@ name = "likable"
 version = "0.1.0"
 source = { virtual = "." }
 dependencies = [
+    { name = "duckduckgo-search" },
     { name = "gradio" },
-    { name = "smolagents", extra = ["litellm"] },
+    { name = "mcp" },
+    { name = "requests" },
+    { name = "selenium" },
+    { name = "smolagents", extra = ["litellm", "mcp"] },
 ]
 
 [package.dev-dependencies]
@@ -623,8 +691,12 @@ dev = [
 
 [package.metadata]
 requires-dist = [
+    { name = "duckduckgo-search", specifier = ">=8.0.2" },
     { name = "gradio", specifier = ">=5.32.0" },
-    { name = "smolagents", extras = ["litellm"], specifier = ">=1.17.0" },
+    { name = "mcp", specifier = ">=1.9.2" },
+    { name = "requests", specifier = ">=2.32.0" },
+    { name = "selenium", specifier = ">=4.25.0" },
+    { name = "smolagents", extras = ["litellm", "mcp"], specifier = ">=1.17.0" },
 ]
 
 [package.metadata.requires-dev]
@@ -655,6 +727,48 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/c2/98/bec08f5a3e504013db6f52b5fd68375bd92b463c91eb454d5a6460e957af/litellm-1.72.0-py3-none-any.whl", hash = "sha256:88360a7ae9aa9c96278ae1bb0a459226f909e711c5d350781296d0640386a824", size = 7979630, upload-time = "2025-06-01T02:12:50.458Z" },
 ]
 
+[[package]]
+name = "lxml"
+version = "5.4.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/76/3d/14e82fc7c8fb1b7761f7e748fd47e2ec8276d137b6acfe5a4bb73853e08f/lxml-5.4.0.tar.gz", hash = "sha256:d12832e1dbea4be280b22fd0ea7c9b87f0d8fc51ba06e92dc62d52f804f78ebd", size = 3679479, upload-time = "2025-04-23T01:50:29.322Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f8/4c/d101ace719ca6a4ec043eb516fcfcb1b396a9fccc4fcd9ef593df34ba0d5/lxml-5.4.0-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:b5aff6f3e818e6bdbbb38e5967520f174b18f539c2b9de867b1e7fde6f8d95a4", size = 8127392, upload-time = "2025-04-23T01:46:04.09Z" },
+    { url = "https://files.pythonhosted.org/packages/11/84/beddae0cec4dd9ddf46abf156f0af451c13019a0fa25d7445b655ba5ccb7/lxml-5.4.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:942a5d73f739ad7c452bf739a62a0f83e2578afd6b8e5406308731f4ce78b16d", size = 4415103, upload-time = "2025-04-23T01:46:07.227Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/25/d0d93a4e763f0462cccd2b8a665bf1e4343dd788c76dcfefa289d46a38a9/lxml-5.4.0-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:460508a4b07364d6abf53acaa0a90b6d370fafde5693ef37602566613a9b0779", size = 5024224, upload-time = "2025-04-23T01:46:10.237Z" },
+    { url = "https://files.pythonhosted.org/packages/31/ce/1df18fb8f7946e7f3388af378b1f34fcf253b94b9feedb2cec5969da8012/lxml-5.4.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:529024ab3a505fed78fe3cc5ddc079464e709f6c892733e3f5842007cec8ac6e", size = 4769913, upload-time = "2025-04-23T01:46:12.757Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/62/f4a6c60ae7c40d43657f552f3045df05118636be1165b906d3423790447f/lxml-5.4.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7ca56ebc2c474e8f3d5761debfd9283b8b18c76c4fc0967b74aeafba1f5647f9", size = 5290441, upload-time = "2025-04-23T01:46:16.037Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/aa/04f00009e1e3a77838c7fc948f161b5d2d5de1136b2b81c712a263829ea4/lxml-5.4.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a81e1196f0a5b4167a8dafe3a66aa67c4addac1b22dc47947abd5d5c7a3f24b5", size = 4820165, upload-time = "2025-04-23T01:46:19.137Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/1f/e0b2f61fa2404bf0f1fdf1898377e5bd1b74cc9b2cf2c6ba8509b8f27990/lxml-5.4.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:00b8686694423ddae324cf614e1b9659c2edb754de617703c3d29ff568448df5", size = 4932580, upload-time = "2025-04-23T01:46:21.963Z" },
+    { url = "https://files.pythonhosted.org/packages/24/a2/8263f351b4ffe0ed3e32ea7b7830f845c795349034f912f490180d88a877/lxml-5.4.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:c5681160758d3f6ac5b4fea370495c48aac0989d6a0f01bb9a72ad8ef5ab75c4", size = 4759493, upload-time = "2025-04-23T01:46:24.316Z" },
+    { url = "https://files.pythonhosted.org/packages/05/00/41db052f279995c0e35c79d0f0fc9f8122d5b5e9630139c592a0b58c71b4/lxml-5.4.0-cp312-cp312-manylinux_2_28_ppc64le.whl", hash = "sha256:2dc191e60425ad70e75a68c9fd90ab284df64d9cd410ba8d2b641c0c45bc006e", size = 5324679, upload-time = "2025-04-23T01:46:27.097Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/be/ee99e6314cdef4587617d3b3b745f9356d9b7dd12a9663c5f3b5734b64ba/lxml-5.4.0-cp312-cp312-manylinux_2_28_s390x.whl", hash = "sha256:67f779374c6b9753ae0a0195a892a1c234ce8416e4448fe1e9f34746482070a7", size = 4890691, upload-time = "2025-04-23T01:46:30.009Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/36/239820114bf1d71f38f12208b9c58dec033cbcf80101cde006b9bde5cffd/lxml-5.4.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:79d5bfa9c1b455336f52343130b2067164040604e41f6dc4d8313867ed540079", size = 4955075, upload-time = "2025-04-23T01:46:32.33Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/e1/1b795cc0b174efc9e13dbd078a9ff79a58728a033142bc6d70a1ee8fc34d/lxml-5.4.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3d3c30ba1c9b48c68489dc1829a6eede9873f52edca1dda900066542528d6b20", size = 4838680, upload-time = "2025-04-23T01:46:34.852Z" },
+    { url = "https://files.pythonhosted.org/packages/72/48/3c198455ca108cec5ae3662ae8acd7fd99476812fd712bb17f1b39a0b589/lxml-5.4.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:1af80c6316ae68aded77e91cd9d80648f7dd40406cef73df841aa3c36f6907c8", size = 5391253, upload-time = "2025-04-23T01:46:37.608Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/10/5bf51858971c51ec96cfc13e800a9951f3fd501686f4c18d7d84fe2d6352/lxml-5.4.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:4d885698f5019abe0de3d352caf9466d5de2baded00a06ef3f1216c1a58ae78f", size = 5261651, upload-time = "2025-04-23T01:46:40.183Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/11/06710dd809205377da380546f91d2ac94bad9ff735a72b64ec029f706c85/lxml-5.4.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:aea53d51859b6c64e7c51d522c03cc2c48b9b5d6172126854cc7f01aa11f52bc", size = 5024315, upload-time = "2025-04-23T01:46:43.333Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/b0/15b6217834b5e3a59ebf7f53125e08e318030e8cc0d7310355e6edac98ef/lxml-5.4.0-cp312-cp312-win32.whl", hash = "sha256:d90b729fd2732df28130c064aac9bb8aff14ba20baa4aee7bd0795ff1187545f", size = 3486149, upload-time = "2025-04-23T01:46:45.684Z" },
+    { url = "https://files.pythonhosted.org/packages/91/1e/05ddcb57ad2f3069101611bd5f5084157d90861a2ef460bf42f45cced944/lxml-5.4.0-cp312-cp312-win_amd64.whl", hash = "sha256:1dc4ca99e89c335a7ed47d38964abcb36c5910790f9bd106f2a8fa2ee0b909d2", size = 3817095, upload-time = "2025-04-23T01:46:48.521Z" },
+    { url = "https://files.pythonhosted.org/packages/87/cb/2ba1e9dd953415f58548506fa5549a7f373ae55e80c61c9041b7fd09a38a/lxml-5.4.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:773e27b62920199c6197130632c18fb7ead3257fce1ffb7d286912e56ddb79e0", size = 8110086, upload-time = "2025-04-23T01:46:52.218Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/3e/6602a4dca3ae344e8609914d6ab22e52ce42e3e1638c10967568c5c1450d/lxml-5.4.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:ce9c671845de9699904b1e9df95acfe8dfc183f2310f163cdaa91a3535af95de", size = 4404613, upload-time = "2025-04-23T01:46:55.281Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/72/bf00988477d3bb452bef9436e45aeea82bb40cdfb4684b83c967c53909c7/lxml-5.4.0-cp313-cp313-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9454b8d8200ec99a224df8854786262b1bd6461f4280064c807303c642c05e76", size = 5012008, upload-time = "2025-04-23T01:46:57.817Z" },
+    { url = "https://files.pythonhosted.org/packages/92/1f/93e42d93e9e7a44b2d3354c462cd784dbaaf350f7976b5d7c3f85d68d1b1/lxml-5.4.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cccd007d5c95279e529c146d095f1d39ac05139de26c098166c4beb9374b0f4d", size = 4760915, upload-time = "2025-04-23T01:47:00.745Z" },
+    { url = "https://files.pythonhosted.org/packages/45/0b/363009390d0b461cf9976a499e83b68f792e4c32ecef092f3f9ef9c4ba54/lxml-5.4.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0fce1294a0497edb034cb416ad3e77ecc89b313cff7adbee5334e4dc0d11f422", size = 5283890, upload-time = "2025-04-23T01:47:04.702Z" },
+    { url = "https://files.pythonhosted.org/packages/19/dc/6056c332f9378ab476c88e301e6549a0454dbee8f0ae16847414f0eccb74/lxml-5.4.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:24974f774f3a78ac12b95e3a20ef0931795ff04dbb16db81a90c37f589819551", size = 4812644, upload-time = "2025-04-23T01:47:07.833Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/8a/f8c66bbb23ecb9048a46a5ef9b495fd23f7543df642dabeebcb2eeb66592/lxml-5.4.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:497cab4d8254c2a90bf988f162ace2ddbfdd806fce3bda3f581b9d24c852e03c", size = 4921817, upload-time = "2025-04-23T01:47:10.317Z" },
+    { url = "https://files.pythonhosted.org/packages/04/57/2e537083c3f381f83d05d9b176f0d838a9e8961f7ed8ddce3f0217179ce3/lxml-5.4.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:e794f698ae4c5084414efea0f5cc9f4ac562ec02d66e1484ff822ef97c2cadff", size = 4753916, upload-time = "2025-04-23T01:47:12.823Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/80/ea8c4072109a350848f1157ce83ccd9439601274035cd045ac31f47f3417/lxml-5.4.0-cp313-cp313-manylinux_2_28_ppc64le.whl", hash = "sha256:2c62891b1ea3094bb12097822b3d44b93fc6c325f2043c4d2736a8ff09e65f60", size = 5289274, upload-time = "2025-04-23T01:47:15.916Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/47/c4be287c48cdc304483457878a3f22999098b9a95f455e3c4bda7ec7fc72/lxml-5.4.0-cp313-cp313-manylinux_2_28_s390x.whl", hash = "sha256:142accb3e4d1edae4b392bd165a9abdee8a3c432a2cca193df995bc3886249c8", size = 4874757, upload-time = "2025-04-23T01:47:19.793Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/04/6ef935dc74e729932e39478e44d8cfe6a83550552eaa072b7c05f6f22488/lxml-5.4.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:1a42b3a19346e5601d1b8296ff6ef3d76038058f311902edd574461e9c036982", size = 4947028, upload-time = "2025-04-23T01:47:22.401Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/f9/c33fc8daa373ef8a7daddb53175289024512b6619bc9de36d77dca3df44b/lxml-5.4.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4291d3c409a17febf817259cb37bc62cb7eb398bcc95c1356947e2871911ae61", size = 4834487, upload-time = "2025-04-23T01:47:25.513Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/30/fc92bb595bcb878311e01b418b57d13900f84c2b94f6eca9e5073ea756e6/lxml-5.4.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:4f5322cf38fe0e21c2d73901abf68e6329dc02a4994e483adbcf92b568a09a54", size = 5381688, upload-time = "2025-04-23T01:47:28.454Z" },
+    { url = "https://files.pythonhosted.org/packages/43/d1/3ba7bd978ce28bba8e3da2c2e9d5ae3f8f521ad3f0ca6ea4788d086ba00d/lxml-5.4.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:0be91891bdb06ebe65122aa6bf3fc94489960cf7e03033c6f83a90863b23c58b", size = 5242043, upload-time = "2025-04-23T01:47:31.208Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/cd/95fa2201041a610c4d08ddaf31d43b98ecc4b1d74b1e7245b1abdab443cb/lxml-5.4.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:15a665ad90054a3d4f397bc40f73948d48e36e4c09f9bcffc7d90c87410e478a", size = 5021569, upload-time = "2025-04-23T01:47:33.805Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/a6/31da006fead660b9512d08d23d31e93ad3477dd47cc42e3285f143443176/lxml-5.4.0-cp313-cp313-win32.whl", hash = "sha256:d5663bc1b471c79f5c833cffbc9b87d7bf13f87e055a5c86c363ccd2348d7e82", size = 3485270, upload-time = "2025-04-23T01:47:36.133Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/14/c115516c62a7d2499781d2d3d7215218c0731b2c940753bf9f9b7b73924d/lxml-5.4.0-cp313-cp313-win_amd64.whl", hash = "sha256:bcb7a1096b4b6b24ce1ac24d4942ad98f983cd3810f9711bcd0293f43a9d8b9f", size = 3814606, upload-time = "2025-04-23T01:47:39.028Z" },
+]
+
 [[package]]
 name = "markdown-it-py"
 version = "3.0.0"
@@ -705,6 +819,41 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/4f/65/6079a46068dfceaeabb5dcad6d674f5f5c61a6fa5673746f42a9f4c233b3/MarkupSafe-3.0.2-cp313-cp313t-win_amd64.whl", hash = "sha256:e444a31f8db13eb18ada366ab3cf45fd4b31e4db1236a4448f68778c1d1a5a2f", size = 15739, upload-time = "2024-10-18T15:21:42.784Z" },
 ]
 
+[[package]]
+name = "mcp"
+version = "1.9.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "httpx" },
+    { name = "httpx-sse" },
+    { name = "pydantic" },
+    { name = "pydantic-settings" },
+    { name = "python-multipart" },
+    { name = "sse-starlette" },
+    { name = "starlette" },
+    { name = "uvicorn", marker = "sys_platform != 'emscripten'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ea/03/77c49cce3ace96e6787af624611b627b2828f0dca0f8df6f330a10eea51e/mcp-1.9.2.tar.gz", hash = "sha256:3c7651c053d635fd235990a12e84509fe32780cd359a5bbef352e20d4d963c05", size = 333066, upload-time = "2025-05-29T14:42:17.76Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5d/a6/8f5ee9da9f67c0fd8933f63d6105f02eabdac8a8c0926728368ffbb6744d/mcp-1.9.2-py3-none-any.whl", hash = "sha256:bc29f7fd67d157fef378f89a4210384f5fecf1168d0feb12d22929818723f978", size = 131083, upload-time = "2025-05-29T14:42:16.211Z" },
+]
+
+[[package]]
+name = "mcpadapt"
+version = "0.1.9"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "jsonref" },
+    { name = "mcp" },
+    { name = "pydantic" },
+    { name = "python-dotenv" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/9e/68/85c0946d567088d8d55f1c30cb942bcfec2585941a3f45b790e423b994c8/mcpadapt-0.1.9.tar.gz", hash = "sha256:03e601c4c083f3f4eb178e6a6bcd157bcb45e25c140ea0895567bab346b67645", size = 3540887, upload-time = "2025-05-24T19:40:35.823Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/83/78/0310684763e5753a3a8128dab6c87ba1e20dd907b696680592bebebc84b6/mcpadapt-0.1.9-py3-none-any.whl", hash = "sha256:9f2a6ad1155efdf1a43c11e8449ae9258295c4e140c3c6ff672983a8ac8bde33", size = 17469, upload-time = "2025-05-24T19:40:34.055Z" },
+]
+
 [[package]]
 name = "mdurl"
 version = "0.1.2"
@@ -878,6 +1027,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/c2/28/f53038a5a72cc4fd0b56c1eafb4ef64aec9685460d5ac34de98ca78b6e29/orjson-3.10.18-cp313-cp313-win_arm64.whl", hash = "sha256:f54c1385a0e6aba2f15a40d703b858bedad36ded0491e55d35d905b2c34a4cc3", size = 131186, upload-time = "2025-04-29T23:29:41.922Z" },
 ]
 
+[[package]]
+name = "outcome"
+version = "1.3.0.post0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "attrs" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/98/df/77698abfac98571e65ffeb0c1fba8ffd692ab8458d617a0eed7d9a8d38f2/outcome-1.3.0.post0.tar.gz", hash = "sha256:9dcf02e65f2971b80047b377468e72a268e15c0af3cf1238e6ff14f7f91143b8", size = 21060, upload-time = "2023-10-26T04:26:04.361Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/55/8b/5ab7257531a5d830fc8000c476e63c935488d74609b50f9384a643ec0a62/outcome-1.3.0.post0-py2.py3-none-any.whl", hash = "sha256:e771c5ce06d1415e356078d3bdd68523f284b4ce5419828922b6871e65eda82b", size = 10692, upload-time = "2023-10-26T04:26:02.532Z" },
+]
+
 [[package]]
 name = "packaging"
 version = "25.0"
@@ -987,6 +1148,22 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/88/74/a88bf1b1efeae488a0c0b7bdf71429c313722d1fc0f377537fbe554e6180/pre_commit-4.2.0-py2.py3-none-any.whl", hash = "sha256:a009ca7205f1eb497d10b845e52c838a98b6cdd2102a6c8e4540e94ee75c58bd", size = 220707, upload-time = "2025-03-18T21:35:19.343Z" },
 ]
 
+[[package]]
+name = "primp"
+version = "0.15.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/56/0b/a87556189da4de1fc6360ca1aa05e8335509633f836cdd06dd17f0743300/primp-0.15.0.tar.gz", hash = "sha256:1af8ea4b15f57571ff7fc5e282a82c5eb69bc695e19b8ddeeda324397965b30a", size = 113022, upload-time = "2025-04-17T11:41:05.315Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f5/5a/146ac964b99ea7657ad67eb66f770be6577dfe9200cb28f9a95baffd6c3f/primp-0.15.0-cp38-abi3-macosx_10_12_x86_64.whl", hash = "sha256:1b281f4ca41a0c6612d4c6e68b96e28acfe786d226a427cd944baa8d7acd644f", size = 3178914, upload-time = "2025-04-17T11:40:59.558Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/8a/cc2321e32db3ce64d6e32950d5bcbea01861db97bfb20b5394affc45b387/primp-0.15.0-cp38-abi3-macosx_11_0_arm64.whl", hash = "sha256:489cbab55cd793ceb8f90bb7423c6ea64ebb53208ffcf7a044138e3c66d77299", size = 2955079, upload-time = "2025-04-17T11:40:57.398Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/7b/cbd5d999a07ff2a21465975d4eb477ae6f69765e8fe8c9087dab250180d8/primp-0.15.0-cp38-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c18b45c23f94016215f62d2334552224236217aaeb716871ce0e4dcfa08eb161", size = 3281018, upload-time = "2025-04-17T11:40:55.308Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/6e/a6221c612e61303aec2bcac3f0a02e8b67aee8c0db7bdc174aeb8010f975/primp-0.15.0-cp38-abi3-manylinux_2_34_aarch64.whl", hash = "sha256:e985a9cba2e3f96a323722e5440aa9eccaac3178e74b884778e926b5249df080", size = 3255229, upload-time = "2025-04-17T11:40:47.811Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/54/bfeef5aca613dc660a69d0760a26c6b8747d8fdb5a7f20cb2cee53c9862f/primp-0.15.0-cp38-abi3-manylinux_2_34_armv7l.whl", hash = "sha256:6b84a6ffa083e34668ff0037221d399c24d939b5629cd38223af860de9e17a83", size = 3014522, upload-time = "2025-04-17T11:40:50.191Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/96/84078e09f16a1dad208f2fe0f8a81be2cf36e024675b0f9eec0c2f6e2182/primp-0.15.0-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:592f6079646bdf5abbbfc3b0a28dac8de943f8907a250ce09398cda5eaebd260", size = 3418567, upload-time = "2025-04-17T11:41:01.595Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/80/8a7a9587d3eb85be3d0b64319f2f690c90eb7953e3f73a9ddd9e46c8dc42/primp-0.15.0-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:5a728e5a05f37db6189eb413d22c78bd143fa59dd6a8a26dacd43332b3971fe8", size = 3606279, upload-time = "2025-04-17T11:41:03.61Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/dd/f0183ed0145e58cf9d286c1b2c14f63ccee987a4ff79ac85acc31b5d86bd/primp-0.15.0-cp38-abi3-win_amd64.whl", hash = "sha256:aeb6bd20b06dfc92cfe4436939c18de88a58c640752cf7f30d9e4ae893cdec32", size = 3149967, upload-time = "2025-04-17T11:41:07.067Z" },
+]
+
 [[package]]
 name = "propcache"
 version = "0.3.1"
@@ -1044,6 +1221,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/b8/d3/c3cb8f1d6ae3b37f83e1de806713a9b3642c5895f0215a62e1a4bd6e5e34/propcache-0.3.1-py3-none-any.whl", hash = "sha256:9a8ecf38de50a7f518c21568c80f985e776397b902f1ce0b01f799aba1608b40", size = 12376, upload-time = "2025-03-26T03:06:10.5Z" },
 ]
 
+[[package]]
+name = "pycparser"
+version = "2.22"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/1d/b2/31537cf4b1ca988837256c910a668b553fceb8f069bedc4b1c826024b52c/pycparser-2.22.tar.gz", hash = "sha256:491c8be9c040f5390f5bf44a5b07752bd07f56edf992381b05c701439eec10f6", size = 172736, upload-time = "2024-03-30T13:22:22.564Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/13/a3/a812df4e2dd5696d1f351d58b8fe16a405b234ad2886a0dab9183fb78109/pycparser-2.22-py3-none-any.whl", hash = "sha256:c3702b6d3dd8c7abc1afa565d7e63d53a1d0bd86cdc24edd75470f4de499cfcc", size = 117552, upload-time = "2024-03-30T13:22:20.476Z" },
+]
+
 [[package]]
 name = "pydantic"
 version = "2.11.5"
@@ -1101,6 +1287,20 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/6f/9a/e73262f6c6656262b5fdd723ad90f518f579b7bc8622e43a942eec53c938/pydantic_core-2.33.2-cp313-cp313t-win_amd64.whl", hash = "sha256:c2fc0a768ef76c15ab9238afa6da7f69895bb5d1ee83aeea2e3509af4472d0b9", size = 1935777, upload-time = "2025-04-23T18:32:25.088Z" },
 ]
 
+[[package]]
+name = "pydantic-settings"
+version = "2.9.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pydantic" },
+    { name = "python-dotenv" },
+    { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/67/1d/42628a2c33e93f8e9acbde0d5d735fa0850f3e6a2f8cb1eb6c40b9a732ac/pydantic_settings-2.9.1.tar.gz", hash = "sha256:c509bf79d27563add44e8446233359004ed85066cd096d8b510f715e6ef5d268", size = 163234, upload-time = "2025-04-18T16:44:48.265Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b6/5f/d6d641b490fd3ec2c4c13b4244d68deea3a1b970a97be64f34fb5504ff72/pydantic_settings-2.9.1-py3-none-any.whl", hash = "sha256:59b4f431b1defb26fe620c71a7d3968a710d719f5f4cdbbdb7926edeb770f6ef", size = 44356, upload-time = "2025-04-18T16:44:46.617Z" },
+]
+
 [[package]]
 name = "pydub"
 version = "0.25.1"
@@ -1119,6 +1319,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/8a/0b/9fcc47d19c48b59121088dd6da2488a49d5f72dacf8262e2790a1d2c7d15/pygments-2.19.1-py3-none-any.whl", hash = "sha256:9ea1544ad55cecf4b8242fab6dd35a93bbce657034b0611ee383099054ab6d8c", size = 1225293, upload-time = "2025-01-06T17:26:25.553Z" },
 ]
 
+[[package]]
+name = "pysocks"
+version = "1.7.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/bd/11/293dd436aea955d45fc4e8a35b6ae7270f5b8e00b53cf6c024c83b657a11/PySocks-1.7.1.tar.gz", hash = "sha256:3f8804571ebe159c380ac6de37643bb4685970655d3bba243530d6558b799aa0", size = 284429, upload-time = "2019-09-20T02:07:35.714Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/8d/59/b4572118e098ac8e46e399a1dd0f2d85403ce8bbaad9ec79373ed6badaf9/PySocks-1.7.1-py3-none-any.whl", hash = "sha256:2725bd0a9925919b9b51739eea5f9e2bae91e83288108a9ad338b2e3a4435ee5", size = 16725, upload-time = "2019-09-20T02:06:22.938Z" },
+]
+
 [[package]]
 name = "python-dateutil"
 version = "2.9.0.post0"
@@ -1350,6 +1559,23 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/4d/c0/1108ad9f01567f66b3154063605b350b69c3c9366732e09e45f9fd0d1deb/safehttpx-0.1.6-py3-none-any.whl", hash = "sha256:407cff0b410b071623087c63dd2080c3b44dc076888d8c5823c00d1e58cb381c", size = 8692, upload-time = "2024-12-02T18:44:08.555Z" },
 ]
 
+[[package]]
+name = "selenium"
+version = "4.33.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi" },
+    { name = "trio" },
+    { name = "trio-websocket" },
+    { name = "typing-extensions" },
+    { name = "urllib3", extra = ["socks"] },
+    { name = "websocket-client" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/5f/7e/4145666dd275760b56d0123a9439915af167932dd6caa19b5f8b281ae297/selenium-4.33.0.tar.gz", hash = "sha256:d90974db95d2cdeb34d2fb1b13f03dc904f53e6c5d228745b0635ada10cd625d", size = 882387, upload-time = "2025-05-23T17:45:22.046Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7e/c0/092fde36918574e144613de73ba43c36ab8d31e7d36bb44c35261909452d/selenium-4.33.0-py3-none-any.whl", hash = "sha256:af9ea757813918bddfe05cc677bf63c8a0cd277ebf8474b3dd79caa5727fca85", size = 9370835, upload-time = "2025-05-23T17:45:19.448Z" },
+]
+
 [[package]]
 name = "semantic-version"
 version = "2.10.0"
@@ -1398,6 +1624,10 @@ wheels = [
 litellm = [
     { name = "litellm" },
 ]
+mcp = [
+    { name = "mcp" },
+    { name = "mcpadapt" },
+]
 
 [[package]]
 name = "sniffio"
@@ -1408,6 +1638,27 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235, upload-time = "2024-02-25T23:20:01.196Z" },
 ]
 
+[[package]]
+name = "sortedcontainers"
+version = "2.4.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e8/c4/ba2f8066cceb6f23394729afe52f3bf7adec04bf9ed2c820b39e19299111/sortedcontainers-2.4.0.tar.gz", hash = "sha256:25caa5a06cc30b6b83d11423433f65d1f9d76c4c6a0c90e3379eaa43b9bfdb88", size = 30594, upload-time = "2021-05-16T22:03:42.897Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/32/46/9cb0e58b2deb7f82b84065f37f3bffeb12413f947f9388e4cac22c4621ce/sortedcontainers-2.4.0-py2.py3-none-any.whl", hash = "sha256:a163dcaede0f1c021485e957a39245190e74249897e2ae4b2aa38595db237ee0", size = 29575, upload-time = "2021-05-16T22:03:41.177Z" },
+]
+
+[[package]]
+name = "sse-starlette"
+version = "2.3.6"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/8c/f4/989bc70cb8091eda43a9034ef969b25145291f3601703b82766e5172dfed/sse_starlette-2.3.6.tar.gz", hash = "sha256:0382336f7d4ec30160cf9ca0518962905e1b69b72d6c1c995131e0a703b436e3", size = 18284, upload-time = "2025-05-30T13:34:12.914Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/81/05/78850ac6e79af5b9508f8841b0f26aa9fd329a1ba00bf65453c2d312bcc8/sse_starlette-2.3.6-py3-none-any.whl", hash = "sha256:d49a8285b182f6e2228e2609c350398b2ca2c36216c2675d875f81e93548f760", size = 10606, upload-time = "2025-05-30T13:34:11.703Z" },
+]
+
 [[package]]
 name = "starlette"
 version = "0.46.2"
@@ -1490,6 +1741,37 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/d0/30/dc54f88dd4a2b5dc8a0279bdd7270e735851848b762aeb1c1184ed1f6b14/tqdm-4.67.1-py3-none-any.whl", hash = "sha256:26445eca388f82e72884e0d580d5464cd801a3ea01e63e5601bdff9ba6a48de2", size = 78540, upload-time = "2024-11-24T20:12:19.698Z" },
 ]
 
+[[package]]
+name = "trio"
+version = "0.30.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "attrs" },
+    { name = "cffi", marker = "implementation_name != 'pypy' and os_name == 'nt'" },
+    { name = "idna" },
+    { name = "outcome" },
+    { name = "sniffio" },
+    { name = "sortedcontainers" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/01/c1/68d582b4d3a1c1f8118e18042464bb12a7c1b75d64d75111b297687041e3/trio-0.30.0.tar.gz", hash = "sha256:0781c857c0c81f8f51e0089929a26b5bb63d57f927728a5586f7e36171f064df", size = 593776, upload-time = "2025-04-21T00:48:19.507Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/69/8e/3f6dfda475ecd940e786defe6df6c500734e686c9cd0a0f8ef6821e9b2f2/trio-0.30.0-py3-none-any.whl", hash = "sha256:3bf4f06b8decf8d3cf00af85f40a89824669e2d033bb32469d34840edcfc22a5", size = 499194, upload-time = "2025-04-21T00:48:17.167Z" },
+]
+
+[[package]]
+name = "trio-websocket"
+version = "0.12.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "outcome" },
+    { name = "trio" },
+    { name = "wsproto" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d1/3c/8b4358e81f2f2cfe71b66a267f023a91db20a817b9425dd964873796980a/trio_websocket-0.12.2.tar.gz", hash = "sha256:22c72c436f3d1e264d0910a3951934798dcc5b00ae56fc4ee079d46c7cf20fae", size = 33549, upload-time = "2025-02-25T05:16:58.947Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c7/19/eb640a397bba49ba49ef9dbe2e7e5c04202ba045b6ce2ec36e9cadc51e04/trio_websocket-0.12.2-py3-none-any.whl", hash = "sha256:df605665f1db533f4a386c94525870851096a223adcb97f72a07e8b4beba45b6", size = 21221, upload-time = "2025-02-25T05:16:57.545Z" },
+]
+
 [[package]]
 name = "typer"
 version = "0.16.0"
@@ -1544,6 +1826,11 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/6b/11/cc635220681e93a0183390e26485430ca2c7b5f9d33b15c74c2861cb8091/urllib3-2.4.0-py3-none-any.whl", hash = "sha256:4e16665048960a0900c702d4a66415956a584919c03361cac9f1df5c5dd7e813", size = 128680, upload-time = "2025-04-10T15:23:37.377Z" },
 ]
 
+[package.optional-dependencies]
+socks = [
+    { name = "pysocks" },
+]
+
 [[package]]
 name = "uvicorn"
 version = "0.34.3"
@@ -1571,6 +1858,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/f3/40/b1c265d4b2b62b58576588510fc4d1fe60a86319c8de99fd8e9fec617d2c/virtualenv-20.31.2-py3-none-any.whl", hash = "sha256:36efd0d9650ee985f0cad72065001e66d49a6f24eb44d98980f630686243cf11", size = 6057982, upload-time = "2025-05-08T17:58:21.15Z" },
 ]
 
+[[package]]
+name = "websocket-client"
+version = "1.8.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e6/30/fba0d96b4b5fbf5948ed3f4681f7da2f9f64512e1d303f94b4cc174c24a5/websocket_client-1.8.0.tar.gz", hash = "sha256:3239df9f44da632f96012472805d40a23281a991027ce11d2f45a6f24ac4c3da", size = 54648, upload-time = "2024-04-23T22:16:16.976Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5a/84/44687a29792a70e111c5c477230a72c4b957d88d16141199bf9acb7537a3/websocket_client-1.8.0-py3-none-any.whl", hash = "sha256:17b44cc997f5c498e809b22cdf2d9c7a9e71c02c8cc2b6c56e7c2d1239bfa526", size = 58826, upload-time = "2024-04-23T22:16:14.422Z" },
+]
+
 [[package]]
 name = "websockets"
 version = "15.0.1"
@@ -1602,6 +1898,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/fa/a8/5b41e0da817d64113292ab1f8247140aac61cbf6cfd085d6a0fa77f4984f/websockets-15.0.1-py3-none-any.whl", hash = "sha256:f7a866fbc1e97b5c617ee4116daaa09b722101d4a3c170c787450ba409f9736f", size = 169743, upload-time = "2025-03-05T20:03:39.41Z" },
 ]
 
+[[package]]
+name = "wsproto"
+version = "1.2.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "h11" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c9/4a/44d3c295350d776427904d73c189e10aeae66d7f555bb2feee16d1e4ba5a/wsproto-1.2.0.tar.gz", hash = "sha256:ad565f26ecb92588a3e43bc3d96164de84cd9902482b130d0ddbaa9664a85065", size = 53425, upload-time = "2022-08-23T19:58:21.447Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/78/58/e860788190eba3bcce367f74d29c4675466ce8dddfba85f7827588416f01/wsproto-1.2.0-py3-none-any.whl", hash = "sha256:b9acddd652b585d75b20477888c56642fdade28bdfd3579aa24a4d2c037dd736", size = 24226, upload-time = "2022-08-23T19:58:19.96Z" },
+]
+
 [[package]]
 name = "yarl"
 version = "1.20.0"