lollms-client 0.20.4__tar.gz → 0.20.6__tar.gz

{lollms_client-0.20.4/lollms_client.egg-info → lollms_client-0.20.6}/PKG-INFO

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

lollms_client-0.20.6/examples/run_remote_mcp_example copy.py

@@ -0,0 +1,226 @@
+# File: run_lollms_client_with_mcp_example.py
+
+import sys
+import os
+import shutil
+from pathlib import Path
+import json
+from lollms_client import LollmsClient
+import subprocess
+# --- Dynamically adjust Python path to find lollms_client ---
+# This assumes the example script is in a directory, and 'lollms_client' is
+# in a sibling directory or a known relative path. Adjust as needed.
+# For example, if script is in 'lollms_client/examples/' and lollms_client code is in 'lollms_client/'
+# then the parent of the script's parent is the project root.
+
+# Get the directory of the current script
+current_script_dir = Path(__file__).resolve().parent
+
+# Option 1: If lollms_client is in the parent directory of this script's directory
+# (e.g. script is in 'project_root/examples' and lollms_client is in 'project_root/lollms_client')
+# project_root = current_script_dir.parent
+# lollms_client_path = project_root / "lollms_client" # Assuming this is where lollms_client.py and bindings are
+
+# Option 2: If lollms_client package is directly one level up
+# (e.g. script is in 'lollms_client/examples' and lollms_client package is 'lollms_client')
+project_root_for_lollms_client = current_script_dir.parent
+if str(project_root_for_lollms_client) not in sys.path:
+    sys.path.insert(0, str(project_root_for_lollms_client))
+    print(f"Added to sys.path: {project_root_for_lollms_client}")
+
+
+# --- Ensure pipmaster is available (core LoLLMs dependency) ---
+try:
+    import pipmaster as pm
+except ImportError:
+    print("ERROR: pipmaster is not installed or not in PYTHONPATH.")
+    sys.exit(1)
+
+# --- Import LollmsClient and supporting components ---
+try:
+
+    from lollms_client.lollms_llm_binding import LollmsLLMBinding # Base for LLM
+    from ascii_colors import ASCIIColors, trace_exception
+    from lollms_client.lollms_types import MSG_TYPE # Assuming MSG_TYPE is here
+except ImportError as e:
+    print(f"ERROR: Could not import LollmsClient components: {e}")
+    print("Ensure 'lollms_client' package structure is correct and accessible via PYTHONPATH.")
+    print(f"Current sys.path: {sys.path}")
+    trace_exception(e)
+    sys.exit(1)
+
+
+# --- Dummy Server Scripts using FastMCP (as per previous successful iteration) ---
+TIME_SERVER_PY = """
+import asyncio
+from datetime import datetime
+from mcp.server.fastmcp import FastMCP
+
+mcp_server = FastMCP("TimeMCP", description="A server that provides the current time.", host="localhost",
+            port=9624,
+            log_level="DEBUG")
+
+@mcp_server.tool(description="Returns the current server time and echoes received parameters.")
+def get_current_time(user_id: str = "unknown_user") -> dict:
+    return {"time": datetime.now().isoformat(), "params_received": {"user_id": user_id}, "server_name": "TimeServer"}
+
+if __name__ == "__main__":
+    mcp_server.run(transport="streamable-http")
+"""
+
+CALCULATOR_SERVER_PY = """
+import asyncio
+from typing import List, Union
+from mcp.server.fastmcp import FastMCP
+
+mcp_server = FastMCP("CalculatorMCP", description="A server that performs addition.", host="localhost",
+            port=9625,
+            log_level="DEBUG")
+
+@mcp_server.tool(description="Adds a list of numbers provided in the 'numbers' parameter.")
+def add_numbers(numbers: List[Union[int, float]]) -> dict:
+    if not isinstance(numbers, list) or not all(isinstance(x, (int, float)) for x in numbers):
+        return {"error": "'numbers' must be a list of numbers."}
+    return {"sum": sum(numbers), "server_name": "CalculatorServer"}
+
+if __name__ == "__main__":
+    mcp_server.run(transport="streamable-http")
+"""
+
+
+def main():
+    ASCIIColors.red("--- Example: Using LollmsClient with StandardMCPBinding ---")
+
+    # --- 1. Setup Temporary Directory for Dummy MCP Servers ---
+    example_base_dir = Path(__file__).parent / "temp_mcp_example_servers"
+    if example_base_dir.exists():
+        shutil.rmtree(example_base_dir)
+    example_base_dir.mkdir(exist_ok=True)
+
+    time_server_script_path = example_base_dir / "time_server.py"
+    with open(time_server_script_path, "w") as f: f.write(TIME_SERVER_PY)
+
+    calculator_server_script_path = example_base_dir / "calculator_server.py"
+    with open(calculator_server_script_path, "w") as f: f.write(CALCULATOR_SERVER_PY)
+    
+    subprocess.Popen(
+        [sys.executable, str(time_server_script_path.resolve())],
+        stdin=subprocess.DEVNULL,
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+        start_new_session=True
+    )    
+
+    subprocess.Popen(
+        [sys.executable, str(calculator_server_script_path.resolve())],
+        stdin=subprocess.DEVNULL,
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+        start_new_session=True
+    )        
+    # MCP Binding Configuration (for RemoteMCPBinding with multiple servers)
+    mcp_config = {
+        "servers_infos":{
+            "time_machine":{
+                "server_url": "http://localhost:9624/mcp",
+            },
+
+            "calc_unit":{
+                "server_url": "http://localhost:9625/mcp",
+            },
+        }
+    }
+    ASCIIColors.magenta("\n1. Initializing LollmsClient...")
+    try:
+        client = LollmsClient(
+            binding_name="ollama", # Use the dummy LLM binding
+            model_name="mistral-nemo:latest",
+            mcp_binding_name="remote_mcp",
+            mcp_binding_config=mcp_config,
+            
+        )
+    except Exception as e:
+        ASCIIColors.error(f"Failed to initialize LollmsClient: {e}")
+        trace_exception(e)
+        shutil.rmtree(example_base_dir)
+        sys.exit(1)
+
+    if not client.binding:
+        ASCIIColors.error("LollmsClient's LLM binding (dummy_llm) failed to load.")
+        shutil.rmtree(example_base_dir)
+        sys.exit(1)
+    if not client.mcp:
+        ASCIIColors.error("LollmsClient's MCP binding (standard_mcp) failed to load.")
+        client.close() # Close LLM binding if it loaded
+        shutil.rmtree(example_base_dir)
+        sys.exit(1)
+
+    ASCIIColors.green("LollmsClient initialized successfully with DummyLLM and StandardMCP bindings.")
+
+    # --- 3. Define a streaming callback for generate_with_mcp ---
+    def mcp_streaming_callback(chunk: str, msg_type: MSG_TYPE, metadata: dict = None, history: list = None) -> bool:
+        if metadata:
+            type_info = metadata.get('type', 'unknown_type')
+            if msg_type == MSG_TYPE.MSG_TYPE_STEP_START:
+                ASCIIColors.cyan(f"MCP Step Start ({type_info}): {chunk}")
+            elif msg_type == MSG_TYPE.MSG_TYPE_STEP_END:
+                ASCIIColors.cyan(f"MCP Step End ({type_info}): {chunk}")
+            elif msg_type == MSG_TYPE.MSG_TYPE_INFO:
+                ASCIIColors.yellow(f"MCP Info ({type_info}): {chunk}")
+            elif msg_type == MSG_TYPE.MSG_TYPE_CHUNK: # Part of final answer typically
+                ASCIIColors.green(chunk, end="") # type: ignore
+            else: # FULL, default, etc.
+                ASCIIColors.green(f"MCP Output ({str(msg_type)}, {type_info}): {chunk}")
+        else:
+             if msg_type == MSG_TYPE.MSG_TYPE_CHUNK:
+                ASCIIColors.green(chunk, end="") # type: ignore
+             else:
+                ASCIIColors.green(f"MCP Output ({str(msg_type)}): {chunk}")
+        sys.stdout.flush()
+        return True # Continue streaming
+
+    # --- 4. Use generate_with_mcp ---
+    ASCIIColors.magenta("\n2. Calling generate_with_mcp to get current time...")
+    time_prompt = "Hey assistant, what time is it right now?"
+    time_response = client.generate_with_mcp(
+        prompt=time_prompt,
+        streaming_callback=mcp_streaming_callback,
+        interactive_tool_execution=False # Set to True to test interactive mode
+    )
+    print() # Newline after streaming
+    ASCIIColors.blue(f"Final response for time prompt: {json.dumps(time_response, indent=2)}")
+
+    assert time_response.get("error") is None, f"Time prompt resulted in an error: {time_response.get('error')}"
+    assert time_response.get("final_answer"), "Time prompt did not produce a final answer."
+    assert len(time_response.get("tool_calls", [])) > 0, "Time prompt should have called a tool."
+    assert time_response["tool_calls"][0]["name"] == "time_machine::get_current_time", "Incorrect tool called for time."
+    assert "time" in time_response["tool_calls"][0].get("result", {}).get("output", {}), "Time tool result missing time."
+
+
+    ASCIIColors.magenta("\n3. Calling generate_with_mcp for calculation...")
+    calc_prompt = "Can you please calculate the sum of 50, 25, and 7.5 for me?"
+    calc_response = client.generate_with_mcp(
+        prompt=calc_prompt,
+        streaming_callback=mcp_streaming_callback
+    )
+    print() # Newline
+    ASCIIColors.blue(f"Final response for calc prompt: {json.dumps(calc_response, indent=2)}")
+
+    assert calc_response.get("error") is None, f"Calc prompt resulted in an error: {calc_response.get('error')}"
+    assert calc_response.get("final_answer"), "Calc prompt did not produce a final answer."
+    assert len(calc_response.get("tool_calls", [])) > 0, "Calc prompt should have called a tool."
+    assert calc_response["tool_calls"][0]["name"] == "calc_unit::add_numbers", "Incorrect tool called for calculation."
+    # The dummy LLM uses hardcoded params [1,2,3] for calc, so result will be 6.
+    # A real LLM would extract 50, 25, 7.5.
+    # For this dummy test, we check against the dummy's behavior.
+    assert calc_response["tool_calls"][0].get("result", {}).get("output", {}).get("sum") == 82.5, "Calculator tool result mismatch for dummy params."
+
+
+    # --- 5. Cleanup ---
+    ASCIIColors.info("Cleaning up temporary server scripts and dummy binding directory...")
+    shutil.rmtree(example_base_dir, ignore_errors=True)
+
+    ASCIIColors.red("\n--- LollmsClient with StandardMCPBinding Example Finished Successfully! ---")
+
+if __name__ == "__main__":
+    main()

