agentic-python-coder 3.4.3__py3-none-any.whl → 3.5.0__py3-none-any.whl

agentic_python_coder/kernel.py

@@ -21,6 +21,7 @@ from queue import Empty
 from typing import Any, Dict, List, Optional
 
 from jupyter_client import KernelManager
+from jupyter_client.kernelspec import KernelSpecManager
 
 log_level = os.environ.get("CODER_LOG_LEVEL", "WARNING").upper()
 logging.basicConfig(
@@ -45,14 +46,50 @@ class KernelState:
     last_used: float = field(default_factory=time.time)
 
 
+def _dead_output() -> Dict[str, Any]:
+    return {
+        "stdout": "",
+        "stderr": "",
+        "result": None,
+        "error": "Kernel died during execution",
+    }
+
+
 # Kernel registry and global lock
 _kernels: Dict[str, Optional[KernelState]] = {}
 _kernels_lock = threading.Lock()
 
+
+@dataclass
+class _CrashRecord:
+    """Restart configuration of a kernel whose process died."""
+
+    packages: List[str]
+    cwd: Optional[str]
+
+
+# Kernels whose process died, by ID, so that restart_kernel() can bring them
+# back with the same packages and cwd. Guarded by _kernels_lock.
+_crashed: Dict[str, _CrashRecord] = {}
+
+# ANSI escape sequences (IPython colours its tracebacks)
+_ANSI_RE = re.compile(r"\x1b\[[0-?]*[ -/]*[@-~]")
+
 # Suppress Jupyter warnings
 warnings.filterwarnings("ignore", category=DeprecationWarning)
 
 
+def _native_kernel_spec_manager() -> KernelSpecManager:
+    """Kernelspec manager that only knows ipykernel's built-in "python3" spec.
+
+    With the default search path, a user or system kernelspec named
+    "python3" (Anaconda, Jupyter installs) would replace the interpreter,
+    environment and launch arguments. The built-in spec launches
+    ``sys.executable -m ipykernel_launcher -f {connection_file}``.
+    """
+    return KernelSpecManager(kernel_dirs=[])
+
+
 class UVKernelManager(KernelManager):
     """KernelManager that can wrap kernel launch with UV for dynamic packages."""
 
@@ -157,7 +194,11 @@ class PythonKernel:
         self.with_packages = with_packages or []
 
         # Set kernel's working directory
-        kernel_kwargs = {}
+        # Send the kernel's fd 1 to our stderr: inherited stdout is the
+        # JSON-RPC pipe under ipython_mcp, and native code (e.g. solver
+        # progress output) writing to fd 1 would corrupt the protocol.
+        # print() is unaffected (ipykernel routes it over iopub).
+        kernel_kwargs = {"stdout": 2}
         if cwd:
             kernel_kwargs["cwd"] = cwd
 
@@ -166,11 +207,17 @@ class PythonKernel:
             if with_packages is not None:
                 logger.info(f"Starting UV kernel with packages: {with_packages}")
                 self.km = UVKernelManager(
-                    with_packages=with_packages, cwd=cwd, kernel_name="python3"
+                    with_packages=with_packages,
+                    cwd=cwd,
+                    kernel_name="python3",
+                    kernel_spec_manager=_native_kernel_spec_manager(),
                 )
             else:
                 logger.info("Starting standard kernel (no dynamic packages)")
-                self.km = KernelManager(kernel_name="python3")
+                self.km = KernelManager(
+                    kernel_name="python3",
+                    kernel_spec_manager=_native_kernel_spec_manager(),
+                )
 
             # Start the kernel
             logger.debug(f"Starting kernel in directory: {cwd}")
@@ -196,30 +243,35 @@ class PythonKernel:
 
     def _inject_startup_code(self):
         """Inject safety and configuration code: block input(), set matplotlib, etc."""
+        # Runs inside a function so its imports do not leak into the user
+        # namespace (code relying on them would fail when run standalone)
         startup_code = """
-import sys
-import warnings
-import builtins
-from IPython.core.interactiveshell import InteractiveShell
-
-# Configure IPython to display last expression value
-InteractiveShell.ast_node_interactivity = 'last_expr'
-
-# Suppress pkg_resources deprecation warning from CPMpy
-warnings.filterwarnings('ignore', message='pkg_resources is deprecated', category=UserWarning)
-warnings.filterwarnings('ignore', message='.*pkg_resources.*', category=DeprecationWarning)
-
-# Block interactive input() - not supported in MCP/automated sessions
-def _blocked_input(*args, **kwargs):
-    raise RuntimeError("Interactive input() not supported")
-builtins.input = _blocked_input
-
-# Set matplotlib to non-interactive backend if available
-try:
-    import matplotlib
-    matplotlib.use('Agg')
-except ImportError:
-    pass
+def __coder_startup():
+    import warnings
+    import builtins
+    from IPython.core.interactiveshell import InteractiveShell
+
+    # Configure IPython to display last expression value
+    InteractiveShell.ast_node_interactivity = 'last_expr'
+
+    # Suppress pkg_resources deprecation warning from CPMpy
+    warnings.filterwarnings('ignore', message='pkg_resources is deprecated', category=UserWarning)
+    warnings.filterwarnings('ignore', message='.*pkg_resources.*', category=DeprecationWarning)
+
+    # Block interactive input() - not supported in MCP/automated sessions
+    def _blocked_input(*args, **kwargs):
+        raise RuntimeError("Interactive input() not supported")
+    builtins.input = _blocked_input
+
+    # Set matplotlib to non-interactive backend if available
+    try:
+        import matplotlib
+        matplotlib.use('Agg')
+    except ImportError:
+        pass
+
+__coder_startup()
+del __coder_startup
 """
         self._execute_raw(startup_code)
 
@@ -234,20 +286,53 @@ except ImportError:
         except Exception:
             pass  # Best effort cleanup
 
-    def _execute_raw(self, code: str, deadline_timeout: int = 60) -> Dict[str, str]:
+    def _alive(self) -> bool:
+        """True if the kernel process runs (False once shut down/retired)."""
+        km = self.km if hasattr(self, "km") else None
+        return km is not None and km.is_alive()
+
+    def _execute_raw(
+        self,
+        code: str,
+        deadline_timeout: int = 60,
+        store_history: bool = True,
+        interrupt_on_timeout: bool = True,
+    ) -> Dict[str, str]:
         """Execute code without locking (internal use only).
 
         Args:
             code: Python code to execute
             deadline_timeout: Hard deadline in seconds for entire execution
+            store_history: Record the cell in IPython history
+            interrupt_on_timeout: Interrupt the kernel when the deadline hits
 
         Returns:
             Dict with stdout, stderr, result, and error fields
         """
+        return self._execute_collect(
+            code, deadline_timeout, store_history, interrupt_on_timeout
+        )[0]
+
+    def _execute_collect(
+        self,
+        code: str,
+        deadline_timeout: int = 60,
+        store_history: bool = True,
+        interrupt_on_timeout: bool = True,
+    ) -> tuple:
+        """Like _execute_raw, but returns (output, completed).
+
+        completed is False when the kernel died or the deadline hit before
+        the kernel reported idle.
+        """
+        if self.kc is None or not self._alive():
+            # Shut down or retired by another caller while we waited
+            return _dead_output(), False
+
         # Send the execution request (silent=False to get execute_result)
         # allow_stdin=False prevents kernel from requesting input
         msg_id = self.kc.execute(
-            code, silent=False, store_history=True, allow_stdin=False
+            code, silent=False, store_history=store_history, allow_stdin=False
         )
 
         # Collect output
@@ -275,17 +360,23 @@ except ImportError:
                 elif msg_type == "execute_result":
                     output["result"] = content["data"].get("text/plain", "")
                 elif msg_type == "error":
-                    output["error"] = f"{content['ename']}: {content['evalue']}"
+                    error = f"{content['ename']}: {content['evalue']}"
                     # Include traceback for debugging
                     if content.get("traceback"):
-                        output["error"] += "\n" + "\n".join(content["traceback"])
+                        error += "\n" + "\n".join(content["traceback"])
+                    output["error"] = _ANSI_RE.sub("", error)
                 elif msg_type == "status" and content["execution_state"] == "idle":
                     completed = True
                     break  # Only exit on idle status
             except Empty:
+                # No idle status will ever come from a dead kernel: report
+                # the crash now instead of waiting for the deadline
+                if not self._alive():
+                    output["error"] = "Kernel died during execution"
+                    return output, False
                 continue  # Keep waiting, don't break
 
-        if not completed:
+        if not completed and interrupt_on_timeout:
             # Deadline hit while the kernel was still running: report a
             # timeout instead of silently returning partial output as success,
             # and interrupt so the kernel doesn't block the next execution
@@ -300,7 +391,7 @@ except ImportError:
             except Exception:
                 pass  # Best effort
 
-        return output
+        return output, completed
 
     def execute(self, code: str, deadline_timeout: int = 60) -> Dict[str, str]:
         """Execute code with thread-safe locking.
@@ -342,6 +433,10 @@ except ImportError:
                 try:
                     if self.km.is_alive():
                         self.km.shutdown_kernel(now=True)
+                    else:
+                        # Dead kernel: still release the control socket,
+                        # zmq context and connection file
+                        self.km.cleanup_resources()
                 except Exception:
                     pass
                 self.km = None  # Clear reference
@@ -364,6 +459,25 @@ except ImportError:
 # =============================================================================
 
 
+def _retire_dead_kernel(kernel_id: str, state: KernelState) -> None:
+    """Drop a dead kernel from the registry, keeping its config for restart.
+
+    Releases the dead kernel's client channels and manager resources.
+    Callers must not hold the kernel's exec lock.
+    """
+    with _kernels_lock:
+        # Record only if this call removed this exact state: a delayed
+        # caller must not resurrect an ID that was reset or shut down since
+        if _kernels.get(kernel_id) is state:
+            _kernels.pop(kernel_id)
+            _crashed[kernel_id] = _CrashRecord(list(state.packages), state.cwd)
+    try:
+        with state.kernel._exec_lock:
+            state.kernel.shutdown()
+    except Exception:
+        pass  # Best effort
+
+
 def create_kernel(
     kernel_id: Optional[str] = None,
     with_packages: Optional[List[str]] = None,
@@ -414,6 +528,7 @@ def create_kernel(
         )
         with _kernels_lock:
             _kernels[kernel_id] = state
+            _crashed.pop(kernel_id, None)
         logger.info(f"Created kernel {kernel_id}")
         return kernel_id
     except Exception:
@@ -449,9 +564,8 @@ def execute_in_kernel(
             raise KeyError(f"Kernel {kernel_id} is being created")
 
     # Check if alive before execution
-    if not state.kernel.km.is_alive():
-        with _kernels_lock:
-            _kernels.pop(kernel_id, None)
+    if not state.kernel._alive():
+        _retire_dead_kernel(kernel_id, state)
         raise RuntimeError(f"Kernel {kernel_id} is dead")
 
     # Execute (uses per-kernel lock internally)
@@ -460,17 +574,54 @@ def execute_in_kernel(
     # Update last_used
     state.last_used = time.time()
 
-    # Check if crashed during execution
-    if not state.kernel.km.is_alive():
-        with _kernels_lock:
-            _kernels.pop(kernel_id, None)
-        result["error"] = f"Kernel {kernel_id} crashed during execution"
+    # Check if crashed during execution (or retired by another caller)
+    if not state.kernel._alive():
+        _retire_dead_kernel(kernel_id, state)
+        result["error"] = (
+            f"Kernel {kernel_id} crashed during execution."
+            " Call python_reset to restart it."
+        )
 
     # Always include kernel_id in result
     result["kernel_id"] = kernel_id
     return result
 
 
+def probe_kernel(
+    kernel_id: str, codes: List[str], timeout: int
+) -> Optional[List[Dict[str, Any]]]:
+    """Run introspection snippets in an idle kernel (for python_status).
+
+    Never waits behind or interrupts running user code: returns None when
+    the kernel is unknown, dead or busy; a dead kernel is retired. Snippets
+    are not stored in the IPython history. If a snippet does not complete,
+    the remaining ones are not sent and the results so far are returned.
+    """
+    with _kernels_lock:
+        state = _kernels.get(kernel_id)
+    if state is None:
+        return None
+    kernel = state.kernel
+    if not kernel._exec_lock.acquire(blocking=False):
+        return None  # busy
+    results: List[Dict[str, Any]] = []
+    try:
+        if kernel._alive():
+            for code in codes:
+                output, completed = kernel._execute_collect(
+                    code, timeout, store_history=False, interrupt_on_timeout=False
+                )
+                if not completed:
+                    break
+                results.append(output)
+    finally:
+        kernel._exec_lock.release()
+    if not kernel._alive():
+        _retire_dead_kernel(kernel_id, state)
+        return None
+    return results
+
+
 def shutdown_kernel_by_id(kernel_id: str) -> bool:
     """Shutdown specific kernel.
 
@@ -479,6 +630,7 @@ def shutdown_kernel_by_id(kernel_id: str) -> bool:
     """
     with _kernels_lock:
         state = _kernels.pop(kernel_id, None)
+        _crashed.pop(kernel_id, None)  # an explicit shutdown forgets a crash
 
     if state is None:
         return False
@@ -504,15 +656,15 @@ def interrupt_kernel_by_id(kernel_id: str) -> bool:
             return False
         state = _kernels[kernel_id]
 
-    if state is None or not state.kernel.km.is_alive():
+    km = state.kernel.km if state is not None else None
+    if km is None or not km.is_alive():
         return False
 
-    state.kernel.km.interrupt_kernel()
+    km.interrupt_kernel()
     time.sleep(0.5)  # Grace period
 
-    if not state.kernel.km.is_alive():
-        with _kernels_lock:
-            _kernels.pop(kernel_id, None)
+    if not state.kernel._alive():
+        _retire_dead_kernel(kernel_id, state)
         raise RuntimeError(f"Kernel {kernel_id} died from interrupt")
 
     return True
@@ -528,10 +680,21 @@ def restart_kernel(
         kernel_id: Kernel to restart.
         with_packages: New packages (None = keep existing).
 
+    A kernel that died (and was dropped from the registry) is restarted
+    with the packages and cwd it had.
+
     Raises:
         KeyError: If kernel not found.
         RuntimeError: If new kernel fails to start.
     """
+    with _kernels_lock:
+        crashed = None if kernel_id in _kernels else _crashed.get(kernel_id)
+    if crashed is not None:
+        packages = with_packages if with_packages is not None else crashed.packages
+        create_kernel(kernel_id, packages, crashed.cwd)
+        logger.info(f"Restarted crashed kernel {kernel_id}")
+        return
+
     with _kernels_lock:
         if kernel_id not in _kernels:
             raise KeyError(f"Unknown kernel: {kernel_id}")
@@ -623,6 +786,7 @@ def shutdown_all_kernels():
     """Shutdown all kernels. Called by atexit."""
     with _kernels_lock:
         kernel_ids = list(_kernels.keys())
+        _crashed.clear()
 
     for kid in kernel_ids:
         try:

agentic_python_coder/mcp_server.py

@@ -10,19 +10,24 @@ import logging
 import os
 import signal
 import threading
+from typing import List, Optional
 
+import jsonschema
 from mcp.server import Server
 from mcp.server.stdio import stdio_server
-from mcp.types import TextContent, Tool
+from mcp.types import CallToolResult, ListToolsResult, TextContent, Tool
+from packaging.requirements import InvalidRequirement, Requirement
 
 from agentic_python_coder.kernel import (
     DEFAULT_KERNEL_ID,
     create_kernel,
     execute_in_kernel,
+    get_kernel_info,
     interrupt_kernel_by_id,
     kernel_exists,
     kill_all_kernel_process_groups,
     list_kernels,
+    probe_kernel,
     restart_kernel,
     shutdown_all_kernels,
 )
@@ -30,8 +35,7 @@ from agentic_python_coder.kernel import (
 # Configure logging
 logger = logging.getLogger(__name__)
 
-# Create MCP server
-server = Server("ipython_mcp")
+# The MCP server object is created at the end of the module (see _make_server).
 
 # Constants
 MAX_OUTPUT = 100 * 1024  # 100KB truncation limit
@@ -57,6 +61,39 @@ def truncate_output(result: dict) -> dict:
     return result
 
 
+def _status_probe(expr: str) -> str:
+    """Code that writes repr(expr) to stdout.
+
+    Writing (instead of a last-expression value) keeps the probe out of the
+    user's ``_``/``Out``, ``__import__`` keeps it from binding names, and
+    sys.stdout.write survives a user-shadowed print.
+    """
+    return f"if True:\n    __import__('sys').stdout.write(repr({expr}) + '\\n')\n"
+
+
+def _distribution_name(requirement: str) -> Optional[str]:
+    """Distribution name of a requirement string ("pkg>=1", "pkg[extra]").
+
+    None when the string is not a PEP 508 requirement, e.g. a local path or
+    a VCS URL, whose distribution name is unknown before installation.
+    """
+    try:
+        return Requirement(requirement).name
+    except InvalidRequirement:
+        return None
+
+
+def _package_versions_probe(packages: List[str]) -> str:
+    """Probe code writing {requirement: version or "?"} to stdout."""
+    pairs = [(p, _distribution_name(p)) for p in packages]
+    return _status_probe(
+        "{req: '?' if name is None else getattr(next(iter("
+        "__import__('importlib.metadata').metadata.distributions(name=name)),"
+        " None), 'version', '?')"
+        f" for req, name in {pairs!r}}}"
+    )
+
+
 def get_kernel_id(arguments: dict) -> str:
     """Get kernel_id from arguments, defaulting to DEFAULT_KERNEL_ID."""
     return arguments.get("kernel_id") or DEFAULT_KERNEL_ID
@@ -147,7 +184,6 @@ async def execute_with_timeout(
         return {"success": False, "kernel_id": kernel_id, "error": error_msg}
 
 
-@server.list_tools()
 async def list_tools():
     """List available MCP tools."""
     return [
@@ -296,7 +332,6 @@ Note: Call this, then call python_exec to continue working.""",
     ]
 
 
-@server.call_tool()
 async def call_tool(name: str, arguments: dict):
     """Handle tool calls."""
     loop = asyncio.get_running_loop()
@@ -312,60 +347,57 @@ async def call_tool(name: str, arguments: dict):
                     None,
                     lambda: create_kernel(None, packages if packages else None),
                 )
-            elif kernel_exists(kernel_id):
-                # kernel_id provided and exists: RESET it
-                await loop.run_in_executor(
-                    None,
-                    lambda: restart_kernel(kernel_id, packages if packages else None),
-                )
             else:
-                # kernel_id provided but doesn't exist: error
-                return [
-                    TextContent(
-                        type="text",
-                        text=json.dumps(
-                            {
-                                "success": False,
-                                "error": f"Kernel {kernel_id} not found. Omit kernel_id to create a new kernel.",
-                            }
+                # kernel_id provided: RESET it (also brings back a kernel
+                # that crashed, with its packages and cwd)
+                try:
+                    await loop.run_in_executor(
+                        None,
+                        lambda: restart_kernel(
+                            kernel_id, packages if packages else None
                         ),
                     )
-                ]
+                except KeyError:
+                    # kernel_id provided but doesn't exist: error
+                    return [
+                        TextContent(
+                            type="text",
+                            text=json.dumps(
+                                {
+                                    "success": False,
+                                    "error": f"Kernel {kernel_id} not found. Omit kernel_id to create a new kernel.",
+                                }
+                            ),
+                        )
+                    ]
+                # Without packages the kernel keeps the ones it had: report
+                # what it actually runs with
+                if not packages:
+                    try:
+                        packages = list(get_kernel_info(kernel_id)["packages"] or [])
+                    except KeyError:
+                        pass
 
             if packages:
-                # Try to get package versions
-                version_code = (
-                    """
-import importlib.metadata
-versions = {}
-for pkg in %r:
-    try:
-        versions[pkg] = importlib.metadata.version(pkg)
-    except:
-        versions[pkg] = "?"
-versions
-"""
-                    % packages
-                )
+                msg = f"Session started with packages: {', '.join(packages)}"
+                # Same probe discipline as python_status: no names bound, no
+                # history entry, _ untouched
                 try:
-                    result = await execute_with_timeout(
-                        version_code, DEFAULT_TIMEOUT, kernel_id
+                    probe = _package_versions_probe(packages)
+                    results = await loop.run_in_executor(
+                        None,
+                        lambda: probe_kernel(kernel_id, [probe], DEFAULT_TIMEOUT),
                     )
-                    if result.get("result"):
-                        versions = ast.literal_eval(result["result"])
+                    result = results[0] if results else None
+                    if result and result.get("error") is None and result.get("stdout"):
+                        versions = ast.literal_eval(result["stdout"].strip())
                         if isinstance(versions, dict):
                             pkg_list = ", ".join(
                                 f"{p} {v}" for p, v in versions.items()
                             )
                             msg = f"Session started. Packages: {pkg_list}"
-                        else:
-                            msg = (
-                                f"Session started with packages: {', '.join(packages)}"
-                            )
-                    else:
-                        msg = f"Session started with packages: {', '.join(packages)}"
                 except Exception:
-                    msg = f"Session started with packages: {', '.join(packages)}"
+                    pass
             else:
                 msg = "Session started (no packages)"
 
@@ -403,6 +435,8 @@ versions
             )
         except (TypeError, ValueError):
             timeout = DEFAULT_TIMEOUT
+        if not timeout > 0:  # also catches NaN
+            timeout = DEFAULT_TIMEOUT
         kernel_id = get_kernel_id(arguments)
 
         if not code.strip():
@@ -459,44 +493,43 @@ versions
         }
 
         if is_active:
-            # Get Python version
-            try:
-                result = await execute_with_timeout(
-                    "import sys; sys.version", STATUS_PROBE_TIMEOUT, kernel_id
-                )
-                if result.get("result"):
-                    status["python_version"] = result["result"].strip("'\"")
-            except Exception:
-                pass
-
-            # Get installed packages
-            try:
-                pkg_code = """
-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, STATUS_PROBE_TIMEOUT, kernel_id
-                )
-                if result.get("result"):
-                    status["packages"] = ast.literal_eval(result["result"])
-            except Exception:
-                pass
-
-            # Get user-defined variables
+            # Probes run only when the kernel is idle (a busy kernel keeps
+            # the defaults above); they never interrupt user code
+            probes = {
+                "python_version": _status_probe("__import__('sys').version"),
+                "packages": _status_probe(
+                    "[f\"{d.metadata['Name']} {d.version}\" for d in"
+                    " __import__('importlib.metadata').metadata.distributions()"
+                    " if d.metadata['Name'] not in"
+                    " ('pip', 'setuptools', 'wheel', 'ipykernel', 'jupyter-client')"
+                    "][:20]"
+                ),
+                "variables": _status_probe(
+                    "[name for name in dir() if not name.startswith('_')"
+                    " and name not in"
+                    " ('In', 'Out', 'get_ipython', 'exit', 'quit', 'open')]"
+                ),
+            }
             try:
-                var_code = """
-[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, STATUS_PROBE_TIMEOUT, kernel_id
+                results = await loop.run_in_executor(
+                    None,
+                    lambda: probe_kernel(
+                        kernel_id, list(probes.values()), STATUS_PROBE_TIMEOUT
+                    ),
                 )
-                if result.get("result"):
-                    status["variables"] = ast.literal_eval(result["result"])
             except Exception:
-                pass
+                results = None
+            for key, result in zip(probes, results or []):
+                if result.get("error") is None and result.get("stdout"):
+                    try:
+                        status[key] = ast.literal_eval(result["stdout"].strip())
+                    except (ValueError, SyntaxError):
+                        pass
+            # The probe retires a kernel found dead: report it like any
+            # kernel that is not in the registry
+            if not kernel_exists(kernel_id):
+                status["active"] = False
+                status["all_kernels"] = [k["id"] for k in list_kernels()]
 
         return [TextContent(type="text", text=json.dumps(status))]
 
@@ -569,6 +602,59 @@ import importlib.metadata
     ]
 
 
+async def _on_list_tools(ctx, params) -> ListToolsResult:
+    """Lowlevel handler: wrap the tool list in its result type."""
+    return ListToolsResult(tools=await list_tools())
+
+
+async def _on_call_tool(ctx, params) -> CallToolResult:
+    """Lowlevel handler.
+
+    The SDK does not wrap a returned content list, and an exception would
+    become a JSON-RPC error instead of an LLM-visible isError result, so both
+    are done here.
+    """
+    arguments = params.arguments or {}
+    # The SDK does not validate arguments against inputSchema
+    tool = next((t for t in await list_tools() if t.name == params.name), None)
+    if tool is not None:
+        schema = tool.model_dump(by_alias=True)["inputSchema"]
+        # Strict function calling sends null for omitted optional arguments:
+        # treat those as absent so the defaults apply (null for a required
+        # argument still fails validation)
+        required = set(schema.get("required", []))
+        arguments = {
+            k: v for k, v in arguments.items() if v is not None or k in required
+        }
+        try:
+            jsonschema.validate(instance=arguments, schema=schema)
+        except jsonschema.ValidationError as e:
+            return CallToolResult(
+                content=[
+                    TextContent(
+                        type="text", text=f"Input validation error: {e.message}"
+                    )
+                ],
+                is_error=True,
+            )
+    try:
+        content = await call_tool(params.name, arguments)
+    except Exception as e:  # error text reaches the model
+        return CallToolResult(
+            content=[TextContent(type="text", text=str(e))], is_error=True
+        )
+    return CallToolResult(content=content)
+
+
+def _make_server() -> Server:
+    return Server(
+        "ipython_mcp", on_list_tools=_on_list_tools, on_call_tool=_on_call_tool
+    )
+
+
+server = _make_server()
+
+
 async def run_server():
     """Run the MCP server."""
     async with stdio_server() as (read, write):

agentic_python_coder/runner.py

@@ -2,7 +2,7 @@
 
 import json
 from pathlib import Path
-from typing import Optional, List, Any, Dict
+from typing import Any, Dict, Iterator, List, Optional
 
 from agentic_python_coder.agent import create_coding_agent, run_agent
 from agentic_python_coder.llm import LLMConfig
@@ -35,6 +35,55 @@ def get_system_prompt_path(todo: bool = False) -> Path:
     return system_prompt_path
 
 
+def _tool_call_event(tool_call: Dict[str, Any]) -> Dict[str, Any]:
+    """Log event for one tool call of an assistant message."""
+    func = tool_call.get("function", {})
+    tool_name = func.get("name", "unknown")
+    try:
+        tool_args = json.loads(func.get("arguments", "{}"))
+    except (json.JSONDecodeError, TypeError):
+        tool_args = {}
+
+    if tool_name == "todo_write":
+        todos = tool_args.get("todos", [])
+        return {
+            "event": "todo",
+            "action": "update",
+            "count": len(todos),
+            "tasks": [
+                {"content": t.get("content", ""), "status": t.get("status", "")}
+                for t in todos
+            ],
+        }
+    if tool_name in ("python_exec", "save_code"):
+        return {"event": tool_name, "code_length": len(tool_args.get("code", ""))}
+    return {"event": "tool_call", "tool": tool_name}
+
+
+def _message_events(msg: Any) -> Iterator[Dict[str, Any]]:
+    """Log events for one run_agent message; run_agent only produces dicts."""
+    if not isinstance(msg, dict):
+        return
+    tool_calls = msg.get("tool_calls", [])
+    if tool_calls:
+        for tool_call in tool_calls:
+            yield _tool_call_event(tool_call)
+    # Tool responses (role=tool messages with JSON content carrying "success")
+    elif msg.get("role") == "tool" and isinstance(msg.get("content"), str):
+        try:
+            content_data = json.loads(msg["content"])
+            if "success" in content_data:
+                yield {
+                    "event": "tool_response",
+                    "success": content_data.get("success", False),
+                    "error": content_data.get("error")
+                    if not content_data.get("success")
+                    else None,
+                }
+        except (json.JSONDecodeError, TypeError):
+            pass
+
+
 def save_conversation_log(
     working_dir: Path,
     messages: List[Any],
@@ -63,157 +112,9 @@ def save_conversation_log(
             json.dumps({"event": "start", "task": task_basename or "inline"}) + "\n"
         )
 
-        # Process messages
         for msg in messages:
-            # Handle dict messages (new format)
-            if isinstance(msg, dict):
-                tool_calls = msg.get("tool_calls", [])
-                if tool_calls:
-                    for tool_call in tool_calls:
-                        func = tool_call.get("function", {})
-                        tool_name = func.get("name", "unknown")
-                        try:
-                            tool_args = json.loads(func.get("arguments", "{}"))
-                        except (json.JSONDecodeError, TypeError):
-                            tool_args = {}
-
-                        if tool_name == "todo_write":
-                            todos = tool_args.get("todos", [])
-                            f.write(
-                                json.dumps(
-                                    {
-                                        "event": "todo",
-                                        "action": "update",
-                                        "count": len(todos),
-                                        "tasks": [
-                                            {
-                                                "content": t.get("content", ""),
-                                                "status": t.get("status", ""),
-                                            }
-                                            for t in todos
-                                        ],
-                                    }
-                                )
-                                + "\n"
-                            )
-                        elif tool_name == "python_exec":
-                            f.write(
-                                json.dumps(
-                                    {
-                                        "event": "python_exec",
-                                        "code_length": len(tool_args.get("code", "")),
-                                    }
-                                )
-                                + "\n"
-                            )
-                        elif tool_name == "save_code":
-                            f.write(
-                                json.dumps(
-                                    {
-                                        "event": "save_code",
-                                        "code_length": len(tool_args.get("code", "")),
-                                    }
-                                )
-                                + "\n"
-                            )
-                        else:
-                            f.write(
-                                json.dumps({"event": "tool_call", "tool": tool_name})
-                                + "\n"
-                            )
-
-                # Handle tool responses (role=tool messages with content)
-                elif msg.get("role") == "tool" and isinstance(msg.get("content"), str):
-                    try:
-                        content_data = json.loads(msg["content"])
-                        if "success" in content_data:
-                            f.write(
-                                json.dumps(
-                                    {
-                                        "event": "tool_response",
-                                        "success": content_data.get("success", False),
-                                        "error": content_data.get("error")
-                                        if not content_data.get("success")
-                                        else None,
-                                    }
-                                )
-                                + "\n"
-                            )
-                    except (json.JSONDecodeError, TypeError):
-                        pass
-
-            # Handle object messages (backward compat)
-            elif hasattr(msg, "tool_calls") and msg.tool_calls:
-                for tool_call in msg.tool_calls:
-                    if isinstance(tool_call, dict):
-                        tool_name = tool_call.get("name", "unknown")
-                        tool_args = tool_call.get("args", {})
-                    else:
-                        tool_name = getattr(tool_call, "name", "unknown")
-                        tool_args = getattr(tool_call, "args", {})
-
-                    if tool_name == "todo_write":
-                        todos = tool_args.get("todos", [])
-                        f.write(
-                            json.dumps(
-                                {
-                                    "event": "todo",
-                                    "action": "update",
-                                    "count": len(todos),
-                                    "tasks": [
-                                        {
-                                            "content": t.get("content", ""),
-                                            "status": t.get("status", ""),
-                                        }
-                                        for t in todos
-                                    ],
-                                }
-                            )
-                            + "\n"
-                        )
-                    elif tool_name == "python_exec":
-                        f.write(
-                            json.dumps(
-                                {
-                                    "event": "python_exec",
-                                    "code_length": len(tool_args.get("code", "")),
-                                }
-                            )
-                            + "\n"
-                        )
-                    elif tool_name == "save_code":
-                        f.write(
-                            json.dumps(
-                                {
-                                    "event": "save_code",
-                                    "code_length": len(tool_args.get("code", "")),
-                                }
-                            )
-                            + "\n"
-                        )
-                    else:
-                        f.write(
-                            json.dumps({"event": "tool_call", "tool": tool_name}) + "\n"
-                        )
-
-            elif hasattr(msg, "content") and isinstance(msg.content, str):
-                try:
-                    content_data = json.loads(msg.content)
-                    if "success" in content_data:
-                        f.write(
-                            json.dumps(
-                                {
-                                    "event": "tool_response",
-                                    "success": content_data.get("success", False),
-                                    "error": content_data.get("error")
-                                    if not content_data.get("success")
-                                    else None,
-                                }
-                            )
-                            + "\n"
-                        )
-                except (json.JSONDecodeError, TypeError):
-                    pass
+            for event in _message_events(msg):
+                f.write(json.dumps(event) + "\n")
 
         # Statistics
         if stats:

{agentic_python_coder-3.4.3.dist-info → agentic_python_coder-3.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agentic-python-coder
-Version: 3.4.3
+Version: 3.5.0
 Summary: A lightweight Python coding agent that writes, executes, and iterates on code through natural language instructions
 Author: Stefan Szeider
 License: Apache-2.0
@@ -17,9 +17,11 @@ Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Software Development :: Code Generators
 Requires-Python: >=3.13
 Requires-Dist: ipykernel>=7.3.0
+Requires-Dist: jsonschema>=4.20.0
 Requires-Dist: jupyter-client>=8.9.1
-Requires-Dist: mcp<2,>=1.28.1
+Requires-Dist: mcp<3,>=2
 Requires-Dist: openai>=2.45.0
+Requires-Dist: packaging>=22
 Requires-Dist: python-dotenv>=1.2.2
 Requires-Dist: pyyaml>=6.0.3
 Requires-Dist: rich>=15.0.0

{agentic_python_coder-3.4.3.dist-info → agentic_python_coder-3.5.0.dist-info}/RECORD

@@ -1,11 +1,11 @@
 agentic_python_coder/__init__.py,sha256=e6o-k__u5xNIiQAkZbHtbZC2-NwpeOdi4MdQtAqJBjE,2112
 agentic_python_coder/agent.py,sha256=0JfVNO-NEss9ZNEYkYvVlJSRzIxNa6sgRqLTdsD4zbs,16484
 agentic_python_coder/cli.py,sha256=NWc1LCEL-L2TVCT6Su9a0AQ3ub3zg5GrY6XG3j_qPgI,14877
-agentic_python_coder/kernel.py,sha256=_gIvDvtLpYGClm5IxTAqijwHG-wi2OtKUaH2Jtk2v0Q,23511
+agentic_python_coder/kernel.py,sha256=z-SgBqErdqAJdsG0SRobrFHKoN_jR3lTHufHPL6_CP8,29756
 agentic_python_coder/llm.py,sha256=ZK3b9wLzjDr6BIxUkfKhuiSDbXNR2XaQsE1J-960IzE,6998
-agentic_python_coder/mcp_server.py,sha256=Osdl8UnjkupXbPLiYCugiapGDJsryZfVai0o-jepuqw,22047
+agentic_python_coder/mcp_server.py,sha256=Xb0MTdfe32dfQRYN26pdwgWiQ8BqD_VvLX6fU0UJGvk,26037
 agentic_python_coder/project_md.py,sha256=4xkQHlWb4cDPEkvegw1YwcfaTJ3aFbrl0CYcC_xxABY,3249
-agentic_python_coder/runner.py,sha256=Kbw1ceYJ4MVfUKgSIkiuBhMb8ZtbZuJwbBeTUsvPRts,13045
+agentic_python_coder/runner.py,sha256=NoYRUyRusIcK-T7bEka_UoZjvcDxUzkONqe4AIXYPtU,7999
 agentic_python_coder/tools.py,sha256=tjhQbsF3n3bFIegnEOtE8czjzbtMSXy6B9gYeb-YAJ4,12088
 agentic_python_coder/examples/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 agentic_python_coder/examples/clingo/README.md,sha256=SgWBqdJ2cHIfYWRV1YYqzfY0rth7mjCR5Act_hchcx0,2345
@@ -45,8 +45,8 @@ agentic_python_coder/models/sonnet5.json,sha256=kf6DIkQlcGVZ40IzRv3GXFtNncZF_gKq
 agentic_python_coder/models/sonnet55.json,sha256=ibqrXCS21NfgE95XBeyeNrbs6XmV00eKA586uf7o0ic,97
 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.4.3.dist-info/METADATA,sha256=Yr9xBjQt73msWBT7C5YABEO3zXSvUp3r2rUOsTdpw74,13255
-agentic_python_coder-3.4.3.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-agentic_python_coder-3.4.3.dist-info/entry_points.txt,sha256=XIW3nZzL4kJ-Igohilj_mTvBcCyHBouDq2jmGzDILrk,107
-agentic_python_coder-3.4.3.dist-info/licenses/LICENSE,sha256=R9-M_V-SPdN71IphOVzM7kCNpUYs_hwj7rtroTwDhs0,11362
-agentic_python_coder-3.4.3.dist-info/RECORD,,
+agentic_python_coder-3.5.0.dist-info/METADATA,sha256=07LE-Gb747kq413uiQlC9K71lQIkAAsNsaoEcoESWpM,13313
+agentic_python_coder-3.5.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+agentic_python_coder-3.5.0.dist-info/entry_points.txt,sha256=XIW3nZzL4kJ-Igohilj_mTvBcCyHBouDq2jmGzDILrk,107
+agentic_python_coder-3.5.0.dist-info/licenses/LICENSE,sha256=R9-M_V-SPdN71IphOVzM7kCNpUYs_hwj7rtroTwDhs0,11362
+agentic_python_coder-3.5.0.dist-info/RECORD,,

{agentic_python_coder-3.4.3.dist-info → agentic_python_coder-3.5.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.32.4
+Generator: hatchling 1.33.0
 Root-Is-Purelib: true
 Tag: py3-none-any