langgraph 1.2.4__tar.gz → 1.2.5__tar.gz

{langgraph-1.2.4 → langgraph-1.2.5}/Makefile

@@ -111,22 +111,19 @@ test_watch_all:
 
 # Define a variable for Python and notebook files.
 PYTHON_FILES=.
-MYPY_CACHE=.mypy_cache
 lint format: PYTHON_FILES=.
 lint_diff format_diff: PYTHON_FILES=$(shell git diff --name-only --relative --diff-filter=d main . | grep -E r'\.py$$|\.ipynb$$')
 lint_package: PYTHON_FILES=langgraph
 lint_tests: PYTHON_FILES=tests
-lint_tests: MYPY_CACHE=.mypy_cache_test
 
 lint lint_diff lint_package lint_tests:
 	uv run ruff check .
 	[ "$(PYTHON_FILES)" = "" ] || uv run ruff format $(PYTHON_FILES) --diff
 	[ "$(PYTHON_FILES)" = "" ] || uv run ruff check --select I $(PYTHON_FILES)
-	[ "$(PYTHON_FILES)" = "" ] || mkdir -p $(MYPY_CACHE)
-	[ "$(PYTHON_FILES)" = "" ] || uv run mypy langgraph --cache-dir $(MYPY_CACHE)
+	[ "$(PYTHON_FILES)" = "" ] || uv run ty check langgraph
 
 type:
-	mkdir -p $(MYPY_CACHE) && uv run mypy langgraph --cache-dir $(MYPY_CACHE)
+	uv run ty check langgraph
 
 format format_diff:
 	uv run ruff format $(PYTHON_FILES)