{lollms_client-0.20.4 → lollms_client-0.20.6}/lollms_client/__init__.py

@@ -7,7 +7,7 @@ from lollms_client.lollms_utilities import PromptReshaper # Keep general utiliti
 from lollms_client.lollms_mcp_binding import LollmsMCPBinding, LollmsMCPBindingManager
 
 
-__version__ = "0.20.4" # Updated version
+__version__ = "0.20.6" # Updated version
 
 # Optionally, you could define __all__ if you want to be explicit about exports
 __all__ = [
@@ -19,4 +19,4 @@ __all__ = [
     "PromptReshaper",
     "LollmsMCPBinding", # Export LollmsMCPBinding ABC
     "LollmsMCPBindingManager", # Export LollmsMCPBindingManager
-]
+]

{lollms_client-0.20.4 → lollms_client-0.20.6}/lollms_client/lollms_discussion.py

@@ -54,10 +54,13 @@ class LollmsDiscussion:
         content: str,
         metadata: Dict = {},
         parent_id: Optional[str] = None,
-        images: Optional[List[Dict[str, str]]] = None
+        images: Optional[List[Dict[str, str]]] = None,
+        override_id: Optional[str] = None
     ) -> str:
         if parent_id is None:
             parent_id = self.active_branch_id
+        if parent_id is None:
+            parent_id = "main"
 
         message = LollmsMessage(
             sender=sender,
@@ -66,6 +69,8 @@ class LollmsDiscussion:
             metadata=str(metadata),
             images=images or []
         )
