fix(sdk): unregister atexit handler in LocalConversation.close()

LocalConversation.__init__ registers atexit.register(self.close), creating
a permanent reference from the atexit handler list to the conversation
object. When close() is called the registration is never removed, so the
entire conversation object graph (agent, LLMs, event log, file store, all
events) is pinned in memory forever.

Add atexit.unregister(self.close) at the top of close() so conversations
become fully GC-able after cleanup. On a long-running server processing
hundreds of conversations this prevents monotonic memory growth.

Closes #3136

Co-authored-by: openhands <openhands@all-hands.dev>

Author: csmith49

openhands-sdk/openhands/sdk/conversation/impl/local_conversation.py

@@ -977,6 +977,9 @@ def set_security_analyzer(self, analyzer: SecurityAnalyzerBase | None) -> None:
 
     def close(self) -> None:
         """Close the conversation and clean up all tool executors."""
+        # Remove the atexit reference so the conversation object can be GC'd
+        # after close. atexit.unregister is a no-op if not registered.
+        atexit.unregister(self.close)
         # Use getattr for safety - object may be partially constructed
         if getattr(self, "_cleanup_initiated", False):
             return

tests/sdk/conversation/test_atexit_cleanup.py

@@ -0,0 +1,45 @@
+"""Tests for atexit handler cleanup to prevent memory leaks."""
+
+import gc
+import tempfile
+import weakref
+from pathlib import Path
+
+from pydantic import SecretStr
+
+from openhands.sdk.agent import Agent
+from openhands.sdk.conversation.impl.local_conversation import LocalConversation
+from openhands.sdk.llm import LLM
+
+
+def _make_conversation(workspace: str) -> LocalConversation:
+    llm = LLM(model="gpt-4o-mini", api_key=SecretStr("k"), usage_id="test")
+    return LocalConversation(agent=Agent(llm=llm, tools=[]), workspace=workspace)
+
+
+def test_close_unregisters_atexit_handler():
+    """close() must remove the atexit handler so the object can be GC'd."""
+    with tempfile.TemporaryDirectory() as tmp:
+        workspace = str(Path(tmp) / "ws")
+        Path(workspace).mkdir()
+        conv = _make_conversation(workspace)
+
+        conv.close()
+
+        # If atexit still held a reference, the weak-ref would stay alive
+        # after we drop the strong reference.
+        ref = weakref.ref(conv)
+        del conv
+        gc.collect()
+        assert ref() is None, "Conversation was not GC'd — atexit leak"
+
+
+def test_close_is_idempotent_with_atexit():
+    """Calling close() twice must not raise, even with atexit handling."""
+    with tempfile.TemporaryDirectory() as tmp:
+        workspace = str(Path(tmp) / "ws")
+        Path(workspace).mkdir()
+        conv = _make_conversation(workspace)
+
+        conv.close()
+        conv.close()  # second call is a no-op