[tool] fix: load MCP tools in async rollout mode (verl-project#2821)

### What does this PR do?

Currently, the tool registry isn't aware of an event loop already
existing, so it may fail when using the new async rollout architecture.
This PR allows `initialize_tools_from_config` to load MCP tools when
using the async architecture by spawning a new, temporary event loop in
a separate thread to load from config.

There is also a minor bugfix to `mcp_base_tool` which fixes a
possibility of concatenating a string to None.

NOTE: in the future, we should use async methods entirely, since this
fix is not the most elegant. This fix works for now as verl is
transitioning to a full async architecture.

### Checklist Before Starting

- [x] Search for similar PRs. Paste at least one query link here: ...
- [x] Format the PR title as `[{modules}] {type}: {description}` (This
will be checked by the CI)
- `{modules}` include `fsdp`, `megatron`, `sglang`, `vllm`, `rollout`,
`trainer`, `ci`, `training_utils`, `recipe`, `hardware`, `deployment`,
`ray`, `worker`, `single_controller`, `misc`, `perf`, `model`, `algo`,
`env`, `tool`, `ckpt`, `doc`, `data`
- If this PR involves multiple modules, separate them with `,` like
`[megatron, fsdp, doc]`
  - `{type}` is in `feat`, `fix`, `refactor`, `chore`, `test`
- If this PR breaks any API (CLI arguments, config, function signature,
etc.), add `[BREAKING]` to the beginning of the title.
  - Example: `[BREAKING][fsdp, megatron] feat: dynamic batching`

### Design & Code Changes

> Demonstrate the high-level design if this PR is complex, and list the
specific changes.

### Checklist Before Submitting

> [!IMPORTANT]
> Please check all the following items before requesting a review,
otherwise the reviewer might deprioritize this PR for review.

- [x] Read the [Contribute
Guide](https://github.com/volcengine/verl/blob/main/CONTRIBUTING.md).
- [x] Apply [pre-commit
checks](https://github.com/volcengine/verl/blob/main/CONTRIBUTING.md#code-linting-and-formatting):
`pre-commit install && pre-commit run --all-files --show-diff-on-failure
--color=always`
- [x] Add / Update [the
documentation](https://github.com/volcengine/verl/tree/main/docs).
- [x] Add unit or end-to-end test(s) to [the CI
workflow](https://github.com/volcengine/verl/tree/main/.github/workflows)
to cover all the code. If not feasible, explain why: ...
- [x] Once your PR is ready for CI, send a message in [the `ci-request`
channel](https://verl-project.slack.com/archives/C091TCESWB1) in [the
`verl` Slack
workspace](https://join.slack.com/t/verl-project/shared_invite/zt-3855yhg8g-CTkqXu~hKojPCmo7k_yXTQ).
(If not accessible, please try [the Feishu group
(飞书群)](https://applink.larkoffice.com/client/chat/chatter/add_by_link?link_token=772jd4f1-cd91-441e-a820-498c6614126a).)

Author: mathewjhan

verl/tools/mcp_base_tool.py

@@ -73,7 +73,7 @@ async def _call_tool(self, instance_id, parameters) -> tuple[str, dict]:
 
         logger.debug(f"Tool result for instance {instance_id} with tool {self.name}: {call_tool_result.content}")
         result, metadata = self._parse_tool_result(call_tool_result.content)
-        metadata["api_request_error"] += err_msg
+        metadata["api_request_error"] = None if not err_msg else err_msg
         return result, metadata
 
     @rollout_trace_op

verl/tools/utils/tool_registry.py

@@ -17,6 +17,7 @@
 import logging
 import os
 import sys
+import threading
 from enum import Enum
 
 from omegaconf import OmegaConf
@@ -81,27 +82,49 @@ def get_tool_class(cls_name):
 def initialize_tools_from_config(tools_config_file):
     tools_config = OmegaConf.load(tools_config_file)
     tool_list = []
-    for tool_config in tools_config.tools:
-        cls_name = tool_config.class_name
-        tool_type = ToolType(tool_config.config.type)
-        tool_cls = get_tool_class(cls_name)
-
-        match tool_type:
-            case ToolType.NATIVE:
-                if tool_config.get("tool_schema", None) is None:
-                    tool_schema = None
-                else:
-                    tool_schema_dict = OmegaConf.to_container(tool_config.tool_schema, resolve=True)
-                    tool_schema = OpenAIFunctionToolSchema.model_validate(tool_schema_dict)
-                tool = tool_cls(
-                    config=OmegaConf.to_container(tool_config.config, resolve=True),
-                    tool_schema=tool_schema,
-                )
-                tool_list.append(tool)
-            case ToolType.MCP:
-                loop = asyncio.get_event_loop()
-                mcp_tools = loop.run_until_complete(initialize_mcp_tool(tool_cls, tool_config))
-                tool_list.extend(mcp_tools)
-            case _:
-                raise NotImplementedError
+
+    # Use a temporary event loop in a new thread because event
+    # loop may already exist in new async architecture while retaining
+    # backwards compatibility
+    tmp_event_loop = asyncio.new_event_loop()
+    thread = threading.Thread(target=tmp_event_loop.run_forever, name="mcp tool list fetcher", daemon=True)
+
+    def run_coroutine(coroutine):
+        if not thread.is_alive():
+            thread.start()
+
+        future = asyncio.run_coroutine_threadsafe(coroutine, tmp_event_loop)
+        return future.result()
+
+    async def stop_loop():
+        tmp_event_loop.stop()
+
+    try:
+        for tool_config in tools_config.tools:
+            cls_name = tool_config.class_name
+            tool_type = ToolType(tool_config.config.type)
+            tool_cls = get_tool_class(cls_name)
+
+            match tool_type:
+                case ToolType.NATIVE:
+                    if tool_config.get("tool_schema", None) is None:
+                        tool_schema = None
+                    else:
+                        tool_schema_dict = OmegaConf.to_container(tool_config.tool_schema, resolve=True)
+                        tool_schema = OpenAIFunctionToolSchema.model_validate(tool_schema_dict)
+                    tool = tool_cls(
+                        config=OmegaConf.to_container(tool_config.config, resolve=True),
+                        tool_schema=tool_schema,
+                    )
+                    tool_list.append(tool)
+                case ToolType.MCP:
+                    mcp_tools = run_coroutine(initialize_mcp_tool(tool_cls, tool_config))
+                    tool_list.extend(mcp_tools)
+                case _:
+                    raise NotImplementedError
+    finally:
+        if thread.is_alive():
+            asyncio.run_coroutine_threadsafe(stop_loop(), tmp_event_loop)
+            thread.join()
+
     return tool_list