Update app.py

app.py

@@ -56,11 +56,8 @@ for space_info in spaces:
 
 # --- Refactored HuggingFaceSpaceSearcherTool ---
 class HuggingFaceSpaceSearcherTool(Tool):
-    # Define attributes as class variables
     name = "huggingface_space_searcher"
     description = "Searches for Hugging Face Spaces that can perform a specific task. Input is a search query string (e.g., 'text to image', 'speech recognition'). Returns a list of Space IDs, their descriptions, and instructions on how to try using them."
-    
-    # Define input schema as required by smolagents.Tool base class
     inputs = {
         "query": {
             "type": "string",
@@ -69,27 +66,18 @@ class HuggingFaceSpaceSearcherTool(Tool):
         "top_k": {
             "type": "integer",
             "description": "The number of top results to return (default is 3).",
-            "nullable": True # Changed from "optional" to "nullable"
+            "nullable": True
         }
     }
-    output_type = "string" # Optional: define output type
+    output_type = "string"
 
-    # The core logic goes into the forward method
-    # The Tool base class will likely call this with arguments unpacked from a dictionary matching the 'inputs' schema.
     def forward(self, query: str, top_k: int = 3) -> str:
-        """
-        Searches Hugging Face Spaces for a given query and returns the top_k results.
-        Provides repo_id, description, likes, and last modified date for each space found.
-        """
         try:
-            # top_k will be provided by the Tool base class mechanism.
-            # If "nullable": True and it's not provided by the agent, it might be None.
-            actual_top_k = top_k if top_k is not None else 3 # Ensure top_k has a value
+            actual_top_k = top_k if top_k is not None else 3
             print(f"Searching spaces with query: {query}, top_k: {actual_top_k}")
             spaces_found = list(list_spaces(search=query, full=True, limit=actual_top_k, sort="likes", direction=-1))
             if not spaces_found:
                 return "No Spaces found for your query."
-
             results = "Found the following Spaces (sorted by likes):\n"
             for i, space_data in enumerate(spaces_found):
                 description = "No description provided."
@@ -97,58 +85,26 @@ class HuggingFaceSpaceSearcherTool(Tool):
                     description = space_data.cardData['description']
                 elif hasattr(space_data, 'title') and space_data.title:
                     description = space_data.title
-
                 results += (
                     f"{i+1}. ID: {space_data.id}\n"
                     f"   Description: {description}\n"
                     f"   Likes: {space_data.likes if hasattr(space_data, 'likes') else 'N/A'}\n"
                     f"   Last Modified: {space_data.lastModified if hasattr(space_data, 'lastModified') else 'N/A'}\n\n"
                 )
-            results += ("\nTo use one of these, you can try creating a tool in the code like this: "
-                        "my_new_tool = Tool.from_space(repo_id='SPACE_ID_HERE', name='custom_tool_name'). "
-                        "Then you can call it: result = my_new_tool(argument_name=value). "
-                        "The arguments depend on the specific Space. If Tool.from_space fails or the tool doesn't work, "
-                        "the Space might not have a compatible public API or may require a specific api_name.")
+            results += ("\nTo use one of these, you should first try creating a tool using "
+                        "`Tool.from_space(repo_id='SPACE_ID_HERE', name='custom_tool_name')`. "
+                        "Then call that new tool: `result = custom_tool_name(argument_name=value)`. "
+                        "The arguments depend on the specific Space. If `Tool.from_space` fails, "
+                        "the Space might not have a compatible public API.")
             return results
         except Exception as e:
             print(f"Error searching Spaces: {str(e)}")
             return f"Error searching Spaces: {str(e)}"
 
-# Instantiate the custom tool
 space_search_tool = HuggingFaceSpaceSearcherTool()
-# ---- Debug print for the refactored tool ----
-try:
-    print(f"\nDEBUG: 'space_search_tool' (refactored class) immediately after creation.")
-    print(f"DEBUG: Name: {space_search_tool.name}") 
-    print(f"DEBUG: Inputs: {space_search_tool.inputs}") # Check if inputs are set
-    print(f"DEBUG: Type: {type(space_search_tool)}")
-    # print(f"DEBUG: All attributes: {dir(space_search_tool)}\n") # Can be verbose
-except AttributeError as e:
-    print(f"\nDEBUG: 'space_search_tool' (refactored class) immediately after creation.")
-    print(f"DEBUG: Attribute MISSING. Error: {e}")
-    print(f"DEBUG: Type: {type(space_search_tool)}")
-    # print(f"DEBUG: All attributes: {dir(space_search_tool)}\n")
-# ---- END Debug print ----
 tools.append(space_search_tool)
 
-
-# --- Debugging: Inspect tools before CodeAgent initialization ---
-print("\n--- Inspecting tools before CodeAgent initialization ---")
-for i, t in enumerate(tools):
-    if t is None:
-        print(f"Tool at index {i} is None!")
-        continue
-    try:
-        tool_name = t.name
-        print(f"Tool {i}: Name='{tool_name}', Type={type(t)}, Inputs: {getattr(t, 'inputs', 'Not defined')}")
-    except AttributeError:
-        print(f"!!! CRITICAL: Tool at index {i} (Type={type(t)}) is missing 'name' attribute.")
-    except Exception as e:
-        print(f"!!! ERROR inspecting tool at index {i} (Type={type(t)}): {str(e)}")
-print("-------------------------------------------------------\n")
-
-
-# Initialize the model - Use InferenceClientModel
+# Initialize the model
 model = InferenceClientModel(model_id="Qwen/Qwen2.5-Coder-32B-Instruct")
 
 # Create the agent
@@ -162,32 +118,52 @@ agent = CodeAgent(
 AGENT_INSTRUCTIONS = """You are a highly capable AI assistant. Your primary goal is to accomplish tasks using a variety of tools, prioritizing Hugging Face Spaces.
 
 Follow these steps:
-1.  **Understand the Request:** Carefully analyze the user's prompt (which will follow these instructions). Identify the core task and any specific requirements or inputs.
+1.  **Understand the Request:** Carefully analyze the user's prompt. Identify the core task and any specific requirements or inputs.
 2.  **Check Predefined Tools:** Review your list of available tools. If a predefined tool can directly address the request, use it.
-    * For the 'huggingface_space_searcher' tool, you MUST provide its arguments as a dictionary. For example: `huggingface_space_searcher(arguments={"query": "your search term", "top_k": 3})`. The `query` is mandatory. `top_k` is optional (defaults to 3 if not provided in the dictionary or if the key is absent).
+    * For the 'huggingface_space_searcher' tool, call it with direct keyword arguments like: `huggingface_space_searcher(query="your search term", top_k=3)`. The `query` is mandatory. `top_k` is optional and defaults to 3 if not provided.
 3.  **Search for Spaces (If Needed):** If no predefined tool is suitable, use the `huggingface_space_searcher` tool as described above.
-4.  **Select and Instantiate a Space Tool:** From the search results, choose the most promising Space. Attempt to create a tool from it using `Tool.from_space(repo_id='SELECTED_SPACE_ID', name='a_unique_tool_name')`. You might need to give it a unique name. If `Tool.from_space` fails, the Space might not be compatible, or you could try another one from the search results.
-5.  **Execute the Tool:** Call the tool (either predefined or dynamically created) with the necessary arguments.
+4.  **Select and Instantiate a Space Tool (PRIORITY):** From the search results, choose the most promising Space. **Your primary method to use this Space is to attempt to create a tool from it using `Tool.from_space(repo_id='SELECTED_SPACE_ID', name='a_unique_tool_name')`.** You *must* give it a unique and descriptive name.
+    * If `Tool.from_space()` succeeds, you now have a new tool. Call this new tool with the appropriate arguments for that Space.
+    * If `Tool.from_space()` fails (e.g., raises an exception), the Space might not have a compatible public API for this method. In this case, you can *then* consider if direct `gradio_client.Client` usage is feasible, but this is a fallback and often more complex.
+5.  **Execute the Tool:** Call the tool (predefined, or dynamically created via `Tool.from_space()`) with the necessary arguments.
     * **File Inputs:** If the user uploads files, their paths will be available as global string variables: `input_image_path`, `input_audio_path`, `input_video_path`, `input_3d_model_path`, `input_file_path`. Before using these variables, check if they exist and are not None. Pass these file paths as arguments to tools that require them.
-    * **Chaining Tools:** If the task requires multiple steps, chain the tools together.
+    * **Imports in Generated Code:** If your code block for execution uses modules like `os` or `uuid`, **you must include the import statements (e.g., `import os`, `import uuid`) within that specific code block.**
 6.  **Output Management:**
-    * If a tool generates a file, save it to the current working directory using a unique filename (e.g., `output_filename = os.path.join(os.getcwd(), f"{uuid.uuid4()}.png")`).
-    * **Return the RESULT:** Your final response should be either a string text answer or the string path to the generated output file.
-7.  **Clarity and Error Handling:** If you encounter issues, explain the problem.
+    * **If a tool returns a filepath string (e.g., to an image, audio, or other file), your final answer for this step should usually be that direct filepath string.** Do NOT attempt to re-save the file using `os.path.join` or `image.save()` unless you are performing an explicit transformation on the file content that requires loading and then saving. The system is designed to handle these returned filepaths.
+    * If a tool returns text, return that text.
+7.  **Clarity and Error Handling:** If you encounter issues (e.g., a Space tool fails, required inputs are missing), clearly explain the problem in your response. If a Space doesn't work, try to explain why or suggest an alternative if possible.
 
-Example of dynamically using a Space after searching:
+Example of the PREFERRED way to use a discovered Space:
 ```python
-# search_results = huggingface_space_searcher(arguments={"query": "text to image cat", "top_k": 1}) # Note the arguments dictionary
-# print(search_results)
+# User prompt: "Find a space that can make an image of a cat and use it."
+#
+# Step 1: Search for the space
+# search_results = huggingface_space_searcher(query="text to image cat", top_k=1)
+# print(search_results) # Assume 'someuser/cat-image-generator' is found.
+#
+# Step 2: Try to create a tool from the discovered space
 # try:
-#     cat_image_tool = Tool.from_space(repo_id="user/cat-generator", name="cat_generator_tool")
-#     image_path = cat_image_tool(prompt="A fluffy siamese cat") # Arguments depend on the Space
-#     return image_path
+#     cat_tool = Tool.from_space(repo_id="someuser/cat-image-generator", name="cat_image_generator_tool")
+#     # Now use the newly created tool. Arguments depend on the Space's API.
+#     # Let's assume it takes a 'prompt'.
+#     image_filepath = cat_tool(prompt="A fluffy siamese cat, cyberpunk style")
+#     return image_filepath # Return the filepath directly
 # except Exception as e:
-#     return f"Failed to use the cat generator Space: {e}"
+#     print(f"Failed to create or use tool from Space 'someuser/cat-image-generator': {e}")
+#     # Optionally, try another space or a predefined tool if appropriate.
+#     # return "Could not use the discovered space. Trying a fallback..." (then try another step)
+```
+
+Example of using a predefined tool that returns a filepath:
+```python
+# User prompt: "Generate an image of a happy robot."
+# (Assuming 'image_generator_flux_schnell' is a predefined tool)
+#
+# image_filepath = image_generator_flux_schnell(prompt="A happy robot coding on a laptop, cyberpunk style")
+# return image_filepath # Return the filepath string directly.
 ```
 Always ensure your generated Python code is complete and directly callable.
-You have access to `os`, `uuid`, `PIL.Image`.
+You have access to `PIL.Image` (as `Image`), `os`, `sys`, `numpy`, `huggingface_hub`, `gradio_client`, `uuid`. Remember to import them if you use them in a code block.
 """
 
 # Gradio interface function
@@ -248,9 +224,7 @@ with gr.Blocks(theme=gr.themes.Soft()) as app:
             input_image = gr.Image(label="Image Input", type="filepath", sources=["upload", "clipboard"], elem_id="input_image_upload")
             input_audio = gr.Audio(label="Audio Input", type="filepath", sources=["upload", "microphone"], elem_id="input_audio_upload")
         with gr.Row():
-            # Removed type="filepath" from gr.Video
             input_video = gr.Video(label="Video Input", sources=["upload"], elem_id="input_video_upload")
-            # Removed type="filepath" from gr.Model3D
             input_model3d = gr.Model3D(label="3D Model Input", elem_id="input_model3d_upload")
         with gr.Row():
             input_file = gr.File(label="Generic File Input", type="filepath", elem_id="input_file_upload")
@@ -262,7 +236,6 @@ with gr.Blocks(theme=gr.themes.Soft()) as app:
         image_output = gr.Image(label="Image Output", interactive=False, visible=False, show_download_button=True, elem_id="output_image_display")
         audio_output = gr.Audio(label="Audio Output", interactive=False, visible=False, show_download_button=True, elem_id="output_audio_display")
     with gr.Row():
-        # Removed show_download_button=True from gr.Model3D
         model3d_output = gr.Model3D(label="3D Model Output", interactive=False, visible=False, elem_id="output_model3d_display")
         text_output = gr.Textbox(label="Text / Log Output", interactive=False, visible=True, lines=5, max_lines=20, elem_id="output_text_log")
     with gr.Row():
@@ -287,4 +260,4 @@ with gr.Blocks(theme=gr.themes.Soft()) as app:
     )
 
 if __name__ == "__main__":
-    app.launch(debug=True)
+    app.launch(debug=True)