agentic-python-coder 3.4.3__tar.gz → 3.4.4__tar.gz

{agentic_python_coder-3.4.3 → agentic_python_coder-3.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agentic-python-coder
-Version: 3.4.3
+Version: 3.4.4
 Summary: A lightweight Python coding agent that writes, executes, and iterates on code through natural language instructions
 Author: Stefan Szeider
 License: Apache-2.0
@@ -18,7 +18,7 @@ Classifier: Topic :: Software Development :: Code Generators
 Requires-Python: >=3.13
 Requires-Dist: ipykernel>=7.3.0
 Requires-Dist: jupyter-client>=8.9.1
-Requires-Dist: mcp<2,>=1.28.1
+Requires-Dist: mcp<3,>=1.28.1
 Requires-Dist: openai>=2.45.0
 Requires-Dist: python-dotenv>=1.2.2
 Requires-Dist: pyyaml>=6.0.3

{agentic_python_coder-3.4.3 → agentic_python_coder-3.4.4}/coder/src/agentic_python_coder/kernel.py

@@ -157,7 +157,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
 

{agentic_python_coder-3.4.3 → agentic_python_coder-3.4.4}/coder/src/agentic_python_coder/mcp_server.py

@@ -5,6 +5,7 @@ Supports multiple concurrent kernels via kernel_id parameter.
 
 import ast
 import asyncio
+import importlib.metadata
 import json
 import logging
 import os
@@ -13,7 +14,7 @@ import threading
 
 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 agentic_python_coder.kernel import (
     DEFAULT_KERNEL_ID,
@@ -27,11 +28,12 @@ from agentic_python_coder.kernel import (
     shutdown_all_kernels,
 )
 
+_MCP_V2 = int(importlib.metadata.version("mcp").split(".")[0]) >= 2
+
 # 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
@@ -147,7 +149,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 +297,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()
@@ -569,6 +569,41 @@ import importlib.metadata
     ]
 
 
+async def _on_list_tools(ctx, params) -> ListToolsResult:
+    """mcp>=2 lowlevel handler: wrap the tool list in its result type."""
+    return ListToolsResult(tools=await list_tools())
+
+
+async def _on_call_tool(ctx, params) -> CallToolResult:
+    """mcp>=2 lowlevel handler.
+
+    v2 no longer wraps a returned content list, and an exception would become
+    a JSON-RPC error instead of an LLM-visible isError result (v1 behaviour),
+    so both are done here.
+    """
+    try:
+        content = await call_tool(params.name, params.arguments or {})
+    except Exception as e:  # keep v1 semantics: 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:
+    if _MCP_V2:
+        return Server(
+            "ipython_mcp", on_list_tools=_on_list_tools, on_call_tool=_on_call_tool
+        )
+    srv = Server("ipython_mcp")
+    srv.list_tools()(list_tools)
+    srv.call_tool()(call_tool)
+    return srv
+
+
+server = _make_server()
+
+
 async def run_server():
     """Run the MCP server."""
     async with stdio_server() as (read, write):

{agentic_python_coder-3.4.3 → agentic_python_coder-3.4.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agentic-python-coder"
-version = "3.4.3"
+version = "3.4.4"
 description = "A lightweight Python coding agent that writes, executes, and iterates on code through natural language instructions"
 readme = "README.md"
 requires-python = ">=3.13"
@@ -27,7 +27,7 @@ dependencies = [
     "jupyter-client>=8.9.1",
     "ipykernel>=7.3.0",
     "PyYAML>=6.0.3",
-    "mcp>=1.28.1,<2",
+    "mcp>=1.28.1,<3",
 ]
 
 [project.scripts]
@@ -82,6 +82,10 @@ target-version = "py313"
 line-length = 88
 exclude = ["CPBENCH", "LOCAL", "TRASH"]
 
+[tool.ruff.lint]
+# Explicit: ruff 0.17 widened its default rule set
+select = ["E4", "E7", "E9", "F"]
+
 [tool.mypy]
 python_version = "3.13"
 warn_return_any = true

agentic_python_coder-3.4.3/coder/tests/test_kernel.py

@@ -1,212 +0,0 @@
-"""Tests for the IPython kernel module."""
-
-import pytest
-from agentic_python_coder.kernel import (
-    PythonKernel,
-    get_kernel,
-    shutdown_kernel,
-    format_output,
-)
-
-
-@pytest.fixture
-def kernel():
-    """Create a fresh kernel for each test."""
-    # Shutdown any existing global kernel
-    shutdown_kernel()
-    # Create a new kernel
-    k = PythonKernel()
-    yield k
-    # Cleanup
-    k.shutdown()
-    shutdown_kernel()
-
-
-class TestKernelBasics:
-    """Test basic kernel execution."""
-
-    def test_simple_expression(self, kernel):
-        """Basic expression returns result."""
-        output = kernel.execute("2 + 2")
-        assert output["error"] is None
-        assert output["result"] == "4"
-
-    def test_print_output(self, kernel):
-        """Print statements captured in stdout."""
-        output = kernel.execute("print('hello world')")
-        assert output["error"] is None
-        assert "hello world" in output["stdout"]
-
-    def test_multiline_code(self, kernel):
-        """Multiline code executes correctly."""
-        code = """
-x = 10
-y = 20
-x + y
-"""
-        output = kernel.execute(code)
-        assert output["error"] is None
-        assert output["result"] == "30"
-
-    def test_syntax_error(self, kernel):
-        """Syntax errors are captured."""
-        output = kernel.execute("def (")
-        assert output["error"] is not None
-        assert "SyntaxError" in output["error"]
-
-    def test_runtime_error(self, kernel):
-        """Runtime errors are captured."""
-        output = kernel.execute("1 / 0")
-        assert output["error"] is not None
-        assert "ZeroDivisionError" in output["error"]
-
-    def test_stderr_capture(self, kernel):
-        """Stderr is captured."""
-        output = kernel.execute("import sys; print('error', file=sys.stderr)")
-        assert "error" in output["stderr"]
-
-
-class TestKernelStatePersistence:
-    """Test that state persists across executions."""
-
-    def test_variable_persistence(self, kernel):
-        """Variables persist between calls."""
-        kernel.execute("x = 42")
-        output = kernel.execute("x * 2")
-        assert output["result"] == "84"
-
-    def test_function_persistence(self, kernel):
-        """Functions persist between calls."""
-        kernel.execute("def double(n): return n * 2")
-        output = kernel.execute("double(21)")
-        assert output["result"] == "42"
-
-    def test_import_persistence(self, kernel):
-        """Imports persist between calls."""
-        kernel.execute("import math")
-        output = kernel.execute("math.pi")
-        assert "3.14" in output["result"]
-
-    def test_class_persistence(self, kernel):
-        """Classes persist between calls."""
-        kernel.execute("class Counter:\n    def __init__(self):\n        self.n = 0")
-        kernel.execute("c = Counter()")
-        kernel.execute("c.n = 5")
-        output = kernel.execute("c.n")
-        assert output["result"] == "5"
-
-
-class TestMessageLoopFix:
-    """Test that message loop waits for idle status."""
-
-    def test_slow_print_captured(self, kernel):
-        """Slow output is fully captured (waits for idle, not Empty)."""
-        # This used to break early on Empty before the fix
-        code = """
-import time
-for i in range(5):
-    print(f"line {i}")
-    time.sleep(0.1)
-print("done")
-"""
-        output = kernel.execute(code)
-        assert output["error"] is None
-        assert "line 0" in output["stdout"]
-        assert "line 4" in output["stdout"]
-        assert "done" in output["stdout"]
-
-    def test_delayed_result(self, kernel):
-        """Result from delayed computation is captured."""
-        code = """
-import time
-time.sleep(0.5)
-42 * 2
-"""
-        output = kernel.execute(code)
-        assert output["error"] is None
-        assert output["result"] == "84"
-
-
-class TestFormatOutput:
-    """Test output formatting."""
-
-    def test_success_format(self):
-        """Successful output is formatted correctly."""
-        output = {"stdout": "hello", "stderr": "", "result": "42", "error": None}
-        result = format_output(output)
-        assert '"success": true' in result
-        assert '"stdout": "hello"' in result
-        assert '"result": "42"' in result
-
-    def test_error_format(self):
-        """Error output is formatted correctly."""
-        output = {
-            "stdout": "",
-            "stderr": "",
-            "result": None,
-            "error": "ValueError: bad",
-        }
-        result = format_output(output)
-        assert '"success": false' in result
-        assert "ValueError" in result
-
-    def test_none_values_removed(self):
-        """None values are removed from output."""
-        output = {"stdout": "", "stderr": None, "result": None, "error": None}
-        result = format_output(output)
-        assert "stderr" not in result
-        assert "result" not in result
-
-
-class TestGlobalKernel:
-    """Test global kernel management."""
-
-    def test_get_kernel_creates_kernel(self):
-        """get_kernel creates a new kernel if none exists."""
-        shutdown_kernel()  # Ensure clean state
-        k = get_kernel()
-        assert k is not None
-        output = k.execute("1 + 1")
-        assert output["result"] == "2"
-        shutdown_kernel()
-
-    def test_get_kernel_reuses_kernel(self):
-        """get_kernel reuses existing kernel with same config."""
-        shutdown_kernel()
-        k1 = get_kernel()
-        k1.execute("x = 123")
-        k2 = get_kernel()
-        output = k2.execute("x")
-        assert output["result"] == "123"
-        shutdown_kernel()
-
-    def test_shutdown_clears_state(self):
-        """shutdown_kernel clears the global kernel."""
-        shutdown_kernel()
-        k = get_kernel()
-        k.execute("y = 456")
-        shutdown_kernel()
-        k2 = get_kernel()
-        output = k2.execute("y")
-        assert output["error"] is not None
-        assert "NameError" in output["error"]
-        shutdown_kernel()
-
-
-class TestDeadlineTimeout:
-    """Deadline overrun must report a timeout error, not silent success."""
-
-    def test_timeout_reports_error_and_interrupts(self, kernel):
-        output = kernel.execute("import time; time.sleep(30)", deadline_timeout=2)
-        assert output["error"] is not None
-        assert "timed out" in output["error"]
-
-        # The interrupt (plus grace period) must leave the kernel usable
-        output2 = kernel.execute("21 * 2")
-        assert output2["error"] is None
-        assert output2["result"] == "42"
-
-    def test_fast_code_unaffected_by_deadline(self, kernel):
-        output = kernel.execute("1 + 1", deadline_timeout=30)
-        assert output["error"] is None
-        assert output["result"] == "2"