++

.gitattributes

@@ -1,35 +0,0 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,13 +0,0 @@
----
-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
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -1,309 +1,153 @@
 import gradio as gr
-import inspect
-import importlib
-import os
-import sys
-
-from src.utils.decorators import tools_registry, mcp_tool_instance
-
-# --- Dynamic Tool Loading --- 
-def load_tools(tools_dir_name="tools"):
-    """Dynamically loads tools from the specified directory (src/tools)."""
-    # Construct the absolute path to the 'src/tools' directory
-    # __file__ is app.py in the project root
-    # tools are in src/tools
-    base_dir = os.path.dirname(os.path.abspath(__file__))
-    tools_path = os.path.join(base_dir, "src", tools_dir_name)
-
-    if not os.path.exists(tools_path):
-        print(f"Tools directory not found: {tools_path}")
-        return
-
-    for filename in os.listdir(tools_path):
-        if filename.endswith(".py") and not filename.startswith("__"):
-            # Module name should be relative to a path in sys.path
-            # e.g., src.tools.echo_tool
-            module_name = f"src.{tools_dir_name}.{filename[:-3]}"
-            try:
-                importlib.import_module(module_name)
-            except ImportError as e:
-                print(f"Error importing tool module {module_name}: {e}")
-            except Exception as e:
-                print(f"An unexpected error occurred while loading {module_name}: {e}")
-
-# --- Gradio UI --- 
-def build_ui():
-    load_tools()
-
-    with gr.Blocks(title="MCP Server") as demo:
-        gr.Markdown("# MCP Server with Custom Tool UIs")
-
-        with gr.Row():
-            tool_dropdown = gr.Dropdown(choices=sorted(list(tools_registry.keys())), label="Select Tool", allow_custom_value=False)
-        
-        tool_docstring_display = gr.Markdown(visible=False)
-        
-        # This area will hold the dynamically generated UI for the selected tool
-        # We use a Group to contain potentially multiple rows/columns from the tool's UI builder
-        tool_specific_ui_area = gr.Group(visible=False) 
-        
-        # Placeholder for where the tool's input components will be rendered
-        # This needs to be a component that can be updated with other components (e.g., gr.Column or gr.Group)
-        # We will manage the actual components within the display_tool_interface function
-        # and pass them to the run_button.click event.
-        # For simplicity, we'll create a list of placeholders for inputs and outputs that can be updated.
-        # The actual components will be created by the tool's ui_builder.
-
-        # We need a way to pass the dynamically created input components to the run_selected_tool function.
-        # Gradio's `inputs` for `click` events expects a list of components.
-        # We'll use a gr.State to hold references to the current tool's input and output components.
-        current_tool_inputs_state = gr.State([])
-        current_tool_outputs_state = gr.State([])
-
-        run_button = gr.Button("Run Tool", visible=False)
-        # Output display will now be part of the tool_specific_ui_area, managed by the tool's UI builder.
-        # We remove the generic tool_output here.
-
-        def display_tool_interface(tool_name, request: gr.Request):
-            # Clear previous tool's UI if any
-            # This is tricky because we can't directly remove components. 
-            # We hide the main container and will repopulate it.
-            # A better approach might involve JavaScript or more complex Gradio state management.
-            # For now, we'll rely on returning gr.update for the container and its contents.
-
-            if not tool_name or tool_name not in tools_registry:
-                return {
-                    tool_docstring_display: gr.update(visible=False, value=""),
-                    tool_specific_ui_area: gr.update(visible=False, children=[]),
-                    run_button: gr.update(visible=False),
-                    current_tool_inputs_state: [],
-                    current_tool_outputs_state: []
-                }
-
-            selected_tool = tools_registry[tool_name]
-            docstring_md = f"### {tool_name}\n\n**Description:** {selected_tool.get('description', 'N/A')}\n\n**Docstring:**\n```\n{selected_tool.get('docstring', 'No docstring provided.')}\n```"
-
-            ui_builder = selected_tool.get("ui_builder")
-            input_components = []
-            output_components = []
-            children_for_ui_area = []
-
-            if ui_builder:
-                try:
-                    # The ui_builder should return two lists: input_components and output_components
-                    # These components are already instantiated Gradio components.
-                    inputs, outputs = ui_builder()
-                    input_components.extend(inputs)
-                    output_components.extend(outputs)
-                    
-                    # Add all returned components to be displayed
-                    children_for_ui_area.extend(input_components)
-                    children_for_ui_area.extend(output_components)
-                    
-                    # Store references for the run button
-                    tools_registry[tool_name]['input_components'] = input_components
-                    tools_registry[tool_name]['output_components'] = output_components
-
-                except Exception as e:
-                    print(f"Error building UI for tool '{tool_name}': {e}")
-                    children_for_ui_area = [gr.Markdown(f"**Error building UI for {tool_name}:** {e}")]
-                    # Fallback or error display
-            else:
-                children_for_ui_area = [gr.Markdown(f"**Note:** No custom UI defined for tool '{tool_name}'. Parameters (if any) will be handled generically if possible, or this tool might not be runnable via UI directly without a UI builder.")]
-                # Potentially fall back to generic inputs if no ui_builder, or disable run button
-                # For now, we assume ui_builder is necessary for runnable tools with this new setup.
-                return {
-                    tool_docstring_display: gr.update(visible=True, value=docstring_md),
-                    tool_specific_ui_area: gr.update(visible=True, children=children_for_ui_area),
-                    run_button: gr.update(visible=False), # No UI, no run
-                    current_tool_inputs_state: [],
-                    current_tool_outputs_state: []
-                }
-
-            return {
-                tool_docstring_display: gr.update(visible=True, value=docstring_md),
-                # Update the group with the new children components
-                tool_specific_ui_area: gr.update(visible=True, children=children_for_ui_area),
-                run_button: gr.update(visible=True if selected_tool.get("function") else False),
-                current_tool_inputs_state: input_components, # Pass actual components
-                current_tool_outputs_state: output_components # Pass actual components
-            }
-
-        # The `run_selected_tool` function now needs to accept `*args` for dynamic inputs.
-        # The order of `*args` will match the order of `input_components` returned by the `ui_builder`.
-        def run_selected_tool(tool_name, *input_values):
-            if not tool_name or tool_name not in tools_registry:
-                return [gr.update(value="Error: Tool not selected or not found.")] * len(tools_registry.get(tool_name, {}).get('output_components', [1])) # Match number of outputs
-            
-            selected_tool_info = tools_registry[tool_name]
-            tool_function = selected_tool_info.get("function")
-            output_ui_components = selected_tool_info.get("output_components", [])
-            num_outputs = len(output_ui_components) if output_ui_components else 1
-
-            if not tool_function:
-                return [gr.update(value=f"Error: No function defined for tool '{tool_name}'.")] * num_outputs
-
-            sig = inspect.signature(tool_function)
-            param_names = list(sig.parameters.keys())
-            
-            kwargs = {}
-            # Map input_values to parameter names based on order
-            # This assumes the ui_builder returns input components in the same order as function parameters.
-            # More robust mapping might use component labels or ids if available and reliable.
-            if len(input_values) != len(param_names):
-                # This can happen if ui_builder provides different number of inputs than function expects
-                # Or if not all inputs are passed correctly by Gradio (e.g. if some are gr.State)
-                # For now, we'll proceed if input_values are fewer, assuming defaults or optional args.
-                # A more robust solution would involve inspecting component properties or explicit mapping.
-                print(f"Warning: Number of input values ({len(input_values)}) from UI does not match number of function parameters ({len(param_names)}) for tool '{tool_name}'. Attempting to call with available values.")
-
-            for i, param_name in enumerate(param_names):
-                if i < len(input_values):
-                    # Type conversion based on annotation - similar to previous logic but simplified for this example
-                    param_annotation = sig.parameters[param_name].annotation
-                    raw_value = input_values[i]
-                    try:
-                        if param_annotation is inspect.Parameter.empty or param_annotation == str:
-                            kwargs[param_name] = str(raw_value)
-                        elif param_annotation == int:
-                            kwargs[param_name] = int(raw_value)
-                        elif param_annotation == float:
-                            kwargs[param_name] = float(raw_value)
-                        elif param_annotation == bool:
-                            kwargs[param_name] = bool(raw_value) # Gradio components like Checkbox pass bool directly
-                        else:
-                            kwargs[param_name] = raw_value # Pass as is for other types or rely on tool validation
-                    except ValueError as ve:
-                        error_msg = f"Error converting parameter '{param_name}' for tool '{tool_name}': {ve}"
-                        return [gr.update(value=error_msg)] * num_outputs
-                # If fewer input_values than params, rely on function defaults for remaining params
-
-            try:
-                result = tool_function(**kwargs)
-                # If the tool function returns multiple values, it should be a tuple/list
-                # matching the number of output_ui_components.
-                if num_outputs == 1:
-                    return [gr.update(value=str(result))]
-                elif isinstance(result, (list, tuple)) and len(result) == num_outputs:
-                    return [gr.update(value=str(r)) for r in result]
-                else:
-                    # Fallback if result format doesn't match output components
-                    print(f"Warning: Tool '{tool_name}' result format mismatch. Expected {num_outputs} outputs, got {type(result)}.")
-                    return [gr.update(value=str(result))] + [gr.update(value="-")] * (num_outputs - 1)
-
-            except Exception as e:
-                error_msg = f"Error executing tool '{tool_name}': {str(e)}"
-                return [gr.update(value=error_msg)] * num_outputs
-
-        tool_dropdown.change(
-            fn=display_tool_interface,
-            inputs=[tool_dropdown],
-            outputs=[
-                tool_docstring_display, 
-                tool_specific_ui_area, 
-                run_button,
-                current_tool_inputs_state, # To store the dynamic input components
-                current_tool_outputs_state # To store the dynamic output components
-            ],
-            # Add request=True if you need access to gr.Request object in display_tool_interface
-            # api_name=False # if you don't want this to be an API endpoint
+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,
         )
 