{langgraph-1.2.4 → langgraph-1.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langgraph
-Version: 1.2.4
+Version: 1.2.5
 Summary: Building stateful, multi-actor applications with LLMs
 Project-URL: Homepage, https://docs.langchain.com/oss/python/langgraph/overview
 Project-URL: Documentation, https://reference.langchain.com/python/langgraph/
@@ -22,7 +22,7 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Python: >=3.10
-Requires-Dist: langchain-core<2,>=1.4.0
+Requires-Dist: langchain-core<2,>=1.4.7
 Requires-Dist: langgraph-checkpoint<5.0.0,>=4.1.0
 Requires-Dist: langgraph-prebuilt<1.2.0,>=1.1.0
 Requires-Dist: langgraph-sdk<0.5.0,>=0.4.2

{langgraph-1.2.4 → langgraph-1.2.5}/langgraph/_internal/_config.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from collections import ChainMap
-from collections.abc import Sequence
+from collections.abc import Mapping, Sequence
 from os import getenv
 from typing import Any, cast
 
@@ -79,6 +79,42 @@ def patch_checkpoint_map(
         return config
 
 
+def _copy_mapping_value(value: Any) -> Any:
+    return dict(value) if isinstance(value, Mapping) else value
+
+
+def _merge_metadata(
+    base: Mapping[str, Any] | None, new: Mapping[str, Any] | None
+) -> dict[str, Any]:
+    """Merge metadata without mutating inputs.
+
+    Top-level keys merge with newer values winning. `lc_versions` is the only
+    mapping-valued key that merges one level deeper, so independent LangChain
+    packages can contribute package versions without changing generic metadata
+    semantics. Mapping values are copied one level, so deeper nested objects
+    remain shared. `None` inputs are treated as empty metadata.
+
+    Mirrors `langchain_core.runnables.config._merge_metadata_dicts` so configs
+    that pass through LangGraph's merge keep the same `lc_versions` semantics;
+    keep the two in sync. Unlike lc-core, this copies mapping values one level
+    (intentionally more defensive — do not "simplify" back to a shared ref).
+    """
+    merged = {key: _copy_mapping_value(value) for key, value in (base or {}).items()}
+    for key, value in (new or {}).items():
+        if (
+            key == "lc_versions"
+            and isinstance(merged.get(key), Mapping)
+            and isinstance(value, Mapping)
+        ):
+            merged[key] = {
+                **cast(Mapping[str, Any], merged[key]),
+                **value,
+            }
+        else:
+            merged[key] = _copy_mapping_value(value)
+    return merged
+
+
 def _merge_callbacks(base: Callbacks, new: Callbacks) -> Callbacks:
     """Merge two callbacks values (None / list / BaseCallbackManager).
 
@@ -126,10 +162,10 @@ def merge_configs(*configs: RunnableConfig | None) -> RunnableConfig:
             if not value:
                 continue
             if key == "metadata":
-                if base_value := base.get(key):
-                    base[key] = {**base_value, **value}  # type: ignore
-                else:
-                    base[key] = value  # type: ignore[literal-required]
+                base[key] = _merge_metadata(
+                    cast(Mapping[str, Any] | None, base.get(key)),
+                    cast(Mapping[str, Any], value),
+                )
             elif key == "tags":
                 if base_value := base.get(key):
                     base[key] = [*base_value, *value]  # type: ignore
@@ -327,14 +363,11 @@ def ensure_config(*configs: RunnableConfig | None) -> RunnableConfig:
                         empty.get("callbacks"), cast(Callbacks, v)
                     )
                 elif k == "metadata":
-                    # Shallow-merge metadata dicts across configs so values
-                    # bound via with_config(...) (e.g. user_id) are preserved
-                    # when later configs supply other metadata keys.
-                    existing = empty.get("metadata")
-                    empty["metadata"] = (
-                        {**cast(dict, existing), **cast(dict, v)}
-                        if existing
-                        else cast(dict, v).copy()
+                    # Matches merge_configs: top-level metadata keys merge, and
+                    # only `lc_versions` merges one level deeper.
+                    empty["metadata"] = _merge_metadata(
+                        cast(Mapping[str, Any] | None, empty.get("metadata")),
+                        cast(Mapping[str, Any], v),
                     )
                 elif k == "tags":
                     # Concatenate tags across configs so values bound via

{langgraph-1.2.4 → langgraph-1.2.5}/langgraph/pregel/main.py

@@ -108,6 +108,7 @@ from langgraph.callbacks import (
     get_sync_graph_callback_manager_for_config,
 )
 from langgraph.channels.base import BaseChannel
+from langgraph.channels.delta import DeltaChannel
 from langgraph.channels.topic import Topic
 from langgraph.config import get_config
 from langgraph.constants import END
@@ -1996,11 +1997,33 @@ class Pregel(
                     ),
                 )
             # save task writes
+            has_delta_writes = any(
+                isinstance(channels.get(c), DeltaChannel)
+                for task in run_tasks
+                for c, _ in task.writes
+            )
+            should_put_writes = saved is not None or has_delta_writes
+
+            if saved is None and has_delta_writes:
+                # If there is no previous checkpoint, we need to create a stub checkpoint
+                # so the first delta writes has a parent to anchor under.
+                # This is the model of DeltaChannel.
+                stub = empty_checkpoint()
+                checkpoint_config = checkpointer.put(
+                    patch_configurable(
+                        checkpoint_config, {CONFIG_KEY_CHECKPOINT_ID: None}
+                    ),
+                    stub,
+                    {"source": "update", "step": -1, "parents": {}},
+                    {},
+                )
+
             for task_id, task in zip(run_task_ids, run_tasks):
                 # channel writes are saved to current checkpoint
                 channel_writes = [w for w in task.writes if w[0] != PUSH]
-                if saved and channel_writes:
+                if should_put_writes and channel_writes:
                     checkpointer.put_writes(checkpoint_config, channel_writes, task_id)
+
             # apply to checkpoint and save
             apply_writes(
                 checkpoint,
@@ -2441,10 +2464,31 @@ class Pregel(
                     ),
                 )
             # save task writes
+            has_delta_writes = any(
+                isinstance(channels.get(c), DeltaChannel)
+                for task in run_tasks
+                for c, _ in task.writes
+            )
+            should_put_writes = saved is not None or has_delta_writes
+
+            if saved is None and has_delta_writes:
+                # If there is no previous checkpoint, we need to create a stub checkpoint
+                # so the first delta writes has a parent to anchor under.
+                # This is the model of DeltaChannel.
+                stub = empty_checkpoint()
+                checkpoint_config = await checkpointer.aput(
+                    patch_configurable(
+                        checkpoint_config, {CONFIG_KEY_CHECKPOINT_ID: None}
+                    ),
+                    stub,
+                    {"source": "update", "step": -1, "parents": {}},
+                    {},
+                )
+
             for task_id, task in zip(run_task_ids, run_tasks):
                 # channel writes are saved to current checkpoint
                 channel_writes = [w for w in task.writes if w[0] != PUSH]
-                if saved and channel_writes:
+                if should_put_writes and channel_writes:
                     await checkpointer.aput_writes(
                         checkpoint_config, channel_writes, task_id
                     )

{langgraph-1.2.4 → langgraph-1.2.5}/langgraph/types.py

@@ -32,7 +32,7 @@ from langgraph.warnings import LangGraphDeprecatedSinceV10, LangGraphDeprecatedS
 
 # Local TypeVars for generic stream TypedDicts.
 # We use separate TypeVars here (rather than importing from langgraph.typing)
-# because the typing module TypeVars have defaults that cause mypy issues
+# because the typing module TypeVars have defaults that cause type checker issues
 # when used in standalone type aliases.
 StateT = TypeVar("StateT")
 OutputT = TypeVar("OutputT")

{langgraph-1.2.4 → langgraph-1.2.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "langgraph"
-version = "1.2.4"
+version = "1.2.5"
 description = "Building stateful, multi-actor applications with LLMs"
 authors = []
 requires-python = ">=3.10"
@@ -24,7 +24,7 @@ classifiers = [
     'Programming Language :: Python :: 3.13',
 ]
 dependencies = [
-    "langchain-core>=1.4.0,<2",
+    "langchain-core>=1.4.7,<2",
     "langgraph-checkpoint>=4.1.0,<5.0.0",
     "langgraph-sdk>=0.4.2,<0.5.0",
     "langgraph-prebuilt>=1.1.0,<1.2.0",
@@ -69,8 +69,8 @@ test = [
     "redis",
 ]
 lint = [
-    "mypy",
     "ruff",
+    "ty",
     "types-requests",
 ]
 dev = [
@@ -99,15 +99,24 @@ target-version = "py310"
 [tool.ruff.lint.flake8-tidy-imports.banned-api]
 "typing.TypedDict".msg = "Use typing_extensions.TypedDict instead."
 
-[tool.mypy]
-# https://mypy.readthedocs.io/en/stable/config_file.html
-disallow_untyped_defs = "True"
-explicit_package_bases = "True"
-warn_no_return = "False"
-warn_unused_ignores = "True"
-warn_redundant_casts = "True"
-allow_redefinition = "True"
-disable_error_code = "typeddict-item, return-value, override, has-type"
+[tool.ty.rules]
+call-non-callable = "ignore"
+deprecated = "ignore"
+invalid-argument-type = "ignore"
+invalid-assignment = "ignore"
+invalid-key = "ignore"
+invalid-method-override = "ignore"
+invalid-paramspec = "ignore"
+invalid-return-type = "ignore"
+invalid-type-form = "ignore"
+invalid-yield = "ignore"
+missing-typed-dict-key = "ignore"
+no-matching-overload = "ignore"
+not-iterable = "ignore"
+unused-type-ignore-comment = "ignore"
+unresolved-attribute = "ignore"
+unsupported-base = "ignore"
+unsupported-operator = "ignore"
 
 [tool.coverage.run]
 omit = ["tests/*"]

langgraph-1.2.5/tests/test_delta_channel_update_state.py

@@ -0,0 +1,294 @@
+"""Tests for `update_state` / `aupdate_state` against `DeltaChannel`.
+
+Originally a regression suite for deepagents#3774 — `update_state` on a *fresh*
+thread silently dropped the first write to a `DeltaChannel`-backed channel
+because channel writes were only persisted when a previous checkpoint existed.
+Fixed by lazily persisting an empty stub checkpoint on a fresh thread so the
+first write has a parent to anchor under (mirrors the exit-mode lazy-stub
+pattern in `_loop._put_exit_delta_writes`).
+
+Coverage:
+
+* fresh-thread regression: single `update_state` writes a message and reads back
+* non-fresh thread: `update_state` after `invoke`, after another `update_state`,
+  and `bulk_update_state` with multiple per-superstep updates
+* update-by-id end-to-end via `update_state` (DeltaChannel reducer semantics)
+* state-history chain shape on a fresh thread (lazy stub + update checkpoint
+  with correct parent linking)
+"""
+
+from typing import Annotated, Any
+
+import pytest
+from langchain_core.messages import HumanMessage
+from langgraph.checkpoint.memory import InMemorySaver
+from typing_extensions import TypedDict
+
+from langgraph.channels.delta import DeltaChannel
+from langgraph.graph import START, StateGraph
+from langgraph.graph.message import _messages_delta_reducer
+
+pytestmark = pytest.mark.anyio
+
+
+def _build_graph(checkpointer: InMemorySaver, *, two_nodes: bool = False) -> Any:
+    """Compile a minimal DeltaChannel-backed `messages` graph.
+
+    `two_nodes=True` adds a second writer node so `bulk_update_state` can route
+    distinct updates to different `as_node` values within a single superstep.
+    """
+    channel = DeltaChannel(_messages_delta_reducer)
+    State = TypedDict("State", {"messages": Annotated[list, channel]})  # type: ignore[call-overload]  # noqa: UP013
+
+    def model(state: dict) -> dict:
+        return {}
+
+    def assistant(state: dict) -> dict:
+        return {}
+
+    builder = StateGraph(State)
+    builder.add_node("model", model)
+    builder.add_edge(START, "model")
+    if two_nodes:
+        builder.add_node("assistant", assistant)
+        builder.add_edge("model", "assistant")
+        builder.set_finish_point("assistant")
+    else:
+        builder.set_finish_point("model")
+    return builder.compile(checkpointer=checkpointer)
+
+
+# ---------------------------------------------------------------------------
+# Fresh-thread regression (deepagents#3774)
+# ---------------------------------------------------------------------------
+
+
+def test_update_state_fresh_thread_delta_channel() -> None:
+    saver = InMemorySaver()
+    graph = _build_graph(saver)
+    config = {"configurable": {"thread_id": "fresh-sync"}}
+    message = HumanMessage(content="hello", id="m1")
+
+    graph.update_state(config, {"messages": [message]}, as_node="model")
+
+    state = graph.get_state(config)
+    assert [m.content for m in state.values["messages"]] == ["hello"]
+
+
+async def test_aupdate_state_fresh_thread_delta_channel() -> None:
+    saver = InMemorySaver()
+    graph = _build_graph(saver)
+    config = {"configurable": {"thread_id": "fresh-async"}}
+    message = HumanMessage(content="hello", id="m1")
+
+    await graph.aupdate_state(config, {"messages": [message]}, as_node="model")
+
+    state = await graph.aget_state(config)
+    assert [m.content for m in state.values["messages"]] == ["hello"]
+
+
+# ---------------------------------------------------------------------------
+# Non-fresh thread: update_state after invoke
+# ---------------------------------------------------------------------------
+
+
+def test_update_state_after_invoke_delta_channel() -> None:
+    """The non-fresh-thread path was already working before the fix; pin it
+    down so the lazy-stub change for fresh threads doesn't regress it."""
+    saver = InMemorySaver()
+    graph = _build_graph(saver)
+    config = {"configurable": {"thread_id": "after-invoke-sync"}}
+
+    graph.invoke({"messages": [HumanMessage(content="seed", id="m1")]}, config)
+    graph.update_state(
+        config,
+        {"messages": [HumanMessage(content="appended", id="m2")]},
+        as_node="model",
+    )
+
+    state = graph.get_state(config)
+    assert [m.content for m in state.values["messages"]] == ["seed", "appended"]
+    assert [m.id for m in state.values["messages"]] == ["m1", "m2"]
+
+
+async def test_aupdate_state_after_invoke_delta_channel() -> None:
+    saver = InMemorySaver()
+    graph = _build_graph(saver)
+    config = {"configurable": {"thread_id": "after-invoke-async"}}
+
+    await graph.ainvoke({"messages": [HumanMessage(content="seed", id="m1")]}, config)
+    await graph.aupdate_state(
+        config,
+        {"messages": [HumanMessage(content="appended", id="m2")]},
+        as_node="model",
+    )
+
+    state = await graph.aget_state(config)
+    assert [m.content for m in state.values["messages"]] == ["seed", "appended"]
+
+
+# ---------------------------------------------------------------------------
+# Non-fresh thread: consecutive update_state calls
+# ---------------------------------------------------------------------------
+
+
+def test_consecutive_update_states_delta_channel() -> None:
+    """First update_state lazily persists a stub; the second sees a real
+    parent (`saved is not None`) and takes the original write path. Both
+    messages must round-trip in chronological order."""
+    saver = InMemorySaver()
+    graph = _build_graph(saver)
+    config = {"configurable": {"thread_id": "consecutive-sync"}}
+
+    graph.update_state(
+        config,
+        {"messages": [HumanMessage(content="first", id="m1")]},
+        as_node="model",
+    )
+    graph.update_state(
+        config,
+        {"messages": [HumanMessage(content="second", id="m2")]},
+        as_node="model",
+    )
+
+    state = graph.get_state(config)
+    assert [m.content for m in state.values["messages"]] == ["first", "second"]
+    assert [m.id for m in state.values["messages"]] == ["m1", "m2"]
+
+
+async def test_aconsecutive_update_states_delta_channel() -> None:
+    saver = InMemorySaver()
+    graph = _build_graph(saver)
+    config = {"configurable": {"thread_id": "consecutive-async"}}
+
+    await graph.aupdate_state(
+        config,
+        {"messages": [HumanMessage(content="first", id="m1")]},
+        as_node="model",
+    )
+    await graph.aupdate_state(
+        config,
+        {"messages": [HumanMessage(content="second", id="m2")]},
+        as_node="model",
+    )
+
+    state = await graph.aget_state(config)
+    assert [m.content for m in state.values["messages"]] == ["first", "second"]
+
+
+# ---------------------------------------------------------------------------
+# Update-by-id semantics through the update_state path
+# ---------------------------------------------------------------------------
+
+
+def test_update_state_replaces_message_by_id_delta_channel() -> None:
+    """`_messages_delta_reducer` dedups by `id` — re-issuing a write with the
+    same id replaces the existing entry rather than appending. Verify this
+    works through the `update_state` path (not just `invoke`)."""
+    saver = InMemorySaver()
+    graph = _build_graph(saver)
+    config = {"configurable": {"thread_id": "update-by-id"}}
+
+    graph.invoke({"messages": [HumanMessage(content="original", id="h1")]}, config)
+    graph.update_state(
+        config,
+        {"messages": [HumanMessage(content="updated", id="h1")]},
+        as_node="model",
+    )
+
+    state = graph.get_state(config)
+    msgs = state.values["messages"]
+    assert len(msgs) == 1
+    assert msgs[0].id == "h1"
+    assert msgs[0].content == "updated"
+
+
+# ---------------------------------------------------------------------------
+# bulk_update_state with multiple updates per superstep
+# ---------------------------------------------------------------------------
+
+
+def test_bulk_update_state_multi_task_per_superstep_delta_channel() -> None:
+    """`bulk_update_state` with N updates in one superstep produces N tasks
+    that each call `put_writes`. Guards the regression where moving
+    `put_writes` outside the per-task loop would persist only the last
+    task's writes.
+
+    Explicit `task_id`s are required to disambiguate writes belonging to
+    different `StateUpdate`s targeting the same node — otherwise both share
+    the deterministic interrupt-derived id and collide in the saver.
+    """
+    from langgraph.types import StateUpdate
+
+    saver = InMemorySaver()
+    graph = _build_graph(saver)
+    config = {"configurable": {"thread_id": "bulk-multi-task"}}
+
+    graph.bulk_update_state(
+        config,
+        [
+            [
+                StateUpdate(
+                    values={"messages": [HumanMessage(content="first", id="m1")]},
+                    as_node="model",
+                    task_id="task-1",
+                ),
+                StateUpdate(
+                    values={"messages": [HumanMessage(content="second", id="m2")]},
+                    as_node="model",
+                    task_id="task-2",
+                ),
+            ]
+        ],
+    )
+
+    state = graph.get_state(config)
+    contents = [m.content for m in state.values["messages"]]
+    ids = [m.id for m in state.values["messages"]]
+    assert sorted(contents) == ["first", "second"], (
+        f"both updates' writes must persist; got {contents}"
+    )
+    assert sorted(ids) == ["m1", "m2"]
+
+
+# ---------------------------------------------------------------------------
+# Public-API observation of the lazy-stub mechanism
+# ---------------------------------------------------------------------------
+
+
+def test_state_history_chain_after_fresh_update_state_delta_channel() -> None:
+    """A fresh-thread `update_state` should produce two checkpoints visible
+    via `get_state_history`: a stub (step=-1, no parent) and the update
+    (step=0, parent=stub). Both attributed `source='update'`."""
+    saver = InMemorySaver()
+    graph = _build_graph(saver)
+    config = {"configurable": {"thread_id": "history-chain"}}
+
+    graph.update_state(
+        config,
+        {"messages": [HumanMessage(content="hello", id="m1")]},
+        as_node="model",
+    )
+
+    # Newest first per `get_state_history` ordering.
+    history = list(graph.get_state_history(config))
+    assert len(history) == 2
+
+    update_snapshot, stub_snapshot = history
+
+    assert update_snapshot.metadata is not None
+    assert update_snapshot.metadata["source"] == "update"
+    assert update_snapshot.metadata["step"] == 0
+    assert [m.content for m in update_snapshot.values["messages"]] == ["hello"]
+
+    assert stub_snapshot.metadata is not None
+    assert stub_snapshot.metadata["source"] == "update"
+    assert stub_snapshot.metadata["step"] == -1
+    assert stub_snapshot.parent_config is None
+
+    # The update checkpoint's parent is the stub.
+    assert update_snapshot.parent_config is not None
+    assert (
+        update_snapshot.parent_config["configurable"]["checkpoint_id"]
+        == stub_snapshot.config["configurable"]["checkpoint_id"]
+    )

{langgraph-1.2.4 → langgraph-1.2.5}/tests/test_large_cases.py

@@ -9,6 +9,7 @@ import pytest
 from langchain_core.messages import AIMessage, AnyMessage, ToolCall
 from langchain_core.runnables import RunnableConfig, RunnableMap, RunnablePick
 from langchain_core.tools import tool
+from langchain_core.version import VERSION as LANGCHAIN_CORE_VERSION
 from langgraph.checkpoint.base import BaseCheckpointSaver
 from langgraph.checkpoint.memory import InMemorySaver
 from langgraph.prebuilt.chat_agent_executor import create_react_agent
@@ -1399,6 +1400,7 @@ def test_prebuilt_tool_chat(snapshot: SnapshotAssertion) -> None:
                 "ls_provider": "fakechatmodel",
                 "ls_model_type": "chat",
                 "ls_integration": "langchain_chat_model",
+                "lc_versions": {"langchain-core": LANGCHAIN_CORE_VERSION},
             },
         ),
         (
@@ -1461,6 +1463,7 @@ def test_prebuilt_tool_chat(snapshot: SnapshotAssertion) -> None:
                 "ls_provider": "fakechatmodel",
                 "ls_model_type": "chat",
                 "ls_integration": "langchain_chat_model",
+                "lc_versions": {"langchain-core": LANGCHAIN_CORE_VERSION},
             },
         ),
     ]
