+

app.py

@@ -1,187 +1,107 @@
+# app.py
+
 import gradio as gr
-import typing as ty
-import inspect
-import json # For potential JSON output formatting
 
-# Importing the tool files automatically registers them with the mcp_tool registry
-import tools.time_tool
+# IMPOR T ALL YOUR TOOLS HERE
+# This is essential so the @tool decorators run and populate the registry
+import tools.get_current_time
+import tools.echo_text
+# Import other tools as you create them: import tools.another_tool
 
-# Import the mcp_tool registry instance
-from utils.mcp_decorator import mcp_tool
+from utils.tool_manager import get_tool_registry
 
-def update_tool_info(selected_api_name: str, *tool_group_visibility_states: gr.State) -> ty.List[gr.update]:
-    """
-    Updates the displayed docstring, visibility of tool UI groups, and
-    visibility of execute/output areas based on the selected tool.
+# Get the registry after all tool files have been imported
+TOOL_REGISTRY = get_tool_registry()
+
+def get_tool_names():
+    """Returns a list of tool names for the dropdown."""
+    return [tool_info['name'] for tool_info in TOOL_REGISTRY.values()]
+
+def get_tool_internal_names():
+     """Returns a list of internal function names for dropdown values."""
+     return list(TOOL_REGISTRY.keys())
 
-    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).
+def get_tool_ui_groups():
+    """Returns a list of the gr.Group components for each tool's UI."""
+    # The order must match the order of internal names from get_tool_internal_names
+    internal_names_order = get_tool_internal_names()
+    return [TOOL_REGISTRY[name]['ui_components']['group'] for name in internal_names_order]
 
-    Returns:
-        A list of gr.update objects for the docstring and each tool UI group.
+
+def on_tool_select(selected_tool_internal_name):
+    """
+    Handles the tool selection dropdown change event.
+    Returns a list of gr.update objects to control visibility of tool UIs.
     """
     updates = []
-    tool_options = mcp_tool.get_tools_list() # List of (name, api_name)
-
-    # Separate tool groups from other inputs received by the handler
-    # The first len(tool_options) outputs are the tool UI groups
-    tool_ui_groups = tool_ui_groups_and_inputs[:len(tool_options)]
-
-    # 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
+    # Iterate through all tools in the registry
+    for internal_name, tool_info in TOOL_REGISTRY.items():
+        ui_group = tool_info['ui_components']['group']
+        # Set visible to True only for the selected tool's group
+        updates.append(gr.update(visible=(internal_name == selected_tool_internal_name)))
+    return updates
 
-# --- 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, configure parameters, and execute.")
-
-    # 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,
-            value=None # Start with no tool selected
-        )
 
-        # Markdown component to display tool documentation
-        # Needs a specific elem_id or be directly referenced as an output
-        doc_display = gr.Markdown(label="Tool Documentation", visible=False)
-
-        # Button to execute the tool (initially hidden)
-        execute_button = gr.Button("Execute Tool", visible=False)
-
-        # Area to display the API call signature (initially hidden)
-        # Using gr.Code for a code-like appearance
-        api_call_display = gr.Code(
-            label="Use Via API (Example Call)",
-            language="json", # Or "yaml" or "text"
-            interactive=False,
-            visible=False,
-            value=""
-        )
+# --- Gradio App Layout ---
+with gr.Blocks() as app:
+    gr.Markdown("# Multi-Tool System")
+
+    # Tool Selection Dropdown
+    tool_dropdown = gr.Dropdown(
+        choices=get_tool_names(), # Display names
+        value=get_tool_names()[0] if get_tool_names() else None, # Select the first tool by default
+        label="Select a Tool",
+        interactive=True
+    )
 
