lollms-client 0.17.2__py3-none-any.whl → 0.19.0__py3-none-any.whl

lollms_client/mcp_bindings/local_mcp/__init__.py

@@ -0,0 +1,311 @@
+# lollms_client/mcp_bindings/local_mcp/__init__.py
+import json
+import importlib.util
+from pathlib import Path
+from typing import Optional, List, Dict, Any, Union
+
+from lollms_client.lollms_mcp_binding import LollmsMCPBinding
+from ascii_colors import ASCIIColors, trace_exception
+
+# This variable is used by the LollmsMCPBindingManager to identify the binding class.
+BindingName = "LocalMCPBinding"
+
+class LocalMCPBinding(LollmsMCPBinding):
+    """
+    Local Model Context Protocol (MCP) Binding.
+
+    This binding discovers and executes tools defined locally in a specified folder.
+    Each tool is expected to have:
+    1. A Python file (`<tool_name>.py`) containing an `execute(params: Dict[str, Any]) -> Dict[str, Any]` function.
+    2. A JSON file (`<tool_name>.mcp.json`) defining the tool's MCP metadata (name, description, input_schema, output_schema).
+    """
+
+    def __init__(self,
+                 tools_folder_path: str|Path|None = None):
+        """
+        Initialize the LocalMCPBinding.
+
+        Args:
+            binding_name (str): The name of this binding.
+            tools_folder_path (str|Path) a folder where to find tools
+        """
+        super().__init__(binding_name="LocalMCP")
+        if tools_folder_path:
+            try:
+                self.tools_folder_path: Optional[Path] = Path(tools_folder_path)
+            except:
+                self.tools_folder_path = None
+        else:
+            self.tools_folder_path = None
+        self.discovered_tools: List[Dict[str, Any]] = []
+        if not self.tools_folder_path:
+            self.tools_folder_path = Path(__file__).parent/"default_tools"
+        self._discover_local_tools()
+
+    def _discover_local_tools(self):
+        """Scans the tools_folder_path for valid tool definitions."""
+        if not self.tools_folder_path or not self.tools_folder_path.is_dir():
+            return
+
+        self.discovered_tools = []
+        ASCIIColors.info(f"Discovering local MCP tools in: {self.tools_folder_path}")
+
+        for item in self.tools_folder_path.iterdir():
+            if item.is_dir(): # Each tool in its own subdirectory
+                tool_name = item.name
+                mcp_json_file = item / f"{tool_name}.mcp.json"
+                python_file = item / f"{tool_name}.py"
+
+                if mcp_json_file.exists() and python_file.exists():
+                    try:
+                        with open(mcp_json_file, 'r', encoding='utf-8') as f:
+                            tool_def = json.load(f)
+                        
+                        # Basic validation of MCP definition
+                        if not all(k in tool_def for k in ["name", "description", "input_schema"]):
+                            ASCIIColors.warning(f"Tool '{tool_name}' MCP definition is missing required fields (name, description, input_schema). Skipping.")
+                            continue
+                        if tool_def["name"] != tool_name:
+                             ASCIIColors.warning(f"Tool name in MCP JSON ('{tool_def['name']}') does not match folder/file name ('{tool_name}'). Using folder name. Consider aligning them.")
+                             tool_def["name"] = tool_name # Standardize to folder name
+
+                        # Store the full definition and path to python file for execution
+                        tool_def['_python_file_path'] = str(python_file.resolve())
+                        self.discovered_tools.append(tool_def)
+                        ASCIIColors.green(f"Discovered local tool: {tool_name}")
+                    except json.JSONDecodeError:
+                        ASCIIColors.warning(f"Could not parse MCP JSON for tool '{tool_name}'. Skipping.")
+                    except Exception as e:
+                        ASCIIColors.warning(f"Error loading tool '{tool_name}': {e}")
+                        trace_exception(e)
+                else:
+                    if not mcp_json_file.exists():
+                        ASCIIColors.debug(f"Tool '{tool_name}' missing MCP JSON definition ({mcp_json_file.name}). Skipping.")
+                    if not python_file.exists():
+                         ASCIIColors.debug(f"Tool '{tool_name}' missing Python implementation ({python_file.name}). Skipping.")
+        ASCIIColors.info(f"Discovery complete. Found {len(self.discovered_tools)} local tools.")
+
+
+    def discover_tools(self, specific_tool_names: Optional[List[str]] = None, **kwargs) -> List[Dict[str, Any]]:
+        """
+        Discover available local tools.
+
+        Args:
+            specific_tool_names (Optional[List[str]]): If provided, filter discovery
+                                                       to only these tool names.
+            **kwargs: Ignored by this binding.
+
+        Returns:
+            List[Dict[str, Any]]: A list of discovered tool definitions.
+        """
+        if not self.tools_folder_path:
+            return []
+            
+        # Re-scan if needed, or if discovery hasn't happened
+        if not self.discovered_tools and self.tools_folder_path:
+             self._discover_local_tools()
+
+        if specific_tool_names:
+            return [tool for tool in self.discovered_tools if tool.get("name") in specific_tool_names]
+        return self.discovered_tools
+
+    def execute_tool(self,
+                     tool_name: str,
+                     params: Dict[str, Any],
+                     lollms_client_instance: Optional[Any] = None, # Added lollms_client_instance
+                     **kwargs) -> Dict[str, Any]:
+        """
+        Execute a locally defined Python tool.
+
+        Args:
+            tool_name (str): The name of the tool to execute.
+            params (Dict[str, Any]): Parameters for the tool.
+            lollms_client_instance (Optional[Any]): The LollmsClient instance, if available.
+            **kwargs: Ignored by this binding.
+
+        Returns:
+            Dict[str, Any]: The result from the tool's execute function, or an error dictionary.
+        """
+        tool_def = next((t for t in self.discovered_tools if t.get("name") == tool_name), None)
+
+        if not tool_def:
+            return {"error": f"Local tool '{tool_name}' not found or not discovered.", "status_code": 404}
+        
+        python_file_path_str = tool_def.get('_python_file_path')
+        if not python_file_path_str:
+            return {"error": f"Python implementation path missing for tool '{tool_name}'.", "status_code": 500}
+        
+        python_file_path = Path(python_file_path_str)
+
+        try:
+            module_name = f"lollms_client.mcp_bindings.local_mcp.tools.{tool_name}" 
+            spec = importlib.util.spec_from_file_location(module_name, str(python_file_path))
+            
+            if not spec or not spec.loader:
+                return {"error": f"Could not create module spec for tool '{tool_name}'.", "status_code": 500}
+
+            tool_module = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(tool_module)
+
+            if not hasattr(tool_module, 'execute'):
+                return {"error": f"Tool '{tool_name}' Python file does not have an 'execute' function.", "status_code": 500}
+            
+            execute_function = getattr(tool_module, 'execute')
+            
+            # Inspect the execute function's signature
+            import inspect
+            sig = inspect.signature(execute_function)
+            
+            exec_params = {}
+            if 'params' in sig.parameters: # Always pass params if expected
+                exec_params['params'] = params
+            
+            # Conditionally pass lollms_client_instance
+            if 'lollms_client_instance' in sig.parameters and lollms_client_instance is not None:
+                exec_params['lollms_client_instance'] = lollms_client_instance
+            elif 'lollms_client_instance' in sig.parameters and lollms_client_instance is None:
+                ASCIIColors.warning(f"Tool '{tool_name}' expects 'lollms_client_instance', but it was not provided to execute_tool.")
+            
+            ASCIIColors.info(f"Executing local tool '{tool_name}' with effective params for its execute(): {exec_params.keys()}")
+            result = execute_function(**exec_params) # Pass parameters accordingly
+            
+            return {"output": result, "status_code": 200}
+
+        except Exception as e:
+            trace_exception(e)
+            return {"error": f"Error executing tool '{tool_name}': {str(e)}", "status_code": 500}
+
+
+# --- Example Usage (for testing within this file) ---
+if __name__ == '__main__':
+    ASCIIColors.magenta("--- LocalMCPBinding Test ---")
+
+    # Create a temporary tools directory for testing
+    test_tools_base_dir = Path(__file__).parent.parent.parent / "temp_mcp_tools_for_test" # Place it outside the package
+    test_tools_base_dir.mkdir(parents=True, exist_ok=True)
+
+    # Define a sample tool: get_weather
+    tool1_dir = test_tools_base_dir / "get_weather"
+    tool1_dir.mkdir(exist_ok=True)
+
+    # MCP JSON for get_weather
+    get_weather_mcp = {
+        "name": "get_weather",
+        "description": "Fetches the current weather for a given city.",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "city": {"type": "string", "description": "The city name."},
+                "unit": {"type": "string", "enum": ["celsius", "fahrenheit"], "default": "celsius"}
+            },
+            "required": ["city"]
+        },
+        "output_schema": { # Optional, but good practice
+            "type": "object",
+            "properties": {
+                "temperature": {"type": "number"},
+                "condition": {"type": "string"},
+                "unit": {"type": "string"}
+            }
+        }
+    }
+    with open(tool1_dir / "get_weather.mcp.json", "w") as f:
+        json.dump(get_weather_mcp, f, indent=2)
+
+    # Python code for get_weather
+    get_weather_py = """
+import random
+def execute(params: dict) -> dict:
+    city = params.get("city")
+    unit = params.get("unit", "celsius")
+    
+    if not city:
+        return {"error": "City not provided"}
+        
+    # Simulate weather fetching
+    conditions = ["sunny", "cloudy", "rainy", "snowy"]
+    temp = random.randint(-10 if unit == "celsius" else 14, 35 if unit == "celsius" else 95)
+    
+    return {
+        "temperature": temp,
+        "condition": random.choice(conditions),
+        "unit": unit
+    }
+"""
+    with open(tool1_dir / "get_weather.py", "w") as f:
+        f.write(get_weather_py)
+
+    # Define another sample tool: sum_numbers
+    tool2_dir = test_tools_base_dir / "sum_numbers"
+    tool2_dir.mkdir(exist_ok=True)
+    sum_numbers_mcp = {
+        "name": "sum_numbers",
+        "description": "Calculates the sum of a list of numbers.",
+        "input_schema": {
+            "type": "object",
+            "properties": {"numbers": {"type": "array", "items": {"type": "number"}}},
+            "required": ["numbers"]
+        },
+        "output_schema": {"type": "object", "properties": {"sum": {"type": "number"}}}
+    }
+    with open(tool2_dir / "sum_numbers.mcp.json", "w") as f:
+        json.dump(sum_numbers_mcp, f, indent=2)
+    sum_numbers_py = """
+def execute(params: dict) -> dict:
+    numbers = params.get("numbers", [])
+    if not isinstance(numbers, list) or not all(isinstance(n, (int, float)) for n in numbers):
+        return {"error": "Invalid input: 'numbers' must be a list of numbers."}
+    return {"sum": sum(numbers)}
+"""
+    with open(tool2_dir / "sum_numbers.py", "w") as f:
+        f.write(sum_numbers_py)
+
+
+    local_mcp_binding = LocalMCPBinding(binding_name="local_mcp_test", tools_folder_path=test_tools_base_dir)
+
+    ASCIIColors.cyan("\n1. Discovering all tools...")
+    all_tools = local_mcp_binding.discover_tools()
+    if all_tools:
+        ASCIIColors.green(f"Discovered {len(all_tools)} tools:")
+        for tool in all_tools:
+            print(f"  - Name: {tool.get('name')}, Description: {tool.get('description')}")
+            assert "_python_file_path" in tool # Internal check
+    else:
+        ASCIIColors.warning("No tools discovered.")
+
+    ASCIIColors.cyan("\n2. Executing 'get_weather' tool...")
+    weather_params = {"city": "London", "unit": "celsius"}
+    weather_result = local_mcp_binding.execute_tool("get_weather", weather_params)
+    ASCIIColors.green(f"Weather result: {weather_result}")
+    assert "error" not in weather_result.get("output", {}), f"Weather tool execution failed: {weather_result}"
+    assert weather_result.get("status_code") == 200
+
+    ASCIIColors.cyan("\n3. Executing 'sum_numbers' tool...")
+    sum_params = {"numbers": [10, 2.5, 7]}
+    sum_result = local_mcp_binding.execute_tool("sum_numbers", sum_params)
+    ASCIIColors.green(f"Sum result: {sum_result}")
+    assert sum_result.get("output", {}).get("sum") == 19.5, f"Sum tool execution incorrect: {sum_result}"
+    assert sum_result.get("status_code") == 200
+
+    ASCIIColors.cyan("\n4. Executing non-existent tool...")
+    non_existent_result = local_mcp_binding.execute_tool("do_magic", {"spell": "abracadabra"})
+    ASCIIColors.warning(f"Non-existent tool result: {non_existent_result}")
+    assert non_existent_result.get("status_code") == 404
+
+    ASCIIColors.cyan("\n5. Discovering a specific tool ('sum_numbers')...")
+    specific_tools = local_mcp_binding.discover_tools(specific_tool_names=["sum_numbers"])
+    if specific_tools and len(specific_tools) == 1 and specific_tools[0].get("name") == "sum_numbers":
+        ASCIIColors.green("Successfully discovered specific tool 'sum_numbers'.")
+    else:
+        ASCIIColors.error(f"Failed to discover specific tool. Found: {specific_tools}")
+
+
+    # Cleanup: Remove the temporary tools directory
+    import shutil
+    try:
+        shutil.rmtree(test_tools_base_dir)
+        ASCIIColors.info(f"Cleaned up temporary tools directory: {test_tools_base_dir}")
+    except Exception as e_clean:
+        ASCIIColors.error(f"Could not clean up temporary tools directory: {e_clean}")
+
+    ASCIIColors.magenta("\n--- LocalMCPBinding Test Finished ---")

