+

app.py

@@ -1,76 +1,187 @@
 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
-# 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]:
+# --- Event Handlers ---
+
+def update_tool_info(
+    selected_api_name: str,
+    execute_button: gr.Button, # Pass component instances to update their visibility
+    api_call_display: ty.Union[gr.Code, gr.Textbox],
+    tool_output_display: ty.Union[gr.Textbox, gr.JSON],
+    *tool_ui_groups_and_inputs # This will receive all tool UI groups and their inputs
+) -> ty.List[ty.Union[gr.update, dict]]:
     """
-    Updates the displayed docstring and the visibility of tool UI groups
-    based on the selected tool from the dropdown.
+    Updates the displayed docstring, visibility of tool UI groups, and
+    visibility of execute/output areas based on the selected tool.
 
     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).
+        selected_api_name: The api_name of the tool selected.
+        execute_button, api_call_display, tool_output_display: Component instances
+        *tool_ui_groups_and_inputs: Tuple containing all tool UI group instances
+                                    followed by all individual input component values.
+                                    Note: We only need the group instances here for visibility.
 
     Returns:
-        A list of gr.update objects for the docstring and each tool UI group.
+        A list of gr.update objects for the docstring, execute button,
+        API/output displays, and each tool UI group.
+        The order must match the order of outputs in the dropdown.change call.
     """
     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
+    docstring_value = ""
+    docstring_visible = False
+    execute_button_visible = False
+    output_area_visible = False # Hide API/Output displays 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---")
+        if tool_info:
+            # Show docstring if available
+            if tool_info.get('tool_func') and tool_info['tool_func'].__doc__:
+                 docstring_value = f"### Tool Documentation\n---\n{tool_info['tool_func'].__doc__}\n---"
+                 docstring_visible = True
+
+            # Show execute button and output area if a tool is selected
+            execute_button_visible = True
+            output_area_visible = True
+
+
+    # Update docstring component
+    updates.append(gr.update(visible=docstring_visible, value=docstring_value))
+
+    # Update visibility of Execute button and output areas
+    updates.append(gr.update(visible=execute_button_visible)) # Execute button
+    updates.append(gr.update(visible=output_area_visible))   # API Call display
+    updates.append(gr.update(visible=output_area_visible))   # Tool Output display
 
-    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:
+    # Iterate through the tool groups *in the order they were passed as outputs*
+    # and update their visibility based on the selected_api_name.
+    # The order of tool_ui_groups list must match the order in tool_options / mcp_tool.get_tools_list()
+    all_tools_api_names = [api_name for _, api_name in tool_options]
+
+    for i, api_name_in_list in enumerate(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))
+         # updates.append(gr.update(component=tool_ui_groups[i], visible=is_selected_tool)) # This syntax also works but the simple value update is fine
+         updates.append(gr.update(visible=is_selected_tool)) # Update the i-th tool group output
 
     # 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