-        # Area to display the tool's output (initially hidden)
-        # Using gr.Textbox for simplicity, could use gr.JSON if outputs are dicts/lists
-        tool_output_display = gr.Textbox(
-            label="Tool Output",
-            interactive=False,
-            visible=False,
-            value="",
-            container=True # Wrap in a container for better spacing
+    # Dictionary to hold references to the UI components for each tool
+    tool_uis = {}
+
+    # Build and store UI components for each registered tool
+    # All UIs are built initially, but their containing gr.Group is hidden by the ui_builder
+    for internal_name, tool_info in TOOL_REGISTRY.items():
+        ui_builder = tool_info['ui_builder']
+        tool_func = tool_info['func']
+
+        # Build the UI components using the tool's ui_builder function
+        # The ui_builder MUST return (ui_group, inputs, outputs, button)
+        ui_group, inputs, outputs, button = ui_builder()
+
+        # Store references to the components
+        tool_uis[internal_name] = {
+            'group': ui_group,
+            'inputs': inputs,
+            'outputs': outputs,
+            'button': button
+        }
+
+        # Wire up the button click event for this tool
+        # Use the actual tool function as the handler
+        # Use api_name corresponding to the tool function's name
+        button.click(
+            fn=tool_func,
+            inputs=inputs,
+            outputs=outputs,
+            api_name=tool_func.__name__ # Required by the user
         )
 
+    # Link the dropdown change event to the function that updates UI visibility
+    # The outputs are the gr.Group components of ALL tools
+    tool_dropdown.change(
+        fn=on_tool_select,
+        inputs=tool_dropdown,
+        outputs=get_tool_ui_groups() # A list of all gr.Group components
+    )
 
-        # Container to hold dynamic UI controls.
-        tool_uis_container = gr.Column()
-
-        # List to hold the UI groups for each tool and map outputs
-        tool_ui_groups_list = []
-        all_input_components_list = []
-
-        # Dynamically create UI components for each tool
-        with tool_uis_container:
-             # Process tools in a consistent order (matching mcp_tool.get_all_arg_components_list)
-             # This ensures the order of components in all_input_components_list is predictable.
-             for tool_name, api_name in sorted(mcp_tool.tools.items()): # Iterate registry items directly for order
-                 ui_builder = api_name.get('ui_builder')
-                 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)
-
-                     # Add the individual input components from this tool to the master list
-                     # Ensure order within a tool is consistent (e.g., alphabetical by arg name)
-                     for arg_name in sorted(arg_component_map.keys()):
-                          component = arg_component_map[arg_name]
-                          all_input_components_list.append(component)
-
-                 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.
+    # Initial UI setup: Trigger the on_tool_select for the default selected tool
+    # This makes the first tool's UI visible on load
+    app.load(
+        fn=on_tool_select,
+        inputs=tool_dropdown, # Pass the initial value of the dropdown
+        outputs=get_tool_ui_groups()
+    )
 
 
-# --- Launch the Gradio App as an MCP Server ---
+# Run the app
 if __name__ == "__main__":
-    print("Launching Gradio app with MCP server enabled...")
-    demo.launch(
-        server_name="0.0.0.0", # Required for Spaces
-        mcp_server=True,      # Enable the MCP server endpoint
-        # share=True,        # Default and recommended for Spaces
-    )
-    print("Gradio app launched.")
+    app.launch()

tools/echo_text.py

@@ -0,0 +1,33 @@
+# tools/echo_text.py
+
+import gradio as gr
+from utils.tool_manager import tool
+
+def echo_ui():
+    """
+    Builds the Gradio UI components for the Echo Text tool.
+    Returns a tuple: (ui_group, input_components, output_components, button_component)
+    """
+    with gr.Group(visible=False) as ui_group: # Initially hidden
+        gr.Markdown("## Echo Text")
+        input_text = gr.Textbox(label="Enter text to echo", placeholder="Type something...")
+        output_text = gr.Textbox(label="Echoed Text", interactive=False)
+        run_button = gr.Button("Echo")
+    # Return the group, input(s), output(s), and the button
+    return ui_group, input_text, output_text, run_button
+
+@tool(
+    name="Echo Text",
+    control_components=echo_ui # Pass the UI builder function
+)
+def echo_function(text: str) -> str:
+    """
+    Echoes the input text.
+
+    Args:
+        text (str): The input text.
+
+    Returns:
+        str: The input text.
+    """
+    return text

tools/{time_tool.py → get_current_time.py}

@@ -1,15 +1,26 @@
+# tools/get_current_time.py
+
+import gradio as gr
 import datetime
 import pytz
-import typing as ty
-import gradio as gr
+from utils.tool_manager import tool
 