@@ -1513,6 +1516,7 @@ def test_prebuilt_tool_chat(snapshot: SnapshotAssertion) -> None:
                 "ls_provider": "fakechatmodel",
                 "ls_model_type": "chat",
                 "ls_integration": "langchain_chat_model",
+                "lc_versions": {"langchain-core": LANGCHAIN_CORE_VERSION},
             },
         ),
     ]
@@ -6884,6 +6888,7 @@ def test_weather_subgraph(
                     "ls_provider": "fakemessageslistchatmodel",
                     "ls_model_type": "chat",
                     "ls_integration": "langchain_chat_model",
+                    "lc_versions": {"langchain-core": LANGCHAIN_CORE_VERSION},
                 },
             ),
         ),
@@ -6911,6 +6916,7 @@ def test_weather_subgraph(
                     "ls_provider": "fakemessageslistchatmodel",
                     "ls_model_type": "chat",
                     "ls_integration": "langchain_chat_model",
+                    "lc_versions": {"langchain-core": LANGCHAIN_CORE_VERSION},
                 },
             ),
         ),
@@ -6947,6 +6953,7 @@ def test_weather_subgraph(
                 "ls_provider": "fakemessageslistchatmodel",
                 "ls_model_type": "chat",
                 "ls_integration": "langchain_chat_model",
+                "lc_versions": {"langchain-core": LANGCHAIN_CORE_VERSION},
             },
         ),
     ]