lollms-client 0.20.0__tar.gz → 0.20.2__tar.gz

{lollms_client-0.20.0/lollms_client.egg-info → lollms_client-0.20.2}/PKG-INFO

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

lollms_client-0.20.2/examples/openai_mcp.py

@@ -0,0 +1,203 @@
+# File: run_openai_mcp_example.py
+# (Keep imports, path adjustments, helper functions, and initial setup as before)
+
+import sys
+import os
+import shutil
+from pathlib import Path
+import json
+import base64
+from dotenv import load_dotenv
+
+load_dotenv() # For this script's own potential .env
+
+try:
+    from lollms_client import LollmsClient
+    from ascii_colors import ASCIIColors, trace_exception
+    from lollms_client.lollms_types import MSG_TYPE
+except ImportError as e:
+    print(f"ERROR: Could not import LollmsClient components: {e}")
+    trace_exception(e)
+    sys.exit(1)
+
+PATH_TO_OPENAI_MCP_SERVER_PROJECT = Path(__file__).resolve().parent # Standard if script is in PArisNeoMCPServers root
+if not PATH_TO_OPENAI_MCP_SERVER_PROJECT.is_dir():
+    print(f"ERROR: openai-mcp-server project not found at {PATH_TO_OPENAI_MCP_SERVER_PROJECT}")
+    sys.exit(1)
+
+OUTPUT_DIRECTORY = Path(__file__).resolve().parent / "mcp_example_outputs"
+OUTPUT_DIRECTORY.mkdir(parents=True, exist_ok=True)
+
+def save_base64_audio(base64_str: str, filename_stem: str, audio_format: str) -> Path:
+    audio_bytes = base64.b64decode(base64_str)
+    file_path = OUTPUT_DIRECTORY / f"{filename_stem}.{audio_format}"
+    with open(file_path, "wb") as f: f.write(audio_bytes)
+    ASCIIColors.green(f"Audio saved to: {file_path}")
+    return file_path
+
+def save_base64_image(base64_str: str, filename_stem: str) -> Path:
+    image_bytes = base64.b64decode(base64_str)
+    file_path = OUTPUT_DIRECTORY / f"{filename_stem}.png"
+    with open(file_path, "wb") as f: f.write(image_bytes)
+    ASCIIColors.green(f"Image saved to: {file_path}")
+    return file_path
+
+def main():
+    ASCIIColors.red(f"--- Example: Using LollmsClient with OpenAI MCP Server (TTS & DALL-E) ---")
+    ASCIIColors.red(f"--- Make sure OPENAI_API_KEY is set in: {PATH_TO_OPENAI_MCP_SERVER_PROJECT / '.env'} ---")
+    ASCIIColors.red(f"--- And that 'uv pip install -e .' has been run in: {PATH_TO_OPENAI_MCP_SERVER_PROJECT} ---")
+
+    # Determine the Python executable within the server's .venv IF IT EXISTS
+    # This is the most robust way to ensure the server runs with its own isolated dependencies.
+    path_to_openai_server_venv_python = PATH_TO_OPENAI_MCP_SERVER_PROJECT / ".venv" / ("Scripts" if os.name == "nt" else "bin") / "python"
+    
+    python_exe_to_use = None
+    if path_to_openai_server_venv_python.exists():
+        python_exe_to_use = str(path_to_openai_server_venv_python.resolve())
+        ASCIIColors.cyan(f"Attempting to use Python from server's .venv: {python_exe_to_use}")
+    else:
+        python_exe_to_use = sys.executable # Fallback to current script's Python
+        ASCIIColors.yellow(f"Server's .venv Python not found at {path_to_openai_server_venv_python}. Using current environment's Python: {python_exe_to_use}")
+        ASCIIColors.yellow("Ensure openai-mcp-server dependencies are met in the current environment if its .venv is not used.")
+
+    mcp_config = {
+        "initial_servers": {
+            "my_openai_server": {
+                "command": [
+                    "uv",       # Use uv to manage the environment for the python execution
+                    "run",
+                    "--quiet",  # Optional: reduce uv's own output unless there's an error
+                    "--",       # Separator: arguments after this are for the command being run by `uv run`
+                    python_exe_to_use, # Explicitly specify the Python interpreter
+                    str((PATH_TO_OPENAI_MCP_SERVER_PROJECT / "openai_mcp_server" / "server.py").resolve()) # Full path to your server script
+                ],
+                "args": [], # No *additional* arguments for server.py itself here
+                "cwd": str(PATH_TO_OPENAI_MCP_SERVER_PROJECT.resolve()), # CRUCIAL
+            }
+        }
+    }
+
+
+    ASCIIColors.magenta("\n1. Initializing LollmsClient...")
+    try:
+        client = LollmsClient(
+            binding_name="ollama",
+            model_name="mistral-nemo:latest",
+            mcp_binding_name="standard_mcp",
+            mcp_binding_config=mcp_config,
+        )
+    except Exception as e:
+        ASCIIColors.error(f"Failed to initialize LollmsClient: {e}")
+        trace_exception(e)
+        sys.exit(1)
+
+    if not client.binding or not client.mcp:
+        ASCIIColors.error("LollmsClient LLM or MCP binding failed to load.")
+        if hasattr(client, 'close'): client.close()
+        sys.exit(1)
+    ASCIIColors.green("LollmsClient initialized successfully.")
+
+    def mcp_streaming_callback(chunk: str, msg_type: MSG_TYPE, metadata: dict = None, history: list = None) -> bool:
+        prefix = ""
+        color_func = ASCIIColors.green
+        if metadata:
+            type_info = metadata.get('type', 'unknown_type')
+            tool_name_info = metadata.get('tool_name', '')
+            prefix = f"MCP ({type_info}{f' - {tool_name_info}' if tool_name_info else ''})"
+            if msg_type == MSG_TYPE.MSG_TYPE_STEP_START: color_func = ASCIIColors.cyan; prefix += " Step Start"
+            elif msg_type == MSG_TYPE.MSG_TYPE_STEP_END: color_func = ASCIIColors.cyan; prefix += " Step End"
+            elif msg_type == MSG_TYPE.MSG_TYPE_INFO: color_func = ASCIIColors.yellow; prefix += " Info"
+            elif msg_type == MSG_TYPE.MSG_TYPE_EXCEPTION: color_func = ASCIIColors.red; prefix += " Exception"
+        else:
+            prefix = f"MCP (Type: {str(msg_type).split('.')[-1]})"
+        if msg_type == MSG_TYPE.MSG_TYPE_CHUNK: ASCIIColors.green(chunk, end="")
+        else: color_func(f"{prefix}: {chunk}")
+        sys.stdout.flush()
+        return True
+
+    # --- Test 1: General Text Query (handled by Ollama, no MCP tool expected) ---
+    ASCIIColors.magenta("\n2. Test: General Text Query (should be handled by Ollama)")
+    general_query = "What is the capital of France?"
+    general_response = client.generate_with_mcp( # generate_with_mcp will discover no suitable text tool
+        prompt=general_query,
+        streaming_callback=mcp_streaming_callback,
+        # tools=[] # Optionally explicitly pass an empty list of tools if you want to be sure
+                  # generate_with_mcp will discover tools from the binding if not passed
+    )
+    print()
+    ASCIIColors.blue(f"Final response for general query: {json.dumps(general_response, indent=2)}")
+    assert general_response.get("error") is None, f"General query error: {general_response.get('error')}"
+    assert general_response.get("final_answer"), "General query: no final answer."
+    tool_calls_general = general_response.get("tool_calls", [])
+    assert len(tool_calls_general) == 0, "General query should NOT have called an MCP tool from my_openai_server."
+    ASCIIColors.green(f"General query handled by LLM directly, as expected. Answer: {general_response.get('final_answer')[:100]}...")
+
+
+    # --- Test 2: Text-to-Speech (TTS) ---
+    ASCIIColors.magenta("\n3. Test: OpenAI TTS via MCP")
+    tts_text = "This audio was generated by the OpenAI MCP server through Lollms Client."
+    tts_prompt_for_llm = f"Please use the OpenAI tool to say the following using tts: '{tts_text}'."
+    
+    tts_response = client.generate_with_mcp(
+        prompt=tts_prompt_for_llm,
+        streaming_callback=mcp_streaming_callback,
+        max_tool_calls=1
+    )
+    print()
+    ASCIIColors.blue(f"Final response for TTS prompt: {json.dumps(tts_response, indent=2)}")
+
+    assert tts_response.get("error") is None, f"TTS error: {tts_response.get('error')}"
+    assert tts_response.get("final_answer"), "TTS: no final answer (LLM should confirm action)."
+    tool_calls_tts = tts_response.get("tool_calls", [])
+    assert len(tool_calls_tts) > 0, "TTS should have called a tool."
+    if tool_calls_tts:
+        assert tool_calls_tts[0]["name"] == "my_openai_server::generate_tts", "Incorrect tool for TTS."
+        tts_result_output = tool_calls_tts[0].get("result", {}).get("output", {})
+        assert "audio_base64" in tts_result_output, "TTS tool result missing 'audio_base64'."
+        assert "format" in tts_result_output, "TTS tool result missing 'format'."
+        if tts_result_output.get("audio_base64"):
+            save_base64_audio(tts_result_output["audio_base64"], "openai_tts_example_output", tts_result_output["format"])
+
+    # --- Test 3: DALL-E Image Generation ---
+    ASCIIColors.magenta("\n4. Test: OpenAI DALL-E Image Generation via MCP")
+    dalle_image_prompt = "A vibrant illustration of a friendly AI robot helping a human plant a tree on a futuristic Earth."
+    dalle_prompt_for_llm = f"I need an image for a presentation. Can you use DALL-E to create this: {dalle_image_prompt}. Please use URL format for the image."
+
+    dalle_response = client.generate_with_mcp(
+        prompt=dalle_prompt_for_llm,
+        streaming_callback=mcp_streaming_callback,
+        max_tool_calls=1,
+        # You could also try to force params for the tool if LLM struggles:
+        # Example: if LLM isn't picking response_format="url"
+        # This requires knowing the exact tool name and schema, usually let LLM handle it.
+    )
+    print()
+    ASCIIColors.blue(f"Final response for DALL-E prompt: {json.dumps(dalle_response, indent=2)}")
+    
+    assert dalle_response.get("error") is None, f"DALL-E error: {dalle_response.get('error')}"
+    assert dalle_response.get("final_answer"), "DALL-E: no final answer (LLM should confirm action)."
+    tool_calls_dalle = dalle_response.get("tool_calls", [])
+    assert len(tool_calls_dalle) > 0, "DALL-E should have called a tool."
+    if tool_calls_dalle:
+        assert tool_calls_dalle[0]["name"] == "my_openai_server::generate_image_dalle", "Incorrect tool for DALL-E."
+        dalle_result_output = tool_calls_dalle[0].get("result", {}).get("output", {})
+        assert "images" in dalle_result_output and isinstance(dalle_result_output["images"], list), "DALL-E result missing 'images' list."
+        if dalle_result_output.get("images"):
+            image_data = dalle_result_output["images"][0]
+            if image_data.get("url"):
+                ASCIIColors.green(f"DALL-E image URL: {image_data['url']}")
+                ASCIIColors.info(f"Revised prompt by DALL-E: {image_data.get('revised_prompt')}")
+            elif image_data.get("b64_json"):
+                save_base64_image(image_data["b64_json"], "openai_dalle_example_output")
+                ASCIIColors.info(f"Revised prompt by DALL-E: {image_data.get('revised_prompt')}")
+
+    ASCIIColors.magenta("\n5. Closing LollmsClient...")
+    if client and hasattr(client, 'close'):
+        try: client.close()
+        except Exception as e: ASCIIColors.error(f"Error closing LollmsClient: {e}"); trace_exception(e)
+
+    ASCIIColors.info(f"Example finished. Check {OUTPUT_DIRECTORY} for any generated files.")
+    ASCIIColors.red("\n--- LollmsClient with OpenAI MCP Server (TTS & DALL-E) Example Finished ---")
+
+if __name__ == "__main__":
+    main()

