Merge branch 'main' of https://huggingface.co/spaces/leafcat/leafcat-mcp

README.md

@@ -0,0 +1,11 @@
+---
+title: Leafcat Mcp
+emoji: 🏃
+colorFrom: gray
+colorTo: yellow
+sdk: gradio
+sdk_version: 5.29.0
+app_file: app.py
+pinned: false
+short_description: LeafCat AIO MCP server with Gradio
+---

app.py

@@ -9,30 +9,18 @@ import tools.time_tool
 # Import the mcp_tool registry instance
 from utils.mcp_decorator import mcp_tool
 
-# --- 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]]:
+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.
 
     Args:
-        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.
+        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, execute button,
-        API/output displays, and each tool UI group.
-        The order must match the order of outputs in the dropdown.change call.
+        A list of gr.update objects for the docstring and each tool UI group.
     """
     updates = []
     tool_options = mcp_tool.get_tools_list() # List of (name, api_name)
@@ -42,141 +30,46 @@ def update_tool_info(
     tool_ui_groups = tool_ui_groups_and_inputs[:len(tool_options)]
 
     # 1. Update Docstring
-    docstring_value = ""
-    docstring_visible = False
-    execute_button_visible = False
-    output_area_visible = False # Hide API/Output displays by default
-
+    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:
-            # 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
+        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
-    # 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):
+    # 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)
-         # 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
+         # 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, 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}"
-
+    # 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:
@@ -199,6 +92,7 @@ with gr.Blocks(title="MCP Server Demo") as demo:
         )
 
         # 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)
@@ -228,7 +122,7 @@ with gr.Blocks(title="MCP Server Demo") as demo:
         # Container to hold dynamic UI controls.
         tool_uis_container = gr.Column()
 
-        # Lists to hold the UI groups and ALL individual input components from ALL tools
+        # List to hold the UI groups for each tool and map outputs
         tool_ui_groups_list = []
         all_input_components_list = []
 
@@ -239,14 +133,11 @@ with gr.Blocks(title="MCP Server Demo") as demo:
              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 and the arg mapping
-                     tool_ui_group, arg_component_map = 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
-                     # 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)
+                     # 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
@@ -257,64 +148,32 @@ with gr.Blocks(title="MCP Server Demo") as demo:
 
                  else:
                      # Handle tools defined without a UI builder
-                     # 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
+                     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 ---
 
-        # 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
+        # --- Event Handling ---
+        # When the dropdown selection changes, update the displayed info and controls
         dropdown.change(
             fn=update_tool_info,
-            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
+            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
         )
-
-        # 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)
+        
+        # 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 ---
@@ -322,8 +181,7 @@ if __name__ == "__main__":
     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=False,        # Default and recommended for Spaces
+        # share=True,        # Default and recommended for Spaces
     )
     print("Gradio app launched.")