lollms-client 0.17.2__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/tti_bindings/dalle/__init__.py

@@ -152,7 +152,8 @@ class DalleTTIBinding_Impl(LollmsTTIBinding):
         # Format size string and validate against the active model for this generation
         size_str = f"{width}x{height}"
         if size_str not in model_props["sizes"]:
-            raise ValueError(f"Unsupported size '{size_str}' for model '{active_model_name}'. Supported sizes: {model_props['sizes']}. Adjust width/height for this model.")
+            ASCIIColors.warning(f"Unsupported size '{size_str}' for model '{active_model_name}'. Supported sizes: {model_props['sizes']}. Adjust width/height for this model.")
+            size_str = model_props["sizes"][0]
 
         # Handle prompt and negative prompt based on the active model
         final_prompt = prompt

{lollms_client-0.17.2.dist-info → lollms_client-0.19.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lollms_client
-Version: 0.17.2
+Version: 0.19.0
 Summary: A client library for LoLLMs generate endpoint
 Author-email: ParisNeo <parisneoai@gmail.com>
 License: Apache Software License

{lollms_client-0.17.2.dist-info → lollms_client-0.19.0.dist-info}/RECORD

@@ -1,3 +1,5 @@
+examples/function_calling_with_local_custom_mcp.py,sha256=g6wOFRB8-p9Cv7hKmQaGzPvtMX3H77gas01QVNEOduM,12407
+examples/local_mcp.py,sha256=w40dgayvHYe01yvekEE0LjcbkpwKjWwJ-9v4_wGYsUk,9113
 examples/simple_text_gen_test.py,sha256=RoX9ZKJjGMujeep60wh5WT_GoBn0O9YKJY6WOy-ZmOc,8710
 examples/simple_text_gen_with_image_test.py,sha256=rR1O5Prcb52UHtJ3c6bv7VuTd1cvbkr5aNZU-v-Rs3Y,9263
 examples/text_2_audio.py,sha256=MfL4AH_NNwl6m0I0ywl4BXRZJ0b9Y_9fRqDIe6O-Sbw,3523
@@ -9,23 +11,21 @@ examples/text_gen_system_prompt.py,sha256=jRQeGe1IVu_zRHX09CFiDYi7WrK9Zd5FlMqC_g
 examples/article_summary/article_summary.py,sha256=CR8mCBNcZEVCR-q34uOmrJyMlG-xk4HkMbsV-TOZEnk,1978
 examples/deep_analyze/deep_analyse.py,sha256=fZNmDrfEAuxEAfdbjAgJYIh1k6wbiuZ4RvwHRvtyUs8,971
 examples/deep_analyze/deep_analyze_multiple_files.py,sha256=fOryShA33P4IFxcxUDe-nJ2kW0v9w9yW8KsToS3ETl8,1032
-examples/function_call/functions_call_with images.py,sha256=jrNtTF7lAzad25Ob0Yv4pwLs12HSzDamKKR9ORkNWjc,1888
 examples/generate_and_speak/generate_and_speak.py,sha256=RAlvRwtEKXCh894l9M3iQbADe8CvF5N442jtRurK02I,13908
 examples/generate_game_sfx/generate_game_fx.py,sha256=MgLNGi4hGBRoyr4bqYuCUdCSqd-ldDVfF0VSDUjgzsg,10467
 examples/personality_test/chat_test.py,sha256=o2jlpoddFc-T592iqAiA29xk3x27KsdK5DluqxBwHqw,1417
 examples/personality_test/chat_with_aristotle.py,sha256=4X_fwubMpd0Eq2rCReS2bgVlUoAqJprjkLXk2Jz6pXU,1774
 examples/personality_test/tesks_test.py,sha256=7LIiwrEbva9WWZOLi34fsmCBN__RZbPpxoUOKA_AtYk,1924
 examples/test_local_models/local_chat.py,sha256=slakja2zaHOEAUsn2tn_VmI4kLx6luLBrPqAeaNsix8,456
-lollms_client/__init__.py,sha256=D-gKzzHJSNT09aCJipQi6CUfwb4bSCUwZ-jP2VmalwE,823
+lollms_client/__init__.py,sha256=7YwfgI-rPt3hNWyG5_ObEgKMsRGXYBu6QDe97v_Cc0g,910
 lollms_client/lollms_config.py,sha256=goEseDwDxYJf3WkYJ4IrLXwg3Tfw73CXV2Avg45M_hE,21876
-lollms_client/lollms_core.py,sha256=fRHdQ0yWAmMuOLZAzDbdlYfCsx0Rb8rQ-RYl_bKgEHk,80049
+lollms_client/lollms_core.py,sha256=psVTrEtHYhjy9h014rHLotBC4Aj72PvG2OV0UAjLcvw,102496
 lollms_client/lollms_discussion.py,sha256=9b83m0D894jwpgssWYTQHbVxp1gJoI-J947Ui_dRXII,2073
-lollms_client/lollms_functions.py,sha256=p8SFtmEPqvVCsIz2fZ5HxyOHaxjrAo5c12uTzJnb6m8,3594
 lollms_client/lollms_js_analyzer.py,sha256=01zUvuO2F_lnUe_0NLxe1MF5aHE1hO8RZi48mNPv-aw,8361
 lollms_client/lollms_llm_binding.py,sha256=bdElz_IBx0zZ-85YTT1fyY_mSoHo46tKIMiHYJlKCkM,9809
+lollms_client/lollms_mcp_binding.py,sha256=0rK9HQCBEGryNc8ApBmtOlhKE1Yfn7X7xIQssXxS2Zc,8933
 lollms_client/lollms_python_analyzer.py,sha256=7gf1fdYgXCOkPUkBAPNmr6S-66hMH4_KonOMsADASxc,10246
 lollms_client/lollms_stt_binding.py,sha256=jAUhLouEhh2hmm1bK76ianfw_6B59EHfY3FmLv6DU-g,5111
-lollms_client/lollms_tasks.py,sha256=Tgqces03gPTHFJCcPaeN9vBCsil3SSJX7nQAjCQ2-yg,34393
 lollms_client/lollms_tti_binding.py,sha256=afO0-d-Kqsmh8UHTijTvy6dZAt-XDB6R-IHmdbf-_fs,5928
 lollms_client/lollms_ttm_binding.py,sha256=FjVVSNXOZXK1qvcKEfxdiX6l2b4XdGOSNnZ0utAsbDg,4167
 lollms_client/lollms_tts_binding.py,sha256=5cJYECj8PYLJAyB6SEH7_fhHYK3Om-Y3arkygCnZ24o,4342
@@ -42,12 +42,17 @@ lollms_client/llm_bindings/pythonllamacpp/__init__.py,sha256=7dM42TCGKh0eV0njNL1
 lollms_client/llm_bindings/tensor_rt/__init__.py,sha256=nPaNhGRd-bsG0UlYwcEqjd_UagCMEf5VEbBUW-GWu6A,32203
 lollms_client/llm_bindings/transformers/__init__.py,sha256=9LkqEC5bp1zHgyeGEcPQ3_uqvEAEf_B4p9DztcBaC5w,37211
 lollms_client/llm_bindings/vllm/__init__.py,sha256=2NqeeqYWXNq1aNicdcAwN9DaoL4gq96GZ7hsKErfC6c,32187
+lollms_client/mcp_bindings/local_mcp/__init__.py,sha256=FxS-0PULS3TZScPLDbwHlfyW5joWucmMfn6b9ydyeM0,14341
+lollms_client/mcp_bindings/local_mcp/default_tools/file_writer/file_writer.py,sha256=2pkt1JcEKj61lIA5zuW3s6qkdpQN5rKfooo7bnebx24,3061
+lollms_client/mcp_bindings/local_mcp/default_tools/generate_image_from_prompt/generate_image_from_prompt.py,sha256=THtZsMxNnXZiBdkwoBlfbWY2C5hhDdmPtnM-8cSKN6s,9488
+lollms_client/mcp_bindings/local_mcp/default_tools/internet_search/internet_search.py,sha256=PLC31-D04QKTOTb1uuCHnrAlpysQjsk89yIJngK0VGc,4586
+lollms_client/mcp_bindings/local_mcp/default_tools/python_interpreter/python_interpreter.py,sha256=McDCBVoVrMDYgU7EYtyOY7mCk1uEeTea0PSD69QqDsQ,6228
 lollms_client/stt_bindings/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lollms_client/stt_bindings/lollms/__init__.py,sha256=jBz3285atdPRqQe9ZRrb-AvjqKRB4f8tjLXjma0DLfE,6082
 lollms_client/stt_bindings/whisper/__init__.py,sha256=vrua7fLwDId9_WiH4y2gXOE0hy3Gr2Ig-z5ScIT2bHI,15447
 lollms_client/stt_bindings/whispercpp/__init__.py,sha256=B45lOn5rSoHXJSG9duPzBEPBOoNTrDzpCUdOL8KHaDM,21874
 lollms_client/tti_bindings/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lollms_client/tti_bindings/dalle/__init__.py,sha256=VuuCWQb6Y3b5-SdU9dMpiKAa2s_4h_B58jE10L8LTak,23577
+lollms_client/tti_bindings/dalle/__init__.py,sha256=V-rODzcwaN9eg0wX8DGOQXXcDtnYYDWYD6t6pFNTo0w,23628
 lollms_client/tti_bindings/diffusers/__init__.py,sha256=Hcu3F3KU8h6b_T4Dpl98OsQrsUoecd_z7xOVIEyYoDc,37679
 lollms_client/tti_bindings/gemini/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lollms_client/tti_bindings/lollms/__init__.py,sha256=GJShFW6Y8MrfM9PXaPrdAp8OUpD6rraSRFt8ZOnrauo,8735
@@ -62,8 +67,8 @@ lollms_client/tts_bindings/piper_tts/__init__.py,sha256=0IEWG4zH3_sOkSb9WbZzkeV5
 lollms_client/tts_bindings/xtts/__init__.py,sha256=FgcdUH06X6ZR806WQe5ixaYx0QoxtAcOgYo87a2qxYc,18266
 lollms_client/ttv_bindings/__init__.py,sha256=UZ8o2izQOJLQgtZ1D1cXoNST7rzqW22rL2Vufc7ddRc,3141
 lollms_client/ttv_bindings/lollms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-lollms_client-0.17.2.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
-lollms_client-0.17.2.dist-info/METADATA,sha256=tAj-msqkBvc8uFcVXq0a-RLD8lP70hAkkrsEUBRLsb0,9798
-lollms_client-0.17.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lollms_client-0.17.2.dist-info/top_level.txt,sha256=NI_W8S4OYZvJjb0QWMZMSIpOrYzpqwPGYaklhyWKH2w,23
-lollms_client-0.17.2.dist-info/RECORD,,
+lollms_client-0.19.0.dist-info/licenses/LICENSE,sha256=HrhfyXIkWY2tGFK11kg7vPCqhgh5DcxleloqdhrpyMY,11558
+lollms_client-0.19.0.dist-info/METADATA,sha256=omhefcFH2TBEIAs0dRspAQN3mBHpJqga8Q_Qhy14bcE,9798
+lollms_client-0.19.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lollms_client-0.19.0.dist-info/top_level.txt,sha256=NI_W8S4OYZvJjb0QWMZMSIpOrYzpqwPGYaklhyWKH2w,23
+lollms_client-0.19.0.dist-info/RECORD,,

examples/function_call/functions_call_with images.py

@@ -1,52 +0,0 @@
-import cv2
-from lollms_client import LollmsClient, LollmsTTS, TasksLibrary, FunctionCalling_Library
-import random
-
-# Initialize the LollmsClient instance
-lc = LollmsClient()
-tl = TasksLibrary(lc)
-tts = LollmsTTS(lc)
-fcl = FunctionCalling_Library(tl)
-voices = tts.get_voices()
-if voices:
-    # Pick a voice randomly
-    random_voice = random.choice(voices)
-    print(f"Selected voice: {random_voice}")
-
-# File path to save the captured image
-file_path = "captured_image.jpg"
-images = []
-# Capture image from webcam and save it to a file
-def capture_image():
-    cap = cv2.VideoCapture(0)
-    if not cap.isOpened():
-        raise Exception("Could not open webcam")
-
-    ret, frame = cap.read()
-    if not ret:
-        raise Exception("Failed to capture image")
-    images.clear()
-    images.append(file_path)
-    cv2.imwrite(file_path, frame)
-    cap.release()
-    return "Image captured successfully"
-
-
-fcl.register_function("capture_image",capture_image,"Captures an image from the user webcam",[])
-
-
-
-# Function to handle streaming callback
-def cb(chunk, type):
-    print(chunk, end="", flush=True)
-
-# Generate text with image
-response, function_calls = fcl.generate_with_functions_and_images(prompt="user: take a look at me then tell ma how i look.\nassistant: ", images=images, stream=False, temperature=0.5, streaming_callback=cb)
-print(f"response: {response}")
-if len(function_calls)>0:
-    results = fcl.execute_function_calls(function_calls)
-    result = "\n".join(results)
-    prompt="user: take a look at me then tell ma how i look.\nassistant: "+response + f"\nfunction execution result: {result}\nassistant: "
-    response, function_calls = fcl.generate_with_functions_and_images(prompt, images=images, stream=False, temperature=0.5, streaming_callback=cb)
-print(f"response: {response}")
-tts.text2Audio(response, random_voice)

lollms_client/lollms_functions.py

@@ -1,72 +0,0 @@
-from functools import partial
-from lollms_client.lollms_tasks import TasksLibrary
-from typing import Dict, Any, List
-
-class FunctionCalling_Library:
-    def __init__(self, tasks_library:TasksLibrary):
-        self.tl = tasks_library
-        self.function_definitions = []
-
-    def register_function(self, function_name, function_callable, function_description, function_parameters):
-        self.function_definitions.append({
-            "function_name": function_name,
-            "function": function_callable,
-            "function_description": function_description,
-            "function_parameters": function_parameters
-        })
-
-    def unregister_function(self, function_name):
-        self.function_definitions = [func for func in self.function_definitions if func["function_name"] != function_name]
-
-
-
-    def execute_function_calls(self, function_calls: List[Dict[str, Any]]) -> List[Any]:
-        """
-        Executes the function calls with the parameters extracted from the generated text,
-        using the original functions list to find the right function to execute.
-
-        Args:
-            function_calls (List[Dict[str, Any]]): A list of dictionaries representing the function calls.
-            function_definitions (List[Dict[str, Any]]): The original list of functions with their descriptions and callable objects.
-
-        Returns:
-            List[Any]: A list of results from executing the function calls.
-        """
-        results = []
-        # Convert function_definitions to a dict for easier lookup
-        functions_dict = {func['function_name']: func['function'] for func in self.function_definitions}
-
-        for call in function_calls:
-            function_name = call.get("function_name")
-            parameters = call.get("function_parameters", [])
-            function = functions_dict.get(function_name)
-
-            if function:
-                try:
-                    # Assuming parameters is a dictionary that maps directly to the function's arguments.
-                    if type(parameters)==list:
-                        result = function(*parameters)
-                    elif type(parameters)==dict:
-                        result = function(**parameters)
-                    results.append(result)
-                except TypeError as e:
-                    # Handle cases where the function call fails due to incorrect parameters, etc.
-                    results.append(f"Error calling {function_name}: {e}")
-            else:
-                results.append(f"Function {function_name} not found.")
-
-        return results
-    
-    def generate_with_functions(self, prompt, stream=False, temperature=0.5, streaming_callback=None):
-        # Assuming generate_with_function_calls is a method from TasksLibrary
-        ai_response, function_calls = self.tl.generate_with_function_calls(prompt, self.function_definitions, callback=streaming_callback)
-        return ai_response, function_calls
-
-    def generate_with_functions_and_images(self, prompt, images=[], stream=False, temperature=0.5, streaming_callback=None):
-        # Assuming generate_with_function_calls_and_images is a method from TasksLibrary
-        if len(images) > 0:
-            ai_response, function_calls = self.tl.generate_with_function_calls_and_images(prompt, images, self.function_definitions, callback=streaming_callback)
-        else:
-            ai_response, function_calls = self.tl.generate_with_function_calls(prompt, self.function_definitions)
-
-        return ai_response, function_calls