Fix dynamic actions loading by implementing lazy async initialization

Co-authored-by: Matanga1-2 <24847398+Matanga1-2@users.noreply.github.com>

Author: Copilot

src/models/tools/tool_map.py

@@ -13,17 +13,42 @@
 class ToolMap:
     port_client: PortClient
     tools: dict[str, Tool] = field(default_factory=dict)
+    _dynamic_tools_loaded: bool = field(default=False, init=False)
 
     def __post_init__(self):
         # Register static tools
         for tool in mcp_tools.__all__:
             module = mcp_tools.__dict__[tool]
             self.register_tool(module(self.port_client))
         logger.info(f"ToolMap initialized with {len(self.tools)} static tools")
-        self._register_dynamic_action_tools()
+        # Don't load dynamic tools here - they'll be loaded lazily when needed
+
+    async def ensure_dynamic_tools_loaded(self) -> None:
+        """Ensure dynamic action tools are loaded (async version)."""
+        if self._dynamic_tools_loaded:
+            return
+            
+        try:
+            logger.info("Loading dynamic action tools asynchronously...")
+            dynamic_manager = DynamicActionToolsManager(self.port_client)
+            dynamic_tools = await dynamic_manager.get_dynamic_action_tools()
+
+            for tool in dynamic_tools:
+                self.register_tool(tool)
+
+            logger.info(f"Successfully registered {len(dynamic_tools)} dynamic action tools")
+            if len(dynamic_tools) == 0:
+                logger.warning("No dynamic action tools were registered - this may indicate a configuration or network issue")
+                
+            self._dynamic_tools_loaded = True
+        except Exception as e:
+            logger.error(f"Failed to register dynamic action tools: {e}")
+            logger.exception("Full traceback for dynamic action tools registration failure:")
+            # Mark as loaded even if failed to avoid repeated attempts
+            self._dynamic_tools_loaded = True
 
     def _register_dynamic_action_tools(self) -> None:
-        """Register dynamic tools for each Port action."""
+        """Register dynamic tools for each Port action (legacy sync version)."""
         try:
             logger.info("Starting dynamic action tools registration...")
             dynamic_manager = DynamicActionToolsManager(self.port_client)

src/server.py

@@ -28,13 +28,17 @@ def main():
         @mcp.call_tool()
         async def call_tool(tool_name: str, arguments: dict[str, Any]):
             tool_map = get_tool_map()
+            # Ensure dynamic tools are loaded before calling
+            await tool_map.ensure_dynamic_tools_loaded()
             tool = tool_map.get_tool(tool_name)
             logger.debug(f"Calling tool: {tool_name} with arguments: {arguments}")
             return await execute_tool(tool, arguments)
 
         @mcp.list_tools()
         async def list_tools() -> list[types.Tool]:
             tool_map = get_tool_map()
+            # Ensure dynamic tools are loaded before listing
+            await tool_map.ensure_dynamic_tools_loaded()
             return tool_map.list_tools()
 
         # Run the server

src/tools/action/dynamic_actions.py

@@ -143,17 +143,21 @@ async def get_dynamic_action_tools(self) -> list[Tool]:
         return tools
 
     def get_dynamic_action_tools_sync(self) -> list[Tool]:
-        """Synchronous wrapper for getting dynamic action tools."""
+        """Synchronous wrapper for getting dynamic action tools (fallback only)."""
         try:
-            # First try the simple approach
-            return asyncio.run(self.get_dynamic_action_tools())
-        except RuntimeError as e:
-            if "asyncio.run() cannot be called from a running event loop" in str(e):
-                logger.warning("Cannot call asyncio.run from running event loop, skipping dynamic actions")
-                return []
-            else:
-                logger.error(f"Failed to run dynamic action tools sync: {e}")
+            # Check if we're already in an event loop
+            try:
+                asyncio.get_running_loop()
+                # We're in an event loop, this shouldn't happen with the new architecture
+                logger.warning("get_dynamic_action_tools_sync called from async context - this indicates a design issue")
+                logger.warning("Dynamic actions should be loaded via ensure_dynamic_tools_loaded() instead")
                 return []
+            except RuntimeError:
+                # No event loop running, use asyncio.run
+                logger.info("No event loop running, using asyncio.run for dynamic actions")
+                return asyncio.run(self.get_dynamic_action_tools())
+                
         except Exception as e:
             logger.error(f"Failed to run dynamic action tools sync: {e}")
+            logger.exception("Full traceback for dynamic action tools sync failure:")
             return []