app.py

import gradio as gr
import typing as ty

# Importing the tool files automatically registers them with the mcp_tool registry
# This assumes all tool files are in the 'tools' directory and end with '_tool.py'
# A more robust approach might explicitly import each tool file.
# For this example, we explicitly import the one tool file.
import tools.time_tool

# Import the mcp_tool registry instance
from utils.mcp_decorator import mcp_tool

def update_tool_info(selected_api_name: str, *tool_group_visibility_states: gr.State) -> ty.List[gr.update]:
    """
    Updates the displayed docstring and the visibility of tool UI groups
    based on the selected tool from the dropdown.

    Args:
        selected_api_name: The api_name of the tool selected in the dropdown.
        tool_group_visibility_states: The current state of visibility for each tool group component
                                      (passed automatically by Gradio when they are outputs).

    Returns:
        A list of gr.update objects for the docstring and each tool UI group.
    """
    updates = []

    # 1. Update Docstring
    docstring_update = gr.Markdown.update(visible=False, value="") # Hide and clear by default
    if selected_api_name:
        tool_info = mcp_tool.get_tool_info(selected_api_name)
        if tool_info and tool_info.get('tool_func') and tool_info['tool_func'].__doc__:
             docstring_update = gr.Markdown.update(visible=True, value=f"### Tool Documentation\n---\n{tool_info['tool_func'].__doc__}\n---")

    updates.append(docstring_update)

    # 2. Update Visibility of Tool UI Groups
    # We need to return an update for *each* tool UI group defined in the layout.
    # The order must match the order they appear in the 'outputs' list of the .change() event.
    all_tools_api_names = [api_name for _, api_name in mcp_tool.get_tools_list()]
    
    # Ensure the order of updates matches the order of tool_uis_list created below
    # We'll assume the order from get_tools_list() is consistent.
    
    for api_name_in_list in all_tools_api_names:
         is_selected_tool = (api_name_in_list == selected_api_name)
         # Return gr.update(visible=...) for each tool group
         updates.append(gr.Group.update(visible=is_selected_tool))

    # The total number of updates returned must match the total number of outputs
    # defined in the dropdown.change() call.
    # Outputs are [doc_display, *list_of_tool_groups]
    # Inputs are [dropdown, *list_of_tool_groups]
    # This function signature with *tool_group_visibility_states receiving the
    # current state of the output components is how Gradio handles inputs/outputs
    # when the outputs themselves are also inputs for their own updates (like visibility).
    # However, for simple visibility toggling based *only* on the dropdown value,
    # we don't strictly *need* tool_group_visibility_states as input. We can just
    # return the updates based on the selected_api_name.
    # Let's simplify the function signature and inputs/outputs.
    # The function just needs selected_api_name. It will return the docstring update
    # and visibility updates for *all* groups.

    # Revised update_tool_info:
    # Input: selected_api_name (str)
    # Outputs: doc_display (Markdown), Tool_UI_Group_1 (Group), Tool_UI_Group_2 (Group), ...

    return updates # This list contains updates for docstring + all tool groups

# --- Gradio App Layout ---
with gr.Blocks(title="MCP Server Demo") as demo:
    gr.Markdown("# Gradio MCP Server Demo")
    gr.Markdown("Select a tool to view its documentation and UI controls.")

    # Get defined tools
    tool_options = mcp_tool.get_tools_list() # Returns list of (name, api_name)

    if not tool_options:
        gr.Warning("No tools defined. Please check the 'tools' directory.")
        gr.Markdown("No tools available.")
    else:
        # Dropdown to select tool. Using api_name as value for easier lookup.
        dropdown = gr.Dropdown(
            choices=[(name, api_name) for name, api_name in tool_options],
            label="Select a Tool",
            interactive=True,
        )

        # Markdown component to display tool documentation
        doc_display = gr.Markdown(label="Tool Documentation", visible=False)

        # Container to hold dynamic UI controls.
        # We will create a separate gr.Group for each tool's UI inside this container.
        tool_uis_container = gr.Column()

        # List to hold the UI groups for each tool and map outputs
        tool_ui_groups_list = []

        # Dynamically create UI components for each tool
        with tool_uis_container:
             for tool_name, api_name in tool_options:
                 ui_builder = mcp_tool.get_tool_ui_builder(api_name)
                 if ui_builder:
                     # Call the UI builder function to get the components (should be a gr.Group/Column)
                     tool_ui_group = ui_builder()
                     # Ensure the group is initially hidden
                     tool_ui_group.visible = False
                     # Add the group to our list for output mapping
                     tool_ui_groups_list.append(tool_ui_group)
                 else:
                     # Handle tools defined without a UI builder
                     gr.Markdown(f"Tool '{tool_name}' ({api_name}) has no UI controls defined.", visible=False, elem_id=f"no_ui_{api_name}")
                     # Add a placeholder to maintain output count consistency if necessary,
                     # or ensure build_ui_control always returns a gr.Group (even empty).
                     # Let's assume build_ui_control always returns a group/column.
                     if api_name not in [g.elem_id for g in tool_ui_groups_list if hasattr(g, 'elem_id')]: # Avoid duplicates if builder called earlier
                         # Create a dummy group if builder was missing or returned None unexpectedly
                         with gr.Group(visible=False) as dummy_group:
                             gr.Markdown(f"No UI for {tool_name}")
                         tool_ui_groups_list.append(dummy_group)


        # --- Event Handling ---
        # When the dropdown selection changes, update the displayed info and controls
        dropdown.change(
            fn=update_tool_info,
            inputs=[dropdown], # Just the selected value from the dropdown
            outputs=[doc_display, *tool_ui_groups_list], # Docstring + all tool UI groups for visibility updates
            # Set queue=False for smoother UI updates if needed, depends on complexity
            # queue=False # might cause issues with visibility updates in complex layouts, test if needed
        )
        
        # Trigger an initial update if a default value is set or after loading
        # This ensures the UI is correct when the app first loads if a tool is pre-selected
        # or if you want to show the first tool's info by default.
        # Let's not trigger initially unless a tool is pre-selected in the dropdown.
        # If allow_clear=True and value is None, initial update won't show anything which is fine.


# --- Launch the Gradio App as an MCP Server ---
if __name__ == "__main__":
    # To host on Hugging Face Spaces, use server_name="0.0.0.0" and server_port=7860 (default)
    # The mcp_server=True flag enables the SSE endpoint for MCP clients.
    # Gradio automatically discovers functions decorated with __mcp_tool__ attribute
    # (which our @mcp_tool.define decorator adds) and exposes them via the MCP endpoint.
    print("Launching Gradio app with MCP server enabled...")
    demo.launch(
        server_name="0.0.0.0", # Required for Spaces
        # server_port=7860, # Default port for Spaces, can be omitted
        mcp_server=True,      # Enable the MCP server endpoint
        # share=True,        # Default and recommended for Spaces
    )
    print("Gradio app launched.")