agentic-python-coder 3.3.0__py3-none-any.whl → 3.4.1__py3-none-any.whl

agentic_python_coder/kernel.py

@@ -10,6 +10,7 @@ import logging
 import os
 import re
 import shutil
+import signal
 import threading
 import time
 import uuid
@@ -219,13 +220,13 @@ except ImportError:
         self._execute_raw(startup_code)
 
     def _cleanup_on_error(self):
-        """Clean up resources if initialization fails."""
+        """Clean up resources if initialization fails.
+
+        Routes through shutdown() so a partially-started kernel tree gets
+        the same defensive process-group kill as a healthy one.
+        """
         try:
-            if hasattr(self, "kc") and self.kc:
-                self.kc.stop_channels()
-            if hasattr(self, "km") and self.km:
-                if self.km.is_alive():
-                    self.km.shutdown_kernel(now=True)
+            self.shutdown()
         except Exception:
             pass  # Best effort cleanup
 
@@ -311,7 +312,21 @@ except ImportError:
             return self._execute_raw(code, deadline_timeout)
 
     def shutdown(self):
-        """Shutdown the kernel and clean up."""
+        """Shutdown the kernel and clean up.
+
+        Kernels run in their own process group (jupyter_client launches with
+        start_new_session=True). After the regular shutdown, defensively kill
+        the whole group: uv-wrapped kernels are a tree (uv parent + python
+        child) and a surviving member would be orphaned.
+        """
+        # Capture the kernel's process group before shutdown clears it
+        pgid = None
+        try:
+            if hasattr(self, "km") and self.km:
+                pgid = getattr(getattr(self.km, "provisioner", None), "pgid", None)
+        except Exception:
+            pass
+
         try:
             if hasattr(self, "kc") and self.kc:
                 try:
@@ -330,6 +345,15 @@ except ImportError:
             # Ignore errors during shutdown
             pass
 
+        # Defensive: ensure no process-tree member survived. Never signal our
+        # own group (pgid could be bogus if start_new_session did not apply).
+        if pgid and pgid > 0:
+            try:
+                if pgid != os.getpgid(0):
+                    os.killpg(pgid, signal.SIGKILL)
+            except (ProcessLookupError, PermissionError, OSError):
+                pass
+
 
 # =============================================================================
 # Core Registry Functions
@@ -603,6 +627,33 @@ def shutdown_all_kernels():
             pass  # Best effort
 
 
+def kill_all_kernel_process_groups():
+    """Hard-kill (SIGKILL) every registered kernel's process group.
+
+    Deliberately lock-free: this is the termination path, where a busy
+    kernel's _exec_lock may be held indefinitely by an in-flight execution
+    and the graceful shutdown_all_kernels() would block behind it. Snapshot
+    the registry and signal each group directly. Never signals our own
+    process group. Kernels mid-creation (registry slot still None) cannot
+    be reached here — that sub-second window is a known limitation.
+    """
+    try:
+        own_pgid = os.getpgid(0)
+    except OSError:
+        own_pgid = None
+
+    for state in list(_kernels.values()):
+        if state is None:
+            continue
+        try:
+            km = state.kernel.km
+            pgid = getattr(getattr(km, "provisioner", None), "pgid", None)
+            if pgid and pgid > 0 and pgid != own_pgid:
+                os.killpg(pgid, signal.SIGKILL)
+        except (ProcessLookupError, PermissionError, OSError, AttributeError):
+            pass  # Best effort
+
+
 # =============================================================================
 # Backward Compatibility API
 # =============================================================================

agentic_python_coder/mcp_server.py

@@ -7,6 +7,9 @@ import ast
 import asyncio
 import json
 import logging
+import os
+import signal
+import threading
 
 from mcp.server import Server
 from mcp.server.stdio import stdio_server
@@ -18,8 +21,10 @@ from agentic_python_coder.kernel import (
     execute_in_kernel,
     interrupt_kernel_by_id,
     kernel_exists,
+    kill_all_kernel_process_groups,
     list_kernels,
     restart_kernel,
+    shutdown_all_kernels,
 )
 
 # Configure logging
@@ -32,6 +37,7 @@ server = Server("ipython_mcp")
 MAX_OUTPUT = 100 * 1024  # 100KB truncation limit
 MAX_TIMEOUT = 300  # Maximum allowed timeout in seconds
 DEFAULT_TIMEOUT = 30  # Default timeout in seconds
+STATUS_PROBE_TIMEOUT = 10  # Timeout for python_status introspection probes
 KERNEL_TIMEOUT_BUFFER = 5  # Extra seconds for kernel deadline vs asyncio timeout
 
 # Async lock for session operations (default kernel management)
