mcp wip

docker/base/fs/ins/install_base_packages.sh

@@ -3,11 +3,15 @@ set -e
 
 echo "====================BASE PACKAGES START===================="
 
+apt-get update && apt-get upgrade -y
+
 apt-get install -y --no-install-recommends \
     nodejs npm openssh-server sudo curl wget git ffmpeg supervisor cron
 
 echo "====================BASE PACKAGES NPM===================="
 
-npm i -g npx shx
+# we shall not install npx separately, it's discontinued and some versions are broken
+# npm i -g npx
+npm i -g shx
 
 echo "====================BASE PACKAGES END===================="

docker/base/fs/ins/install_python.sh

@@ -49,4 +49,8 @@ pip install --upgrade pip ipython requests
 pip install torch==2.7.0+cpu torchvision==0.22.0+cpu --index-url https://download.pytorch.org/whl/cpu
 
 
+echo "====================PYTHON UV ===================="
+
+curl -Ls https://astral.sh/uv/install.sh | sh
+
 echo "====================PYTHON END===================="

initialize.py

@@ -82,9 +82,10 @@ def initialize():
     args_override(config)
 
     # initialize MCP in deferred task to prevent blocking the main thread
-    async def initialize_mcp_async(mcp_servers_config: str):
-        return initialize_mcp(mcp_servers_config)
-    defer.DeferredTask(thread_name="mcp-initializer").start_task(initialize_mcp_async, config.mcp_servers)
+    # async def initialize_mcp_async(mcp_servers_config: str):
+    #     return initialize_mcp(mcp_servers_config)
+    # defer.DeferredTask(thread_name="mcp-initializer").start_task(initialize_mcp_async, config.mcp_servers)
+    initialize_mcp(config.mcp_servers)
 
     # import python.helpers.mcp_handler as mcp_helper
     # import agent as agent_helper

python/api/mcp_server_get_log.py

@@ -0,0 +1,19 @@
+from python.helpers.api import ApiHandler
+from flask import Request, Response
+
+from typing import Any
+
+from python.helpers.mcp_handler import MCPConfig
+
+
+class McpServerGetLog(ApiHandler):
+    async def process(self, input: dict[Any, Any], request: Request) -> dict[Any, Any] | Response:
+        
+        # try:
+            server_name = input.get("server_name")
+            if not server_name:
+                return {"success": False, "error": "Missing server_name"}
+            log = MCPConfig.get_instance().get_server_log(server_name)
+            return {"success": True, "log": log}
+        # except Exception as e:
+        #     return {"success": False, "error": str(e)}

python/helpers/errors.py

@@ -18,35 +18,46 @@ def format_error(e: Exception, start_entries=6, end_entries=4):
     # Split the traceback into lines
     lines = traceback_text.split("\n")
 
-    # Find all "File" lines
-    file_indices = [
-        i for i, line in enumerate(lines) if line.strip().startswith("File ")
-    ]
-
-    # If we found at least one "File" line, trim the middle if there are more than start_entries+end_entries lines
-    if len(file_indices) > start_entries + end_entries:
-        start_index = max(0, len(file_indices) - start_entries - end_entries)
-        trimmed_lines = (
-            lines[: file_indices[start_index]]
-            + [
-                f"\n>>>  {len(file_indices) - start_entries - end_entries} stack lines skipped <<<\n"
-            ]
-            + lines[file_indices[start_index + end_entries] :]
-        )
+    if not start_entries and not end_entries:
+        trimmed_lines = []
     else:
-        # If no "File" lines found, or not enough to trim, just return the original traceback
-        trimmed_lines = lines
+
+        # Find all "File" lines
+        file_indices = [
+            i for i, line in enumerate(lines) if line.strip().startswith("File ")
+        ]
+
+        # If we found at least one "File" line, trim the middle if there are more than start_entries+end_entries lines
+        if len(file_indices) > start_entries + end_entries:
+            start_index = max(0, len(file_indices) - start_entries - end_entries)
+            trimmed_lines = (
+                lines[: file_indices[start_index]]
+                + [
+                    f"\n>>>  {len(file_indices) - start_entries - end_entries} stack lines skipped <<<\n"
+                ]
+                + lines[file_indices[start_index + end_entries] :]
+            )
+        else:
+            # If no "File" lines found, or not enough to trim, just return the original traceback
+            trimmed_lines = lines
 
     # Find the error message at the end
     error_message = ""
-    for line in reversed(trimmed_lines):
+    for line in reversed(lines):
         if re.match(r"\w+Error:", line):
             error_message = line
             break
 
     # Combine the trimmed traceback with the error message
-    result = "Traceback (most recent call last):\n" + "\n".join(trimmed_lines)
-    if error_message:
-        result += f"\n\n{error_message}"
+    if not trimmed_lines:
+        result = error_message
+    else:
+        result = "Traceback (most recent call last):\n" + "\n".join(trimmed_lines)
+        if error_message:
+            result += f"\n\n{error_message}"
+
+    # at least something
+    if not result:
+        result = str(e)
 
     return result

python/helpers/mcp_handler.py

@@ -1,19 +1,36 @@
 from abc import ABC, abstractmethod
 import re
-from typing import List, Dict, Optional, Any, Union, Literal, Annotated, ClassVar, cast, Callable, Awaitable, TypeVar
+from typing import (
+    List,
+    Dict,
+    Optional,
+    Any,
+    Union,
+    Literal,
+    Annotated,
+    ClassVar,
+    cast,
+    Callable,
+    Awaitable,
+    TypeVar,
+)
 import threading
 import asyncio
 from contextlib import AsyncExitStack
 from shutil import which
 from datetime import timedelta
 import json
+from python.helpers import errors
+from python.helpers import settings
 
 import os
+
 # print(f"DEBUG: Listing /opt/venv/lib/python3.11/site-packages/ before mcp import: {os.listdir('/opt/venv/lib/python3.11/site-packages/')}") # This line caused FileNotFoundError, **FOR CUDA CHANGE TO '3.12'**
 
 from mcp import ClientSession, StdioServerParameters
 from mcp.client.stdio import stdio_client
 from mcp.client.sse import sse_client
