fix(python): reuse tokio runtime instead of creating per call

Store a shared `tokio::runtime::Runtime` (current-thread) in PyBash,
BashTool, and ScriptedTool structs. Previously each `execute_sync()`
and `reset()` call created a new runtime, spawning OS threads that
could exhaust thread/fd limits under rapid-fire usage.

Fixes #414

https://claude.ai/code/session_01WZjYqxm5xMPAEe7FSHJkDy

Author: claude

crates/bashkit-python/src/lib.rs

@@ -165,6 +165,9 @@ impl ExecResult {
 #[allow(dead_code)]
 pub struct PyBash {
     inner: Arc<Mutex<Bash>>,
+    /// Shared tokio runtime — reused across all sync calls to avoid
+    /// per-call OS thread/fd exhaustion (issue #414).
+    rt: tokio::runtime::Runtime,
     username: Option<String>,
     hostname: Option<String>,
     max_commands: Option<u64>,
@@ -201,8 +204,14 @@ impl PyBash {
 
         let bash = builder.build();
 
+        let rt = tokio::runtime::Builder::new_current_thread()
+            .enable_all()
+            .build()
+            .map_err(|e| PyRuntimeError::new_err(format!("Failed to create runtime: {e}")))?;
+
         Ok(Self {
             inner: Arc::new(Mutex::new(bash)),
+            rt,
             username,
             hostname,
             max_commands,
@@ -235,10 +244,8 @@ impl PyBash {
     /// Execute commands synchronously (blocking).
     fn execute_sync(&self, commands: String) -> PyResult<ExecResult> {
         let inner = self.inner.clone();
-        let rt = tokio::runtime::Runtime::new()
-            .map_err(|e| PyRuntimeError::new_err(format!("Failed to create runtime: {}", e)))?;
 
-        rt.block_on(async move {
+        self.rt.block_on(async move {
             let mut bash = inner.lock().await;
             match bash.exec(&commands).await {
                 Ok(result) => Ok(ExecResult {
@@ -260,10 +267,8 @@ impl PyBash {
     /// Reset interpreter to fresh state.
     fn reset(&self) -> PyResult<()> {
         let inner = self.inner.clone();
-        let rt = tokio::runtime::Runtime::new()
-            .map_err(|e| PyRuntimeError::new_err(format!("Failed to create runtime: {}", e)))?;
 
-        rt.block_on(async move {
+        self.rt.block_on(async move {
             let mut bash = inner.lock().await;
             let builder = Bash::builder();
             *bash = builder.build();
@@ -312,6 +317,9 @@ impl PyBash {
 #[allow(dead_code)]
 pub struct BashTool {
     inner: Arc<Mutex<Bash>>,
+    /// Shared tokio runtime — reused across all sync calls to avoid
+    /// per-call OS thread/fd exhaustion (issue #414).
+    rt: tokio::runtime::Runtime,
     username: Option<String>,
     hostname: Option<String>,
     max_commands: Option<u64>,
@@ -348,8 +356,14 @@ impl BashTool {
 
         let bash = builder.build();
 
+        let rt = tokio::runtime::Builder::new_current_thread()
+            .enable_all()
+            .build()
+            .map_err(|e| PyRuntimeError::new_err(format!("Failed to create runtime: {e}")))?;
+
         Ok(Self {
             inner: Arc::new(Mutex::new(bash)),
+            rt,
             username,
             hostname,
             max_commands,
@@ -380,10 +394,8 @@ impl BashTool {
 
     fn execute_sync(&self, commands: String) -> PyResult<ExecResult> {
         let inner = self.inner.clone();
-        let rt = tokio::runtime::Runtime::new()
-            .map_err(|e| PyRuntimeError::new_err(format!("Failed to create runtime: {}", e)))?;
 
-        rt.block_on(async move {
+        self.rt.block_on(async move {
             let mut bash = inner.lock().await;
             match bash.exec(&commands).await {
                 Ok(result) => Ok(ExecResult {
@@ -404,10 +416,8 @@ impl BashTool {
 
     fn reset(&self) -> PyResult<()> {
         let inner = self.inner.clone();
-        let rt = tokio::runtime::Runtime::new()
-            .map_err(|e| PyRuntimeError::new_err(format!("Failed to create runtime: {}", e)))?;
 
-        rt.block_on(async move {
+        self.rt.block_on(async move {
             let mut bash = inner.lock().await;
             let builder = Bash::builder();
             *bash = builder.build();
@@ -509,6 +519,9 @@ pub struct ScriptedTool {
     short_desc: Option<String>,
     tools: Vec<PyToolEntry>,
     env_vars: Vec<(String, String)>,
+    /// Shared tokio runtime — reused across all sync calls to avoid
+    /// per-call OS thread/fd exhaustion (issue #414).
+    rt: tokio::runtime::Runtime,
     max_commands: Option<u64>,
     max_loop_iterations: Option<u64>,
 }
@@ -582,15 +595,21 @@ impl ScriptedTool {
         short_description: Option<String>,
         max_commands: Option<u64>,
         max_loop_iterations: Option<u64>,
-    ) -> Self {
-        Self {
+    ) -> PyResult<Self> {
+        let rt = tokio::runtime::Builder::new_current_thread()
+            .enable_all()
+            .build()
+            .map_err(|e| PyRuntimeError::new_err(format!("Failed to create runtime: {e}")))?;
+
+        Ok(Self {
             name,
             short_desc: short_description,
             tools: Vec::new(),
             env_vars: Vec::new(),
+            rt,
             max_commands,
             max_loop_iterations,
-        }
+        })
     }
 
     /// Register a tool command.
@@ -654,10 +673,8 @@ impl ScriptedTool {
     /// Execute a bash script synchronously (blocking).
     fn execute_sync(&self, commands: String) -> PyResult<ExecResult> {
         let mut tool = self.build_rust_tool();
-        let rt = tokio::runtime::Runtime::new()
-            .map_err(|e| PyRuntimeError::new_err(format!("Failed to create runtime: {}", e)))?;
 
-        let resp = rt.block_on(async move {
+        let resp = self.rt.block_on(async move {
             tool.execute(ToolRequest {
                 commands,
                 timeout_ms: None,

crates/bashkit-python/tests/test_bashkit.py

@@ -728,3 +728,47 @@ async def test_async_multiple_tools():
     assert r.exit_code == 0
     assert "A" in r.stdout
     assert "B" in r.stdout
+
+
+# ===========================================================================
+# Runtime reuse (issue #414)
+# ===========================================================================
+
+
+def test_bash_rapid_sync_calls_no_resource_exhaustion():
+    """Rapid execute_sync calls reuse a single runtime (no thread/fd leak)."""
+    bash = Bash()
+    for i in range(200):
+        r = bash.execute_sync(f"echo {i}")
+        assert r.exit_code == 0
+        assert r.stdout.strip() == str(i)
+
+
+def test_bashtool_rapid_sync_calls_no_resource_exhaustion():
+    """Rapid execute_sync calls reuse a single runtime (no thread/fd leak)."""
+    tool = BashTool()
+    for i in range(200):
+        r = tool.execute_sync(f"echo {i}")
+        assert r.exit_code == 0
+        assert r.stdout.strip() == str(i)
+
+
+def test_bashtool_rapid_reset_no_resource_exhaustion():
+    """Rapid reset calls reuse a single runtime (no thread/fd leak)."""
+    tool = BashTool()
+    for _ in range(200):
+        tool.reset()
+    # After many resets, tool still works
+    r = tool.execute_sync("echo ok")
+    assert r.exit_code == 0
+    assert r.stdout.strip() == "ok"
+
+
+def test_scripted_tool_rapid_sync_calls_no_resource_exhaustion():
+    """Rapid execute_sync calls on ScriptedTool reuse a single runtime."""
+    tool = ScriptedTool("api")
+    tool.add_tool("ping", "Ping", callback=lambda p, s=None: "pong\n")
+    for i in range(200):
+        r = tool.execute_sync("ping")
+        assert r.exit_code == 0
+        assert r.stdout.strip() == "pong"