refactor(langchain): keep sandbox_client enhancements, remove thread manager

Thread-aware sandbox management (ThreadedSandboxManager,
create_threaded_backend_factory, multi_thread_chat example) is
application-specific and belongs in the consuming project, not
in the generic agent-sandbox library.

Retained in sandbox_client.py: claim_name, delete_on_exit,
connect(), delete(), was_reconnected.

Author: johannhartmann

clients/python/langchain-agent-sandbox/langchain_agent_sandbox/__init__.py

@@ -3,15 +3,11 @@
     SandboxPolicyWrapper,
     WarmPoolBackend,
     create_sandbox_backend_factory,
-    create_threaded_backend_factory,
 )
-from .thread_manager import ThreadedSandboxManager
 
 __all__ = [
     "AgentSandboxBackend",
     "SandboxPolicyWrapper",
     "WarmPoolBackend",
-    "ThreadedSandboxManager",
     "create_sandbox_backend_factory",
-    "create_threaded_backend_factory",
 ]

clients/python/langchain-agent-sandbox/langchain_agent_sandbox/backend.py

@@ -669,97 +669,6 @@ def factory(_runtime: Any) -> AgentSandboxBackend:
     return factory
 
 
-def _get_thread_manager_class() -> type:
-    """Lazy import of ThreadedSandboxManager to avoid circular imports."""
-    from .thread_manager import ThreadedSandboxManager
-    return ThreadedSandboxManager
-
-
-def create_threaded_backend_factory(
-    template_name: str,
-    manager: Optional[Any] = None,
-    namespace: str = "default",
-    **kwargs: Any,
-) -> Callable[[Any], AgentSandboxBackend]:
-    """Create a BackendFactory that provides per-thread sandbox isolation.
-
-    This factory reads the thread_id from the LangGraph config and uses a
-    ThreadedSandboxManager to provide isolated sandboxes per conversation thread.
-    Each thread gets its own sandbox with persistent filesystem.
-
-    Usage:
-        from deepagents import create_deep_agent
-        from langgraph.checkpoint.memory import MemorySaver
-        from langchain_agent_sandbox import (
-            ThreadedSandboxManager,
-            create_threaded_backend_factory,
-        )
-
-        # Create manager for lifecycle control
-        manager = ThreadedSandboxManager(
-            template_name="python-deepagent",
-            idle_ttl=timedelta(hours=1),
-        )
-
-        # Create agent with threaded backend
-        agent = create_deep_agent(
-            model=model,
-            backend=create_threaded_backend_factory("python-deepagent", manager=manager),
-            checkpointer=MemorySaver(),  # For message history
-        )
-
-        # Same thread = same sandbox (filesystem persists)
-        agent.invoke(msg1, config={"configurable": {"thread_id": "user-123"}})
-        agent.invoke(msg2, config={"configurable": {"thread_id": "user-123"}})
-
-        # Different thread = different sandbox
-        agent.invoke(msg3, config={"configurable": {"thread_id": "user-456"}})
-
-        # Cleanup when done
-        manager.close()
-
-    Args:
-        template_name: Name of the SandboxTemplate to claim.
-        manager: Optional ThreadedSandboxManager instance. If not provided,
-            one will be created (but you won't have lifecycle control).
-        namespace: Kubernetes namespace for the sandbox.
-        **kwargs: Additional arguments passed to ThreadedSandboxManager.
-
-    Returns:
-        A factory callable that accepts a ToolRuntime and returns an
-        AgentSandboxBackend for the current thread.
-
-    Note:
-        The thread_id is read from `runtime.config.get("configurable", {}).get("thread_id")`.
-        If no thread_id is found, a default "default-thread" is used.
-
-    Warning:
-        If no manager is provided, an internal manager is created but you will
-        have no way to call close() or delete_thread(). For production use,
-        always pass an explicit manager instance for lifecycle control.
-    """
-    # Create manager if not provided
-    _manager = manager
-    if _manager is None:
-        ThreadedSandboxManager = _get_thread_manager_class()
-        _manager = ThreadedSandboxManager(
-            template_name=template_name,
-            namespace=namespace,
-            **kwargs,
-        )
-
-    def factory(runtime: Any) -> AgentSandboxBackend:
-        # Extract thread_id from LangGraph config
-        config = getattr(runtime, "config", {}) or {}
-        configurable = config.get("configurable", {}) or {}
-        thread_id = configurable.get("thread_id", "default-thread")
-
-        logger.debug("Creating backend for thread_id: %s", thread_id)
-        return _manager.get_backend(thread_id)
-
-    return factory
-
-
 class SandboxPolicyWrapper:
     """Wraps AgentSandboxBackend with policy enforcement.