codeocean-mcp-server 0.12.0__tar.gz → 0.12.2__tar.gz

{codeocean_mcp_server-0.12.0 → codeocean_mcp_server-0.12.2}/CHANGELOG.md

@@ -1,6 +1,14 @@
 CHANGELOG
 =========
 
+## 0.12.2 (2026-09-03)
+
+- [#42](https://github.com/codeocean/codeocean-mcp-server/pull/42) fix: run synchronous tool bodies in a worker thread
+
+## 0.12.1 (2026-08-28)
+
+- [#40](https://github.com/codeocean/codeocean-mcp-server/pull/40) fix: apply `LOG_FORMAT` to uvicorn's own log records
+
 ## 0.12.0 (2026-08-27)
 
 - [#38](https://github.com/codeocean/codeocean-mcp-server/pull/38) feat: serve over streamable HTTP with per-request credentials

{codeocean_mcp_server-0.12.0 → codeocean_mcp_server-0.12.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: codeocean-mcp-server
-Version: 0.12.0
+Version: 0.12.2
 Summary: Code Ocean MCP Server
 Project-URL: Homepage, https://github.com/codeocean/codeocean-mcp-server
 Project-URL: Issues, https://github.com/codeocean/codeocean-mcp-server/issues
@@ -12,6 +12,7 @@ Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.10
+Requires-Dist: anyio>=4.5
 Requires-Dist: codeocean<0.15.0,>=0.14.0
 Requires-Dist: mcp<1.24.0,>=1.23.0
 Description-Content-Type: text/markdown

{codeocean_mcp_server-0.12.0 → codeocean_mcp_server-0.12.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codeocean-mcp-server"
-version = "0.12.0"
+version = "0.12.2"
 authors = [{ name = "Code Ocean", email = "dev@codeocean.com" }]
 description = "Code Ocean MCP Server"
 readme = "README.md"
@@ -11,6 +11,7 @@ classifiers = [
   "Operating System :: OS Independent",
 ]
 dependencies = [
+  "anyio>=4.5",
   "codeocean>=0.14.0,<0.15.0",
   "mcp>=1.23.0,<1.24.0",
 ]

{codeocean_mcp_server-0.12.0 → codeocean_mcp_server-0.12.2}/src/codeocean_mcp_server/logging_config.py

@@ -3,16 +3,21 @@ import os
 import sys
 
 
-def configure_logging() -> None:
+def configure_logging(transport: str = "stdio") -> None:
     """Configure logging based on LOG_FORMAT environment variable.
 
     If LOG_FORMAT is set, configures the root logger with a StreamHandler
-    using the specified format string. This must be called before FastMCP
-    initialization to ensure our configuration takes precedence.
+    using the specified format string, and, for a transport uvicorn serves,
+    applies the same format to uvicorn's own loggers. This must be called
+    before FastMCP initialization to ensure our configuration takes
+    precedence.
 
     If LOG_FORMAT is not set or is empty, does nothing and lets FastMCP
     configure logging with its default settings.
 
+    Args:
+        transport: The transport the server is about to serve on.
+
     Environment variables:
         LOG_FORMAT: Python logging format string (optional)
 
@@ -45,3 +50,18 @@ def configure_logging() -> None:
     # This must be done before FastMCP calls logging.basicConfig()
     logging.root.addHandler(handler)
     logging.root.setLevel(logging.INFO)
+
+    if transport == "stdio":
+        return
+
+    # Serving over HTTP, uvicorn logs through its own loggers, which it gives handlers that do not
+    # propagate to the root logger. It configures them from this dictionary, which FastMCP leaves
+    # at its default value, so its contents have to be replaced to be reached at all. The import
+    # is local because uvicorn, like in FastMCP itself, is only needed for the transports it serves.
+    from uvicorn.config import LOGGING_CONFIG
+
+    LOGGING_CONFIG["formatters"]["default"]["fmt"] = log_format
+    # Access records carry the request in fields of their own rather than in the message.
+    LOGGING_CONFIG["formatters"]["access"]["fmt"] = log_format.replace(
+        "%(message)s", '%(client_addr)s - "%(request_line)s" %(status_code)s'
+    )

{codeocean_mcp_server-0.12.0 → codeocean_mcp_server-0.12.2}/src/codeocean_mcp_server/server.py

@@ -1,6 +1,10 @@
 import argparse
+import functools
+import inspect
 import os
+from collections.abc import Callable
 
+import anyio
 from codeocean import CodeOcean
 from mcp.server.fastmcp import FastMCP
 
@@ -14,6 +18,34 @@ from codeocean_mcp_server.tools import (
 )
 
 
+class ThreadedFastMCP(FastMCP):
+    """A server that runs synchronous tool bodies in a worker thread.
+
+    FastMCP awaits an asynchronous tool but calls a synchronous one on the event loop, where it
+    blocks the whole process for as long as it runs: no other tool call, and no other session's
+    requests, are served meanwhile. The tools here are synchronous and some wait on a computation,
+    so they are handed to a thread instead. anyio copies the context into it, leaving each call's
+    per-request credentials in place.
+    """
+
+    def tool(self, *args, **kwargs) -> Callable[[Callable], Callable]:
+        """Register a tool, moving a synchronous one off the event loop."""
+        register = super().tool(*args, **kwargs)
+
+        def decorator(fn: Callable) -> Callable:
+            if inspect.iscoroutinefunction(fn):
+                return register(fn)
+
+            @functools.wraps(fn)
+            async def in_worker_thread(**arguments):
+                return await anyio.to_thread.run_sync(functools.partial(fn, **arguments))
+
+            register(in_worker_thread)
+            return fn
+
+        return decorator
+
+
 def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
     """Parse command line arguments."""
     parser = argparse.ArgumentParser(prog="codeocean-mcp-server", description="Code Ocean MCP Server")
@@ -31,8 +63,8 @@ def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
 
 def main():
     """Run the MCP server."""
-    configure_logging()
     args = parse_args()
+    configure_logging(args.transport)
     stdio = args.transport == "stdio"
     domain = os.getenv("CODEOCEAN_DOMAIN")
     token = os.getenv("CODEOCEAN_TOKEN")
@@ -40,7 +72,7 @@ def main():
         raise ValueError("Environment variable CODEOCEAN_DOMAIN must be set.")
     agent_id = os.getenv("AGENT_ID", "AI Agent")
 
-    mcp = FastMCP(
+    mcp = ThreadedFastMCP(
         name="Code Ocean",
         instructions=(
             f"MCP server for Code Ocean: search & run capsules, pipelines, and assets using Code Ocean domain {domain}."

{codeocean_mcp_server-0.12.0 → codeocean_mcp_server-0.12.2}/tests/test_http_transport.py

@@ -23,12 +23,17 @@ from mcp_client import get_tools
 
 SERVER_SCRIPT_PATH = str(Path(__file__).parent.parent / "src" / "codeocean_mcp_server" / "server.py")
 
+# How long the stub API takes to answer a token named "slow-...", standing in for a tool that waits.
+SLOW_API_SECONDS = 3.0
+
 
 class _EchoTokenHandler(BaseHTTPRequestHandler):
     """Answer the custom metadata endpoint with the basic-auth user, which is the API token."""
 
     def do_GET(self):  # noqa: D102, N802
         user = base64.b64decode(self.headers["Authorization"].split(" ")[1]).decode().split(":")[0]
+        if user.startswith("slow-"):
+            time.sleep(SLOW_API_SECONDS)
         body = json.dumps({"categories": [user]}).encode()
         self.send_response(200)
         self.send_header("Content-Type", "application/json")
@@ -110,6 +115,23 @@ def test_concurrent_requests_use_their_own_token(http_server):
     assert bob.structuredContent["categories"] == ["bob-token"]
 
 
+def test_a_slow_tool_does_not_hold_up_other_requests(http_server):
+    """A tool call still waiting on Code Ocean leaves the server free to serve another session."""
+    url, _ = http_server
+
+    async def call_and_time(token: str):
+        result = await _call_get_custom_metadata(url, token)
+        return result, time.monotonic()
+
+    async def both():
+        return await asyncio.gather(call_and_time("slow-token"), call_and_time("fast-token"))
+
+    (slow, slow_finished), (fast, fast_finished) = asyncio.run(both())
+    assert slow.structuredContent["categories"] == ["slow-token"]
+    assert fast.structuredContent["categories"] == ["fast-token"]
+    assert fast_finished < slow_finished - 1
+
+
 def test_request_without_credential_is_refused(http_server):
     """A request carrying no token is refused rather than served with the environment's client."""
     url, _ = http_server

codeocean_mcp_server-0.12.2/tests/test_logging_config.py

@@ -0,0 +1,68 @@
+"""End-to-end test for LOG_FORMAT, over the transport that brings a logger of its own along."""
+
+import os
+import re
+import socket
+import subprocess
+import sys
+import time
+import urllib.error
+import urllib.request
+from pathlib import Path
+
+SERVER_SCRIPT_PATH = str(Path(__file__).parent.parent / "src" / "codeocean_mcp_server" / "server.py")
+LOG_FORMAT = "%(asctime)s server %(levelname)s [%(name)s] %(message)s"
+
+
+def _free_port() -> int:
+    with socket.socket() as sock:
+        sock.bind(("127.0.0.1", 0))
+        return sock.getsockname()[1]
+
+
+def _wait_until_listening(port: int, timeout: float = 30.0):
+    deadline = time.monotonic() + timeout
+    while time.monotonic() < deadline:
+        with socket.socket() as sock:
+            if sock.connect_ex(("127.0.0.1", port)) == 0:
+                return
+        time.sleep(0.1)
+    raise TimeoutError(f"MCP server did not start listening on port {port}")
+
+
+def _serve_and_request(port: int) -> str:
+    """Serve over streamable HTTP, make one request, and return everything the server logged."""
+    env = {**os.environ, "CODEOCEAN_DOMAIN": "test-domain", "LOG_FORMAT": LOG_FORMAT}
+    process = subprocess.Popen(
+        [sys.executable, SERVER_SCRIPT_PATH, "--transport", "streamable-http", "--port", str(port)],
+        env=env,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        text=True,
+    )
+    try:
+        _wait_until_listening(port)
+        request = urllib.request.Request(f"http://127.0.0.1:{port}/mcp", data=b"{}")
+        try:
+            urllib.request.urlopen(request, timeout=30)
+        except urllib.error.HTTPError:
+            pass  # The request is rejected; it is logged either way, which is what is under test.
+    finally:
+        process.terminate()
+        process.wait(timeout=30)
+    return process.stdout.read()
+
+
+def test_log_format_applies_to_uvicorns_own_records():
+    """Uvicorn brings its own logging configuration, in whose format these records would be."""
+    log = _serve_and_request(_free_port())
+
+    timestamp = r"^[\d-]{10} [\d:,]+"
+    assert re.search(rf"{timestamp} server INFO \[uvicorn\.error\] Uvicorn running", log, re.MULTILINE)
+    assert re.search(
+        # The status runs to the end of the line as code and phrase, which only uvicorn's own
+        # access formatter puts there; the raw record carries the code alone.
+        rf'{timestamp} server INFO \[uvicorn\.access\] 127\.0\.0\.1:\d+ - "POST /mcp HTTP/1.1" \d{{3}} \w+( \w+)*$',
+        log,
+        re.MULTILINE,
+    )

{codeocean_mcp_server-0.12.0 → codeocean_mcp_server-0.12.2}/uv.lock

@@ -558,9 +558,10 @@ wheels = [
 
 [[package]]
 name = "codeocean-mcp-server"
-version = "0.12.0"
+version = "0.12.2"
 source = { editable = "." }
 dependencies = [
+    { name = "anyio" },
     { name = "codeocean" },
     { name = "mcp" },
 ]
@@ -577,6 +578,7 @@ dev = [
 
 [package.metadata]
 requires-dist = [
+    { name = "anyio", specifier = ">=4.5" },
     { name = "codeocean", specifier = ">=0.14.0,<0.15.0" },
     { name = "mcp", specifier = ">=1.23.0,<1.24.0" },
 ]