lollms_client/mcp_bindings/local_mcp/default_tools/file_writer/file_writer.py

@@ -0,0 +1,74 @@
+from pathlib import Path
+from typing import Dict, Any
+
+def execute(params: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Writes or appends text content to a specified file.
+    """
+    file_path_str = params.get("file_path")
+    content = params.get("content")
+    mode = params.get("mode", "overwrite") # Default to overwrite
+
+    if not file_path_str:
+        return {"status": "error", "message": "file_path parameter is required."}
+    if content is None: # Allow empty string, but not None
+        return {"status": "error", "message": "content parameter is required."}
+    if mode not in ["overwrite", "append"]:
+        return {"status": "error", "message": "Invalid mode. Must be 'overwrite' or 'append'."}
+
+    try:
+        # Security consideration: Restrict file paths if necessary in a real application.
+        # For this local tool, we'll assume the user/AI provides paths responsibly.
+        # However, avoid absolute paths starting from root unless explicitly intended.
+        # For simplicity here, we allow relative and 'safe' absolute paths.
+        
+        # Make path relative to a 'workspace' if not absolute, to prevent writing anywhere.
+        # For this example, let's assume a 'tool_workspace' directory next to the tools_folder.
+        # This needs to be configurable or defined by the LocalMCPBinding.
+        # For now, we'll just resolve the path. A real implementation would need sandboxing.
+        
+        target_file = Path(file_path_str)
+
+        # Create parent directories if they don't exist
+        target_file.parent.mkdir(parents=True, exist_ok=True)
+
+        write_mode = "w" if mode == "overwrite" else "a"
+
+        with open(target_file, write_mode, encoding='utf-8') as f:
+            f.write(content)
+        
+        return {
+            "status": "success",
+            "message": f"Content successfully {'written to' if mode == 'overwrite' else 'appended to'} file.",
+            "file_path": str(target_file.resolve())
+        }
+    except Exception as e:
+        return {
+            "status": "error",
+            "message": f"Failed to write to file: {str(e)}",
+            "file_path": str(Path(file_path_str).resolve() if file_path_str else "N/A")
+        }
+
+if __name__ == '__main__':
+    # Example test
+    test_params_overwrite = {
+        "file_path": "test_output/example.txt",
+        "content": "Hello from the file_writer tool!\nThis is the first line.",
+        "mode": "overwrite"
+    }
+    result_overwrite = execute(test_params_overwrite)
+    print(f"Overwrite Test Result: {result_overwrite}")
+
+    test_params_append = {
+        "file_path": "test_output/example.txt",
+        "content": "\nThis is an appended line.",
+        "mode": "append"
+    }
+    result_append = execute(test_params_append)
+    print(f"Append Test Result: {result_append}")
+
+    test_params_error = {
+        "content": "Missing file path"
+    }
+    result_error = execute(test_params_error)
+    print(f"Error Test Result: {result_error}")

lollms_client/mcp_bindings/local_mcp/default_tools/generate_image_from_prompt/generate_image_from_prompt.py

@@ -0,0 +1,195 @@
+from pathlib import Path
+from typing import Dict, Any
+import uuid
+import io
+# We expect LollmsClient instance to be passed if the tool needs it.
+# from lollms_client import LollmsClient # Not imported directly, but type hint is useful
+
+def execute(params: Dict[str, Any], lollms_client_instance: Any = None) -> Dict[str, Any]:
+    """
+    Generates an image using the LollmsClient's TTI binding.
+    The lollms_client_instance is expected to be passed by the LocalMCPBinding if available.
+    """
+    prompt = params.get("prompt")
+    negative_prompt = params.get("negative_prompt", "")
+    width = params.get("width") # Will be None if not provided
+    height = params.get("height") # Will be None if not provided
+    output_filename_suggestion = params.get("output_filename_suggestion", "generated_image.png")
+
+    if not prompt:
+        return {"status": "error", "message": "'prompt' parameter is required."}
+
+    if not lollms_client_instance or not hasattr(lollms_client_instance, 'tti') or not lollms_client_instance.tti:
+        return {
+            "status": "tti_not_available",
+            "message": "LollmsClient instance with an active TTI binding was not provided or TTI is not configured.",
+            "image_path": None,
+            "image_url": None
+        }
+
+    try:
+        tti_binding = lollms_client_instance.tti
+        
+        # Prepare arguments for the TTI binding's generate_image method
+        tti_kwargs = {}
+        if width is not None:
+            tti_kwargs['width'] = width
+        if height is not None:
+            tti_kwargs['height'] = height
+        # Add other common TTI params if desired, e.g. seed, steps, cfg_scale
+        # These would need to be added to the MCP JSON input_schema as well.
+
+        image_bytes = tti_binding.generate_image(
+            prompt=prompt,
+            negative_prompt=negative_prompt,
+            **tti_kwargs
+        )
+
+        if not image_bytes:
+            return {
+                "status": "error",
+                "message": "TTI binding returned no image data.",
+                "image_path": None,
+                "image_url": None
+            }
+
+        # Define where to save the image.
+        # This should ideally be a secure, configurable workspace.
+        # For this example, we save it into a 'mcp_generated_images' subdirectory
+        # of the current working directory OR a path derived from lollms_paths if available.
+        
+        # Prefer using a path from lollms_client_instance if available (e.g., an output or data path)
+        # This part needs careful consideration for a real application.
+        save_dir_base = Path.cwd() 
+        if hasattr(lollms_client_instance, 'lollms_paths_config') and lollms_client_instance.lollms_paths_config.get('personal_outputs_path'):
+            save_dir_base = Path(lollms_client_instance.lollms_paths_config['personal_outputs_path'])
+        elif hasattr(lollms_client_instance, 'lollms_paths_config') and lollms_client_instance.lollms_paths_config.get('shared_outputs_path'): # type: ignore
+            save_dir_base = Path(lollms_client_instance.lollms_paths_config['shared_outputs_path']) # type: ignore
+
+        save_dir = save_dir_base / "mcp_generated_images"
+        save_dir.mkdir(parents=True, exist_ok=True)
+
+        # Sanitize filename and make it unique
+        base, ext = Path(output_filename_suggestion).stem, Path(output_filename_suggestion).suffix
+        if not ext: ext = ".png" # Default to png
+        safe_base = "".join(c if c.isalnum() or c in ['_', '-'] else '_' for c in base)
+        unique_filename = f"{safe_base}_{uuid.uuid4().hex[:8]}{ext}"
+        
+        image_save_path = save_dir / unique_filename
+
+        with open(image_save_path, "wb") as f:
+            f.write(image_bytes)
+        
+        # TODO: How to best represent the URL? For local files, it might be a file:// URL
+        # or a relative path that the client application understands.
+        # For now, returning a relative path from a conceptual 'outputs' root.
+        # A more robust solution would involve the LollmsClient serving these images
+        # or providing data URLs.
+        
+        # Create a relative path for client display if possible
+        # This assumes the client knows how to interpret "mcp_generated_images/..."
+        relative_image_path = f"mcp_generated_images/{unique_filename}"
+        image_url = f"file:///{image_save_path.resolve()}" # Example data URL or file path
+
+        return {
+            "status": "success",
+            "message": f"Image generated and saved successfully.",
+            "image_path": relative_image_path, # More of a hint
+            "image_url": image_url # More concrete path
+        }
+
+    except Exception as e:
+        # from ascii_colors import trace_exception # If you need full trace
+        # trace_exception(e)
+        return {
+            "status": "error",
+            "message": f"Failed to generate image via TTI binding: {str(e)}",
+            "image_path": None,
+            "image_url": None
+        }
+
+if __name__ == '__main__':
+    import json
+    from PIL import Image as PILImage # To avoid conflict with module-level Image if any
+    print("--- Generate Image (via LollmsClient TTI) Tool Test ---")
+
+    # This test requires a LollmsClient instance with a configured TTI binding.
+    # We'll mock it for a standalone test of the execute function's logic.
+
+    class MockTTIBinding:
+        def __init__(self, works=True):
+            self.works = works
+            self.config = {"default_width": 512, "default_height": 512} # Mock config
+
+        def generate_image(self, prompt, negative_prompt="", width=None, height=None, **kwargs):
+            if not self.works:
+                # return None # Simulate TTI returning no data
+                raise ValueError("Simulated TTI error in generate_image")
+            
+            print(f"MockTTI: Generating image for prompt: '{prompt}', neg: '{negative_prompt}', W:{width}, H:{height}")
+            # Create a dummy PIL image and return its bytes
+            img = PILImage.new('RGB', (width or 512, height or 512), color = 'skyblue' if "sky" in prompt else "lightcoral")
+            from PIL import ImageDraw
+            draw = ImageDraw.Draw(img)
+            draw.text((10,10), prompt[:30], fill=(0,0,0))
+            byte_arr = io.BytesIO()
+            img.save(byte_arr, format='PNG')
+            return byte_arr.getvalue()
+
+    class MockLollmsClient:
+        def __init__(self, tti_works=True):
+            self.tti = MockTTIBinding(works=tti_works)
+            self.lollms_paths_config = {"personal_outputs_path": Path("./test_lollms_client_outputs")} # Mock path
+            Path(self.lollms_paths_config["personal_outputs_path"]).mkdir(exist_ok=True)
+
+
+    mock_lc_success = MockLollmsClient(tti_works=True)
+    mock_lc_tti_fail = MockLollmsClient(tti_works=False)
+    mock_lc_no_tti = MockLollmsClient()
+    mock_lc_no_tti.tti = None # Simulate TTI not configured
+
+    # Test 1: Successful generation
+    params1 = {"prompt": "A beautiful sunset over mountains", "width": 256, "height": 256}
+    result1 = execute(params1, lollms_client_instance=mock_lc_success)
+    print(f"\nTest 1 Result (Success):\n{json.dumps(result1, indent=2)}")
+    assert result1["status"] == "success"
+    assert result1["image_path"] is not None
+    if result1["image_path"]:
+        # Verify file was created (adjust path based on where it's saved by tool)
+        # For this test, it's saved in ./test_lollms_client_outputs/mcp_generated_images/
+        full_saved_path = Path(mock_lc_success.lollms_paths_config["personal_outputs_path"]) / result1["image_path"]
+        print(f"Checking for image at: {full_saved_path}")
+        assert full_saved_path.exists()
+        # Optional: Clean up created image after test
+        # full_saved_path.unlink(missing_ok=True)
+
+
+    # Test 2: TTI binding itself fails to generate
+    params2 = {"prompt": "A futuristic city"}
+    result2 = execute(params2, lollms_client_instance=mock_lc_tti_fail)
+    print(f"\nTest 2 Result (TTI Fails):\n{json.dumps(result2, indent=2)}")
+    assert result2["status"] == "error"
+    assert "Simulated TTI error" in result2["message"]
+
+    # Test 3: No TTI binding available in LollmsClient
+    params3 = {"prompt": "A cat wearing a hat"}
+    result3 = execute(params3, lollms_client_instance=mock_lc_no_tti)
+    print(f"\nTest 3 Result (No TTI Binding):\n{json.dumps(result3, indent=2)}")
+    assert result3["status"] == "tti_not_available"
+
+    # Test 4: Missing prompt
+    params4 = {}
+    result4 = execute(params4, lollms_client_instance=mock_lc_success)
+    print(f"\nTest 4 Result (Missing Prompt):\n{json.dumps(result4, indent=2)}")
+    assert result4["status"] == "error"
+    assert "'prompt' parameter is required" in result4["message"]
+    
+    # Test 5: No LollmsClient instance passed (should also result in tti_not_available)
+    params5 = {"prompt": "A dog"}
+    result5 = execute(params5, lollms_client_instance=None)
+    print(f"\nTest 5 Result (No LollmsClient passed):\n{json.dumps(result5, indent=2)}")
+    assert result5["status"] == "tti_not_available"
+
+
+    print("\n--- Tests Finished ---")
+    print(f"Generated test images (if any) are in subdirectories of: {mock_lc_success.lollms_paths_config['personal_outputs_path']}")