first commit

README.md

@@ -0,0 +1,84 @@
+# AI Agent Builder with SmolaGents
+
+This application allows you to build AI agents using the SmolaGents library from Hugging Face. You can select tools from Hugging Face Hub collections and Spaces, and interact with your agent through a chat interface.
+
+## Features
+
+- Add tools from Hugging Face Hub collections
+- Add tools from Hugging Face Spaces
+- Chat with your agent in an interactive interface
+- Customize the model used for your agent
+- Regenerate responses if needed
+
+## Installation
+
+1. Make sure you have Python 3.11 or higher installed
+2. Install the required dependencies:
+
+```bash
+pip install -r requirements.txt
+```
+
+## Usage
+
+1. Run the application:
+
+```bash
+python app.py
+```
+
+2. Open your browser and navigate to the URL displayed in the terminal (usually http://127.0.0.1:7860)
+
+3. Configure your agent:
+   - Select a model (default is Qwen/Qwen2.5-Coder-32B-Instruct)
+   - Add at least one tool from Hugging Face Hub collections or Spaces
+   - Click "Create Agent"
+
+4. Chat with your agent in the chat interface
+   - Type your message and press Enter
+   - Use the "Regenerate Response" button if you want a different answer
+   - Use "Clear Chat" to start a new conversation
+
+## Adding Tools
+
+### Hugging Face Hub Collections
+Enter the collection slug for a tool collection from Hugging Face Hub.
+Example: `huggingface-tools/diffusion-tools-6630bb19a942c2306a2cdb6f`
+
+### Hugging Face Spaces
+Enter the space ID for a Gradio app on Hugging Face Spaces.
+Example: `black-forest-labs/FLUX.1-schnell`
+
+This allows you to use any Gradio app on Hugging Face Spaces as a tool for your agent.
+
+## Example Spaces to Try
+
+### Image Generation Spaces
+- `black-forest-labs/FLUX.1-schnell`: Text-to-image generation
+- `stabilityai/stable-diffusion-xl-base-1.0`: High-quality image generation
+
+### Text Analysis Spaces
+- `sentence-transformers/text-similarity`: Compare text similarity
+- `facebook/bart-large-mnli`: Text classification
+
+### Other Useful Spaces
+- `spaces/jxnl/instructor-xl`: Generate structured data
+- `spaces/fffiloni/text-to-speech`: Convert text to speech
+
+## Troubleshooting
+
+If you encounter issues with the Space tool not being recognized, make sure:
+1. You've entered the correct Space ID
+2. The Space has a Gradio interface
+3. The Space is publicly accessible
+
+## Requirements
+
+- gradio>=5.15.0
+- smolagents>=1.10.0
+- huggingface_hub
+
+## Note
+
+For some tools and models, you may need to set up API keys as environment variables. For example:
+- `HF_TOKEN` for Hugging Face Hub access

app.py

@@ -0,0 +1,546 @@
+import os
+from typing import Optional
+import gradio as gr
+import requests
+from smolagents import CodeAgent, Tool
+from smolagents.models import HfApiModel
+from smolagents.monitoring import LogLevel
+from gradio import ChatMessage
+
+DEFAULT_MODEL = "Qwen/Qwen2.5-Coder-32B-Instruct"
+HF_API_TOKEN = os.getenv("HF_TOKEN")
+
+# Tool descriptions for the UI
+TOOL_DESCRIPTIONS = {
+    "Hub Collections": "Add tool collections from Hugging Face Hub.",
+    "Spaces": "Add tools from Hugging Face Spaces.",
+}
+
+
+def search_spaces(query, limit=1):
+    """
+    Search for Hugging Face Spaces using the API.
+    Returns the first result or None if no results.
+    """
+    try:
+        url = f"https://huggingface.co/api/spaces?search={query}&limit={limit}"
+        response = requests.get(
+            url, headers={"Authorization": f"Bearer {HF_API_TOKEN}"}
+        )
+        response.raise_for_status()
+
+        spaces = response.json()
+        if not spaces:
+            return None
+
+        # Get the first space
+        space = spaces[0]
+        space_id = space["id"]
+
+        # Extract title and description
+        title = space_id.split("/")[-1]  # Default to the last part of the ID
+        description = f"Tool from {space_id}"
+
+        # Try to get title from different possible locations
+        if "title" in space:
+            title = space["title"]
+        elif "cardData" in space and "title" in space["cardData"]:
+            title = space["cardData"]["title"]
+
+        # Try to get description from different possible locations
+        if "description" in space:
+            description = space["description"]
+        elif "cardData" in space and "description" in space["cardData"]:
+            description = space["cardData"]["description"]
+
+        return {
+            "id": space_id,
+            "title": title,
+            "description": description,
+        }
+    except Exception as e:
+        print(f"Error searching spaces: {e}")
+        return None
+
+
+def get_space_metadata(space_id):
+    """
+    Get metadata for a specific Hugging Face Space.
+    """
+    try:
+        url = f"https://huggingface.co/api/spaces/{space_id}"
+        response = requests.get(
+            url, headers={"Authorization": f"Bearer {HF_API_TOKEN}"}
+        )
+        response.raise_for_status()
+
+        space = response.json()
+
+        # Extract title and description from the space data
+        # The structure can vary, so we need to handle different cases
+        title = space_id
+        description = f"Tool from {space_id}"
+
+        # Try to get title from different possible locations
+        if "title" in space:
+            title = space["title"]
+        elif "cardData" in space and "title" in space["cardData"]:
+            title = space["cardData"]["title"]
+        else:
+            # Use the last part of the space_id as a fallback title
+            title = space_id.split("/")[-1]
+
+        # Try to get description from different possible locations
+        if "description" in space:
+            description = space["description"]
+        elif "cardData" in space and "description" in space["cardData"]:
+            description = space["cardData"]["description"]
+
+        return {
+            "id": space_id,
+            "title": title,
+            "description": description,
+        }
+    except Exception as e:
+        print(f"Error getting space metadata: {e}")
+        return None
+
+
+def create_agent(model_name, space_tools=None):
+    """
+    Create a CodeAgent with the specified model and tools.
+    """
+    if not space_tools:
+        space_tools = []
+
+    try:
+        # Convert space tools to Tool objects
+        tools = []
+        for tool_info in space_tools:
+            space_id = tool_info["id"]
+            tool = Tool.from_space(
+                space_id,
+                name=tool_info.get("name", space_id),
+                description=tool_info.get("description", ""),
+            )
+            tools.append(tool)
+
+        # Initialize the HfApiModel with the model name
+        model = HfApiModel(model_id=model_name, token=HF_API_TOKEN)
+
+        # Create the agent with the tools and additional imports
+        agent = CodeAgent(
+            tools=tools,
+            model=model,
+            additional_authorized_imports=["PIL", "requests"],
+            verbosity_level=LogLevel.DEBUG,  # Set higher verbosity for detailed logs
+        )
+        print(f"Agent created successfully with {len(tools)} tools")
+        return agent
+    except Exception as e:
+        print(f"Error creating agent: {e}")
+
+        # Try with a fallback model if the specified one fails
+        try:
+            print("Trying fallback model...")
+            fallback_model = HfApiModel(
+                model_id="Qwen/Qwen2.5-Coder-7B-Instruct", token=HF_API_TOKEN
+            )
+
+            agent = CodeAgent(
+                tools=tools,
+                model=fallback_model,
+                additional_authorized_imports=["PIL", "requests"],
+                verbosity_level=LogLevel.DEBUG,  # Set higher verbosity for detailed logs
+            )
+            print("Agent created successfully with fallback model")
+            return agent
+        except Exception as e:
+            print(f"Error creating agent: {e}")
+            return None
+
+
+# Event handler functions
+def on_search_spaces(query):
+    if not query:
+        return "Please enter a search term.", "", "", ""
+
+    try:
+        space_info = search_spaces(query)
+        if space_info is None:
+            return "No spaces found.", "", "", ""
+
+        # Format the results as markdown
+        results_md = "### Search Results:\n"
+        results_md += f"- ID: `{space_info['id']}`\n"
+        results_md += f"- Title: {space_info['title']}\n"
+        results_md += f"- Description: {space_info['description']}\n"
+
+        # Return values to update the UI
+        return (
+            results_md,
+            space_info["id"],
+            space_info["title"],
+            space_info["description"],
+        )
+    except Exception as e:
+        print(f"Error in search: {e}")
+        return f"Error: {str(e)}", "", "", ""
+
+
+def on_validate_space(space_id):
+    if not space_id:
+        return "Please enter a space ID or search term.", "", ""
+
+    try:
+        # First try to get metadata directly if it's a valid space ID
+        space_info = get_space_metadata(space_id)
+
+        # If not found, try to search for it
+        if space_info is None:
+            # Try to search for the space using the ID as a search term
+            space_info = search_spaces(space_id)
+            if space_info is None:
+                return f"No spaces found for '{space_id}'.", "", ""
+
+            # Format search result as markdown
+            result_md = f"### Found Space via Search:\n"
+            result_md += f"- ID: `{space_info['id']}`\n"
+            result_md += f"- Title: {space_info['title']}\n"
+            result_md += f"- Description: {space_info['description']}\n"
+
+            return (
+                result_md,
+                space_info["title"],
+                space_info["description"],
+            )
+
+        # Format direct match as markdown
+        result_md = f"### Space Validated Successfully:\n"
+        result_md += f"- ID: `{space_info['id']}`\n"
+        result_md += f"- Title: {space_info['title']}\n"
+        result_md += f"- Description: {space_info['description']}\n"
+
+        return (
+            result_md,
+            space_info["title"],
+            space_info["description"],
+        )
+    except Exception as e:
+        print(f"Error validating space: {e}")
+        return f"Error: {str(e)}", "", ""
+
+
+def on_add_tool(space_id, space_name, space_description, current_tools):
+    if not space_id:
+        return (
+            current_tools,
+            "Please enter a space ID.",
+        )
+
+    # Check if this tool is already added
+    for tool in current_tools:
+        if tool["id"] == space_id:
+            return (
+                current_tools,
+                f"Tool '{space_id}' is already added.",
+            )
+
+    # Add the new tool
+    new_tool = {
+        "id": space_id,
+        "name": space_name if space_name else space_id,
+        "description": space_description if space_description else "No description",
+    }
+
+    updated_tools = current_tools + [new_tool]
+
+    # Format the tools as markdown
+    tools_md = "### Added Tools:\n"
+    for i, tool in enumerate(updated_tools, 1):
+        tools_md += f"{i}. **{tool['name']}** (`{tool['id']}`)\n"
+        tools_md += f"   {tool['description']}\n\n"
+
+    return updated_tools, tools_md
+
+
+def on_create_agent(model, space_tools):
+    if not space_tools:
+        return (
+            None,
+            [],
+            "",
+            "Please add at least one tool before creating an agent.",
+            "No agent created yet.",
+        )
+
+    try:
+        # Create the agent
+        agent = create_agent(model, space_tools)
+
+        if agent is None:
+            return (
+                None,
+                [],
+                "",
+                "Failed to create agent. Please try again with different tools or model.",
+                "No agent created yet.",
+            )
+
+        # Format the tools for display
+        tools_str = ", ".join(
+            [f"{tool['name']} ({tool['id']})" for tool in space_tools]
+        )
+
+        # Generate agent status
+        agent_status = update_agent_status(agent)
+
+        return (
+            agent,
+            [],
+            "",
+            f"✅ Agent created successfully with {model}!\nTools: {tools_str}",
+            agent_status,
+        )
+    except Exception as e:
+        print(f"Error creating agent: {e}")
+        return None, [], "", f"Error creating agent: {str(e)}", "No agent created yet."
+
+
+def add_user_message(message, chat_history):
+    """Add the user message to the chat history."""
+    # For Gradio chatbot with type="messages", we need to use ChatMessage objects
+    if not message:
+        return "", chat_history
+
+    # Add user message to chat history
+    chat_history = chat_history + [ChatMessage(role="user", content=message)]
+    return message, chat_history
+
+
+def stream_to_gradio(
+    agent,
+    task: str,
+    reset_agent_memory: bool = False,
+    additional_args: Optional[dict] = None,
+):
+    """Runs an agent with the given task and streams the messages from the agent as gradio ChatMessages."""
+
+    from smolagents.gradio_ui import pull_messages_from_step, handle_agent_output_types
+    from smolagents.agent_types import AgentAudio, AgentImage, AgentText
+
+    for step_log in agent.run(
+        task, stream=True, reset=reset_agent_memory, additional_args=additional_args
+    ):
+        for message in pull_messages_from_step(
+            step_log,
+        ):
+            yield message
+
+    final_answer = step_log  # Last log is the run's final_answer
+    final_answer = handle_agent_output_types(final_answer)
+
+    if isinstance(final_answer, AgentImage):
+        yield gr.ChatMessage(
+            role="assistant",
+            content={"path": final_answer.to_string(), "mime_type": "image/png"},
+        )
+    elif isinstance(final_answer, AgentText) and os.path.exists(
+        final_answer.to_string()
+    ):
+        yield gr.ChatMessage(
+            role="assistant",
+            content=gr.Image(final_answer.to_string()),
+        )
+    elif isinstance(final_answer, AgentAudio):
+        yield gr.ChatMessage(
+            role="assistant",
+            content={"path": final_answer.to_string(), "mime_type": "audio/wav"},
+        )
+    else:
+        yield gr.ChatMessage(
+            role="assistant", content=f"**Final answer:** {str(final_answer)}"
+        )
+
+
+def stream_agent_response(agent, message, chat_history):
+    """Stream the agent's response to the chat history."""
+    if not message or agent is None:
+        return chat_history
+
+    # First yield the current chat history
+    yield chat_history
+
+    try:
+        # Stream the agent's response
+        for msg in stream_to_gradio(agent, message):
+            # Add the message to chat history
+            chat_history = chat_history + [msg]
+            # Yield updated chat history
+            yield chat_history
+    except Exception as e:
+        # Handle errors
+        error_msg = f"Error: {str(e)}"
+        chat_history = chat_history + [ChatMessage(role="assistant", content=error_msg)]
+        yield chat_history
+
+
+def on_clear(agent=None):
+    """Clear the chat and reset the agent."""
+    return (
+        agent,
+        [],
+        "",
+        "Agent cleared. Create a new one to continue.",
+        "",
+        gr.update(interactive=False),
+    )
+
+
+def update_agent_status(agent):
+    """Update the agent status display with current information."""
+    if agent is None:
+        return "No agent created yet. Add a Space tool to get started."
+
+    # Get agent information
+    tools = agent.tools if hasattr(agent, "tools") else []
+    tool_count = len(tools)
+
+    # Create status message
+    status = f"Agent ready with {tool_count} tools"
+    return status
+
+
+# Create the Gradio app
+with gr.Blocks(title="AI Agent Builder") as app:
+    gr.Markdown("# AI Agent Builder with SmolaGents")
+    gr.Markdown("Build your own AI agent by selecting tools from Hugging Face Spaces.")
+
+    # Agent state
+    agent_state = gr.State(None)
+    last_message = gr.State("")
+    space_tools_state = gr.State([])
+
+    # Message store for preserving user message
+    msg_store = gr.State("")
+
+    with gr.Row():
+        # Left sidebar for tool configuration
+        with gr.Column(scale=1):
+            gr.Markdown("## Tool Configuration")
+            gr.Markdown("Add multiple Hugging Face Spaces as tools for your agent:")
+
+            # Hidden model input with default value
+            model_input = gr.Textbox(
+                value=DEFAULT_MODEL,
+                label="Model",
+                visible=False,
+            )
+
+            # Space tool input
+            with gr.Group():
+                gr.Markdown("### Add Space as Tool")
+                space_tool_input = gr.Textbox(
+                    label="Space ID or Search Term",
+                    placeholder=("Enter a Space ID or search term"),
+                    info="Enter a Space ID (username/space-name) or search term",
+                )
+                space_name_input = gr.Textbox(
+                    label="Tool Name (optional)",
+                    placeholder="Enter a name for this tool",
+                )
+                space_description_input = gr.Textbox(
+                    label="Tool Description (optional)",
+                    placeholder="Enter a description for this tool",
+                    lines=2,
+                )
+                add_tool_button = gr.Button("Add Tool", variant="primary")
+
+            # Display added tools
+            gr.Markdown("### Added Tools")
+            tools_display = gr.Markdown(
+                "No tools added yet. Add at least one tool before creating an agent."
+            )
+
+            # Create agent button
+            create_button = gr.Button(
+                "Create Agent with Selected Tools", variant="secondary", size="lg"
+            )
+
+            # Status message
+            status_msg = gr.Markdown("")
+
+            # Agent status display
+            agent_status = gr.Markdown("No agent created yet.")
+
+        # Main content area
+        with gr.Column(scale=2):
+            # Chat interface for the agent
+            chatbot = gr.Chatbot(
+                label="Agent Chat",
+                height=600,
+                show_copy_button=True,
+                avatar_images=("👤", "🤖"),
+                type="messages",  # Use messages type for ChatMessage objects
+            )
+            msg = gr.Textbox(
+                label="Your message",
+                placeholder="Type a message to your agent...",
+                interactive=True,
+            )
+
+            with gr.Row():
+                with gr.Column(scale=1, min_width=60):
+                    clear = gr.Button("🗑️", scale=1)
+                with gr.Column(scale=8):
+                    # Empty column for spacing
+                    pass
+
+    # Connect event handlers
+    # Connect the space_tool_input submit event to the validation handler
+    space_tool_input.submit(
+        on_validate_space,
+        inputs=[space_tool_input],
+        outputs=[status_msg, space_name_input, space_description_input],
+    )
+
+    # Connect the add tool button
+    add_tool_button.click(
+        on_add_tool,
+        inputs=[
+            space_tool_input,
+            space_name_input,
+            space_description_input,
+            space_tools_state,
+        ],
+        outputs=[space_tools_state, tools_display],
+    )
+
+    # Connect the create button to the handler
+    create_button.click(
+        on_create_agent,
+        inputs=[model_input, space_tools_state],
+        outputs=[agent_state, chatbot, msg, status_msg, agent_status],
+    )
+
+    # Connect the message input to the chain of handlers
+    msg.submit(
+        lambda message: (message, message, ""),  # Store message and clear input
+        inputs=[msg],
+        outputs=[msg_store, msg, msg],
+        queue=False,
+    ).then(
+        add_user_message,  # Add user message to chat
+        inputs=[msg_store, chatbot],
+        outputs=[msg_store, chatbot],
+        queue=False,
+    ).then(
+        stream_agent_response,  # Generate and stream response
+        inputs=[agent_state, msg_store, chatbot],
+        outputs=chatbot,
+        queue=True,
+    )
+
+
+if __name__ == "__main__":
+    app.queue().launch()

build/lib/app.py

@@ -0,0 +1,218 @@
+import gradio as gr
+import os
+from smolagents import CodeAgent, ToolCollection, Tool
+from smolagents.models import HfApiModel, LiteLLMModel
+
+# Default model to use
+DEFAULT_MODEL = "Qwen/Qwen2.5-Coder-7B-Instruct"
+
+# Tool descriptions for the UI
+TOOL_DESCRIPTIONS = {
+    "Hub Collections": "Add tool collections from Hugging Face Hub.",
+    "Spaces": "Add tools from Hugging Face Spaces.",
+}
+
+
+# Function to create an agent with selected tools
+def create_agent(model_name, hub_tool=None, space_tool=None):
+    tools = []
+
+    # Add tool from Hub if provided
+    if hub_tool:
+        try:
+            hub_collection = ToolCollection.from_hub(collection_slug=hub_tool)
+            tools.extend(hub_collection.tools)
+        except Exception as e:
+            print(f"Error loading Hub tool: {e}")
+
+    # Add tool from Space if provided
+    if space_tool:
+        try:
+            space_tool_obj = Tool.from_space(
+                space_id=space_tool,
+                name=f"space_{space_tool.replace('/', '_')}",
+                description=f"Tool from Hugging Face Space: {space_tool}",
+            )
+            tools.append(space_tool_obj)
+        except Exception as e:
+            print(f"Error loading Space tool: {e}")
+
+    # Create and return the agent
+    try:
+        # Try to use HfApiModel first
+        model = HfApiModel(model_id=model_name)
+        return CodeAgent(tools=tools, model=model)
+    except Exception:
+        # Fall back to LiteLLMModel if HfApiModel fails
+        try:
+            model = LiteLLMModel(model_id=model_name)
+            return CodeAgent(tools=tools, model=model)
+        except Exception as e:
+            print(f"Error creating agent: {e}")
+            return None
+
+
+# Main application
+def main():
+    with gr.Blocks(title="AI Agent Builder") as app:
+        gr.Markdown("# AI Agent Builder with SmolaGents")
+        gr.Markdown(
+            "Build your own AI agent by selecting tools from Hugging Face Hub and Spaces."
+        )
+
+        with gr.Tabs():
+            with gr.TabItem("Build Agent"):
+                with gr.Row():
+                    with gr.Column(scale=1):
+                        # Model selection
+                        model_input = gr.Textbox(
+                            label="Model Name",
+                            placeholder="Enter model name or ID",
+                            value=DEFAULT_MODEL,
+                        )
+
+                        # Hub tool input
+                        hub_tool_input = gr.Textbox(
+                            label="Add Tool Collection from Hub (collection slug)",
+                            placeholder="e.g., huggingface-tools/diffusion-tools-...",
+                        )
+
+                        # Space tool input
+                        space_tool_input = gr.Textbox(
+                            label="Add Tool from Space (space ID)",
+                            placeholder="e.g., black-forest-labs/FLUX.1-schnell",
+                        )
+
+                        # Create agent button
+                        create_button = gr.Button("Create Agent")
+
+                        # Status message
+                        status_msg = gr.Markdown("")
+
+                    with gr.Column(scale=2):
+                        # Chat interface for the agent
+                        chatbot = gr.Chatbot(label="Agent Chat")
+                        msg = gr.Textbox(label="Your message")
+
+                        with gr.Row():
+                            clear = gr.Button("Clear Chat")
+                            regenerate = gr.Button("Regenerate Response")
+
+            with gr.TabItem("Tool Descriptions"):
+                tool_descriptions_md = """
+## Hugging Face Hub Tool Collections
+
+You can add tool collections from Hugging Face Hub by providing the collection slug.
+Example: `huggingface-tools/diffusion-tools-6630bb19a942c2306a2cdb6f`
+
+## Hugging Face Spaces as Tools
+
+You can add tools from Hugging Face Spaces by providing the space ID.
+Example: `black-forest-labs/FLUX.1-schnell`
+
+This allows you to use any Gradio app on Hugging Face Spaces as a tool for your agent.
+                """
+
+                gr.Markdown(tool_descriptions_md)
+
+        # Agent state
+        agent_state = gr.State(None)
+        last_message = gr.State("")
+
+        # Event handlers
+        def on_create_agent(model, hub_tool, space_tool):
+            if not model:
+                return None, [], "", "⚠️ Please enter a model name."
+
+            if not hub_tool and not space_tool:
+                return None, [], "", "⚠️ Please add at least one tool from Hub or Space."
+
+            agent = create_agent(model, hub_tool, space_tool)
+
+            if agent is None:
+                return (
+                    None,
+                    [],
+                    "",
+                    "❌ Failed to create agent. Check console for details.",
+                )
+
+            tools_info = []
+            if hub_tool:
+                tools_info.append(f"Hub collection: {hub_tool}")
+            if space_tool:
+                tools_info.append(f"Space: {space_tool}")
+
+            tools_str = " | ".join(tools_info)
+
+            return (
+                agent,
+                [],
+                "",
+                f"✅ Agent created successfully with {model}! ({tools_str})",
+            )
+
+        create_button.click(
+            on_create_agent,
+            inputs=[model_input, hub_tool_input, space_tool_input],
+            outputs=[agent_state, chatbot, msg, status_msg],
+        )
+
+        def on_message(message, chat_history, agent, last_msg):
+            if not message:
+                return "", chat_history, last_msg
+
+            if agent is None:
+                chat_history.append((message, "Please create an agent first."))
+                return "", chat_history, last_msg
+
+            try:
+                response = agent.run(message, reset=False)
+                chat_history.append((message, response))
+                return "", chat_history, message
+            except Exception as e:
+                error_msg = f"Error: {str(e)}"
+                chat_history.append((message, error_msg))
+                return "", chat_history, message
+
+        msg.submit(
+            on_message,
+            inputs=[msg, chatbot, agent_state, last_message],
+            outputs=[msg, chatbot, last_message],
+        )
+
+        def on_regenerate(chat_history, agent, last_msg):
+            if not chat_history or not last_msg or agent is None:
+                return chat_history, last_msg
+
+            try:
+                # Remove the last exchange
+                if chat_history:
+                    chat_history.pop()
+
+                # Regenerate the response
+                response = agent.run(last_msg, reset=False)
+                chat_history.append((last_msg, response))
+                return chat_history, last_msg
+            except Exception as e:
+                error_msg = f"Error regenerating response: {str(e)}"
+                chat_history.append((last_msg, error_msg))
+                return chat_history, last_msg
+
+        regenerate.click(
+            on_regenerate,
+            inputs=[chatbot, agent_state, last_message],
+            outputs=[chatbot, last_message],
+        )
+
+        def on_clear():
+            return None, [], "", "Agent cleared. Create a new one to continue."
+
+        clear.click(on_clear, outputs=[agent_state, chatbot, last_message, status_msg])
+
+    return app
+
+
+if __name__ == "__main__":
+    app = main()
+    app.launch()

pyproject.toml

@@ -0,0 +1,11 @@
+[project]
+name = "agent-builder"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.11"
+dependencies = [
+    "gradio>=5.20.0",
+    "huggingface-hub>=0.28.1",
+    "smolagents>=1.10.0",
+]

requirements.txt

@@ -0,0 +1,179 @@
+# This file was autogenerated by uv via the following command:
+#    uv pip compile --output-file requirements.txt pyproject.toml
+aiofiles==23.2.1
+    # via gradio
+annotated-types==0.7.0
+    # via pydantic
+anyio==4.8.0
+    # via
+    #   gradio
+    #   httpx
+    #   starlette
+beautifulsoup4==4.13.3
+    # via markdownify
+certifi==2025.1.31
+    # via
+    #   httpcore
+    #   httpx
+    #   requests
+charset-normalizer==3.4.1
+    # via requests
+click==8.1.8
+    # via
+    #   duckduckgo-search
+    #   typer
+    #   uvicorn
+duckduckgo-search==7.5.0
+    # via smolagents
+fastapi==0.115.11
+    # via gradio
+ffmpy==0.5.0
+    # via gradio
+filelock==3.17.0
+    # via huggingface-hub
+fsspec==2025.2.0
+    # via
+    #   gradio-client
+    #   huggingface-hub
+gradio==5.20.0
+    # via agent-builder (pyproject.toml)
+gradio-client==1.7.2
+    # via gradio
+groovy==0.1.2
+    # via gradio
+h11==0.14.0
+    # via
+    #   httpcore
+    #   uvicorn
+httpcore==1.0.7
+    # via httpx
+httpx==0.28.1
+    # via
+    #   gradio
+    #   gradio-client
+    #   safehttpx
+huggingface-hub==0.29.2
+    # via
+    #   agent-builder (pyproject.toml)
+    #   gradio
+    #   gradio-client
+    #   smolagents
+idna==3.10
+    # via
+    #   anyio
+    #   httpx
+    #   requests
+jinja2==3.1.6
+    # via
+    #   gradio
+    #   smolagents
+lxml==5.3.1
+    # via duckduckgo-search
+markdown-it-py==3.0.0
+    # via rich
+markdownify==1.1.0
+    # via smolagents
+markupsafe==2.1.5
+    # via
+    #   gradio
+    #   jinja2
+mdurl==0.1.2
+    # via markdown-it-py
+numpy==2.2.3
+    # via
+    #   gradio
+    #   pandas
+orjson==3.10.15
+    # via gradio
+packaging==24.2
+    # via
+    #   gradio
+    #   gradio-client
+    #   huggingface-hub
+pandas==2.2.3
+    # via
+    #   gradio
+    #   smolagents
+pillow==11.1.0
+    # via
+    #   gradio
+    #   smolagents
+primp==0.14.0
+    # via duckduckgo-search
+pydantic==2.10.6
+    # via
+    #   fastapi
+    #   gradio
+pydantic-core==2.27.2
+    # via pydantic
+pydub==0.25.1
+    # via gradio
+pygments==2.19.1
+    # via rich
+python-dateutil==2.9.0.post0
+    # via pandas
+python-dotenv==1.0.1
+    # via smolagents
+python-multipart==0.0.20
+    # via gradio
+pytz==2025.1
+    # via pandas
+pyyaml==6.0.2
+    # via
+    #   gradio
+    #   huggingface-hub
+requests==2.32.3
+    # via
+    #   huggingface-hub
+    #   smolagents
+rich==13.9.4
+    # via
+    #   smolagents
+    #   typer
+ruff==0.9.9
+    # via gradio
+safehttpx==0.1.6
+    # via gradio
+semantic-version==2.10.0
+    # via gradio
+shellingham==1.5.4
+    # via typer
+six==1.17.0
+    # via
+    #   markdownify
+    #   python-dateutil
+smolagents==1.10.0
+    # via agent-builder (pyproject.toml)
+sniffio==1.3.1
+    # via anyio
+soupsieve==2.6
+    # via beautifulsoup4
+starlette==0.46.0
+    # via
+    #   fastapi
+    #   gradio
+tomlkit==0.13.2
+    # via gradio
+tqdm==4.67.1
+    # via huggingface-hub
+typer==0.15.2
+    # via gradio
+typing-extensions==4.12.2
+    # via
+    #   anyio
+    #   beautifulsoup4
+    #   fastapi
+    #   gradio
+    #   gradio-client
+    #   huggingface-hub
+    #   pydantic
+    #   pydantic-core
+    #   typer
+tzdata==2025.1
+    # via pandas
+urllib3==2.3.0
+    # via requests
+uvicorn==0.34.0
+    # via gradio
+websockets==15.0.1
+    # via gradio-client