+        if override_id:
+            message.id = override_id
 
         self.messages.append(message)
         self.message_index[message.id] = message
@@ -491,4 +496,4 @@ if __name__ == "__main__":
     final_message = new_discussion.message_index[new_discussion.active_branch_id]
     assert len(final_message.images) == 2
     assert final_message.images[1]['type'] == 'base64'
-    print("\n✅ Verification successful: Images were loaded correctly from the file.")
+    print("\n✅ Verification successful: Images were loaded correctly from the file.")

lollms_client-0.20.6/lollms_client/mcp_bindings/remote_mcp/__init__.py

@@ -0,0 +1,342 @@
+import asyncio
+from contextlib import AsyncExitStack
+from typing import Optional, List, Dict, Any, Tuple
+from lollms_client.lollms_mcp_binding import LollmsMCPBinding
+from ascii_colors import ASCIIColors, trace_exception
+import threading
+import json
+
+try:
+    from mcp import ClientSession, types
+    from mcp.client.streamable_http import streamablehttp_client
+    MCP_LIBRARY_AVAILABLE = True
+except ImportError:
+    MCP_LIBRARY_AVAILABLE = False
+    ClientSession = None
+    streamablehttp_client = None
+
+
+BindingName = "RemoteMCPBinding"
+TOOL_NAME_SEPARATOR  = "::"
+
+class RemoteMCPBinding(LollmsMCPBinding):
+    """
+    This binding allows the connection to one or more remote MCP servers.
+    Tools from all connected servers are aggregated and prefixed with the server's alias.
+    """
+    def __init__(self,
+                 servers_infos: Dict[str, Dict[str, Any]],
+                 **other_config_params: Any):
+        """
+        Initializes the binding to connect to multiple MCP servers.
+
+        Args:
+            servers_infos (Dict[str, Dict[str, Any]]): A dictionary where each key is a unique
+                alias for a server, and the value is another dictionary containing connection
+                details for that server.
+                Example:
+                {
+                    "main_server": {"server_url": "http://localhost:8787", "auth_config": {}},
+                    "experimental_server": {"server_url": "http://test.server:9000"}
+                }
+            **other_config_params (Any): Additional configuration parameters.
+        """
+        super().__init__(binding_name="remote_mcp")
+        
+        if not MCP_LIBRARY_AVAILABLE:
+            ASCIIColors.error(f"{self.binding_name}: MCP library not available. This binding will be disabled.")
+            return
+
+        if not servers_infos or not isinstance(servers_infos, dict):
+            ASCIIColors.error(f"{self.binding_name}: `servers_infos` dictionary is required and cannot be empty.")
+            return
+
+        ### NEW: Store the overall configuration
+        self.config = {
+            "servers_infos": servers_infos,
+            **other_config_params
+        }
+
+        ### NEW: State management for multiple servers.
+        # The key is the server alias. The value is a dictionary holding the state for that server.
+        self.servers: Dict[str, Dict[str, Any]] = {}
+        for alias, info in servers_infos.items():
+            if "server_url" not in info:
+                ASCIIColors.warning(f"{self.binding_name}: Skipping server '{alias}' due to missing 'server_url'.")
+                continue
+            
+            self.servers[alias] = {
+                "url": info["server_url"],
+                "auth_config": info.get("auth_config", {}),
+                "session": None,        # Will hold the ClientSession
+                "exit_stack": None,     # Will hold the AsyncExitStack
+                "initialized": False,
+                "initializing_lock": threading.Lock() # Prevents race conditions on initialization
+            }
+
+        self._discovered_tools_cache: List[Dict[str, Any]] = []
+
+        ### MODIFIED: These are now shared across all connections
+        self._loop: Optional[asyncio.AbstractEventLoop] = None
+        self._thread: Optional[threading.Thread] = None
+        self._loop_started_event = threading.Event()
+
+        if self.servers:
+            self._start_event_loop_thread()
+        else:
+            ASCIIColors.warning(f"{self.binding_name}: No valid servers configured.")
+
+    # _start_event_loop_thread, _run_loop_forever, _wait_for_loop, _run_async
+    # are utility methods for the shared event loop and do not need to be changed.
+    # They manage the async infrastructure for the entire binding instance.
+    def _start_event_loop_thread(self):
+        if self._loop and self._loop.is_running(): return
+        self._loop = asyncio.new_event_loop()
+        self._thread = threading.Thread(target=self._run_loop_forever, daemon=True)
+        self._thread.start()
+
+    def _run_loop_forever(self):
+        if not self._loop: return
+        asyncio.set_event_loop(self._loop)
+        try:
+            self._loop_started_event.set()
+            self._loop.run_forever()
+        finally:
+            if not self._loop.is_closed(): self._loop.close()
+
+    def _wait_for_loop(self, timeout=5.0):
+        if not self._loop_started_event.wait(timeout=timeout):
+            raise RuntimeError(f"{self.binding_name}: Event loop thread failed to start in time.")
+        if not self._loop or not self._loop.is_running():
+            raise RuntimeError(f"{self.binding_name}: Event loop is not running after start signal.")
+
+    def _run_async(self, coro, timeout=None):
+        if not self._loop or not self._loop.is_running(): 
+            raise RuntimeError("Event loop not running. This should have been caught earlier.")
+        future = asyncio.run_coroutine_threadsafe(coro, self._loop)
+        return future.result(timeout)
+
+    ### MODIFIED: Now operates on a specific server identified by alias
+    async def _initialize_connection_async(self, alias: str) -> bool:
+        server_info = self.servers[alias]
+        if server_info["initialized"]:
+            return True
+            
+        server_url = server_info["url"]
+        ASCIIColors.info(f"{self.binding_name}: Initializing connection to '{alias}' ({server_url})...")
+        try:
+            exit_stack = AsyncExitStack()
+            
+            client_streams = await exit_stack.enter_async_context(
+                streamablehttp_client(server_url)
+            )
+            read_stream, write_stream, _ = client_streams
+
+            session = await exit_stack.enter_async_context(
+                ClientSession(read_stream, write_stream)
+            )
+            await session.initialize()
+
+            # Update the state for this specific server
+            server_info["session"] = session
+            server_info["exit_stack"] = exit_stack
+            server_info["initialized"] = True
+
+            ASCIIColors.green(f"{self.binding_name}: Connected to '{alias}' ({server_url})")
+            return True
+        except Exception as e:
+            trace_exception(e)
+            ASCIIColors.error(f"{self.binding_name}: Failed to connect to '{alias}' ({server_url}): {e}")
+            if 'exit_stack' in locals() and exit_stack:
+                await exit_stack.aclose()
+            
+            # Reset state for this server on failure
+            server_info["session"] = None
+            server_info["exit_stack"] = None
+            server_info["initialized"] = False
+            return False
+
+    ### MODIFIED: Ensures a specific server is initialized
+    def _ensure_initialized_sync(self, alias: str, timeout=30.0):
+        self._wait_for_loop() 
+        
+        server_info = self.servers.get(alias)
+        if not server_info:
+            raise ValueError(f"Unknown server alias: '{alias}'")
+
+        # Use a lock to prevent multiple threads trying to initialize the same server
+        with server_info["initializing_lock"]:
+            if not server_info["initialized"]:
+                success = self._run_async(self._initialize_connection_async(alias), timeout=timeout)
+                if not success:
+                    raise ConnectionError(f"Failed to initialize remote MCP connection to '{alias}' ({server_info['url']})")
+        
+        if not server_info.get("session"):
+             raise ConnectionError(f"MCP Session not valid after init attempt for '{alias}' ({server_info['url']})")
+
+    ### MODIFIED: Refreshes tools from ALL connected servers and aggregates them
+    async def _refresh_all_tools_cache_async(self):
+        ASCIIColors.info(f"{self.binding_name}: Refreshing tools from all servers...")
+        all_tools = []
+        # Create a list of tasks to run concurrently
+        refresh_tasks = [
+            self._fetch_tools_from_server_async(alias) for alias in self.servers.keys()
+        ]
+        
+        # Gather results from all tasks
+        results = await asyncio.gather(*refresh_tasks, return_exceptions=True)
+        
+        for result in results:
+            if isinstance(result, Exception):
+                # Error already logged inside the fetch function
+                continue
+            if result:
+                all_tools.extend(result)
+        
+        self._discovered_tools_cache = all_tools
+        ASCIIColors.green(f"{self.binding_name}: Tool refresh complete. Found {len(all_tools)} tools across all servers.")
+
+    ### NEW: Helper async function to fetch tools from a single server
+    async def _fetch_tools_from_server_async(self, alias: str) -> List[Dict[str, Any]]:
+        server_info = self.servers[alias]
+        if not server_info["initialized"] or not server_info["session"]:
+            ASCIIColors.debug(f"{self.binding_name}: Skipping tool refresh for non-initialized server '{alias}'.")
+            return []
+        
+        try:
+            list_tools_result = await server_info["session"].list_tools()
+            server_tools = []
+            for tool_obj in list_tools_result.tools:
+                input_schema_dict = {}
+                tool_input_schema = getattr(tool_obj, 'inputSchema', getattr(tool_obj, 'input_schema', None))
+                if tool_input_schema:
+                    if hasattr(tool_input_schema, 'model_dump'):
+                        input_schema_dict = tool_input_schema.model_dump(mode='json', exclude_none=True)
+                    elif isinstance(tool_input_schema, dict):
+                        input_schema_dict = tool_input_schema
+                
+                tool_name_for_client = f"{alias}{TOOL_NAME_SEPARATOR}{tool_obj.name}"
+
+                server_tools.append({
+                    "name": tool_name_for_client,
+                    "description": tool_obj.description or "",
+                    "input_schema": input_schema_dict
+                })
+            ASCIIColors.info(f"{self.binding_name}: Found {len(server_tools)} tools on server '{alias}'.")
+            return server_tools
+        except Exception as e:
+            trace_exception(e)
+            ASCIIColors.error(f"{self.binding_name}: Error refreshing tools from '{alias}': {e}")
+            return []
+
+
+    ### MODIFIED: Discovers tools from all configured servers
+    def discover_tools(self, force_refresh: bool = False, timeout_per_server: float = 30.0, **kwargs) -> List[Dict[str, Any]]:
+        if not self.servers:
+            return []
+
+        # Initialize all servers that are not yet initialized.
+        for alias in self.servers.keys():
+            try:
+                # _ensure_initialized_sync is internally locked and idempotent
+                self._ensure_initialized_sync(alias, timeout=timeout_per_server)
+            except Exception as e:
+                # One server failing to connect shouldn't stop discovery on others.
+                ASCIIColors.warning(f"{self.binding_name}: Could not ensure connection to '{alias}' for discovery: {e}")
+        
+        try:
+            if force_refresh or not self._discovered_tools_cache:
+                # The timeout for refreshing all tools should be longer
+                self._run_async(self._refresh_all_tools_cache_async(), timeout=timeout_per_server * len(self.servers))
+            return self._discovered_tools_cache
+        except Exception as e:
+            trace_exception(e)
+            ASCIIColors.error(f"{self.binding_name}: Problem during tool discovery: {e}")
+            return []
+            
+    ### MODIFIED: Now operates on a specific server identified by alias
+    async def _execute_tool_async(self, alias: str, actual_tool_name: str, params: Dict[str, Any]) -> Dict[str, Any]:
+        server_info = self.servers[alias]
+        server_url = server_info["url"]
+        
+        if not server_info["initialized"] or not server_info["session"]:
+            return {"error": f"Not connected to server '{alias}' ({server_url})", "status_code": 503}
+        
+        ASCIIColors.info(f"{self.binding_name}: Executing remote tool '{actual_tool_name}' on '{alias}' ({server_url}) with params: {json.dumps(params)}")
+        try:
+            mcp_call_result = await server_info["session"].call_tool(name=actual_tool_name, arguments=params)
+            output_parts = [p.text for p in mcp_call_result.content if isinstance(p, types.TextContent) and p.text is not None] if mcp_call_result.content else []
+            if not output_parts: return {"output": {"message": "Tool executed but returned no textual content."}, "status_code": 200}
+            
+            combined_output_str = "\n".join(output_parts)
+            try:
+                return {"output": json.loads(combined_output_str), "status_code": 200}
+            except json.JSONDecodeError:
+                return {"output": combined_output_str, "status_code": 200}
+        except Exception as e:
+            trace_exception(e)
+            return {"error": f"Error executing remote tool '{actual_tool_name}' on '{alias}': {str(e)}", "status_code": 500}
+
+    ### MODIFIED: Parses alias from tool name and routes the call
+    def execute_tool(self, tool_name_with_alias: str, params: Dict[str, Any], **kwargs) -> Dict[str, Any]:
+        timeout = float(kwargs.get('timeout', 60.0))
+        
+        if TOOL_NAME_SEPARATOR not in tool_name_with_alias:
+            return {"error": f"Invalid tool name format. Expected 'alias{TOOL_NAME_SEPARATOR}tool_name', but got '{tool_name_with_alias}'.", "status_code": 400}
+
+        alias, actual_tool_name = tool_name_with_alias.split(TOOL_NAME_SEPARATOR, 1)
+
+        if alias not in self.servers:
+            return {"error": f"Tool name '{tool_name_with_alias}' has an unknown server alias '{alias}'.", "status_code": 400}
+
+        try:
+            # Ensure this specific server is connected before executing
+            self._ensure_initialized_sync(alias, timeout=min(timeout, 30.0))
+            return self._run_async(self._execute_tool_async(alias, actual_tool_name, params), timeout=timeout)
+        except (ConnectionError, RuntimeError) as e:
+            return {"error": f"{self.binding_name}: Connection issue for server '{alias}': {e}", "status_code": 503}
+        except TimeoutError:
+            return {"error": f"{self.binding_name}: Remote tool '{actual_tool_name}' on '{alias}' timed out.", "status_code": 504}
+        except Exception as e:
+            trace_exception(e)
+            return {"error": f"{self.binding_name}: Failed to run remote MCP tool '{actual_tool_name}' on '{alias}': {e}", "status_code": 500}
+
+    ### MODIFIED: Closes all connections
+    def close(self):
+        ASCIIColors.info(f"{self.binding_name}: Closing all remote connections...")
+        
+        async def _close_all_connections():
+            close_tasks = []
+            for alias, server_info in self.servers.items():
+                if server_info.get("exit_stack"):
+                    ASCIIColors.info(f"{self.binding_name}: Closing connection to '{alias}'...")
+                    close_tasks.append(server_info["exit_stack"].aclose())
+            
+            if close_tasks:
+                await asyncio.gather(*close_tasks, return_exceptions=True)
+
+        # Check if loop is running before trying to schedule work on it
+        if self._loop and self._loop.is_running():
+            try:
+                self._run_async(_close_all_connections(), timeout=10.0)
+            except Exception as e:
+                ASCIIColors.error(f"{self.binding_name}: Error during async close: {e}")
+        
+        # Reset all server states
+        for alias in self.servers:
+            self.servers[alias].update({
+                "exit_stack": None,
+                "session": None,
+                "initialized": False
+            })
+        
+        if self._loop and self._loop.is_running():
+            self._loop.call_soon_threadsafe(self._loop.stop)
+        
+        if self._thread and self._thread.is_alive():
+            self._thread.join(timeout=5.0)
+
+        ASCIIColors.info(f"{self.binding_name}: Remote connection binding closed.")
+
+    def get_binding_config(self) -> Dict[str, Any]:
+        return self.config

