Your lightweight open-source personal agent.
Python agent-frameworkai-agentai-agentschatbotchatopsdiscord-botllm-agentsllmslocal-llmmcpmodel-context-protocolmulti-agentopenai-compatibleopenclawpersonal-ai-assistantpythonself-hostedtelegram-bot-ai-assistantwebuiworkflow-automation
fix: close MCP stdio transports from agent task
Xubin Renfbaa85117b4c
diff --git a/nanobot/agent/loop.py b/nanobot/agent/loop.pyindex 9b744e047..1d1de4ab4 100644--- a/nanobot/agent/loop.py+++ b/nanobot/agent/loop.py@@ -873,89 +873,93 @@ class AgentLoop:async def run(self) -> None:"""Run the agent loop, dispatching messages as tasks to stay responsive to /stop."""self._running = True- await self._connect_mcp()- logger.info("Agent loop started")+ try:+ await self._connect_mcp()+ logger.info("Agent loop started")- while self._running:- try:- msg = await asyncio.wait_for(self.bus.consume_inbound(), timeout=1.0)- except asyncio.TimeoutError:- self.auto_compact.check_expired(- self._schedule_background,- active_session_keys=self._pending_queues.keys(),- )- continue- except asyncio.CancelledError:- # Preserve real task cancellation so shutdown can complete cleanly.- # Only ignore non-task CancelledError signals that may leak from integrations.- if not self._running or asyncio.current_task().cancelling():- raise- continue- except Exception as e:- logger.warning("Error consuming inbound message: {}, continuing...", e)- continue+ while self._running:+ try:+ msg = await asyncio.wait_for(self.bus.consume_inbound(), timeout=1.0)+ except asyncio.TimeoutError:+ self.auto_compact.check_expired(+ self._schedule_background,+ active_session_keys=self._pending_queues.keys(),+ )+ continue+ except asyncio.CancelledError:+ # Preserve real task cancellation so shutdown can complete cleanly.+ # Only ignore non-task CancelledError signals that may leak from integrations.+ if not self._running or asyncio.current_task().cancelling():+ raise+ continue+ except Exception as e:+ logger.warning("Error consuming inbound message: {}, continuing...", e)+ continue- raw = msg.content.strip()- effective_key = self._effective_session_key(msg)- if await agent_context.handle_runtime_control(self, msg, self.tools):- continue- if self.commands.is_priority(raw):- await self._dispatch_command_inline(- msg, effective_key, raw,- self.commands.dispatch_priority,- )- continue- if self._cron_turns.defer_if_active(- msg,- session_key=effective_key,- active_session_keys=self._pending_queues.keys(),- ):- logger.info(- "Deferred cron turn for active session {}",- effective_key,- )- continue- # If this session already has an active pending queue (i.e. a task- # is processing this session), route the message there for mid-turn- # injection instead of creating a competing task.- if effective_key in self._pending_queues:- # Non-priority commands must not be queued for injection;- # dispatch them directly (same pattern as priority commands).- if self.commands.is_dispatchable_command(raw):+ raw = msg.content.strip()+ effective_key = self._effective_session_key(msg)+ if await agent_context.handle_runtime_control(self, msg, self.tools):+ continue+ if self.commands.is_priority(raw):await self._dispatch_command_inline(msg, effective_key, raw,- self.commands.dispatch,+ self.commands.dispatch_priority,)continue- pending_msg = msg- if effective_key != msg.session_key:- pending_msg = dataclasses.replace(- msg,- session_key_override=effective_key,- )- try:- self._pending_queues[effective_key].put_nowait(pending_msg)- except asyncio.QueueFull:- logger.warning(- "Pending queue full for session {}, falling back to queued task",- effective_key,- )- else:+ if self._cron_turns.defer_if_active(+ msg,+ session_key=effective_key,+ active_session_keys=self._pending_queues.keys(),+ ):logger.info(- "Routed follow-up message to pending queue for session {}",+ "Deferred cron turn for active session {}",effective_key,)continue- # Compute the effective session key before dispatching- # This ensures /stop command can find tasks correctly when unified session is enabled- task = asyncio.create_task(self._dispatch(msg))- self._active_tasks.setdefault(effective_key, []).append(task)- task.add_done_callback(- lambda t, k=effective_key: self._active_tasks.get(k, [])- and self._active_tasks[k].remove(t)- if t in self._active_tasks.get(k, [])- else None- )+ # If this session already has an active pending queue (i.e. a task+ # is processing this session), route the message there for mid-turn+ # injection instead of creating a competing task.+ if effective_key in self._pending_queues:+ # Non-priority commands must not be queued for injection;+ # dispatch them directly (same pattern as priority commands).+ if self.commands.is_dispatchable_command(raw):+ await self._dispatch_command_inline(+ msg, effective_key, raw,+ self.commands.dispatch,+ )+ continue+ pending_msg = msg+ if effective_key != msg.session_key:+ pending_msg = dataclasses.replace(+ msg,+ session_key_override=effective_key,+ )+ try:+ self._pending_queues[effective_key].put_nowait(pending_msg)+ except asyncio.QueueFull:+ logger.warning(+ "Pending queue full for session {}, falling back to queued task",+ effective_key,+ )+ else:+ logger.info(+ "Routed follow-up message to pending queue for session {}",+ effective_key,+ )+ continue+ # Compute the effective session key before dispatching+ # This ensures /stop command can find tasks correctly when unified session is enabled+ task = asyncio.create_task(self._dispatch(msg))+ self._active_tasks.setdefault(effective_key, []).append(task)+ task.add_done_callback(+ lambda t, k=effective_key: self._active_tasks.get(k, [])+ and self._active_tasks[k].remove(t)+ if t in self._active_tasks.get(k, [])+ else None+ )+ finally:+ # MCP stdio transports use AnyIO cancel scopes; close them from the task that opened them.+ await self.close_mcp()async def _dispatch(self, msg: InboundMessage) -> None:"""Process a message: per-session serial, cross-session concurrent."""diff --git a/nanobot/cli/commands.py b/nanobot/cli/commands.pyindex 3388b63be..8caa714cf 100644--- a/nanobot/cli/commands.py+++ b/nanobot/cli/commands.py@@ -1105,16 +1105,23 @@ def _run_gateway(console.print(f"[yellow]Could not open browser ({e}); visit {open_browser_url}[/yellow]")async def run():+ tasks: list[asyncio.Task] = []try:await cron.start()tasks = [- agent.run(),- channels.start_all(),+ asyncio.create_task(agent.run(), name="nanobot-agent-loop"),+ asyncio.create_task(channels.start_all(), name="nanobot-channels"),]if health_server_enabled:- tasks.append(_health_server(config.gateway.host, port))+ tasks.append(asyncio.create_task(+ _health_server(config.gateway.host, port),+ name="nanobot-health-server",+ ))if open_browser_url:- tasks.append(_open_browser_when_ready())+ tasks.append(asyncio.create_task(+ _open_browser_when_ready(),+ name="nanobot-open-browser",+ ))await asyncio.gather(*tasks)except KeyboardInterrupt:console.print("\nShutting down...")@@ -1124,9 +1131,13 @@ def _run_gateway(console.print("\n[red]Error: Gateway crashed unexpectedly[/red]")console.print(traceback.format_exc())finally:- await agent.close_mcp()cron.stop()agent.stop()+ for task in tasks:+ if not task.done():+ task.cancel()+ if tasks:+ await asyncio.gather(*tasks, return_exceptions=True)await channels.stop_all()# Flush all cached sessions to durable storage before exit.# This prevents data loss on filesystems with write-backdiff --git a/tests/agent/test_mcp_connection.py b/tests/agent/test_mcp_connection.pyindex d70c6b37b..45f4bd47d 100644--- a/tests/agent/test_mcp_connection.py+++ b/tests/agent/test_mcp_connection.py@@ -135,6 +135,43 @@ async def test_connect_mcp_retries_when_no_servers_connect(tmp_path, monkeypatchassert loop._mcp_stacks == {}+async def test_agent_loop_run_closes_mcp_from_connection_owner_task(+ tmp_path,+ monkeypatch: pytest.MonkeyPatch,+):+ loop = _make_loop(tmp_path, mcp_servers={"playwright": object()})+ connected = asyncio.Event()+ owner_tasks: list[asyncio.Task | None] = []+ closed_tasks: list[asyncio.Task | None] = []++ class _OwnerCheckedStack:+ def __init__(self) -> None:+ self.owner = asyncio.current_task()+ owner_tasks.append(self.owner)++ async def aclose(self) -> None:+ closed_tasks.append(asyncio.current_task())+ assert asyncio.current_task() is self.owner++ async def _fake_connect(servers, _registry):+ stacks = {name: _OwnerCheckedStack() for name in servers}+ connected.set()+ return stacks++ monkeypatch.setattr("nanobot.agent.tools.mcp.connect_mcp_servers", _fake_connect)++ task = asyncio.create_task(loop.run())+ await asyncio.wait_for(connected.wait(), timeout=1)+ loop.stop()+ task.cancel()+ await asyncio.gather(task, return_exceptions=True)++ assert owner_tasks+ assert closed_tasks == owner_tasks+ assert loop._mcp_stacks == {}++@pytest.mark.asyncioasync def test_reload_mcp_servers_adds_and_removes_tools_without_restart(tmp_path,diff --git a/tests/cli/test_commands.py b/tests/cli/test_commands.pyindex ef462348a..7825bc5d6 100644--- a/tests/cli/test_commands.py+++ b/tests/cli/test_commands.py@@ -1960,6 +1960,103 @@ def test_gateway_health_endpoint_binds_and_serves_expected_responses(assert missing_response.endswith("\r\n\r\nNot Found")+def test_gateway_shutdown_lets_agent_task_own_mcp_cleanup(+ monkeypatch,+ tmp_path: Path,+) -> None:+ config_file = _write_instance_config(tmp_path)+ config = Config()+ config.gateway.port = 18791+ seen: dict[str, object] = {}++ class _FakeSessionManager:+ def flush_all(self) -> int:+ return 0++ class _FakeAgentLoop:+ @classmethod+ def from_config(cls, config, bus=None, **extra):+ return cls(**extra)++ def __init__(self, **_kwargs) -> None:+ self.model = "test-model"+ self.provider = object()+ self.sessions = _FakeSessionManager()++ def llm_runtime(self) -> None:+ return None++ async def run(self) -> None:+ try:+ await asyncio.Event().wait()+ finally:+ seen["agent_task_cleaned_up"] = True++ async def close_mcp(self) -> None:+ raise AssertionError("gateway must not close MCP from the outer task")++ def stop(self) -> None:+ seen["agent_stopped"] = True++ class _FakeChannelManager:+ def __init__(self, _config, _bus, **_kwargs) -> None:+ self.enabled_channels = ["telegram"]++ async def start_all(self) -> None:+ await asyncio.Event().wait()++ async def stop_all(self) -> None:+ seen["channels_stopped"] = True++ class _FakeCronService:+ def __init__(self, _store_path: Path) -> None:+ self.on_job = None++ async def start(self) -> None:+ return None++ def stop(self) -> None:+ seen["cron_stopped"] = True++ def status(self) -> dict[str, int]:+ return {"jobs": 0}++ def register_system_job(self, _job) -> None:+ return None++ class _FakeServer:+ async def __aenter__(self):+ return self++ async def __aexit__(self, exc_type, exc, tb) -> bool:+ return False++ async def serve_forever(self) -> None:+ raise _StopGatewayError("stop")++ async def _fake_start_server(_handler, _host: str, _port: int):+ return _FakeServer()++ _patch_cli_command_runtime(+ monkeypatch,+ config,+ message_bus=lambda: object(),+ session_manager=lambda _workspace: object(),+ )+ monkeypatch.setattr("nanobot.cli.commands.AgentLoop", _FakeAgentLoop)+ monkeypatch.setattr("nanobot.channels.manager.ChannelManager", _FakeChannelManager)+ monkeypatch.setattr("nanobot.cron.service.CronService", _FakeCronService)+ monkeypatch.setattr("asyncio.start_server", _fake_start_server)++ result = runner.invoke(app, ["gateway", "--config", str(config_file)])++ assert result.exit_code == 0+ assert seen["agent_stopped"] is True+ assert seen["agent_task_cleaned_up"] is True+ assert seen["channels_stopped"] is True+ assert seen["cron_stopped"] is True++def test_serve_uses_api_config_defaults_and_workspace_override(monkeypatch, tmp_path: Path) -> None: