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

lollms_client/mcp_bindings/local_mcp/default_tools/internet_search/internet_search.py

@@ -0,0 +1,107 @@
+from typing import Dict, Any, List
+
+# --- Package Management ---
+_duckduckgo_search_installed = False
+_installation_error_message = ""
+try:
+    import pipmaster as pm
+    pm.ensure_packages(["duckduckgo_search"])
+    from duckduckgo_search import DDGS
+    _duckduckgo_search_installed = True
+except Exception as e:
+    _installation_error_message = str(e)
+    DDGS = None # Ensure DDGS is None if import fails
+# --- End Package Management ---
+
+def execute(params: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Performs an internet search using DuckDuckGo.
+    """
+    if not _duckduckgo_search_installed:
+        return {
+            "search_results": [],
+            "error": f"Required library 'duckduckgo_search' is not installed or import failed: {_installation_error_message}"
+        }
+
+    query = params.get("query")
+    num_results = params.get("num_results", 5)
+
+    if not query:
+        return {"search_results": [], "error": "'query' parameter is required."}
+    if not isinstance(num_results, int) or num_results <= 0:
+        num_results = 5 # Default to 5 if invalid
+
+    try:
+        search_results_formatted: List[Dict[str, str]] = []
+        # DDGS().text returns a generator, max_results limits it.
+        # Note: The DDGS library might sometimes return fewer results than max_results.
+        with DDGS() as ddgs:
+            results = ddgs.text(keywords=query, max_results=num_results)
+            if results:
+                for r in results:
+                    search_results_formatted.append({
+                        "title": r.get("title", "N/A"),
+                        "link": r.get("href", "#"),
+                        "snippet": r.get("body", "N/A")
+                    })
+            
+        if not search_results_formatted and results is None: # Check if ddgs.text itself returned None
+             return {"search_results": [], "error": "Search returned no results or failed to connect."}
+
+
+        return {"search_results": search_results_formatted, "error": None}
+
+    except Exception as e:
+        # Log the exception for server-side debugging if possible
+        # For now, just return it in the error field.
+        print(f"Error during internet search: {str(e)}") # Basic logging
+        # from ascii_colors import trace_exception (if you want to import it here)
+        # trace_exception(e)
+        return {"search_results": [], "error": f"An unexpected error occurred during search: {str(e)}"}
+
+if __name__ == '__main__':
+    import json
+    print("--- Internet Search Tool Test ---")
+
+    if not _duckduckgo_search_installed:
+        print(f"Cannot run test: duckduckgo_search not installed. Error: {_installation_error_message}")
+    else:
+        # Test 1: Simple search
+        params1 = {"query": "What is the capital of France?", "num_results": 3}
+        result1 = execute(params1)
+        print(f"\nTest 1 Result (Query: '{params1['query']}'):\n{json.dumps(result1, indent=2)}")
+        if result1.get("search_results"):
+            assert len(result1["search_results"]) <= 3
+            assert "error" not in result1 or result1["error"] is None
+        else:
+            print(f"Warning: Test 1 might have failed to retrieve results. Error: {result1.get('error')}")
+
+
+        # Test 2: Search with more results
+        params2 = {"query": "Latest AI breakthroughs", "num_results": 6}
+        result2 = execute(params2)
+        print(f"\nTest 2 Result (Query: '{params2['query']}'):\n{json.dumps(result2, indent=2)}")
+        if result2.get("search_results"):
+            assert len(result2["search_results"]) <= 6
+        else:
+            print(f"Warning: Test 2 might have failed to retrieve results. Error: {result2.get('error')}")
+
+
+        # Test 3: No query
+        params3 = {}
+        result3 = execute(params3)
+        print(f"\nTest 3 Result (No query):\n{json.dumps(result3, indent=2)}")
+        assert result3["error"] is not None
+        assert "query' parameter is required" in result3["error"]
+
+        # Test 4: Invalid num_results
+        params4 = {"query": "python programming", "num_results": -1}
+        result4 = execute(params4) # Should default to 5
+        print(f"\nTest 4 Result (Invalid num_results):\n{json.dumps(result4, indent=2)}")
+        if result4.get("search_results"):
+             assert len(result4["search_results"]) <= 5
+        else:
+            print(f"Warning: Test 4 might have failed to retrieve results. Error: {result4.get('error')}")
+
+
+    print("\n--- Tests Finished ---")

lollms_client/mcp_bindings/local_mcp/default_tools/python_interpreter/python_interpreter.py

@@ -0,0 +1,141 @@
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import Dict, Any
+import sys
+import json
+import pipmaster as pm
+pm.ensure_packages(["RestrictedPython"])
+
+import RestrictedPython
+from RestrictedPython import compile_restricted, safe_globals
+from RestrictedPython.PrintCollector import PrintCollector
+
+
+def execute(params: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Executes a snippet of Python code in a restricted environment.
+    """
+    code = params.get("code")
+    timeout_seconds = params.get("timeout_seconds", 10)
+
+    if not code:
+        return {
+            "stdout": "",
+            "stderr": "Error: 'code' parameter is required.",
+            "returned_value": None,
+            "execution_status": "error"
+        }
+
+    # For this local tool, we'll use RestrictedPython for a degree of safety.
+    # A more robust solution for untrusted code would involve containers (e.g., Docker)
+    # or a more heavily sandboxed environment. RestrictedPython is not foolproof.
+
+    restricted_globals = dict(safe_globals) # type: ignore
+    restricted_globals['_print_'] = PrintCollector # Capture print statements
+    restricted_globals['_getattr_'] = RestrictedPython.Guards.safer_getattr # Allow safer attribute access
+    # Add more globals if needed, e.g., math module, but be cautious.
+    # restricted_globals['math'] = math
+
+    stdout_capture = ""
+    stderr_capture = ""
+    returned_value_str = None
+    status = "error" # Default to error
+
+    try:
+        # Compile the code in restricted mode
+        # Adding "<string>" as the filename for tracebacks
+        byte_code = compile_restricted(code, filename='<inline_script>', mode='exec')
+        
+        # Prepare a dictionary for local variables, including the print collector
+        local_vars = {} 
+        
+        # Execute the compiled code
+        # Note: RestrictedPython's exec doesn't directly support timeout.
+        # A more complex setup with threading or multiprocessing would be needed for true timeout.
+        # For simplicity, this example doesn't implement a hard timeout for RestrictedPython's exec.
+        # The timeout_seconds param is more of a hint for now or for alternative execution methods.
+
+        exec(byte_code, restricted_globals, local_vars)
+        
+        stdout_capture = restricted_globals['_print']() # Get captured prints
+        # RestrictedPython itself doesn't easily separate stdout/stderr from exec.
+        # Errors during compilation or guarded execution will raise exceptions.
+
+        # Try to get a returned value if the script used 'return' (not typical for 'exec' mode)
+        # or if a specific variable was set to indicate a return.
+        # For this example, we won't try to capture implicit returns from 'exec'.
+        # If the executed code sets a variable like `result = ...`, it would be in `local_vars`.
+        # We'll consider `returned_value` as None for simplicity with 'exec'.
+
+        status = "success"
+
+    except SyntaxError as se:
+        stderr_capture = f"SyntaxError: {se}"
+        status = "error"
+    except RestrictedPython.Guards. इलाकोंOnlyĐiPythonGuardViolation as rpe: # Common RestrictedPython error
+        stderr_capture = f"RestrictedPythonError: {rpe}"
+        status = "error"
+    except NameError as ne: # Undeclared variable
+        stderr_capture = f"NameError: {ne}"
+        status = "error"
+    except TypeError as te:
+        stderr_capture = f"TypeError: {te}"
+        status = "error"
+    except Exception as e:
+        stderr_capture = f"Execution Error: {type(e).__name__}: {e}"
+        status = "error"
+        trace_exception(e) # For more detailed logging if needed
+
+    return {
+        "stdout": stdout_capture,
+        "stderr": stderr_capture,
+        "returned_value": returned_value_str, # Typically None with exec
+        "execution_status": status
+    }
+
+
+if __name__ == '__main__':
+    # Example Tests
+    print("--- Python Interpreter Tool Test ---")
+
+    # Test 1: Simple print
+    params1 = {"code": "print('Hello from restricted Python!')\nx = 10 + 5\nprint(f'Result is {x}')"}
+    result1 = execute(params1)
+    print(f"\nTest 1 Result:\n{json.dumps(result1, indent=2)}")
+    assert result1["execution_status"] == "success"
+    assert "Hello from restricted Python!" in result1["stdout"]
+    assert "Result is 15" in result1["stdout"]
+
+    # Test 2: Code with an error (e.g., trying to access restricted features)
+    params2 = {"code": "import os\nprint(os.getcwd())"} # os is usually restricted
+    result2 = execute(params2)
+    print(f"\nTest 2 Result (expected error):\n{json.dumps(result2, indent=2)}")
+    assert result2["execution_status"] == "error"
+    assert "RestrictedPythonError" in result2["stderr"] or "NameError" in result2["stderr"] # Depending on how os import fails
+
+    # Test 3: Syntax error
+    params3 = {"code": "print('Hello without closing quote"}
+    result3 = execute(params3)
+    print(f"\nTest 3 Result (syntax error):\n{json.dumps(result3, indent=2)}")
+    assert result3["execution_status"] == "error"
+    assert "SyntaxError" in result3["stderr"]
+    
+    # Test 4: No code
+    params4 = {"code": ""}
+    result4 = execute(params4) # Should succeed with empty output or be handled if empty code is invalid.
+                               # Current RestrictedPython might raise error on empty.
+    print(f"\nTest 4 Result (empty code):\n{json.dumps(result4, indent=2)}")    
+    # Depending on compile_restricted behavior for empty string, this might be success or error.
+    # It seems compile_restricted can handle empty strings.
+    assert result4["execution_status"] == "success" 
+    assert result4["stdout"] == ""
+
+    # Test 5: Attempting a disallowed attribute
+    params5 = {"code": "x = ().__class__"} # Example of trying to access something disallowed
+    result5 = execute(params5)
+    print(f"\nTest 5 Result (disallowed attribute):\n{json.dumps(result5, indent=2)}")
+    assert result5["execution_status"] == "error"
+    assert "RestrictedPythonError" in result5["stderr"]
+    
+    print("\n--- Tests Finished ---")

lollms_client/stt_bindings/whisper/__init__.py

@@ -30,7 +30,7 @@ try:
     torch_index_url = None
     if preferred_torch_device_for_install == "cuda":
         # Specify a common CUDA version index. Pip should resolve the correct torch version.
-        # As of late 2023/early 2024, cu118 or cu121 are common. Let's use cu121.
+        # As of late 2023/early 2024, cu118 or cu121 are common. Let's use cu126.
         # Users with different CUDA setups might need to pre-install torch manually.
         torch_index_url = "https://download.pytorch.org/whl/cu126"
         ASCIIColors.info(f"Attempting to ensure PyTorch with CUDA support (target index: {torch_index_url})")