{lollms_client-0.20.4 → lollms_client-0.20.6/lollms_client.egg-info}/PKG-INFO

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

{lollms_client-0.20.4 → lollms_client-0.20.6}/lollms_client.egg-info/SOURCES.txt

@@ -9,6 +9,7 @@ examples/gradio_chat_app.py
 examples/internet_search_with_rag.py
 examples/local_mcp.py
 examples/openai_mcp.py
+examples/run_remote_mcp_example copy.py
 examples/run_standard_mcp_example.py
 examples/simple_text_gen_test.py
 examples/simple_text_gen_with_image_test.py

lollms_client-0.20.4/lollms_client/mcp_bindings/remote_mcp/__init__.py

@@ -1,241 +0,0 @@
-# Conceptual: lollms_client/mcp_bindings/remote_mcp/__init__.py
-
-import asyncio
-from contextlib import AsyncExitStack
-from typing import Optional, List, Dict, Any, Tuple
-from lollms_client.lollms_mcp_binding import LollmsMCPBinding
-from ascii_colors import ASCIIColors, trace_exception
-import threading
-try:
-    from mcp import ClientSession, types
-    # Import the specific network client from MCP SDK
-    from mcp.client.streamable_http import streamablehttp_client
-    # If supporting OAuth, you'd import auth components:
-    # from mcp.client.auth import OAuthClientProvider, TokenStorage
-    # from mcp.shared.auth import OAuthClientMetadata, OAuthToken
-    MCP_LIBRARY_AVAILABLE = True
-except ImportError:
-    # ... (error handling as in StandardMCPBinding) ...
-    MCP_LIBRARY_AVAILABLE = False
-    ClientSession = None # etc.
-    streamablehttp_client = None
-
-
-BindingName = "RemoteMCPBinding"
-# No TOOL_NAME_SEPARATOR needed if connecting to one remote server per instance,
-# or if server aliases are handled differently (e.g. part of URL or config)
-TOOL_NAME_SEPARATOR  = "::"
-
-class RemoteMCPBinding(LollmsMCPBinding):
-    def __init__(self,
-                 server_url: str, # e.g., "http://localhost:8000/mcp"
-                 alias: str = "remote_server", # An alias for this connection
-                 auth_config: Optional[Dict[str, Any]] = None, # For API keys, OAuth, etc.
-                 **other_config_params: Any):
-        super().__init__(binding_name="remote_mcp")
-        
-        if not MCP_LIBRARY_AVAILABLE:
-            ASCIIColors.error(f"{self.binding_name}: MCP library not available.")
-            return
-
-        if not server_url:
-            ASCIIColors.error(f"{self.binding_name}: server_url is required.")
-            # Or raise ValueError
-            return
-
-        self.server_url = server_url
-        self.alias = alias # Could be used to prefix tool names if managing multiple remotes
-        self.auth_config = auth_config or {}
-        self.config = {
-            "server_url": server_url,
-            "alias": alias,
-            "auth_config": self.auth_config
-        }
-        self.config.update(other_config_params)
-
-        self._mcp_session: Optional[ClientSession] = None
-        self._exit_stack: Optional[AsyncExitStack] = None
-        self._discovered_tools_cache: List[Dict[str, Any]] = []
-        self._is_initialized = False
-        self._loop: Optional[asyncio.AbstractEventLoop] = None
-        self._thread: Optional[threading.Thread] = None
-
-        self._start_event_loop_thread() # Similar to StandardMCPBinding
-
-    def _start_event_loop_thread(self): # Simplified from StandardMCPBinding
-        if self._loop and self._loop.is_running(): return
-        self._loop = asyncio.new_event_loop()
-        self._thread = threading.Thread(target=self._run_loop_forever, daemon=True)
-        self._thread.start()
-
-    def _run_loop_forever(self):
-        if not self._loop: return
-        asyncio.set_event_loop(self._loop)
-        try: self._loop.run_forever()
-        finally:
-            # ... (loop cleanup as in StandardMCPBinding) ...
-            if not self._loop.is_closed(): self._loop.close()
-
-    def _run_async(self, coro, timeout=None): # Simplified
-        if not self._loop or not self._loop.is_running(): raise RuntimeError("Event loop not running.")
-        future = asyncio.run_coroutine_threadsafe(coro, self._loop)
-        return future.result(timeout)
-
-    async def _initialize_connection_async(self) -> bool:
-        if self._is_initialized: return True
-        ASCIIColors.info(f"{self.binding_name}: Initializing connection to {self.server_url}...")
-        try:
-            self._exit_stack = AsyncExitStack()
-            
-            # --- Authentication Setup (Conceptual) ---
-            # oauth_provider = None
-            # if self.auth_config.get("type") == "oauth":
-            #     # oauth_provider = OAuthClientProvider(...) # Setup based on auth_config
-            #     pass
-            # http_headers = {}
-            # if self.auth_config.get("type") == "api_key":
-            #     key = self.auth_config.get("key")
-            #     header_name = self.auth_config.get("header_name", "X-API-Key")
-            #     if key: http_headers[header_name] = key
-            
-            # Use streamablehttp_client from MCP SDK
-            # The `auth` parameter of streamablehttp_client takes an OAuthClientProvider
-            # For simple API key headers, you might need to use `httpx` directly
-            # or see if streamablehttp_client allows passing custom headers.
-            # The MCP client example for streamable HTTP doesn't show custom headers directly,
-            # it focuses on OAuth.
-            # If `streamablehttp_client` takes `**kwargs` that are passed to `httpx.AsyncClient`,
-            # then `headers=http_headers` might work.
-            
-            # Assuming streamablehttp_client can take headers if needed, or auth provider
-            # For now, let's assume no auth for simplicity or that it's handled by underlying httpx if passed via kwargs
-            client_streams = await self._exit_stack.enter_async_context(
-                streamablehttp_client(self.server_url) # Add auth=oauth_provider or headers=http_headers if supported
-            )
-            read_stream, write_stream, _http_client_instance = client_streams # http_client_instance might be useful
-
-            self._mcp_session = await self._exit_stack.enter_async_context(
-                ClientSession(read_stream, write_stream)
-            )
-            await self._mcp_session.initialize()
-            self._is_initialized = True
-            ASCIIColors.green(f"{self.binding_name}: Connected to {self.server_url}")
-            await self._refresh_tools_cache_async()
-            return True
-        except Exception as e:
-            trace_exception(e)
-            ASCIIColors.error(f"{self.binding_name}: Failed to connect to {self.server_url}: {e}")
-            if self._exit_stack: await self._exit_stack.aclose() # Cleanup on failure
-            self._exit_stack = None
-            self._mcp_session = None
-            self._is_initialized = False
-            return False
-
-    def _ensure_initialized_sync(self, timeout=30.0):
-        if not self._is_initialized:
-            success = self._run_async(self._initialize_connection_async(), timeout=timeout)
-            if not success: raise ConnectionError(f"Failed to initialize remote MCP connection to {self.server_url}")
-        if not self._mcp_session: # Double check
-             raise ConnectionError(f"MCP Session not valid after init attempt for {self.server_url}")
-
-
-    async def _refresh_tools_cache_async(self):
-        if not self._is_initialized or not self._mcp_session: return
-        ASCIIColors.info(f"{self.binding_name}: Refreshing tools from {self.server_url}...")
-        try:
-            list_tools_result = await self._mcp_session.list_tools()
-            current_tools = []
-            # ... (tool parsing logic similar to StandardMCPBinding, but no server alias prefix needed if one server per binding instance)
-            for tool_obj in list_tools_result.tools:
-                # ...
-                input_schema_dict = {}
-                tool_input_schema = getattr(tool_obj, 'inputSchema', getattr(tool_obj, 'input_schema', None))
-                if tool_input_schema:
-                    if hasattr(tool_input_schema, 'model_dump'):
-                        input_schema_dict = tool_input_schema.model_dump(mode='json', exclude_none=True)
-                    elif isinstance(tool_input_schema, dict):
-                        input_schema_dict = tool_input_schema
-                
-                tool_name_for_client = f"{self.alias}{TOOL_NAME_SEPARATOR}{tool_obj.name}" if TOOL_NAME_SEPARATOR else tool_obj.name
-
-                current_tools.append({
-                    "name": tool_name_for_client, # Use self.alias to prefix
-                    "description": tool_obj.description or "",
-                    "input_schema": input_schema_dict
-                })
-            self._discovered_tools_cache = current_tools
-            ASCIIColors.green(f"{self.binding_name}: Tools refreshed for {self.server_url}. Found {len(current_tools)} tools.")
-        except Exception as e:
-            trace_exception(e)
-            ASCIIColors.error(f"{self.binding_name}: Error refreshing tools from {self.server_url}: {e}")
-
-    def discover_tools(self, force_refresh: bool = False, timeout_per_server: float = 10.0, **kwargs) -> List[Dict[str, Any]]:
-        # This binding instance connects to ONE server, so timeout_per_server is just 'timeout'
-        try:
-            self._ensure_initialized_sync(timeout=timeout_per_server)
-            if force_refresh or not self._discovered_tools_cache:
-                self._run_async(self._refresh_tools_cache_async(), timeout=timeout_per_server)
-            return self._discovered_tools_cache
-        except Exception as e:
-            ASCIIColors.error(f"{self.binding_name}: Problem during tool discovery for {self.server_url}: {e}")
-            return []
-            
-    async def _execute_tool_async(self, actual_tool_name: str, params: Dict[str, Any]) -> Dict[str, Any]:
-        if not self._is_initialized or not self._mcp_session:
-            return {"error": f"Not connected to {self.server_url}", "status_code": 503}
-        
-        ASCIIColors.info(f"{self.binding_name}: Executing remote tool '{actual_tool_name}' on {self.server_url} with params: {json.dumps(params)}")
-        try:
-            mcp_call_result = await self._mcp_session.call_tool(name=actual_tool_name, arguments=params)
-            # ... (result parsing as in StandardMCPBinding) ...
-            output_parts = [p.text for p in mcp_call_result.content if isinstance(p, types.TextContent) and p.text is not None] if mcp_call_result.content else []
-            if not output_parts: return {"output": {"message": "Tool executed but returned no textual content."}, "status_code": 200}
-            combined_output_str = "\n".join(output_parts)
-            try: return {"output": json.loads(combined_output_str), "status_code": 200}
-            except json.JSONDecodeError: return {"output": combined_output_str, "status_code": 200}
-        except Exception as e:
-            trace_exception(e)
-            return {"error": f"Error executing remote tool '{actual_tool_name}': {str(e)}", "status_code": 500}
-
-
-    def execute_tool(self, tool_name_with_alias: str, params: Dict[str, Any], **kwargs) -> Dict[str, Any]:
-        timeout = float(kwargs.get('timeout', 60.0))
-        
-        # If using alias prefixing (self.alias + TOOL_NAME_SEPARATOR + actual_name)
-        expected_prefix = f"{self.alias}{TOOL_NAME_SEPARATOR}"
-        if TOOL_NAME_SEPARATOR and tool_name_with_alias.startswith(expected_prefix):
-            actual_tool_name = tool_name_with_alias[len(expected_prefix):]
-        elif not TOOL_NAME_SEPARATOR and tool_name_with_alias: # No prefixing, tool_name is actual_tool_name
-             actual_tool_name = tool_name_with_alias
-        else:
-            return {"error": f"Tool name '{tool_name_with_alias}' does not match expected alias '{self.alias}'.", "status_code": 400}
-
-        try:
-            self._ensure_initialized_sync(timeout=min(timeout, 30.0))
-            return self._run_async(self._execute_tool_async(actual_tool_name, params), timeout=timeout)
-        # ... (error handling as in StandardMCPBinding) ...
-        except ConnectionError as e: return {"error": f"{self.binding_name}: Connection issue for '{self.server_url}': {e}", "status_code": 503}
-        except TimeoutError: return {"error": f"{self.binding_name}: Remote tool '{actual_tool_name}' on '{self.server_url}' timed out.", "status_code": 504}
-        except Exception as e:
-            trace_exception(e)
-            return {"error": f"{self.binding_name}: Failed to run remote MCP tool '{actual_tool_name}': {e}", "status_code": 500}
-
-    def close(self):
-        ASCIIColors.info(f"{self.binding_name}: Closing connection to {self.server_url}...")
-        if self._exit_stack:
-            try:
-                # The anyio task error might also occur here if not careful
-                self._run_async(self._exit_stack.aclose(), timeout=10.0)
-            except Exception as e:
-                ASCIIColors.error(f"{self.binding_name}: Error during async close for {self.server_url}: {e}")
-        self._exit_stack = None
-        self._mcp_session = None
-        self._is_initialized = False
-        
-        # Stop event loop thread
-        if self._loop and self._loop.is_running(): self._loop.call_soon_threadsafe(self._loop.stop)
-        if self._thread and self._thread.is_alive(): self._thread.join(timeout=5.0)
-        ASCIIColors.info(f"{self.binding_name}: Remote connection binding closed.")
-
-    def get_binding_config(self) -> Dict[str, Any]: # LollmsMCPBinding might expect this
-        return self.config