Fix MCP tool_resolver asyncio.run() coroutine thread affinity crash - #6879

#!/bin/bash
set -e
printf '%s\n' '--- candidate files ---'
git ls-files | rg '(^|/)(test_tool_resolver_native\.py|tool_resolver\.py)$'
printf '%s\n' '--- resolver symbols ---'
rg -n --glob '*.py' 'def _resolve_native|new_loop|run_until_complete|asyncio\.run|connected|disconnect' lib/crewai lib 2>/dev/null | head -240
printf '%s\n' '--- test file outline ---'
ast-grep outline lib/crewai/tests/mcp/test_tool_resolver_native.py
printf '%s\n' '--- test file size ---'
wc -l lib/crewai/tests/mcp/test_tool_resolver_native.py

#!/bin/bash
set -e
printf '%s\n' '--- tool_resolver.py 300-490 ---'
cat -n lib/crewai/src/crewai/mcp/tool_resolver.py | sed -n '300,490p'
printf '%s\n' '--- test_tool_resolver_native.py 1-180 ---'
cat -n lib/crewai/tests/mcp/test_tool_resolver_native.py | sed -n '1,180p'
printf '%s\n' '--- related MCP client methods ---'
cat -n lib/crewai/src/crewai/mcp/client.py | sed -n '80,125p;140,230p;350,380p'

#!/bin/bash
set -e
python3 - <<'PY'
import asyncio
import threading

events = []

class FakeClient:
    def __init__(self):
        self.connected = False
        self.disconnect_calls = 0

    async def connect(self):
        events.append(("connect", threading.current_thread().name))
        self.connected = True

    async def list_tools(self):
        events.append(("list_tools", threading.current_thread().name))
        raise RuntimeError("discovery failed")

    async def disconnect(self):
        self.disconnect_calls += 1
        events.append(("disconnect", self.disconnect_calls, threading.current_thread().name))
        if self.disconnect_calls == 1:
            raise RuntimeError("disconnect failed")
        self.connected = False

def resolve_like_source():
    client = FakeClient()

    async def setup():
        try:
            if not client.connected:
                await client.connect()
            await client.list_tools()
        except Exception as exc:
            if client.connected:
                # Matches the resolver's inner cleanup path.
                await client.disconnect()
            raise RuntimeError(f"Error during setup client and list tools: {exc}") from exc

    try:
        # Matches the resolver's active-loop executor path.
        with __import__("concurrent.futures").futures.ThreadPoolExecutor() as executor:
            executor.submit(asyncio.run, setup()).result()
    except Exception as exc:
        events.append(("outer_exception", type(exc).__name__, str(exc)))
        if client.connected:
            try:
                asyncio.get_running_loop()
                new_loop = asyncio.new_event_loop()
                try:
                    new_loop.run_until_complete(client.disconnect())
                finally:
                    new_loop.close()
            except RuntimeError as cleanup_exc:
                events.append(("cleanup_fallback", type(cleanup_exc).__name__, str(cleanup_exc)))
                # Matches the resolver's fallback.
                asyncio.run(client.disconnect())
        raise RuntimeError(f"Failed to get native MCP tools: {exc}") from exc

async def main():
    try:
        resolve_like_source()
    except Exception as exc:
        print("raised:", type(exc).__name__, str(exc))
        print("cause:", type(exc.__cause__).__name__, str(exc.__cause__))
    print("events:", events)

asyncio.run(main())
PY