+    # Outputs are: [doc_display, execute_button, api_call_display, tool_output_display, *tool_ui_groups_list]
+
+    return updates
+
+def execute_tool(
+    selected_api_name: str,
+    *all_potential_input_values # This receives values from ALL input components across ALL tool UIs
+) -> ty.Tuple[str, str]: # Returns (api_call_string, tool_output_string)
+    """
+    Executes the selected tool using the values from the visible UI controls.
+
+    Args:
+        selected_api_name: The api_name of the tool selected.
+        *all_potential_input_values: A tuple containing the values of all input components
+                                     listed in the 'inputs' parameter of the click event.
+
+    Returns:
+        A tuple: (string representation of the API call, string representation of the tool's output).
+    """
+    if not selected_api_name:
+        return "No tool selected.", "No tool output."
+
+    tool_info = mcp_tool.get_tool_info(selected_api_name)
+    if not tool_info:
+        return f"Error: Tool '{selected_api_name}' not found.", "Error."
+
+    tool_func = tool_info.get('tool_func')
+    arg_component_map = tool_info.get('arg_component_map')
+
+    if not tool_func or not arg_component_map:
+        return f"Error: Tool '{selected_api_name}' is not properly configured.", "Error."
+
+    # Get the complete ordered list of all input components to find value indices
+    all_input_components_list = mcp_tool.get_all_arg_components_list()
+
+    # Build the arguments dictionary for the tool function
+    tool_args = {}
+    try:
+        # Get the function signature to know expected arguments
+        sig = inspect.signature(tool_func)
+        param_names = list(sig.parameters.keys())
+
+        for arg_name in param_names:
+             if arg_name in arg_component_map:
+                 component = arg_component_map[arg_name]
+                 try:
+                     # Find the index of this component in the master list of all inputs
+                     # This index corresponds to the position of its value in all_potential_input_values
+                     # Add 1 because the first input is the dropdown value (selected_api_name)
+                     component_index_in_all_inputs = all_input_components_list.index(component) + 1
+                     arg_value = all_potential_input_values[component_index_in_all_inputs]
+                     tool_args[arg_name] = arg_value
+                 except ValueError:
+                     # Should not happen if setup is correct, but good for debugging
+                     print(f"Warning: Component for arg '{arg_name}' not found in master input list.")
+                     # You might want to skip this arg or handle missing input
+             else:
+                 # Handle cases where a tool argument doesn't have a corresponding UI component
+                 # Check if the argument has a default value
+                 param = sig.parameters[arg_name]
+                 if param.default is inspect.Parameter.empty:
+                      # Required argument with no UI component and no default
+                      return f"Error: Missing UI input for required argument '{arg_name}'.", "Error."
+                 # If it has a default, it won't be in tool_args, which is correct for **kwargs
+
+        # --- Execute the tool function ---
+        print(f"Executing tool: {selected_api_name} with args: {tool_args}")
+        tool_output = tool_func(**tool_args)
+
+        # --- Format API Call Display ---
+        api_call_string = f"Tool: {selected_api_name}\n"
+        api_call_string += "Args:\n"
+        if tool_args:
+            # Format args nicely, especially for complex types if needed
+            try:
+                 api_call_string += json.dumps(tool_args, indent=2)
+            except TypeError:
+                 # Fallback for non-JSON serializable args
+                 api_call_string += str(tool_args)
+        else:
+            api_call_string += "{}"
+
+
+        # --- Format Tool Output Display ---
+        # Convert output to string for display
+        tool_output_string = str(tool_output)
+
+        return api_call_string, tool_output_string
+
+    except Exception as e:
+        # Catch any errors during argument collection or function execution
+        error_message = f"An error occurred during tool execution: {e}"
+        print(error_message)
+        return f"API Call Error: {error_message}", f"Tool Output Error: {e}"
+
 
 # --- 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.")
+    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)
@@ -84,70 +195,135 @@ with gr.Blocks(title="MCP Server Demo") as demo:
             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
         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=""
+        )
+
+        # 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
+        )
+
+
         # 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
+        # Lists to hold the UI groups and ALL individual input components from ALL tools
         tool_ui_groups_list = []
+        all_input_components_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)
+             # 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()
+                     # Call the UI builder function to get the components and the arg mapping
+                     tool_ui_group, arg_component_map = ui_builder()
                      # Ensure the group is initially hidden
                      tool_ui_group.visible = False
-                     # Add the group to our list for output mapping
+                     # Store the created group and component map in the registry instance
+                     mcp_tool.set_tool_ui_components(api_name=tool_name, ui_group=tool_ui_group, arg_component_map=arg_component_map)
+
+                     # Add the group to our list for output mapping (for visibility updates)
                      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)
-
+                     # Add a placeholder group for consistency in outputs list
+                     with gr.Group(visible=False) as empty_group_placeholder:
+                          gr.Markdown(f"No UI defined for {tool_name} ({api_name})", visible=False)
+                     tool_ui_groups_list.append(empty_group_placeholder)
+                     # Note: No input components are added to all_input_components_list for this tool
 
         # --- Event Handling ---
-        # When the dropdown selection changes, update the displayed info and controls
+
+        # Define the list of outputs for the dropdown change event
+        # The order must match the order the updates are returned by update_tool_info
+        dropdown_outputs = [
+            doc_display,
+            execute_button,
+            api_call_display,
+            tool_output_display,
+            *tool_ui_groups_list # Spread all the tool UI groups
+        ]
+
+        # When the dropdown selection changes, update visibility of UI elements
         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