@@ -240,6 +246,30 @@ No side effects - safe to call anytime.""",
                 },
             },
         ),
+        Tool(
+            name="submit_code",
+            description="""Submit your final, verified, self-contained Python program.
+
+Call this ONCE at the end of a solve, only after you have executed the program
+via python_exec and your verification passed. The submission must be a
+standalone program: all imports included, no reliance on session state.
+
+The code is syntax-checked with compile():
+- {"ok": true} if it parses
+- {"ok": false, "error": "<detail>"} on a syntax error — fix and resubmit
+
+The code is NOT executed and NOT written to disk; the client persists it.""",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "code": {
+                        "type": "string",
+                        "description": "Complete standalone Python program (final answer).",
+                    },
+                },
+                "required": ["code"],
+            },
+        ),
         Tool(
             name="python_interrupt",
             description="""Interrupt running code in the session.
@@ -318,7 +348,9 @@ versions
                     % packages
                 )
                 try:
-                    result = await execute_with_timeout(version_code, 30, kernel_id)
+                    result = await execute_with_timeout(
+                        version_code, DEFAULT_TIMEOUT, kernel_id
+                    )
                     if result.get("result"):
                         versions = ast.literal_eval(result["result"])
                         if isinstance(versions, dict):
@@ -391,6 +423,24 @@ versions
         result = await execute_with_timeout(code, timeout, kernel_id)
         return [TextContent(type="text", text=json.dumps(result))]
 
+    elif name == "submit_code":
+        code = arguments.get("code", "")
+        if not code.strip():
+            payload = {"ok": False, "error": "Empty submission"}
+        else:
+            try:
+                compile(code, "<submission>", "exec")
+                payload = {"ok": True}
+            except SyntaxError as e:
+                payload = {
+                    "ok": False,
+                    "error": f"Syntax error at line {e.lineno or '?'}: {e.msg}",
+                }
+            except ValueError as e:
+                # compile() raises ValueError e.g. for null bytes in source
+                payload = {"ok": False, "error": f"Invalid source: {e}"}
+        return [TextContent(type="text", text=json.dumps(payload))]
+
     elif name == "python_status":
         kernel_id = get_kernel_id(arguments)
         is_active = kernel_exists(kernel_id)
@@ -412,7 +462,7 @@ versions
             # Get Python version
             try:
                 result = await execute_with_timeout(
-                    "import sys; sys.version", 10, kernel_id
+                    "import sys; sys.version", STATUS_PROBE_TIMEOUT, kernel_id
                 )
                 if result.get("result"):
                     status["python_version"] = result["result"].strip("'\"")
@@ -426,7 +476,9 @@ import importlib.metadata
 [f"{d.metadata['Name']} {d.version}" for d in importlib.metadata.distributions()
  if d.metadata['Name'] not in ('pip', 'setuptools', 'wheel', 'ipykernel', 'jupyter-client')][:20]
 """
-                result = await execute_with_timeout(pkg_code, 10, kernel_id)
+                result = await execute_with_timeout(
+                    pkg_code, STATUS_PROBE_TIMEOUT, kernel_id
+                )
                 if result.get("result"):
                     status["packages"] = ast.literal_eval(result["result"])
             except Exception:
@@ -438,7 +490,9 @@ import importlib.metadata
 [name for name in dir() if not name.startswith('_')
  and name not in ('In', 'Out', 'get_ipython', 'exit', 'quit', 'open')]
 """
-                result = await execute_with_timeout(var_code, 10, kernel_id)
+                result = await execute_with_timeout(
+                    var_code, STATUS_PROBE_TIMEOUT, kernel_id
+                )
                 if result.get("result"):
                     status["variables"] = ast.literal_eval(result["result"])
             except Exception:
@@ -521,9 +575,51 @@ async def run_server():
         await server.run(read, write, server.create_initialization_options())
 
 
+# Hard-exit fallback if kernel cleanup hangs after a termination signal
+_TERMINATION_CLEANUP_TIMEOUT = 10.0
+
+# Set on the first termination signal; later signals are ignored instead of
+# stacking additional timers and cleanup threads
+_terminating = threading.Event()
+
+
+def _handle_termination(signum, frame):
+    """Shut down all kernels on SIGTERM/SIGINT, then exit.
+
+    Kernel process groups are hard-killed first (lock-free, cannot block on
+    a busy kernel's exec lock); the graceful registry cleanup then runs in a
+    thread, with a timer that hard-exits if it hangs.
+    """
+    if _terminating.is_set():
+        return
+    _terminating.set()
+
+    def _cleanup_and_exit():
+        try:
+            kill_all_kernel_process_groups()
+            shutdown_all_kernels()
+        finally:
+            os._exit(128 + signum)
+
+    threading.Timer(
+        _TERMINATION_CLEANUP_TIMEOUT, lambda: os._exit(128 + signum)
+    ).start()
+    threading.Thread(target=_cleanup_and_exit, daemon=True).start()
+
+
 def main():
     """Entry point for coder-mcp command."""