{lollms_client-0.20.0 → lollms_client-0.20.2}/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.0" # Updated version
+__version__ = "0.20.2" # Updated version
 
 # Optionally, you could define __all__ if you want to be explicit about exports
 __all__ = [

{lollms_client-0.20.0 → lollms_client-0.20.2}/lollms_client/lollms_core.py

@@ -587,7 +587,7 @@ Don't forget encapsulate the code inside a html code tag. This is mandatory.
         # 1. Discover tools if not provided
         if tools is None:
             try:
-                tools = self.mcp.discover_tools()
+                tools = self.mcp.discover_tools(force_refresh=True)
                 if not tools:
                     ASCIIColors.warning("No MCP tools discovered by the binding.")
             except Exception as e_disc:
@@ -898,7 +898,7 @@ Respond with a JSON object containing ONE of the following structures:
         # 0. Optional Objectives Extraction Step
         if extract_objectives:
             if streaming_callback:
-                streaming_callback("Extracting and structuring objectives...", MSG_TYPE.MSG_TYPE_STEP, {"type": "objectives_extraction"}, turn_rag_history_for_callback)
+                streaming_callback("Extracting and structuring objectives...", MSG_TYPE.MSG_TYPE_STEP_START, {"id": "objectives_extraction"}, turn_rag_history_for_callback)
             obj_prompt = (
                 "You are an expert analyst. "
                 "Your task is to extract and structure the key objectives from the user's request below. "
@@ -914,22 +914,33 @@ Respond with a JSON object containing ONE of the following structures:
             )
             objectives_text = self.remove_thinking_blocks(obj_gen).strip()
             if streaming_callback:
-                streaming_callback(f"Objectives extracted:\n{objectives_text}", MSG_TYPE.MSG_TYPE_STEP_END, {"type": "objectives_extracted"}, turn_rag_history_for_callback)
+                streaming_callback(f"Objectives: {objectives_text}", MSG_TYPE.MSG_TYPE_STEP, {"id": "objectives_extraction"}, turn_rag_history_for_callback)
+
+            if streaming_callback:
+                streaming_callback(f"Objectives extracted:\n{objectives_text}", MSG_TYPE.MSG_TYPE_STEP_END, {"id": "objectives_extraction"}, turn_rag_history_for_callback)
 
         current_query_for_rag = rag_query_text or None
         previous_queries=[]
         # 1. RAG Hops
         for hop_count in range(max_rag_hops + 1):
             if streaming_callback:
-                streaming_callback(f"Starting RAG Hop {hop_count + 1}", MSG_TYPE.MSG_TYPE_STEP, {"type": "rag_hop_start", "hop": hop_count + 1}, turn_rag_history_for_callback)
+                streaming_callback(f"Starting RAG Hop {hop_count + 1}", MSG_TYPE.MSG_TYPE_STEP_START, {"id": f"rag_hop_{hop_count + 1}", "hop": hop_count + 1}, turn_rag_history_for_callback)
             txt_previous_queries = f"Previous queries:\n"+'\n'.join(previous_queries)+"\n\n" if len(previous_queries)>0 else ""
             txt_informations = f"Information:\n"+'\n'.join([f"(from {chunk['document']}):{chunk['content']}" for _, chunk in all_unique_retrieved_chunks_map.items()]) if len(all_unique_retrieved_chunks_map)>0 else "This is the first request. No data received yet. Build a new query."
-            txt_sp = "Your objective is to analyze the provided chunks of information, then decise if they are sufficient to reach the objective. If you need more information, formulate a new query to extract more data."
-            txt_formatting = """The output format must be in form of json placed inside a json markdown tag. Here is the schema to use:
+            txt_sp = (
+                "Your objective is to analyze the provided chunks of information to determine "
+                "whether they are sufficient to reach the objective. If not, formulate a refined and focused query "
+                "that can retrieve more relevant information from a vector database. Ensure the query captures the semantic essence "
+                "of what is missing, is contextually independent, and is optimized for vector-based similarity search. "
+                "Do not repeat or rephrase earlier queries—always generate a new, meaningful atomic query targeting the current gap in knowledge."
+            )
+
+            txt_formatting = """The output format must be in form of JSON placed inside a JSON markdown tag. Use the following schema:
 ```json
 {
-    "decision": A boolean depicting your decision (true: more data is needed, false: there is enough data to reach objective),
-    "query": (str, optional, only if decision is true). A new query to recover more information from the data source (do not use previous queries as they have already been used)
+    "decision": A boolean indicating your decision (true: more data is needed, false: the current data is sufficient),
+    "query": (str, optional, only if decision is true). A new, atomic query suitable for semantic search in a vector database. 
+            It should capture the missing concept or insight in concise, context-rich language, avoiding reuse of earlier queries.
 }
 ```
 """
@@ -939,12 +950,18 @@ Respond with a JSON object containing ONE of the following structures:
                 answer = json.loads(response)
                 decision = answer["decision"]
                 if not decision:
+                    if streaming_callback:
+                        streaming_callback(f"RAG Hop {hop_count + 1} done", MSG_TYPE.MSG_TYPE_STEP_END, {"id": f"rag_hop_{hop_count + 1}", "hop": hop_count + 1}, turn_rag_history_for_callback)
+
                     break
                 else:
                     current_query_for_rag = str(answer["query"])
             except Exception as ex:
                 trace_exception(ex)
 
+            if streaming_callback:
+                streaming_callback(f"Query: {current_query_for_rag}", MSG_TYPE.MSG_TYPE_STEP, {"id": f"query for hop {hop_count + 1}", "hop": hop_count + 1}, turn_rag_history_for_callback)
+
             # Retrieve chunks
             try:
                 retrieved = rag_query_function(current_query_for_rag, rag_vectorizer_name, rag_top_k, rag_min_similarity_percent)
@@ -971,6 +988,8 @@ Respond with a JSON object containing ONE of the following structures:
                 hop_details["status"] = "No *new* unique chunks retrieved"
             rag_hops_details_list.append(hop_details)
 
+            if streaming_callback:
+                streaming_callback(f"RAG Hop {hop_count + 1} done", MSG_TYPE.MSG_TYPE_STEP_END, {"id": f"rag_hop_{hop_count + 1}", "hop": hop_count + 1}, turn_rag_history_for_callback)
 
 
         # 2. Prepare & Summarize Context
@@ -994,7 +1013,7 @@ Respond with a JSON object containing ONE of the following structures:
         # If context exceeds our effective limit, summarize it
         if self.count_tokens(accumulated_context) > effective_ctx_size:
             if streaming_callback:
-                streaming_callback("Context too large, performing intermediate summary...", MSG_TYPE.MSG_TYPE_STEP, {"type": "intermediate_summary"}, turn_rag_history_for_callback)
+                streaming_callback("Context too large, performing intermediate summary...", MSG_TYPE.MSG_TYPE_STEP_START, {"id": "intermediate_summary"}, turn_rag_history_for_callback)
             summary_prompt = (
                 "Summarize the following gathered context into a concise form "
                 "that preserves all key facts and sources needed to answer the user's request:\n\n"
@@ -1009,7 +1028,7 @@ Respond with a JSON object containing ONE of the following structures:
             )
             accumulated_context = self.remove_thinking_blocks(summary).strip()
             if streaming_callback:
-                streaming_callback("Intermediate summary complete.", MSG_TYPE.MSG_TYPE_STEP_END, {"type": "intermediate_summary"}, turn_rag_history_for_callback)
+                streaming_callback("Intermediate summary complete.", MSG_TYPE.MSG_TYPE_STEP_END, {"id": "intermediate_summary"}, turn_rag_history_for_callback)
 
         # 3. Final Answer Generation
         final_prompt = [

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

@@ -0,0 +1,241 @@
+# 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

{lollms_client-0.20.0 → lollms_client-0.20.2}/lollms_client/mcp_bindings/standard_mcp/__init__.py

@@ -285,15 +285,22 @@ class StandardMCPBinding(LollmsMCPBinding):
                 ASCIIColors.info(f"{self.binding_name}: Connection for '{alias}' not initialized. Attempting initialization...")
                 try:
                     success = self._run_async_task(self._initialize_connection_async(alias), timeout=timeout)
-                    if not success:
-                        raise ConnectionError(f"Failed to initialize MCP connection for server '{alias}'. Check previous logs for details.")
+                    if not success: 
+                        # If init itself reports failure (e.g. returns False from _initialize_connection_async)
+                        self._discovered_tools_cache[alias] = [] # CLEAR CACHE ON FAILURE
+                        raise ConnectionError(f"MCP init for '{alias}' reported failure.")
                 except TimeoutError:
-                    raise ConnectionError(f"MCP initialization for server '{alias}' timed out after {timeout} seconds.")
-                except Exception as e:
-                    raise ConnectionError(f"MCP initialization for server '{alias}' failed: {str(e)}")
-
+                    self._discovered_tools_cache[alias] = [] # CLEAR CACHE ON FAILURE
+                    raise ConnectionError(f"MCP init for '{alias}' timed out.")
+                except Exception as e: # Other exceptions during run_async_task
+                    self._discovered_tools_cache[alias] = [] # CLEAR CACHE ON FAILURE
+                    raise ConnectionError(f"MCP init for '{alias}' failed: {e}")
+        
         if not self._initialization_status.get(alias) or alias not in self._mcp_sessions:
-            raise ConnectionError(f"MCP Session for server '{alias}' is not valid after initialization attempt.")
+            # This means init was thought to be successful by the lock block, but status is bad
+            # This case might indicate a race or an issue if _initialize_connection_async doesn't set status correctly on all paths
+            self._discovered_tools_cache[alias] = [] # Also clear here as a safeguard
+            raise ConnectionError(f"MCP Session for '{alias}' not valid post-init attempt, despite no immediate error.")
 
     async def _refresh_tools_cache_async(self, alias: str):
         if not MCP_LIBRARY_AVAILABLE or not types:
@@ -368,8 +375,17 @@ class StandardMCPBinding(LollmsMCPBinding):
 
         for alias in active_aliases:
             try:
+                if force_refresh: # Explicitly clear before ensuring init if forcing
+                    ASCIIColors.yellow(f"{self.binding_name}: Force refresh - clearing cache for '{alias}' before init.")
+                    self._discovered_tools_cache[alias] = [] 
+                
                 self._ensure_server_initialized_sync(alias, timeout=tps)
 
+                # If force_refresh OR if server is initialized but cache is empty/stale
+                if force_refresh or (self._initialization_status.get(alias) and not self._discovered_tools_cache.get(alias)):
+                    ASCIIColors.info(f"{self.binding_name}: Refreshing tools for '{alias}' (force_refresh={force_refresh}, cache_empty={not self._discovered_tools_cache.get(alias)}).")
+                    self._run_async_task(self._refresh_tools_cache_async(alias), timeout=tps)
+
                 if fr or (self._initialization_status.get(alias) and not self._discovered_tools_cache.get(alias)):
                     ASCIIColors.info(f"{self.binding_name}: Force refreshing tools for '{alias}' or cache is empty.")
                     self._run_async_task(self._refresh_tools_cache_async(alias), timeout=tps)

{lollms_client-0.20.0 → lollms_client-0.20.2/lollms_client.egg-info}/PKG-INFO

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

{lollms_client-0.20.0 → lollms_client-0.20.2}/lollms_client.egg-info/SOURCES.txt

@@ -7,6 +7,7 @@ examples/generate_a_benchmark_for_safe_store.py
 examples/generate_text_with_multihop_rag_example.py
 examples/internet_search_with_rag.py
 examples/local_mcp.py
+examples/openai_mcp.py
 examples/run_standard_mcp_example.py
 examples/simple_text_gen_test.py
 examples/simple_text_gen_with_image_test.py
@@ -60,6 +61,7 @@ lollms_client/mcp_bindings/local_mcp/default_tools/file_writer/file_writer.py
 lollms_client/mcp_bindings/local_mcp/default_tools/generate_image_from_prompt/generate_image_from_prompt.py
 lollms_client/mcp_bindings/local_mcp/default_tools/internet_search/internet_search.py
 lollms_client/mcp_bindings/local_mcp/default_tools/python_interpreter/python_interpreter.py
+lollms_client/mcp_bindings/remote_mcp/__init__.py
 lollms_client/mcp_bindings/standard_mcp/__init__.py
 lollms_client/stt_bindings/__init__.py
 lollms_client/stt_bindings/lollms/__init__.py

{lollms_client-0.20.0 → lollms_client-0.20.2}/lollms_client.egg-info/top_level.txt

@@ -1,4 +1,5 @@
 ai_documentation
 dist
+docs
 examples
 lollms_client