-        # The run_button.click event needs to be set up *after* display_tool_interface 
-        # has potentially populated current_tool_inputs_state and current_tool_outputs_state.
-        # However, Gradio's event system defines inputs/outputs statically when the UI is built.
-        # This means we can't directly use the components from current_tool_inputs_state in the inputs list here
-        # in a way that Gradio understands for dynamic component lists.
-        # The *args approach in run_selected_tool is the way to handle dynamic inputs.
-        # We need to ensure that the `inputs` list for `run_button.click` correctly refers to the components
-        # that are *currently visible and active* for the selected tool.
-        # This is the most complex part of dynamic UI in Gradio.
-
-        # A common pattern is to have a fixed maximum number of input slots and update them,
-        # or to use gr.update to change the `inputs` of the click event dynamically (more advanced, often needs JS).
-        
-        # For now, the `run_selected_tool` will receive `tool_name` and `*input_values`.
-        # The `*input_values` will be sourced from the components held in `current_tool_inputs_state`.
-        # Gradio needs a list of components for the `inputs` argument of `click`.
-        # We will pass the `current_tool_inputs_state` itself, and unpack it inside `run_selected_tool` if needed,
-        # or rely on Gradio to pass the *values* from these components if they are correctly registered.
-
-        # Let's adjust `run_button.click`:
-        # The `inputs` should be `tool_dropdown` and then the components from `current_tool_inputs_state`.
-        # The `outputs` should be the components from `current_tool_outputs_state`.
-        # This requires `display_tool_interface` to correctly populate these states with component instances.
-
-        # This is a simplified approach. A fully dynamic setup where the number and type of inputs/outputs
-        # to .click() change based on dropdown selection is hard in pure Python Gradio.
-        # The `*args` in `run_selected_tool` is key.
-        # We will pass the state objects that *contain* the lists of components.
-        # Gradio will pass the *values* from the components referenced by the state at the time of the click.
-
-        # The `run_button.click` will be connected when a tool is selected and its UI is built.
-        # We can't define it here with dynamic inputs/outputs directly in the initial build.
-        # Instead, we will update the click event or handle it via the `current_tool_inputs_state`.
-
-        # Let's try to make the `run_button.click` inputs dynamic by passing the state
-        # and then accessing the components from the state inside the handler or relying on Gradio's behavior.
-        # The `inputs` to `run_button.click` will be `tool_dropdown` and then the components themselves.
-        # This means `display_tool_interface` must return the components to be wired up.
-        # This is getting complex. Let's simplify: `run_selected_tool` will take `tool_name` and `*args`.
-        # The `inputs` to `run_button.click` will be `tool_dropdown` plus the *actual input components*.
-        # The `outputs` will be the *actual output components*.
-        # This means `display_tool_interface` must update the `run_button.click` event or its `inputs`/`outputs`.
-        # This is not directly possible without re-creating the button or using JS.
-
-        # Alternative: Use a fixed number of placeholder inputs/outputs for the click event, 
-        # and map them inside run_selected_tool based on the actual active tool's UI components.
-        # This is a common workaround.
-        # Let's assume a maximum of, say, 5 input components and 5 output components for any tool for now.
-        # These would be placeholder components in the main UI, and the tool's UI builder would update them.
-        # This brings us back to a semi-generic approach but with tool-specific UI builders.
-
-        # For a truly dynamic approach as intended by the new decorator:
-        # The `run_button.click` needs to be able to gather values from dynamically added components.
-        # The `*args` in `run_selected_tool` is the most Gradio-idiomatic way.
-        # The `inputs` to `click` must be a list of components. 
-        # `current_tool_inputs_state` (which is `gr.State`) will pass its *value* (the list of components) 
-        # to `run_selected_tool`. Gradio doesn't automatically unpack this list of components 
-        # and pass their values as `*args`. 
-
-        # The most straightforward way with the current Gradio version for this dynamicism is to
-        # have `run_selected_tool` accept the list of input values directly. 
-        # The `inputs` to `run_button.click` will be `[tool_dropdown, current_tool_inputs_state]`
-        # Then, inside `run_selected_tool`, `current_tool_inputs_state` will be the *list of values* from those components.
-
-        # Let's refine `run_selected_tool` to expect `input_values_list` from `current_tool_inputs_state`.
-
-        # The `outputs` for `tool_dropdown.change` needs to include the `current_tool_inputs_state` and `current_tool_outputs_state`
-        # so they are correctly populated with the component instances.
-
-        # The `inputs` for `run_button.click` will be `[tool_dropdown, current_tool_inputs_state]`
-        # The `outputs` for `run_button.click` will be `current_tool_outputs_state`
-        # This means `run_selected_tool` will receive the *values* from the components in `current_tool_inputs_state` as its second argument.
-
-        # Revisit `run_selected_tool` signature and logic:
-        # def run_selected_tool(tool_name, input_values_from_state_components):
-        #    ... where input_values_from_state_components is a list of values.
-
-        # This seems to be the most viable path with Gradio's Python API for dynamic inputs/outputs to an event.
-
-        # The `outputs` of `tool_dropdown.change` are correct in setting the states.
-        # Now, wire `run_button.click`:
-        run_button.click(
-            fn=run_selected_tool, 
-            inputs=[tool_dropdown, current_tool_inputs_state], # Pass tool_name and the list of input component values
-            outputs=current_tool_outputs_state # The list of output components to update
+        # 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.
 
-    return demo
 
+# --- Launch the Gradio App as an MCP Server ---
 if __name__ == "__main__":
-    app_ui = build_ui()
-    # The mcp_server=True enables Server-Sent Events for MCP communication if Gradio supports it directly.
-    # For Gradio versions that don't directly use mcp_server for custom SSE, 
-    # this flag might be for internal Gradio features or future compatibility.
-    # The core MCP functionality here is through the tool registration and execution via UI.
-    # Using share=False for local development by default, can be changed to True if ngrok tunneling is desired.
-    app_ui.launch(server_name="0.0.0.0", server_port=7860, mcp_server=True, share=False) 
-    # print("Gradio App Launched. Registered tools:", list(tools_registry.keys()))
+    # 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.")

src/tools/echo_tool.py

@@ -1,49 +0,0 @@
-import gradio as gr
-from src.utils.decorators import mcp_tool_instance # Updated import
-
-TOOL_NAME = "Echo Message"
-
-@mcp_tool_instance.define(name=TOOL_NAME, description="Echoes a message a specified number of times.")
-def echo_message(message: str, count: int = 1) -> str:
-    """Repeats the given message a specified number of times.
-
-    Args:
-        message (str): The message to echo.
-        count (int, optional): The number of times to repeat the message. Defaults to 1.
-
-    Returns:
-        str: The echoed message, or an error message if inputs are invalid.
-    """
-    if not isinstance(message, str):
-        return f"Error: Message must be a string. Received type: {type(message)}"
-    if not isinstance(count, int):
-        try:
-            # Attempt to convert count to int if it's a string representation of an int
-            count = int(count)
-        except ValueError:
-            return f"Error: Count must be an integer. Received type: {type(count)}, value: {count}"
-        except TypeError: # Handles cases where count might be None or other non-convertible types
-             return f"Error: Count must be an integer. Received invalid type: {type(count)}"
-
-    if count < 0:
-        return "Error: Count cannot be negative."
-    if count > 1000: # Adding a reasonable upper limit
-        return "Error: Count is too large (max 1000)."
-
-    # Ensure message is not excessively long to prevent performance issues
-    if len(message) * count > 10000: # Arbitrary limit for total output length
-        return "Error: Resulting message is too long."
-
-    return (message + "\n") * count
-
-@mcp_tool_instance.ui()
-def echo_tool_ui():
-    """Creates the Gradio UI components for the Echo Message tool."""
-    # Input components
-    message_input = gr.Textbox(label="Message", info="The message to repeat.")
-    count_input = gr.Number(label="Count", value=1, minimum=0, maximum=1000, step=1, info="Number of times to repeat the message.")
-    
-    # Output component
-    output_display = gr.Textbox(label="Echoed Message", interactive=False, lines=3)
-    
-    return [message_input, count_input], [output_display]

src/tools/time_tool.py

@@ -1,49 +0,0 @@
-from datetime import datetime
-import pytz
-import gradio as gr
-from src.utils.decorators import mcp_tool_instance # Updated import
-
-TOOL_NAME = "Get Current Time"
-
-@mcp_tool_instance.define(name=TOOL_NAME, description="Gets the current time in a specified IANA timezone.")
-def get_time(timezone: str) -> str:
-    """Fetches the current time for a given IANA timezone.
-
-    Args:
-        timezone (str): The IANA timezone name (e.g., 'America/New_York', 'Europe/London').
-
-    Returns:
-        str: The current time in 'YYYY-MM-DD HH:MM:SS TZ' format, or an error message.
-    """
-    try:
-        if not isinstance(timezone, str):
-            return f"Error: Timezone must be a string. Received type: {type(timezone)}"
-        if not timezone.strip():
-             return f"Error: Timezone cannot be empty."
-        # Validate if the timezone is known
-        if timezone not in pytz.all_timezones:
-            # Provide a hint for common mistakes
-            suggestion = ""
-            if timezone.lower() == "utc" or timezone.lower() == "gmt":
-                suggestion = " Did you mean 'UTC' or 'Etc/GMT'?"
-            return f"Error: Unknown timezone '{timezone}'. Please use a valid IANA timezone name.{suggestion}"
-        
-        tz = pytz.timezone(timezone)
-        current_time = datetime.now(tz)
-        return current_time.strftime("%Y-%m-%d %H:%M:%S %Z%z")
-    except pytz.exceptions.UnknownTimeZoneError:
-        return f"Error: Unknown timezone '{timezone}'."
-    except Exception as e:
-        return f"An unexpected error occurred while fetching time for '{timezone}': {str(e)}"
-
-@mcp_tool_instance.ui()
-def time_tool_ui():
-    """Creates the Gradio UI components for the Get Current Time tool."""
-    # Input component: Textbox for the timezone
-    timezone_input = gr.Textbox(label="Timezone", info="Enter IANA timezone (e.g., America/New_York, UTC, Europe/London)", value="UTC")
-    
-    # Output component: Textbox to display the result
-    output_display = gr.Textbox(label="Current Time", interactive=False)
-    
-    # Return a list of input components and a list of output components
-    return [timezone_input], [output_display]

src/utils/decorators.py

@@ -1,66 +0,0 @@
-import inspect
-import gradio as gr
-
-tools_registry = {}
-
-class MCPTool:
-    def __init__(self):
-        self._last_defined_tool_name = None # To store the name of the tool most recently defined
-
-    def define(self, name, description):
-        """Decorator factory to define a tool's metadata and core function."""
-        def decorator(func):
-            if name in tools_registry and "function" in tools_registry[name]:
-                # If UI was defined first, merge, otherwise overwrite/update.
-                tools_registry[name].update({
-                    "function": func,
-                    "description": description,
-                    "parameters": func.__annotations__,
-                    "docstring": inspect.getdoc(func)
-                })
-            else:
-                tools_registry[name] = {
-                    "function": func,
-                    "description": description,
-                    "parameters": func.__annotations__,
-                    "docstring": inspect.getdoc(func),
-                    "ui_builder": None, # Placeholder for UI builder function
-                    "input_components": [], # Placeholder for actual input Gradio components
-                    "output_components": [] # Placeholder for actual output Gradio components
-                }
-            self._last_defined_tool_name = name # Store the name for the ui decorator
-            # print(f"Defined tool: {name}")
-            return func
-        return decorator
-
-    def ui(self): # Removed tool_name parameter
-        """Decorator factory to define a tool's UI builder function."""
-        def decorator(ui_func):
-            tool_name_to_use = self._last_defined_tool_name
-            if not tool_name_to_use:
-                raise ValueError("MCPTool.define() must be called before MCPTool.ui() for the same tool instance.")
-
-            if tool_name_to_use not in tools_registry:
-                # Define tool structure if UI is defined before the main function
-                # This case should ideally not happen if define is always called first for a given name.
-                # However, if ui() is called after define() for a *different* tool name without an intervening define(),
-                # this logic might still be hit if _last_defined_tool_name was from a previous, unrelated tool.
-                # The ValueError above should prevent misuse for the *same* tool instance flow.
-                tools_registry[tool_name_to_use] = {
-                    "function": None, 
-                    "description": "(Description to be defined)", 
-                    "parameters": {},
-                    "docstring": "(Docstring to be defined)",
-                    "ui_builder": ui_func,
-                    "input_components": [],
-                    "output_components": []
-                }
-            else:
-                tools_registry[tool_name_to_use]["ui_builder"] = ui_func
-            
-            # print(f"Registered UI for tool: {tool_name_to_use}")
-            return ui_func
-        return decorator
-
-# Default instance for convenience, or users can create their own MCPTool instances
-mcp_tool_instance = MCPTool()

tools/time_tool.py

@@ -0,0 +1,67 @@
+import datetime
+import pytz # You need to install pytz: pip install pytz
+import typing as ty
+import gradio as gr
+
+# 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 get_current_time(timezone: str = "UTC") -> str:
+    """
+    Gets the current time for the given timezone string.
+
+    This tool takes an IANA timezone name (like "UTC", "America/New_York",
+    "Asia/Ho_Chi_Minh") and returns the current datetime in that zone.
+    Defaults to "UTC" if no timezone is provided.
+
+    Args:
+        timezone (str): The IANA timezone string (e.g., "UTC").
+
+    Returns:
+        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."
+    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() -> gr.Group:
+    """
+    Builds Gradio UI components for the Get current time tool.
+    Returns a gr.Group containing the controls.
+    """
+    # Use a gr.Group to contain the controls for this tool
+    # We will manage the visibility of this group in the main app
+    with gr.Group(visible=False) as time_tool_group:
+        gr.Markdown("Configure **Get current time** tool:")
+        # Create a textbox for the 'timezone' argument
+        timezone_input = gr.Textbox(
+            label="Timezone",
+            value="UTC",
+            placeholder="e.g., America/New_York, Asia/Ho_Chi_Minh",
+            interactive=True,
+        )
+        # 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
+
+# When this file is imported, the decorators register the tool and its UI builder

utils/mcp_decorator.py

@@ -0,0 +1,72 @@
+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}}
+        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
+            }
+            
+            # 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, ...]]]):
+            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
+            self.tools[api_name]['ui_builder'] = ui_builder_func
+
+            # Return the original UI builder function
+            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['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
+
+# Instantiate the registry. This instance will be used by decorators
+mcp_tool = MCPToolRegistry()
+
+# 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.