-    asyncio.run(run_server())
+    signal.signal(signal.SIGTERM, _handle_termination)
+    signal.signal(signal.SIGINT, _handle_termination)
+    try:
+        asyncio.run(run_server())
+    finally:
+        # stdin EOF / transport close / normal exit: the client is gone, so
+        # hard-kill kernel groups first (immune to a busy kernel's exec
+        # lock), then clean up the registry (atexit also runs the graceful
+        # path, but only on clean interpreter shutdown)
+        kill_all_kernel_process_groups()
+        shutdown_all_kernels()
 
 
 if __name__ == "__main__":

{agentic_python_coder-3.3.0.dist-info → agentic_python_coder-3.4.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentic-python-coder
-Version: 3.3.0
+Version: 3.4.1
 Summary: A lightweight Python coding agent that writes, executes, and iterates on code through natural language instructions
 Author: Stefan Szeider
 License: Apache-2.0

{agentic_python_coder-3.3.0.dist-info → agentic_python_coder-3.4.1.dist-info}/RECORD

@@ -1,9 +1,9 @@
 agentic_python_coder/__init__.py,sha256=e6o-k__u5xNIiQAkZbHtbZC2-NwpeOdi4MdQtAqJBjE,2112
 agentic_python_coder/agent.py,sha256=gzDFf4n7J1JdWawYPzWQFVwcHZ2rsRHUzVZVcGYjQWo,14451
 agentic_python_coder/cli.py,sha256=HS9nlqsiWZAvg0Hc8ExoVT8eEcy2t3Bux6UGukERWqQ,14663
-agentic_python_coder/kernel.py,sha256=PQrKMi0_mKVeG1q2wXTu3-W2ZYKwYNjtPI_3A4m4Gvg,21284
+agentic_python_coder/kernel.py,sha256=Q-yLb8Il54kZv41qev2uzASFlr6bGjQ7ztBy7yD48GM,23273
 agentic_python_coder/llm.py,sha256=zjsk4-Kdx92hFSxywPGIkLv8zflWnE2cMEcpeXu6ttw,6998
-agentic_python_coder/mcp_server.py,sha256=2Z5O9n5QgZrgn3GdFljjF7Yq5e9tE1zNlAWBPyckrlI,18503
+agentic_python_coder/mcp_server.py,sha256=Osdl8UnjkupXbPLiYCugiapGDJsryZfVai0o-jepuqw,22047
 agentic_python_coder/project_md.py,sha256=4xkQHlWb4cDPEkvegw1YwcfaTJ3aFbrl0CYcC_xxABY,3249
 agentic_python_coder/runner.py,sha256=Kbw1ceYJ4MVfUKgSIkiuBhMb8ZtbZuJwbBeTUsvPRts,13045
 agentic_python_coder/tools.py,sha256=tjhQbsF3n3bFIegnEOtE8czjzbtMSXy6B9gYeb-YAJ4,12088
@@ -41,8 +41,8 @@ agentic_python_coder/models/sonnet46.json,sha256=Ops1FpBoyx9PBGRhIXG8u-YGBgIui9D
 agentic_python_coder/models/sonnet5.json,sha256=kf6DIkQlcGVZ40IzRv3GXFtNncZF_gKqQeGzZAxE_KM,87
 agentic_python_coder/prompts/system.md,sha256=hREDVAhJXwCBAgJ3AE9JD6j-JRHREUPlkRSvThOvM3A,3807
 agentic_python_coder/prompts/system_todo.md,sha256=TuNeeUNS9KqyF62Da6t2mlUCYhKsgzwGe5ic_vFPDqw,5054
-agentic_python_coder-3.3.0.dist-info/METADATA,sha256=ec4FIlQitVNa_5bMQhu2NPpJV-5VwDRQy1hzK_4b_G8,12872
-agentic_python_coder-3.3.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
-agentic_python_coder-3.3.0.dist-info/entry_points.txt,sha256=XIW3nZzL4kJ-Igohilj_mTvBcCyHBouDq2jmGzDILrk,107
-agentic_python_coder-3.3.0.dist-info/licenses/LICENSE,sha256=R9-M_V-SPdN71IphOVzM7kCNpUYs_hwj7rtroTwDhs0,11362
-agentic_python_coder-3.3.0.dist-info/RECORD,,
+agentic_python_coder-3.4.1.dist-info/METADATA,sha256=C9UTWTVtnf7-0Bgiu44LMEd16zA00T3UxkS92MVV_Ac,12872
+agentic_python_coder-3.4.1.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+agentic_python_coder-3.4.1.dist-info/entry_points.txt,sha256=XIW3nZzL4kJ-Igohilj_mTvBcCyHBouDq2jmGzDILrk,107
+agentic_python_coder-3.4.1.dist-info/licenses/LICENSE,sha256=R9-M_V-SPdN71IphOVzM7kCNpUYs_hwj7rtroTwDhs0,11362
+agentic_python_coder-3.4.1.dist-info/RECORD,,