+            inputs=[
+                dropdown,              # Input 0: Selected API Name
+                execute_button,        # Input 1: Execute Button instance (needed for output mapping logic in handler)
+                api_call_display,      # Input 2: API Display instance
+                tool_output_display,   # Input 3: Output Display instance
+                *tool_ui_groups_list   # Inputs 4 to 4 + len(tool_ui_groups_list) -1: Tool UI Group instances
+                                       # Although update_tool_info only uses their identity/order,
+                                       # Gradio requires them as inputs if they are also outputs.
+            ],
+            outputs=dropdown_outputs,
+            # queue=False # Could potentially improve responsiveness 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.
+
+        # Define the list of inputs for the execute button click event
+        # The order must match the order expected by execute_tool function
+        execute_inputs = [
+            dropdown,                 # Input 0: Selected API Name
+            *all_input_components_list # Inputs 1 onwards: Values from all individual input components
+        ]
+
+        # When the execute button is clicked, run the selected tool
+        execute_button.click(
+            fn=execute_tool,
+            inputs=execute_inputs,
+            outputs=[
+                api_call_display,   # Output 0: Update the API Call display
+                tool_output_display # Output 1: Update the Tool Output display
+            ],
+            # queue=True # Keep queue=True for potential long-running tool executions
+        )
+
+        # Optional: Trigger initial load to set visibility correctly on app startup
+        # This requires setting a default value in the dropdown or handling None correctly
+        # in the event handler if you don't want a default tool shown.
+        # If value=None in dropdown and allow_clear=True, the initial state handled by
+        # update_tool_info when selected_api_name is None will hide everything, which is fine.
+        # demo.load(fn=update_tool_info, inputs=[dropdown, execute_button, api_call_display, tool_output_display, *tool_ui_groups_list], outputs=dropdown_outputs)
 
 
 # --- 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
+        # share=False,        # Default and recommended for Spaces
     )
     print("Gradio app launched.")

tools/time_tool.py

@@ -1,5 +1,5 @@
 import datetime
-import pytz # You need to install pytz: pip install pytz
+import pytz
 import typing as ty
 import gradio as gr
 
@@ -26,12 +26,9 @@ def get_current_time(timezone: str = "UTC") -> str:
         str: The current time in the specified timezone, or an error message.
     """
     try:
-        # Get the timezone object
         tz = pytz.timezone(timezone)
-        # Get the current UTC time and convert it to the target timezone
         now_utc = datetime.datetime.utcnow()
         now_in_tz = pytz.utc.localize(now_utc).astimezone(tz)
-        # Format the time
         return now_in_tz.strftime('%Y-%m-%d %H:%M:%S %Z%z')
     except pytz.UnknownTimeZoneError:
         return f"Error: Unknown timezone '{timezone}'. Please provide a valid IANA timezone name."
@@ -40,28 +37,26 @@ def get_current_time(timezone: str = "UTC") -> str:
 
 # --- UI Control Builder ---
 @mcp_tool.build_ui_control(api_name="get_current_time")
-def build_time_ui_control() -> gr.Group:
+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 gr.Group containing the controls.
+    Returns a tuple: (gr.Group containing controls, dict mapping arg name to component).
     """
-    # Use a gr.Group to contain the controls for this tool
-    # We will manage the visibility of this group in the main app
+    # 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
         )
-        # Note: We are only building the *display* components here.
-        # If you wanted a "Run" button in the UI, you would add it here
-        # and define an event handler in the main app.
-        # For dynamic display based on tool selection, returning a container
-        # (like gr.Group or gr.Column) is a good pattern.
-
-    return time_tool_group # Return the group containing the controls
+        arg_components["timezone"] = timezone_input
 
-# When this file is imported, the decorators register the tool and its UI builder
+    # Return the group and the dictionary mapping arg names to components
+    return time_tool_group, arg_components

utils/mcp_decorator.py

@@ -6,7 +6,14 @@ 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}}
+        # 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):
@@ -20,28 +27,35 @@ class MCPToolRegistry:
                 '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.
-            # This is a Gradio-specific requirement for mcp_server=True
-            # The structure below is based on Gradio's internal handling.
             setattr(tool_func, "__mcp_tool__", {"name": name, "api_name": api_name})
 
-            # Return the original function so it can be called if needed
             return tool_func
         return decorator
 
     def build_ui_control(self, api_name: str):
-        """Decorator to associate a UI builder function with a tool."""
-        def decorator(ui_builder_func: ty.Callable[..., ty.Union[gr.components.Component, tuple[gr.components.Component, ...]]]):
+        """
+        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
+            # Store the UI builder function reference
             self.tools[api_name]['ui_builder'] = ui_builder_func
 
-            # Return the original UI builder function
+            # 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
 
@@ -56,17 +70,38 @@ class MCPToolRegistry:
     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['ui_builder'] if info else None
+        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['tool_func'] if info else None
+        return info.get('tool_func') if info else None
 
-# Instantiate the registry. This instance will be used by decorators
-mcp_tool = MCPToolRegistry()
+    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
 
-# Note: Gradio's mcp_server=True inspects functions decorated with the
-# __mcp_tool__ attribute. Our @mcp_tool.define decorator handles this.
-# The registry (`mcp_tool` instance) is primarily for the Gradio UI
-# part to list tools, get docstrings, and build dynamic interfaces.
+    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()