-# Import the decorator instance
-from utils.mcp_decorator import mcp_tool
-
-# --- Tool Definition ---
-@mcp_tool.define(
-    name="Get current time",
-    api_name="get_current_time",
+def time_ui():
+    """
+    Builds the Gradio UI components for the Get Current Time tool.
+    Returns a tuple: (ui_group, input_components, output_components, button_component)
+    """
+    with gr.Group(visible=False) as ui_group: # Initially hidden
+        gr.Markdown("## Get Current Time")
+        timezone_input = gr.Textbox(label="Timezone (e.g., UTC, Asia/Ho_Chi_Minh)", value="UTC", placeholder="Enter IANA timezone name")
+        output_text = gr.Textbox(label="Current Time", interactive=False)
+        run_button = gr.Button("Get Time")
+    # Return the group, input(s), output(s), and the button
+    return ui_group, timezone_input, output_text, run_button
+
+@tool(
+    name="Get Current Time",
+    control_components=time_ui # Pass the UI builder function
 )
 def get_current_time(timezone: str = "UTC") -> str:
     """
@@ -26,6 +37,7 @@ def get_current_time(timezone: str = "UTC") -> str:
         str: The current time in the specified timezone, or an error message.
     """
     try:
+        # pytz requires the timezone string to be correct
         tz = pytz.timezone(timezone)
         now_utc = datetime.datetime.utcnow()
         now_in_tz = pytz.utc.localize(now_utc).astimezone(tz)
@@ -33,30 +45,4 @@ def get_current_time(timezone: str = "UTC") -> str:
     except pytz.UnknownTimeZoneError:
         return f"Error: Unknown timezone '{timezone}'. Please provide a valid IANA timezone name."
     except Exception as e:
-        return f"An unexpected error occurred: {e}"
-
-# --- UI Control Builder ---
-@mcp_tool.build_ui_control(api_name="get_current_time")
-def build_time_ui_control() -> ty.Tuple[gr.Group, ty.Dict[str, gr.components.Component]]:
-    """
-    Builds Gradio UI components for the Get current time tool.
-    Returns a tuple: (gr.Group containing controls, dict mapping arg name to component).
-    """
-    # Dictionary to hold the mapping from argument name (string) to component instance
-    arg_components = {}
-
-    with gr.Group(visible=False) as time_tool_group:
-        gr.Markdown("Configure **Get current time** tool:")
-        # Create a textbox for the 'timezone' argument
-        # Store the component instance in the dictionary
-        timezone_input = gr.Textbox(
-            label="Timezone",
-            value="UTC",
-            placeholder="e.g., America/New_York, Asia/Ho_Chi_Minh",
-            interactive=True,
-            # elem_id=f"get_current_time_timezone_input" # Good practice for debugging, not strictly needed by logic
-        )
-        arg_components["timezone"] = timezone_input
-
-    # Return the group and the dictionary mapping arg names to components
-    return time_tool_group, arg_components
+        return f"An unexpected error occurred: {e}"

utils/mcp_decorator.py

@@ -1,107 +0,0 @@
-import functools
-import inspect
-import typing as ty
-import gradio as gr
-
-# Define a registry to store tools and their metadata
-class MCPToolRegistry:
-    def __init__(self):
-        # Stores tool data:
-        # {'api_name': {
-        #     'name': str,
-        #     'tool_func': func,
-        #     'ui_builder': func,
-        #     'ui_group': gr.Group, # Store the created group instance
-        #     'arg_component_map': {str: gr.components.Component} # Map arg name to component instance
-        # }}
-        self.tools = {}
-
-    def define(self, name: str, api_name: str):
-        """Decorator to define an MCP tool."""
-        def decorator(tool_func: ty.Callable):
-            if api_name in self.tools:
-                raise ValueError(f"Tool with api_name '{api_name}' already defined.")
-
-            # Store the tool function and metadata
-            self.tools[api_name] = {
-                'name': name,
-                'tool_func': tool_func,
-                'ui_builder': None, # Will be filled by @build_ui_control
-                'ui_group': None, # Will be filled during UI construction
-                'arg_component_map': {}, # Will be filled during UI construction
-            }
-
-            # Gradio's MCP server needs the function itself to be decorated
-            # with an attribute carrying the MCP metadata.
-            setattr(tool_func, "__mcp_tool__", {"name": name, "api_name": api_name})
-
-            return tool_func
-        return decorator
-
-    def build_ui_control(self, api_name: str):
-        """
-        Decorator to associate a UI builder function with a tool.
-        The decorated function should return a tuple:
-        (gr.Group or gr.Column component, dict[str, gr.components.Component])
-        where the dict maps argument names (matching tool_func signature)
-        to the corresponding input component instance.
-        """
-        def decorator(ui_builder_func: ty.Callable[..., ty.Tuple[ty.Union[gr.components.Component, tuple[gr.components.Component, ...]], ty.Dict[str, gr.components.Component]]]):
-            if api_name not in self.tools:
-                raise ValueError(f"Tool with api_name '{api_name}' not defined. Define it using @mcp_tool.define first.")
-
-            # Store the UI builder function reference
-            self.tools[api_name]['ui_builder'] = ui_builder_func
-
-            # Note: The actual ui_group and arg_component_map will be populated
-            # when app.py calls the ui_builder_func during Blocks setup.
-
-            return ui_builder_func
-        return decorator
-
-    def get_tools_list(self) -> list[tuple[str, str]]:
-        """Returns a list of (tool_name, api_name) for all defined tools."""
-        return [(data['name'], api_name) for api_name, data in self.tools.items()]
-
-    def get_tool_info(self, api_name: str) -> ty.Optional[dict]:
-        """Returns the full info dict for a given api_name."""
-        return self.tools.get(api_name)
-
-    def get_tool_ui_builder(self, api_name: str) -> ty.Optional[ty.Callable]:
-        """Returns the UI builder function for a given api_name."""
-        info = self.get_tool_info(api_name)
-        return info.get('ui_builder') if info else None
-
-    def get_tool_function(self, api_name: str) -> ty.Optional[ty.Callable]:
-        """Returns the tool function for a given api_name."""
-        info = self.get_tool_info(api_name)
-        return info.get('tool_func') if info else None
-
-    def set_tool_ui_components(self, api_name: str, ui_group: gr.components.Component, arg_component_map: ty.Dict[str, gr.components.Component]):
-        """Stores the actual UI group and component map after building."""
-        if api_name not in self.tools:
-             print(f"Warning: Tried to set UI components for undefined tool '{api_name}'")
-             return
-        self.tools[api_name]['ui_group'] = ui_group
-        self.tools[api_name]['arg_component_map'] = arg_component_map
-
-    def get_all_arg_components_list(self) -> ty.List[gr.components.Component]:
-        """Returns a flat list of ALL input components from ALL tools, preserving order."""
-        all_components = []
-        # Iterate through tools in a consistent order (e.g., by api_name)
-        for api_name in sorted(self.tools.keys()):
-             tool_info = self.tools[api_name]
-             # Iterate through the arg_component_map in a consistent order (e.g., by arg name)
-             for arg_name in sorted(tool_info['arg_component_map'].keys()):
-                 component = tool_info['arg_component_map'][arg_name]
-                 all_components.append(component)
-        return all_components
-
-    def get_arg_component_map(self, api_name: str) -> ty.Optional[ty.Dict[str, gr.components.Component]]:
-        """Returns the arg_component_map for a specific tool."""
-        info = self.get_tool_info(api_name)
-        return info.get('arg_component_map') if info else None
-
-
-# Instantiate the registry. This instance will be used by decorators
-mcp_tool = MCPToolRegistry()

utils/tool_manager.py

@@ -0,0 +1,38 @@
+# utils/tool_manager.py
+
+# A dictionary to store registered tools
+# Key: Internal function name (str)
+# Value: Dictionary { 'name': display_name (str), 'func': tool_function (callable), 'ui_builder': ui_builder_function (callable) }
+_tool_registry = {}
+
+def tool(name: str, control_components):
+    """
+    Decorator to register a tool function and its UI builder.
+
+    Args:
+        name (str): The display name of the tool in the UI dropdown.
+        control_components (callable): A function that builds the Gradio UI
+                                       components (input, output, button) for this tool.
+                                       This function should return a tuple of
+                                       (ui_group, input_components, output_components, button_component).
+                                       The ui_group should be a gr.Group or similar container
+                                       that holds all the tool's UI and whose visibility can be toggled.
+    """
+    def decorator(func):
+        # Store the function and its metadata in the registry
+        if func.__name__ in _tool_registry:
+            print(f"Warning: Tool '{func.__name__}' is already registered. Overwriting.")
+
+        _tool_registry[func.__name__] = {
+            "name": name,
+            "func": func,
+            "ui_builder": control_components
+        }
+        print(f"Registered tool: {name} (Internal name: {func.__name__})")
+        # Return the original function so it can be called
+        return func
+    return decorator
+
+def get_tool_registry():
+    """Returns the dictionary of registered tools."""
+    return _tool_registry