+from mcp.shared.message import SessionMessage
 from mcp.types import CallToolResult, ListToolsResult, JSONRPCMessage
 from anyio.streams.memory import (
     MemoryObjectReceiveStream,
@@ -26,39 +43,52 @@ from python.helpers.dirty_json import DirtyJson
 from python.helpers.print_style import PrintStyle
 from python.helpers.tool import Tool, Response
 
+
 def normalize_name(name: str) -> str:
     # Lowercase and strip whitespace
     name = name.strip().lower()
     # Replace all non-alphanumeric (unicode) chars with underscore
     # \W matches non-alphanumeric, but also matches underscore, so use [^\w] with re.UNICODE
     # To also replace underscores from non-latin chars, use [^a-zA-Z0-9] with re.UNICODE
-    name = re.sub(r'[^\w]', '_', name, flags=re.UNICODE)
+    name = re.sub(r"[^\w]", "_", name, flags=re.UNICODE)
     return name
 
-def initialize_mcp(mcp_servers_config:str):
+
+def initialize_mcp(mcp_servers_config: str):
     if not MCPConfig.get_instance().is_initialized():
         try:
             MCPConfig.update(mcp_servers_config)
         except Exception as e:
             from agent import AgentContext
-            first_context = AgentContext.first() # TODO replace with better reporting
+
+            first_context = AgentContext.first()  # TODO replace with better reporting
             if first_context:
                 (
-                    first_context.log
-                    .log(type="warning", content=f"Failed to update MCP settings: {e}", temp=False)
+                    first_context.log.log(
+                        type="warning",
+                        content=f"Failed to update MCP settings: {e}",
+                        temp=False,
+                    )
                 )
             (
-                PrintStyle(background_color="black", font_color="red", padding=True)
-                .print(f"Failed to update MCP settings: {e}")
+                PrintStyle(
+                    background_color="black", font_color="red", padding=True
+                ).print(f"Failed to update MCP settings: {e}")
             )
 
+
 class MCPTool(Tool):
     """MCP Tool wrapper"""
+
     async def execute(self, **kwargs: Any):
         error = ""
         try:
-            response: CallToolResult = await MCPConfig.get_instance().call_tool(self.name, kwargs)
-            message = "\n\n".join([item.text for item in response.content if item.type == "text"])
+            response: CallToolResult = await MCPConfig.get_instance().call_tool(
+                self.name, kwargs
+            )
+            message = "\n\n".join(
+                [item.text for item in response.content if item.type == "text"]
+            )
             if response.isError:
                 error = message
         except Exception as e:
@@ -69,7 +99,9 @@ class MCPTool(Tool):
             PrintStyle(
                 background_color="#CC34C3", font_color="white", bold=True, padding=True
             ).print(f"MCPTool::Failed to call mcp tool {self.name}:")
-            PrintStyle(background_color="#AA4455", font_color="white", padding=False).print(error)
+            PrintStyle(
+                background_color="#AA4455", font_color="white", padding=False
+            ).print(error)
 
             self.agent.context.log.log(
                 type="warning",
@@ -80,43 +112,60 @@ class MCPTool(Tool):
 
     async def before_execution(self, **kwargs: Any):
         (
-            PrintStyle(font_color="#1B4F72", padding=True, background_color="white", bold=True)
-            .print(f"{self.agent.agent_name}: Using tool '{self.name}'")
+            PrintStyle(
+                font_color="#1B4F72", padding=True, background_color="white", bold=True
+            ).print(f"{self.agent.agent_name}: Using tool '{self.name}'")
         )
         self.log = self.get_log_object()
 
         for key, value in self.args.items():
-            PrintStyle(font_color="#85C1E9", bold=True).stream(self.nice_key(key) + ": ")
-            PrintStyle(font_color="#85C1E9", padding=isinstance(value, str) and "\n" in value).stream(value)
+            PrintStyle(font_color="#85C1E9", bold=True).stream(
+                self.nice_key(key) + ": "
+            )
+            PrintStyle(
+                font_color="#85C1E9", padding=isinstance(value, str) and "\n" in value
+            ).stream(value)
             PrintStyle().print()
 
     async def after_execution(self, response: Response, **kwargs: Any):
         raw_tool_response = response.message.strip() if response.message else ""
         if not raw_tool_response:
-            PrintStyle(font_color="red").print(f"Warning: Tool '{self.name}' returned an empty message.")
+            PrintStyle(font_color="red").print(
+                f"Warning: Tool '{self.name}' returned an empty message."
+            )
             # Even if empty, we might still want to provide context for the agent
             raw_tool_response = "[Tool returned no textual content]"
 
         # Prepare user message context
-        user_message_text = "No specific user message context available for this exact step."
-        if self.agent and self.agent.last_user_message and self.agent.last_user_message.content:
+        user_message_text = (
+            "No specific user message context available for this exact step."
+        )
+        if (
+            self.agent
+            and self.agent.last_user_message
+            and self.agent.last_user_message.content
+        ):
             content = self.agent.last_user_message.content
             if isinstance(content, dict):
                 # Attempt to get a 'message' field, otherwise stringify the dict
-                user_message_text = content.get("message", json.dumps(content, indent=2))
+                user_message_text = content.get(
+                    "message", json.dumps(content, indent=2)
+                )
             elif isinstance(content, str):
                 user_message_text = content
             else:
                 # Fallback for any other types (e.g. list, if that were possible for content)
-                user_message_text = str(content) 
-        
+                user_message_text = str(content)
+
         # Ensure user_message_text is a string before length check and slicing
-        user_message_text = str(user_message_text) 
+        user_message_text = str(user_message_text)
 
         # Truncate user message context if it's too long to avoid overwhelming the prompt
-        max_user_context_len = 500 # characters
+        max_user_context_len = 500  # characters
         if len(user_message_text) > max_user_context_len:
-            user_message_text = user_message_text[:max_user_context_len] + "... (truncated)"
+            user_message_text = (
+                user_message_text[:max_user_context_len] + "... (truncated)"
+            )
 
         contextual_block = f"""
 \n--- End of Results for MCP Tool: {self.name} ---
@@ -139,13 +188,22 @@ If this action is part of an ongoing sequence, consider the next step with this
 
         self.agent.hist_add_tool_result(self.name, final_text_for_agent)
         (
-            PrintStyle(font_color="#1B4F72", background_color="white", padding=True, bold=True)
-            .print(f"{self.agent.agent_name}: Response from tool '{self.name}' (plus context added)")
+            PrintStyle(
+                font_color="#1B4F72", background_color="white", padding=True, bold=True
+            ).print(
+                f"{self.agent.agent_name}: Response from tool '{self.name}' (plus context added)"
+            )
         )
         # Print only the raw response to console for brevity, agent gets the full context.
-        PrintStyle(font_color="#85C1E9").print(raw_tool_response if raw_tool_response else "[No direct textual output from tool]")
+        PrintStyle(font_color="#85C1E9").print(
+            raw_tool_response
+            if raw_tool_response
+            else "[No direct textual output from tool]"
+        )
         if self.log:
-             self.log.update(content=final_text_for_agent) # Log includes the full context
+            self.log.update(
+                content=final_text_for_agent
+            )  # Log includes the full context
 
 
 class MCPServerRemote(BaseModel):
@@ -165,6 +223,14 @@ class MCPServerRemote(BaseModel):
         self.__client = MCPClientRemote(self)
         self.update(config)
 
+    def get_error(self) -> str:
+        with self.__lock:
+            return self.__client.error  # type: ignore
+
+    def get_log(self) -> str:
+        with self.__lock:
+            return self.__client.get_log()  # type: ignore
+
     def get_tools(self) -> List[dict[str, Any]]:
         """Get all tools from the server"""
         with self.__lock:
@@ -175,7 +241,9 @@ class MCPServerRemote(BaseModel):
         with self.__lock:
             return self.__client.has_tool(tool_name)  # type: ignore
 
-    async def call_tool(self, tool_name: str, input_data: Dict[str, Any]) -> CallToolResult:
+    async def call_tool(
+        self, tool_name: str, input_data: Dict[str, Any]
+    ) -> CallToolResult:
         """Call a tool with the given input data"""
         with self.__lock:
             # We already run in an event loop, dont believe Pylance
@@ -184,7 +252,15 @@ class MCPServerRemote(BaseModel):
     def update(self, config: dict[str, Any]) -> "MCPServerRemote":
         with self.__lock:
             for key, value in config.items():
-                if key in ["name", "description", "url", "headers", "timeout", "sse_read_timeout", "disabled"]:
+                if key in [
+                    "name",
+                    "description",
+                    "url",
+                    "headers",
+                    "timeout",
+                    "sse_read_timeout",
+                    "disabled",
+                ]:
                     if key == "name":
                         value = normalize_name(value)
                     setattr(self, key, value)
@@ -203,7 +279,9 @@ class MCPServerLocal(BaseModel):
     args: list[str] = Field(default_factory=list)
     env: dict[str, str] | None = Field(default_factory=dict[str, str])
     encoding: str = Field(default="utf-8")
-    encoding_error_handler: Literal["strict", "ignore", "replace"] = Field(default="strict")
+    encoding_error_handler: Literal["strict", "ignore", "replace"] = Field(
+        default="strict"
+    )
     disabled: bool = Field(default=False)
 
     __lock: ClassVar[threading.Lock] = PrivateAttr(default=threading.Lock())
@@ -214,6 +292,14 @@ class MCPServerLocal(BaseModel):
         self.__client = MCPClientLocal(self)
         self.update(config)
 
+    def get_error(self) -> str:
+        with self.__lock:
+            return self.__client.error  # type: ignore
+   
+    def get_log(self) -> str:
+        with self.__lock:
+            return self.__client.get_log()  # type: ignore
+
     def get_tools(self) -> List[dict[str, Any]]:
         """Get all tools from the server"""
         with self.__lock:
@@ -224,7 +310,9 @@ class MCPServerLocal(BaseModel):
         with self.__lock:
             return self.__client.has_tool(tool_name)  # type: ignore
 
-    async def call_tool(self, tool_name: str, input_data: Dict[str, Any]) -> CallToolResult:
+    async def call_tool(
+        self, tool_name: str, input_data: Dict[str, Any]
+    ) -> CallToolResult:
         """Call a tool with the given input data"""
         with self.__lock:
             # We already run in an event loop, dont believe Pylance
@@ -233,7 +321,16 @@ class MCPServerLocal(BaseModel):
     def update(self, config: dict[str, Any]) -> "MCPServerLocal":
         with self.__lock:
             for key, value in config.items():
-                if key in ["name", "description", "command", "args", "env", "encoding", "encoding_error_handler", "disabled"]:
+                if key in [
+                    "name",
+                    "description",
+                    "command",
+                    "args",
+                    "env",
+                    "encoding",
+                    "encoding_error_handler",
+                    "disabled",
+                ]:
                     if key == "name":
                         value = normalize_name(value)
                     setattr(self, key, value)
@@ -247,10 +344,10 @@ class MCPServerLocal(BaseModel):
 
 MCPServer = Annotated[
     Union[
-        Annotated[MCPServerRemote, Tag('MCPServerRemote')],
-        Annotated[MCPServerLocal, Tag('MCPServerLocal')]
+        Annotated[MCPServerRemote, Tag("MCPServerRemote")],
+        Annotated[MCPServerLocal, Tag("MCPServerLocal")],
     ],
-    Discriminator(lambda v: "MCPServerRemote" if "url" in v else "MCPServerLocal")
+    Discriminator(lambda v: "MCPServerRemote" if "url" in v else "MCPServerLocal"),
 ]
 
 
@@ -272,30 +369,42 @@ class MCPConfig(BaseModel):
         with cls.__lock:
             servers_data: List[Dict[str, Any]] = []  # Default to empty list
 
-            if config_str and config_str.strip():  # Only parse if non-empty and not just whitespace
+            if (
+                config_str and config_str.strip()
+            ):  # Only parse if non-empty and not just whitespace
                 try:
                     # Try with standard json.loads first, as it should handle escaped strings correctly
                     parsed_value = dirty_json.try_parse(config_str)
                     normalized = cls.normalize_config(parsed_value)
-                    
+
                     if isinstance(normalized, list):
                         valid_servers = []
                         for item in normalized:
                             if isinstance(item, dict):
                                 valid_servers.append(item)
                             else:
-                                PrintStyle(background_color="yellow", font_color="black", padding=True).print(
+                                PrintStyle(
+                                    background_color="yellow",
+                                    font_color="black",
+                                    padding=True,
+                                ).print(
                                     f"Warning: MCP config item (from json.loads) was not a dictionary and was ignored: {item}"
                                 )
                         servers_data = valid_servers
                     else:
-                        PrintStyle(background_color="red", font_color="white", padding=True).print(
+                        PrintStyle(
+                            background_color="red", font_color="white", padding=True
+                        ).print(
                             f"Error: Parsed MCP config (from json.loads) top-level structure is not a list. Config string was: '{config_str}'"
                         )
                         # servers_data remains empty
-                except Exception as e_json: # Catch json.JSONDecodeError specifically if possible, or general Exception
-                    PrintStyle.error(f"Error parsing MCP config string: {e_json}. Config string was: '{config_str}'")
-                    
+                except (
+                    Exception
+                ) as e_json:  # Catch json.JSONDecodeError specifically if possible, or general Exception
+                    PrintStyle.error(
+                        f"Error parsing MCP config string: {e_json}. Config string was: '{config_str}'"
+                    )
+
                     # # Fallback to DirtyJson or log error if standard json.loads fails
                     # PrintStyle(background_color="orange", font_color="black", padding=True).print(
                     #     f"Standard json.loads failed for MCP config: {e_json}. Attempting DirtyJson as fallback."
@@ -322,13 +431,15 @@ class MCPConfig(BaseModel):
                     #         f"Error parsing MCP config string with DirtyJson as well: {e_dirty}. Config string was: '{config_str}'"
                     #     )
                     #     # servers_data remains empty, allowing graceful degradation
-            
+
             # Initialize/update the singleton instance with the (potentially empty) list of server data
             instance = cls.get_instance()
             # Directly update the servers attribute of the existing instance or re-initialize carefully
             # For simplicity and to ensure __init__ logic runs if needed for setup:
-            new_instance_data = {'servers': servers_data} # Prepare data for re-initialization or update
-            
+            new_instance_data = {
+                "servers": servers_data
+            }  # Prepare data for re-initialization or update
+
             # Option 1: Re-initialize the existing instance (if __init__ is idempotent for other fields)
             instance.__init__(servers_list=servers_data)
 
@@ -345,7 +456,7 @@ class MCPConfig(BaseModel):
             #         PrintStyle(background_color="grey", font_color="red", padding=True).print(
             #             f"MCPConfig.update: Failed to create MCPServer from item '{server_item_data.get('name', 'Unknown')}': {e_init}"
             #         )
-            
+
             cls.__initialized = True
             return instance
 
@@ -368,21 +479,23 @@ class MCPConfig(BaseModel):
                         if isinstance(server, dict):
                             normalized.append(server)
             else:
-                normalized.append(servers) # single server?
+                normalized.append(servers)  # single server?
         return normalized
-            
 
     def __init__(self, servers_list: List[Dict[str, Any]]):
         from collections.abc import Mapping, Iterable
 
         # DEBUG: Print the received servers_list
-        if servers_list: PrintStyle(background_color="blue", font_color="white", padding=True).print(f"MCPConfig.__init__ received servers_list: {servers_list}")
+        if servers_list:
+            PrintStyle(background_color="blue", font_color="white", padding=True).print(
+                f"MCPConfig.__init__ received servers_list: {servers_list}"
+            )
 
         # This empties the servers list if MCPConfig is a Pydantic model and servers is a field.
-        # If servers is a field like `servers: List[MCPServer] = Field(default_factory=list)`, 
+        # If servers is a field like `servers: List[MCPServer] = Field(default_factory=list)`,
         # then super().__init__() might try to initialize it.
         # We are re-assigning self.servers later in this __init__.
-        super().__init__() 
+        super().__init__()
 
         # Clear any servers potentially initialized by super().__init__() before we populate based on servers_list
         self.servers = []
@@ -391,8 +504,9 @@ class MCPConfig(BaseModel):
 
         if not isinstance(servers_list, Iterable):
             (
-                PrintStyle(background_color="grey", font_color="red", padding=True)
-                .print("MCPConfig::__init__::servers_list must be a list")
+                PrintStyle(
+                    background_color="grey", font_color="red", padding=True
+                ).print("MCPConfig::__init__::servers_list must be a list")
             )
             return
 
@@ -401,15 +515,22 @@ class MCPConfig(BaseModel):
                 # log the error
                 error_msg = "server_item must be a mapping"
                 (
-                    PrintStyle(background_color="grey", font_color="red", padding=True)
-                    .print(f"MCPConfig::__init__::{error_msg}")
+                    PrintStyle(
+                        background_color="grey", font_color="red", padding=True
+                    ).print(f"MCPConfig::__init__::{error_msg}")
                 )
                 # add to failed servers with generic name
-                self.disconnected_servers.append({
-                    "config": server_item if isinstance(server_item, dict) else {"raw": str(server_item)},
-                    "error": error_msg,
-                    "name": "invalid_server_config"
-                })
+                self.disconnected_servers.append(
+                    {
+                        "config": (
+                            server_item
+                            if isinstance(server_item, dict)
+                            else {"raw": str(server_item)}
+                        ),
+                        "error": error_msg,
+                        "name": "invalid_server_config",
+                    }
+                )
                 continue
 
             if server_item.get("disabled", False):
@@ -418,13 +539,15 @@ class MCPConfig(BaseModel):
                 # normalize server name if it exists
                 if server_name != "unnamed_server":
                     server_name = normalize_name(server_name)
-                
+
                 # add to failed servers
-                self.disconnected_servers.append({
-                    "config": server_item,
-                    "error": "Disabled in config",
-                    "name": server_name
-                })
+                self.disconnected_servers.append(
+                    {
+                        "config": server_item,
+                        "error": "Disabled in config",
+                        "name": server_name,
+                    }
+                )
                 continue
 
             server_name = server_item.get("name", "__not__found__")
@@ -432,15 +555,18 @@ class MCPConfig(BaseModel):
                 # log the error
                 error_msg = "server_name is required"
                 (
-                    PrintStyle(background_color="grey", font_color="red", padding=True)
-                    .print(f"MCPConfig::__init__::{error_msg}")
+                    PrintStyle(
+                        background_color="grey", font_color="red", padding=True
+                    ).print(f"MCPConfig::__init__::{error_msg}")
                 )
                 # add to failed servers
-                self.disconnected_servers.append({
-                    "config": server_item,
-                    "error": error_msg,
-                    "name": "unnamed_server"
-                })
+                self.disconnected_servers.append(
+                    {
+                        "config": server_item,
+                        "error": error_msg,
+                        "name": "unnamed_server",
+                    }
+                )
                 continue
 
             try:
@@ -453,15 +579,23 @@ class MCPConfig(BaseModel):
                 # log the error
                 error_msg = str(e)
                 (
-                    PrintStyle(background_color="grey", font_color="red", padding=True)
-                    .print(f"MCPConfig::__init__: Failed to create MCPServer '{server_name}': {error_msg}")
+                    PrintStyle(
+                        background_color="grey", font_color="red", padding=True
+                    ).print(
+                        f"MCPConfig::__init__: Failed to create MCPServer '{server_name}': {error_msg}"
+                    )
                 )
                 # add to failed servers
-                self.disconnected_servers.append({
-                    "config": server_item,
-                    "error": error_msg,
-                    "name": server_name
-                })
+                self.disconnected_servers.append(
+                    {"config": server_item, "error": error_msg, "name": server_name}
+                )
+
+    def get_server_log(self, server_name: str) -> str:
+        with self.__lock:
+            for server in self.servers:
+                if server.name == server_name:
+                    return server.get_log() # type: ignore
+            return ""
 
     def get_servers_status(self) -> list[dict[str, Any]]:
         """Get status of all servers"""
@@ -474,29 +608,33 @@ class MCPConfig(BaseModel):
                 # get tool count
                 tool_count = len(server.get_tools())
                 # check if server is connected
-                connected = tool_count > 0
+                connected = True # tool_count > 0
                 # get error message if any
-                error = ""
-                
+                error = server.get_error()
+
                 # add server status to result
-                result.append({
-                    "name": name,
-                    "connected": connected,
-                    "error": error,
-                    "tool_count": tool_count
-                })
-            
+                result.append(
+                    {
+                        "name": name,
+                        "connected": connected,
+                        "error": error,
+                        "tool_count": tool_count,
+                    }
+                )
+
             # add failed servers
             for disconnected in self.disconnected_servers:
-                result.append({
-                    "name": disconnected["name"],
-                    "connected": False,
-                    "error": disconnected["error"],
-                    "tool_count": 0
-                })
-                
+                result.append(
+                    {
+                        "name": disconnected["name"],
+                        "connected": False,
+                        "error": disconnected["error"],
+                        "tool_count": 0,
+                    }
+                )
+
         return result
-                        
+
     def is_initialized(self) -> bool:
         """Check if the client is initialized"""
         with self.__lock:
@@ -541,7 +679,7 @@ class MCPConfig(BaseModel):
                     if "input_schema" in tool and "properties" in tool["input_schema"]:
                         properties: dict[str, Any] = tool["input_schema"]["properties"]
                         for key, value in properties.items():
-                            tool_args += f"            \"{key}\": \"...\",\n"
+                            tool_args += f'            "{key}": "...",\n'
                             examples = ""
                             description = ""
                             if "examples" in value:
@@ -557,11 +695,11 @@ class MCPConfig(BaseModel):
                         f"#### Usage:\n"
                         f"~~~json\n"
                         f"{{\n"
-                        f"    \"observations\": [\"...\"],\n"
-                        f"    \"thoughts\": [\"...\"],\n"
-                        f"    \"reflection\": [\"...\"],\n"
+                        f'    "observations": ["..."],\n'
+                        f'    "thoughts": ["..."],\n'
+                        f'    "reflection": ["..."],\n'
                         f"    \"tool_name\": \"{server_name}.{tool['name']}\",\n"
-                        f"    \"tool_args\": {{\n"
+                        f'    "tool_args": {{\n'
                         f"{tool_args}"
                         f"    }}\n"
                         f"}}\n"
@@ -586,7 +724,9 @@ class MCPConfig(BaseModel):
             return None
         return MCPTool(agent=agent, name=tool_name, method=None, args={}, message="")
 
-    async def call_tool(self, tool_name: str, input_data: Dict[str, Any]) -> CallToolResult:
+    async def call_tool(
+        self, tool_name: str, input_data: Dict[str, Any]
+    ) -> CallToolResult:
         """Call a tool with the given input data"""
         if "." not in tool_name:
             raise ValueError(f"Tool {tool_name} not found")
@@ -598,7 +738,8 @@ class MCPConfig(BaseModel):
             raise ValueError(f"Tool {tool_name} not found")
 
 
-T = TypeVar('T')
+T = TypeVar("T")
+
 
 class MCPClientBase(ABC):
     # server: Union[MCPServerLocal, MCPServerRemote] # Defined in __init__
@@ -609,81 +750,117 @@ class MCPClientBase(ABC):
 
     def __init__(self, server: Union[MCPServerLocal, MCPServerRemote]):
         self.server = server
-        self.tools: List[dict[str, Any]] = [] # Tools are cached on the client instance
+        self.tools: List[dict[str, Any]] = []  # Tools are cached on the client instance
+        self.error: str = ""
+        self.log: List[str] = []
 
     # Protected method
     @abstractmethod
-    async def _create_stdio_transport(self, current_exit_stack: AsyncExitStack) -> tuple[MemoryObjectReceiveStream[JSONRPCMessage | Exception], MemoryObjectSendStream[JSONRPCMessage]]:
+    async def _create_stdio_transport(
+        self, current_exit_stack: AsyncExitStack
+    ) -> tuple[
+        MemoryObjectReceiveStream[SessionMessage | Exception],
+        MemoryObjectSendStream[SessionMessage],
+    ]:
         """Create stdio/write streams using the provided exit_stack."""
         ...
 
-    async def _execute_with_session(self, coro_func: Callable[[ClientSession], Awaitable[T]]) -> T:
+    async def _execute_with_session(
+        self,
+        coro_func: Callable[[ClientSession], Awaitable[T]],
+        read_timeout_seconds=60,
+    ) -> T:
         """
         Manages the lifecycle of an MCP session for a single operation.
         Creates a temporary session, executes coro_func with it, and ensures cleanup.
         """
-        operation_name = coro_func.__name__ # For logging
+        operation_name = coro_func.__name__  # For logging
         # PrintStyle(font_color="cyan").print(f"MCPClientBase ({self.server.name}): Creating new session for operation '{operation_name}'...")
-        async with AsyncExitStack() as temp_stack:
-            try:
-                stdio, write = await self._create_stdio_transport(temp_stack)
-                # PrintStyle(font_color="cyan").print(f"MCPClientBase ({self.server.name} - {operation_name}): Transport created. Initializing session...")
-                session = await temp_stack.enter_async_context(
-                    ClientSession(
-                        stdio,
-                        write,
-                        read_timeout_seconds=timedelta(seconds=600)
-                    )
-                )
+        # Store the original exception outside the async block
+        original_exception = None
+        try:
+            async with AsyncExitStack() as temp_stack:
                 try:
-                    # Add timeout to session.initialize
-                    await asyncio.wait_for(session.initialize(), timeout=10)
-                except Exception as e:
-                    PrintStyle(background_color="#AA4455", font_color="white", padding=False).print(
-                        f"MCPClientBase ({self.server.name} - {operation_name}): Session initialization failed: {type(e).__name__}: {e}"
+                    async def log_callback(params):
+                        msg = getattr(params, "message", str(params))
+                        self.log.append(f"[{self.server.name}] [session]: {msg}")
+
+                    stdio, write = await self._create_stdio_transport(temp_stack)
+                    # PrintStyle(font_color="cyan").print(f"MCPClientBase ({self.server.name} - {operation_name}): Transport created. Initializing session...")
+                    session = await temp_stack.enter_async_context(
+                        ClientSession(
+                            stdio,  # type: ignore
+                            write,  # type: ignore
+                            read_timeout_seconds=timedelta(seconds=read_timeout_seconds),
+                            # logging_callback=log_callback,
+                        )
                     )
-                    raise
-                # PrintStyle(font_color="green").print(f"MCPClientBase ({self.server.name} - {operation_name}): Session initialized.")
-                
-                result = await coro_func(session)
-                
-                # PrintStyle(font_color="green").print(f"MCPClientBase ({self.server.name} - {operation_name}): Operation successful.")
-                return result
-            except Exception as e:
-                PrintStyle(background_color="#AA4455", font_color="white", padding=False).print(
-                    f"MCPClientBase ({self.server.name} - {operation_name}): Error during operation: {type(e).__name__}: {e}"
-                )
-                raise # Re-raise the exception to be handled by the caller of update_tools/call_tool
-            finally:
-                PrintStyle(font_color="cyan").print(
-                    f"MCPClientBase ({self.server.name} - {operation_name}): Session and transport will be closed by AsyncExitStack."
-                )
+                    await session.initialize()
+                    # PrintStyle(font_color="green").print(f"MCPClientBase ({self.server.name} - {operation_name}): Session initialized.")
+
+                    result = await coro_func(session)
+
+                    # PrintStyle(font_color="green").print(f"MCPClientBase ({self.server.name} - {operation_name}): Operation successful.")
+                    return result
+                except Exception as e:
+                    # Store the original exception and raise a dummy exception
+                    original_exception = e
+                    # Create a dummy exception to break out of the async block
+                    raise RuntimeError("Dummy exception to break out of async block")
+        except Exception as e:
+            # Check if this is our dummy exception
+            if original_exception is not None:
+                e = original_exception
+            # We have the original exception stored
+            PrintStyle(
+                background_color="#AA4455", font_color="white", padding=False
+            ).print(
+                f"MCPClientBase ({self.server.name} - {operation_name}): Error during operation: {type(e).__name__}: {e}"
+            )
+            raise e  # Re-raise the original exception
+        finally:
+            PrintStyle(font_color="cyan").print(
+                f"MCPClientBase ({self.server.name} - {operation_name}): Session and transport will be closed by AsyncExitStack."
+            )
         # This line should ideally be unreachable if the try/except/finally logic within the 'async with' is exhaustive.
         # Adding it to satisfy linters that might not fully trace the raise/return paths through async context managers.
-        raise RuntimeError(f"MCPClientBase ({self.server.name} - {operation_name}): _execute_with_session exited 'async with' block unexpectedly.")
+        raise RuntimeError(
+            f"MCPClientBase ({self.server.name} - {operation_name}): _execute_with_session exited 'async with' block unexpectedly."
+        )
 
     async def update_tools(self) -> "MCPClientBase":
         # PrintStyle(font_color="cyan").print(f"MCPClientBase ({self.server.name}): Starting 'update_tools' operation...")
-        
+
         async def list_tools_op(current_session: ClientSession):
             response: ListToolsResult = await current_session.list_tools()
-            with self.__lock: 
-                self.tools = [{                             
-                    "name": tool.name,
-                    "description": tool.description,
-                    "input_schema": tool.inputSchema
-                } for tool in response.tools]
-            PrintStyle(font_color="green").print(f"MCPClientBase ({self.server.name}): Tools updated. Found {len(self.tools)} tools.")
+            with self.__lock:
+                self.tools = [
+                    {
+                        "name": tool.name,
+                        "description": tool.description,
+                        "input_schema": tool.inputSchema,
+                    }
+                    for tool in response.tools
+                ]
+            PrintStyle(font_color="green").print(
+                f"MCPClientBase ({self.server.name}): Tools updated. Found {len(self.tools)} tools."
+            )
 
         try:
-            await self._execute_with_session(list_tools_op)
+            set = settings.get_settings()
+            await self._execute_with_session(list_tools_op, read_timeout_seconds=set["mcp_client_init_timeout"])
         except Exception as e:
+            # e = eg.exceptions[0]
+            error_text = errors.format_error(e, 0, 0)
             # Error already logged by _execute_with_session, this is for specific handling if needed
-            PrintStyle(background_color="#CC34C3", font_color="white", bold=True, padding=True).print(
-                f"MCPClientBase ({self.server.name}): 'update_tools' operation failed: {e}"
+            PrintStyle(
+                background_color="#CC34C3", font_color="white", bold=True, padding=True
+            ).print(
+                f"MCPClientBase ({self.server.name}): 'update_tools' operation failed: {error_text}"
             )
             with self.__lock:
-                self.tools = [] # Ensure tools are cleared on failure
+                self.tools = []  # Ensure tools are cleared on failure
+                self.error = f"Failed to initialize. {error_text}"  # store error from tools fetch
         return self
 
     def has_tool(self, tool_name: str) -> bool:
@@ -699,19 +876,32 @@ class MCPClientBase(ABC):
         with self.__lock:
             return self.tools
 
-    async def call_tool(self, tool_name: str, input_data: Dict[str, Any]) -> CallToolResult:
+    async def call_tool(
+        self, tool_name: str, input_data: Dict[str, Any]
+    ) -> CallToolResult:
         # PrintStyle(font_color="cyan").print(f"MCPClientBase ({self.server.name}): Preparing for 'call_tool' operation for tool '{tool_name}'.")
         if not self.has_tool(tool_name):
-            PrintStyle(font_color="orange").print(f"MCPClientBase ({self.server.name}): Tool '{tool_name}' not in cache for 'call_tool', refreshing tools...")
-            await self.update_tools() # This will use its own properly managed session
+            PrintStyle(font_color="orange").print(
+                f"MCPClientBase ({self.server.name}): Tool '{tool_name}' not in cache for 'call_tool', refreshing tools..."
+            )
+            await self.update_tools()  # This will use its own properly managed session
             if not self.has_tool(tool_name):
-                PrintStyle(font_color="red").print(f"MCPClientBase ({self.server.name}): Tool '{tool_name}' not found after refresh. Raising ValueError.")
-                raise ValueError(f"Tool {tool_name} not found after refreshing tool list for server {self.server.name}.")
-            PrintStyle(font_color="green").print(f"MCPClientBase ({self.server.name}): Tool '{tool_name}' found after updating tools.")
+                PrintStyle(font_color="red").print(
+                    f"MCPClientBase ({self.server.name}): Tool '{tool_name}' not found after refresh. Raising ValueError."
+                )
+                raise ValueError(
+                    f"Tool {tool_name} not found after refreshing tool list for server {self.server.name}."
+                )
+            PrintStyle(font_color="green").print(
+                f"MCPClientBase ({self.server.name}): Tool '{tool_name}' found after updating tools."
+            )
 
         async def call_tool_op(current_session: ClientSession):
+            set = settings.get_settings()
             # PrintStyle(font_color="cyan").print(f"MCPClientBase ({self.server.name}): Executing 'call_tool' for '{tool_name}' via MCP session...")
-            response: CallToolResult = await current_session.call_tool(tool_name, input_data)
+            response: CallToolResult = await current_session.call_tool(
+                tool_name, input_data, read_timeout_seconds=timedelta(seconds=set["mcp_client_tool_timeout"])
+            )
             # PrintStyle(font_color="green").print(f"MCPClientBase ({self.server.name}): Tool '{tool_name}' call successful via session.")
             return response
 
@@ -719,36 +909,92 @@ class MCPClientBase(ABC):
             return await self._execute_with_session(call_tool_op)
         except Exception as e:
             # Error logged by _execute_with_session. Re-raise a specific error for the caller.
-            PrintStyle(background_color="#AA4455", font_color="white", padding=True).print(
+            PrintStyle(
+                background_color="#AA4455", font_color="white", padding=True
+            ).print(
                 f"MCPClientBase ({self.server.name}): 'call_tool' operation for '{tool_name}' failed: {type(e).__name__}: {e}"
             )
-            raise ConnectionError(f"MCPClientBase::Failed to call tool '{tool_name}' on server '{self.server.name}'. Original error: {type(e).__name__}: {e}")
+            raise ConnectionError(
+                f"MCPClientBase::Failed to call tool '{tool_name}' on server '{self.server.name}'. Original error: {type(e).__name__}: {e}"
+            )
 
 
 class MCPClientLocal(MCPClientBase):
-    async def _create_stdio_transport(self, current_exit_stack: AsyncExitStack) -> tuple[MemoryObjectReceiveStream[JSONRPCMessage | Exception], MemoryObjectSendStream[JSONRPCMessage]]:
+    def get_log(self):
+        # read and return lines from self.log_file, do not close it
+        if not hasattr(self, 'log_file') or self.log_file is None:
+            return ""
+        self.log_file.seek(0)
+        try:
+            log = self.log_file.read()
+        except Exception:
+            log = ""
+        return log
+
+    def __del__(self):
+        # close the log file if it exists
+        if hasattr(self, 'log_file') and self.log_file is not None:
+            try:
+                self.log_file.close()
+            except Exception:
+                pass
+            self.log_file = None
+
+    async def _create_stdio_transport(
+        self, current_exit_stack: AsyncExitStack
+    ) -> tuple[
+        MemoryObjectReceiveStream[SessionMessage | Exception],
+        MemoryObjectSendStream[SessionMessage],
+    ]:
         """Connect to an MCP server, init client and save stdio/write streams"""
         server: MCPServerLocal = cast(MCPServerLocal, self.server)
 
+        if not server.command:
+            raise ValueError("Command not specified")
         if not which(server.command):
-            raise ValueError(f"Command {server.command} not found")
+            raise ValueError(f"Command '{server.command}' not found")
 
         server_params = StdioServerParameters(
             command=server.command,
             args=server.args,
             env=server.env,
             encoding=server.encoding,
-            encoding_error_handler=server.encoding_error_handler
+            encoding_error_handler=server.encoding_error_handler,
         )
-        stdio_transport = await current_exit_stack.enter_async_context(stdio_client(server_params))
+        # create a custom error log handler that will capture error output
+        import tempfile
+
+        # use a temporary file for error logging (text mode) if not already present
+        if not hasattr(self, 'log_file') or self.log_file is None:
+            self.log_file = tempfile.TemporaryFile(mode="w+", encoding="utf-8")
+
+        # use the stdio_client with our error log file
+        stdio_transport = await current_exit_stack.enter_async_context(
+            stdio_client(server_params, errlog=self.log_file)
+        )
+        # do not read or close the file here, as stdio is async
         return stdio_transport
 
 
 class MCPClientRemote(MCPClientBase):
-    async def _create_stdio_transport(self, current_exit_stack: AsyncExitStack) -> tuple[MemoryObjectReceiveStream[JSONRPCMessage | Exception], MemoryObjectSendStream[JSONRPCMessage]]:
+
+    def get_log(self):
+        return "Logging not implemented for remote servers yet"
+
+    async def _create_stdio_transport(
+        self, current_exit_stack: AsyncExitStack
+    ) -> tuple[
+        MemoryObjectReceiveStream[SessionMessage | Exception],
+        MemoryObjectSendStream[SessionMessage],
+    ]:
         """Connect to an MCP server, init client and save stdio/write streams"""
         server: MCPServerRemote = cast(MCPServerRemote, self.server)
         stdio_transport = await current_exit_stack.enter_async_context(
-            sse_client(url=server.url, headers=server.headers, timeout=server.timeout, sse_read_timeout=server.sse_read_timeout)
+            sse_client(
+                url=server.url,
+                headers=server.headers,
+                timeout=server.timeout,
+                sse_read_timeout=server.sse_read_timeout,
+            )
         )
         return stdio_transport

python/helpers/settings.py

@@ -44,7 +44,6 @@ class Settings(TypedDict):
     agent_prompts_subdir: str
     agent_memory_subdir: str
     agent_knowledge_subdir: str
-    mcp_servers: str
 
     api_keys: dict[str, str]
 
@@ -64,6 +63,9 @@ class Settings(TypedDict):
     stt_silence_duration: int
     stt_waiting_timeout: int
 
+    mcp_servers: str
+    mcp_client_init_timeout: int
+    mcp_client_tool_timeout: int
     mcp_server_enabled: bool
 
 
@@ -706,6 +708,26 @@ def convert_out(settings: Settings) -> SettingsOutput:
         }
     )
 
+    mcp_client_fields.append(
+        {
+            "id": "mcp_client_init_timeout",
+            "title": "MCP Client Init Timeout",
+            "description": "Timeout for MCP client initialization (in seconds). Higher values might be required for complex MCPs, but might also slowdown system startup.",
+            "type": "number",
+            "value": settings["mcp_client_init_timeout"],
+        }
+    )
+
+    mcp_client_fields.append(
+        {
+            "id": "mcp_client_tool_timeout",
+            "title": "MCP Client Tool Timeout",
+            "description": "Timeout for MCP client tool execution. Higher values might be required for complex tools, but might also result in long responses with failing tools.",
+            "type": "number",
+            "value": settings["mcp_client_tool_timeout"],
+        }
+    )
+
     mcp_client_section: SettingsSection = {
         "id": "mcp_client",
         "title": "External MCP Servers",
@@ -913,6 +935,8 @@ def get_default_settings() -> Settings:
         stt_silence_duration=1000,
         stt_waiting_timeout=2000,
         mcp_servers='{\n    "mcpServers": {}\n}',
+        mcp_client_init_timeout=5,
+        mcp_client_tool_timeout=120,
         mcp_server_enabled=False,
     )
 

webui/components/settings/mcp/client/mcp-servers-log.html

@@ -0,0 +1,34 @@
+<html>
+
+<head>
+    <title>MCP Server Log</title>
+
+    <script type="module">
+        import { store } from "/components/settings/mcp/client/mcp-servers-store.js";
+    </script>
+</head>
+
+<body>
+    <div x-data>
+        <template x-if="$store.mcpServersStore">
+            <div id="mcp-servers-log">
+                <p x-text="$store.mcpServersStore.serverLog && $store.mcpServersStore.serverLog.trim() ? $store.mcpServersStore.serverLog : 'Log empty'"></p>
+            </div>
+        </template>
+    </div>
+
+    <style>
+        #mcp-servers-log {
+            width: 100%;
+        }
+
+        #mcp-servers-log p {
+            font-family: "SFMono-Regular", Consolas, "Liberation Mono", Menlo, Courier, monospace;
+            font-size: 0.8em;
+            white-space: pre-wrap;
+        }
+    </style>
+
+</body>
+
+</html>

webui/components/settings/mcp/client/mcp-servers-store.js

@@ -8,6 +8,7 @@ const model = {
   servers: [],
   loading: false,
   statusCheck: false,
+  serverLog: "",
 
   async initialize() {
     // Initialize the JSON Viewer after the modal is rendered
@@ -104,6 +105,17 @@ const model = {
     }
     this.loading = false;
   },
+
+  async getServerLog(serverName) {
+    this.serverLog = "";
+    const resp = await API.callJsonApi("mcp_server_get_log", {
+      server_name: serverName,
+    });
+    if (resp.success) {
+      this.serverLog = resp.log;
+      openModal("settings/mcp/client/mcp-servers-log.html")
+    }
+  },
 };
 
 const store = createStore("mcpServersStore", model);

webui/components/settings/mcp/client/mcp-servers.html

@@ -26,21 +26,24 @@
                 <div class="server-list">
                     <template x-for="server in $store.mcpServersStore.servers" :key="server.name">
                         <div class="server-item">
-                            <div class="status-icon" style="margin-right: 0.5em;" x-data="{ connected: server.connected }">
+                            <div class="status-icon" style="margin-right: 0.5em;"
+                                x-data="{ connected: server.connected }">
                                 <svg viewBox="0 0 30 30">
-                                    <!-- Connected State (filled circle) -->
-                                    <circle class="connected-circle" cx="15" cy="15" r="8"
-                                        x-bind:fill="server.connected ? '#00c340' : 'none'" x-bind:opacity="server.connected ? 1 : 0" />
+                                    <!-- Connected State (filled circle, green or orange) -->
+                                    <circle x-bind:class="server.error ? 'disconnected-circle' : 'connected-circle'" cx="15" cy="15" r="8" x-bind:fill="server.connected 
+                                        ? (server.error ? '#e40138' : (server.tool_count === 0 ? '#e40138' : '#00c340')) 
+                                        : 'none'" x-bind:opacity="server.connected ? 1 : 0" />
 
                                     <!-- Disconnected State (outline circle) -->
-                                    <circle class="disconnected-circle" cx="15" cy="15" r="9" fill="none" stroke="#e40138"
-                                        stroke-width="3" x-bind:opacity="server.connected ? 0 : 1" />
+                                    <circle x-bind:class="server.error ? 'disconnected-circle' : 'connected-circle'" cx="15" cy="15" r="9" fill="none"
+                                        stroke="#e40138" stroke-width="3" x-bind:opacity="server.connected ? 0 : 1" />
                                 </svg>
                             </div>
                             <span class="server-name" x-text="server.name"></span>
                             <span class="server-tools"
                                 x-text="'- ' + (server.tool_count ? server.tool_count : 0) + ' tools'"></span>
                             <span class="server-error" x-show="server.error" x-text="server.error"></span>
+                            <span class="server-links"><a href="#" @click="$store.mcpServersStore.getServerLog(server.name)">View Log</a></span>
                         </div>
                     </template>
                     <div x-show="$store.mcpServersStore.servers.length === 0" class="no-servers">
@@ -107,12 +110,16 @@
             color: var(--c-fg2);
             font-style: italic;
         }
-        
+
         .server-error {
             color: #F44336;
             font-size: 0.9em;
             margin-left: 0.8em;
         }
+
+        .server-links {
+            margin-left: 0.8em;
+        }
     </style>
 
 </body>

webui/js/modals.js

@@ -1,7 +1,6 @@
 // Import the component loader and page utilities
 import { importComponent } from "/js/components.js";
 
-
 // Modal functionality
 const modalStack = [];
 
@@ -64,6 +63,7 @@ function createModalElement(name) {
     }
   });
 
+
   // Create modal structure
   newModal.innerHTML = `
     <div class="modal-inner">
@@ -77,6 +77,11 @@ function createModalElement(name) {
     </div>
   `;
 
+  // Setup close button handler for this specific modal
+  const close_button = newModal.querySelector(".modal-close");
+  close_button.addEventListener("click", () => closeModal());
+
+
   // Add modal to DOM
   document.body.appendChild(newModal);
 
@@ -90,7 +95,7 @@ function createModalElement(name) {
     element: newModal,
     title: newModal.querySelector(".modal-title"),
     body: newModal.querySelector(".modal-bd"),
-    close: newModal.querySelector(".modal-close"),
+    close: close_button,
     styles: [],
     scripts: [],
   };
@@ -113,9 +118,6 @@ export function openModal(modalPath) {
 
       // Already added to stack above
 
-      // Setup close button handler for this specific modal
-      modal.close.addEventListener("click", () => closeModal());
-
       // Use importComponent to load the modal content
       // This handles all HTML, styles, scripts and nested components
       // Updated path to use the new folder structure with modal.html
@@ -140,9 +142,6 @@ export function openModal(modalPath) {
 
       // Update modal z-indexes
       updateModalZIndexes();
-
-      // Setup close button handler for this specific modal
-      modal.close.addEventListener("click", () => closeModal());
     } catch (error) {
       console.error("Error loading modal content:", error);
       resolve();
@@ -151,7 +150,7 @@ export function openModal(modalPath) {
 }
 
 // Function to close modal
-export function closeModal(modalName=null) {
+export function closeModal(modalName = null) {
   if (modalStack.length === 0) return;
 
   let modalIndex = modalStack.length - 1; // Default to last modal