The agent engineering platform.
Python agentsaiai-agentsanthropicchatgptdeepagentsenterpriseframeworkgeminigenerative-ailangchainlanggraphllmmultiagentopen-sourceopenaipydanticpythonragtypescript
chore(core): reduce streaming metadata / perf (#36588)
Eugene Yurtsevaf4d711a2f2e
diff --git a/libs/core/Makefile b/libs/core/Makefileindex 4f0e1e2022..4df60bc02c 100644--- a/libs/core/Makefile+++ b/libs/core/Makefile@@ -17,7 +17,7 @@ test tests:-u LANGSMITH_API_KEY \-u LANGSMITH_TRACING \-u LANGCHAIN_PROJECT \- uv run --group test pytest -n auto $(PYTEST_EXTRA) --disable-socket --allow-unix-socket $(TEST_FILE)+ uv run --group test pytest -n auto --benchmark-disable $(PYTEST_EXTRA) --disable-socket --allow-unix-socket $(TEST_FILE)test_watch:env \diff --git a/libs/core/langchain_core/callbacks/manager.py b/libs/core/langchain_core/callbacks/manager.pyindex 31aa2ac156..19f66f6d46 100644--- a/libs/core/langchain_core/callbacks/manager.py+++ b/libs/core/langchain_core/callbacks/manager.py@@ -7,7 +7,7 @@ import atexitimport functoolsimport loggingfrom abc import ABC, abstractmethod-from collections.abc import Callable+from collections.abc import Callable, Mappingfrom concurrent.futures import ThreadPoolExecutorfrom contextlib import asynccontextmanager, contextmanagerfrom contextvars import copy_context@@ -1614,6 +1614,9 @@ class CallbackManager(BaseCallbackManager):local_tags: list[str] | None = None,inheritable_metadata: dict[str, Any] | None = None,local_metadata: dict[str, Any] | None = None,+ *,+ langsmith_inheritable_metadata: Mapping[str, Any] | None = None,+ langsmith_inheritable_tags: list[str] | None = None,) -> CallbackManager:"""Configure the callback manager.@@ -1625,6 +1628,10 @@ class CallbackManager(BaseCallbackManager):local_tags: The local tags.inheritable_metadata: The inheritable metadata.local_metadata: The local metadata.+ langsmith_inheritable_metadata: Default inheritable metadata applied+ to any `LangChainTracer` handlers via `set_defaults`.+ langsmith_inheritable_tags: Default inheritable tags applied to any+ `LangChainTracer` handlers via `set_defaults`.Returns:The configured callback manager.@@ -1638,6 +1645,8 @@ class CallbackManager(BaseCallbackManager):inheritable_metadata,local_metadata,verbose=verbose,+ langsmith_inheritable_metadata=langsmith_inheritable_metadata,+ langsmith_inheritable_tags=langsmith_inheritable_tags,)@@ -2134,6 +2143,9 @@ class AsyncCallbackManager(BaseCallbackManager):local_tags: list[str] | None = None,inheritable_metadata: dict[str, Any] | None = None,local_metadata: dict[str, Any] | None = None,+ *,+ langsmith_inheritable_metadata: Mapping[str, Any] | None = None,+ langsmith_inheritable_tags: list[str] | None = None,) -> AsyncCallbackManager:"""Configure the async callback manager.@@ -2145,6 +2157,10 @@ class AsyncCallbackManager(BaseCallbackManager):local_tags: The local tags.inheritable_metadata: The inheritable metadata.local_metadata: The local metadata.+ langsmith_inheritable_metadata: Default inheritable metadata applied+ to any `LangChainTracer` handlers via `set_defaults`.+ langsmith_inheritable_tags: Default inheritable tags applied to any+ `LangChainTracer` handlers via `set_defaults`.Returns:The configured async callback manager.@@ -2158,6 +2174,8 @@ class AsyncCallbackManager(BaseCallbackManager):inheritable_metadata,local_metadata,verbose=verbose,+ langsmith_inheritable_metadata=langsmith_inheritable_metadata,+ langsmith_inheritable_tags=langsmith_inheritable_tags,)@@ -2304,6 +2322,8 @@ def _configure(local_metadata: dict[str, Any] | None = None,*,verbose: bool = False,+ langsmith_inheritable_metadata: Mapping[str, Any] | None = None,+ langsmith_inheritable_tags: list[str] | None = None,) -> T:"""Configure the callback manager.@@ -2316,6 +2336,10 @@ def _configure(inheritable_metadata: The inheritable metadata.local_metadata: The local metadata.verbose: Whether to enable verbose mode.+ langsmith_inheritable_metadata: Default inheritable metadata applied to+ any `LangChainTracer` handlers via `set_defaults`.+ langsmith_inheritable_tags: Default inheritable tags applied to any+ `LangChainTracer` handlers via `set_defaults`.Raises:RuntimeError: If `LANGCHAIN_TRACING` is set but `LANGCHAIN_TRACING_V2` is not.@@ -2387,8 +2411,6 @@ def _configure(if inheritable_metadata or local_metadata:callback_manager.add_metadata(inheritable_metadata or {})callback_manager.add_metadata(local_metadata or {}, inherit=False)- if tracing_metadata:- callback_manager.add_metadata(tracing_metadata.copy())if tracing_tags:callback_manager.add_tags(tracing_tags.copy())@@ -2440,6 +2462,7 @@ def _configure(else tracing_context["client"]),tags=tracing_tags,+ metadata=tracing_metadata,)callback_manager.add_handler(handler)except Exception as e:@@ -2479,6 +2502,32 @@ def _configure(for handler in callback_manager.handlers):callback_manager.add_handler(var_handler, inheritable)++ if tracing_metadata:+ langsmith_inheritable_metadata = {+ **tracing_metadata,+ **(langsmith_inheritable_metadata or {}),+ }++ if langsmith_inheritable_metadata or langsmith_inheritable_tags:+ callback_manager.handlers = [+ handler.copy_with_metadata_defaults(+ metadata=langsmith_inheritable_metadata,+ tags=langsmith_inheritable_tags,+ )+ if isinstance(handler, LangChainTracer)+ else handler+ for handler in callback_manager.handlers+ ]+ callback_manager.inheritable_handlers = [+ handler.copy_with_metadata_defaults(+ metadata=langsmith_inheritable_metadata,+ tags=langsmith_inheritable_tags,+ )+ if isinstance(handler, LangChainTracer)+ else handler+ for handler in callback_manager.inheritable_handlers+ ]return callback_managerdiff --git a/libs/core/langchain_core/runnables/config.py b/libs/core/langchain_core/runnables/config.pyindex b538ff9fa0..5bae048837 100644--- a/libs/core/langchain_core/runnables/config.py+++ b/libs/core/langchain_core/runnables/config.py@@ -138,6 +138,28 @@ COPIABLE_KEYS = ["configurable",]++# Users are expected to use the `context` API with a context object+# (which does not get traced)+CONFIGURABLE_TO_TRACING_METADATA_EXCLUDED_KEYS = frozenset(("api_key",))+++def _get_langsmith_inheritable_metadata_from_config(+ config: RunnableConfig,+) -> dict[str, Any] | None:+ """Get LangSmith-only inheritable metadata defaults derived from config."""+ configurable = config.get("configurable") or {}+ metadata = {+ key: value+ for key, value in configurable.items()+ if not key.startswith("__")+ and isinstance(value, (str, int, float, bool))+ and key not in config.get("metadata", {})+ and key not in CONFIGURABLE_TO_TRACING_METADATA_EXCLUDED_KEYS+ }+ return metadata or None++DEFAULT_RECURSION_LIMIT = 25@@ -264,14 +286,11 @@ def ensure_config(config: RunnableConfig | None = None) -> RunnableConfig:for k, v in config.items():if k not in CONFIG_KEYS and v is not None:empty["configurable"][k] = v- for key, value in empty.get("configurable", {}).items():- if (- not key.startswith("__")- and isinstance(value, (str, int, float, bool))- and key not in empty["metadata"]- and key != "api_key"- ):- empty["metadata"][key] = value+ if (+ isinstance(model := empty.get("configurable", {}).get("model"), str)+ and "model" not in empty["metadata"]+ ):+ empty["metadata"]["model"] = modelreturn empty@@ -508,6 +527,9 @@ def get_callback_manager_for_config(config: RunnableConfig) -> CallbackManager:inheritable_callbacks=config.get("callbacks"),inheritable_tags=config.get("tags"),inheritable_metadata=config.get("metadata"),+ langsmith_inheritable_metadata=_get_langsmith_inheritable_metadata_from_config(+ config+ ),)@@ -526,6 +548,9 @@ def get_async_callback_manager_for_config(inheritable_callbacks=config.get("callbacks"),inheritable_tags=config.get("tags"),inheritable_metadata=config.get("metadata"),+ langsmith_inheritable_metadata=_get_langsmith_inheritable_metadata_from_config(+ config+ ),)diff --git a/libs/core/langchain_core/tracers/core.py b/libs/core/langchain_core/tracers/core.pyindex bbfb5492d8..5d08a03b46 100644--- a/libs/core/langchain_core/tracers/core.py+++ b/libs/core/langchain_core/tracers/core.py@@ -51,6 +51,8 @@ class _TracerCore(ABC):_schema_format: Literal["original", "streaming_events", "original+chat"] = "original",+ run_map: dict[str, Run] | None = None,+ order_map: dict[UUID, tuple[UUID, str]] | None = None,**kwargs: Any,) -> None:"""Initialize the tracer.@@ -70,6 +72,8 @@ class _TracerCore(ABC):streaming events.- `'original+chat'` is a format that is the same as `'original'` exceptit does NOT raise an attribute error `on_chat_model_start`+ run_map: Optional shared map of run ID to run.+ order_map: Optional shared map of run ID to trace ordering data.**kwargs: Additional keyword arguments that will be passed to thesuperclass."""@@ -77,10 +81,10 @@ class _TracerCore(ABC):self._schema_format = _schema_format # For internal use only API will change.- self.run_map: dict[str, Run] = {}+ self.run_map = run_map if run_map is not None else {}"""Map of run ID to run. Cleared on run end."""- self.order_map: dict[UUID, tuple[UUID, str]] = {}+ self.order_map = order_map if order_map is not None else {}"""Map of run ID to (trace_id, dotted_order). Cleared when tracer GCed."""@abstractmethoddiff --git a/libs/core/langchain_core/tracers/langchain.py b/libs/core/langchain_core/tracers/langchain.pyindex 2a2b5ce0f6..a0abe15539 100644--- a/libs/core/langchain_core/tracers/langchain.py+++ b/libs/core/langchain_core/tracers/langchain.py@@ -27,6 +27,8 @@ from langchain_core.tracers.base import BaseTracerfrom langchain_core.tracers.schemas import Runif TYPE_CHECKING:+ from collections.abc import Mapping+from langchain_core.messages import BaseMessagefrom langchain_core.outputs import ChatGenerationChunk, GenerationChunk@@ -124,6 +126,8 @@ class LangChainTracer(BaseTracer):project_name: str | None = None,client: Client | None = None,tags: list[str] | None = None,+ *,+ metadata: Mapping[str, str] | None = None,**kwargs: Any,) -> None:"""Initialize the LangChain tracer.@@ -139,6 +143,9 @@ class LangChainTracer(BaseTracer):tags: The tags.Defaults to an empty list.+ metadata: Additional metadata to include if it isn't already in the run.++ Defaults to None.**kwargs: Additional keyword arguments."""super().__init__(**kwargs)@@ -150,6 +157,39 @@ class LangChainTracer(BaseTracer):self.tags = tags or []self.latest_run: Run | None = Noneself.run_has_token_event_map: dict[str, bool] = {}+ self.tracing_metadata: dict[str, str] | None = (+ dict(metadata) if metadata is not None else None+ )++ def copy_with_metadata_defaults(+ self,+ *,+ metadata: Mapping[str, str] | None = None,+ tags: list[str] | None = None,+ ) -> LangChainTracer:+ """Return a new tracer with merged tracer-only defaults."""+ base_metadata = self.tracing_metadata+ if metadata is None:+ merged_metadata = dict(base_metadata) if base_metadata is not None else None+ elif base_metadata is None:+ merged_metadata = dict(metadata)+ else:+ merged_metadata = dict(base_metadata)+ for key, value in metadata.items():+ if key not in merged_metadata:+ merged_metadata[key] = value++ merged_tags = sorted(set(self.tags + tags)) if tags else self.tags++ return self.__class__(+ example_id=self.example_id,+ project_name=self.project_name,+ client=self.client,+ tags=merged_tags,+ metadata=merged_metadata,+ run_map=self.run_map,+ order_map=self.order_map,+ )def _start_trace(self, run: Run) -> None:if self.project_name:@@ -263,6 +303,7 @@ class LangChainTracer(BaseTracer):try:run.extra["runtime"] = get_runtime_environment()run.tags = self._get_tags(run)+ _patch_missing_metadata(self, run)if run.ls_client is not self.client:run.ls_client = self.clientrun.post()@@ -398,3 +439,17 @@ class LangChainTracer(BaseTracer):"""Wait for the given futures to complete."""if self.client is not None:self.client.flush()+++def _patch_missing_metadata(self: LangChainTracer, run: Run) -> None:+ if not self.tracing_metadata:+ return+ metadata = run.metadata+ patched = None+ for k, v in self.tracing_metadata.items():+ if k not in metadata:+ if patched is None:+ # Copy on first miss to avoid mutating the shared dict.+ patched = {**metadata}+ run.extra["metadata"] = patched+ patched[k] = vdiff --git a/libs/core/tests/unit_tests/runnables/test_config.py b/libs/core/tests/unit_tests/runnables/test_config.pyindex 5897879d90..9a4716e826 100644--- a/libs/core/tests/unit_tests/runnables/test_config.py+++ b/libs/core/tests/unit_tests/runnables/test_config.py@@ -16,6 +16,7 @@ from langchain_core.callbacks.streaming_stdout import StreamingStdOutCallbackHanfrom langchain_core.runnables import RunnableBinding, RunnablePassthroughfrom langchain_core.runnables.config import (RunnableConfig,+ _get_langsmith_inheritable_metadata_from_config,_set_config_context,ensure_config,merge_configs,@@ -61,7 +62,7 @@ def test_ensure_config() -> None:assert config["configurable"] is not arg["configurable"]assert config == {"tags": ["tag1", "tag2"],- "metadata": {"foo": "bar", "baz": "qux", "something": "else"},+ "metadata": {"foo": "bar"},"callbacks": [arg["callbacks"][0]],"recursion_limit": 100,"configurable": {"baz": "qux", "something": "else"},@@ -71,6 +72,145 @@ def test_ensure_config() -> None:}+def test_ensure_config_copies_model_to_metadata() -> None:+ config = ensure_config(+ {+ "configurable": {+ "thread_id": "th-123",+ "checkpoint_id": "ckpt-1",+ "checkpoint_ns": "ns-1",+ "task_id": "task-1",+ "run_id": "run-456",+ "assistant_id": "asst-789",+ "graph_id": "graph-0",+ "model": "gpt-4o",+ "user_id": "uid-1",+ "cron_id": "cron-1",+ "langgraph_auth_user_id": "user-1",+ "some_api_key": "opaque-token",+ "custom_setting": {"nested": True},+ "none_value": None,+ },+ "metadata": {"nooverride": 18},+ }+ )++ assert config["metadata"] == {"nooverride": 18, "model": "gpt-4o"}+ assert config["configurable"] == {+ "thread_id": "th-123",+ "checkpoint_id": "ckpt-1",+ "checkpoint_ns": "ns-1",+ "task_id": "task-1",+ "run_id": "run-456",+ "assistant_id": "asst-789",+ "graph_id": "graph-0",+ "model": "gpt-4o",+ "user_id": "uid-1",+ "cron_id": "cron-1",+ "langgraph_auth_user_id": "user-1",+ "some_api_key": "opaque-token",+ "custom_setting": {"nested": True},+ "none_value": None,+ }+++def test_ensure_config_metadata_is_not_overridden_by_configurable_model() -> None:+ config = ensure_config(+ {+ "configurable": {+ "model": "from-configurable",+ "run_id": None,+ "checkpoint_ns": "from-configurable",+ },+ "metadata": {+ "model": "from-metadata",+ "run_id": "from-metadata",+ "checkpoint_ns": "from-metadata",+ },+ }+ )++ assert config["metadata"] == {+ "model": "from-metadata",+ "run_id": "from-metadata",+ "checkpoint_ns": "from-metadata",+ }+ assert config["configurable"] == {+ "model": "from-configurable",+ "run_id": None,+ "checkpoint_ns": "from-configurable",+ }+++def test_ensure_config_copies_top_level_model_to_metadata() -> None:+ config = ensure_config(+ cast(+ "RunnableConfig",+ {+ "model": "gpt-4o",+ "metadata": {"nooverride": 18},+ },+ )+ )++ assert config["metadata"] == {"nooverride": 18, "model": "gpt-4o"}+ assert config["configurable"] == {"model": "gpt-4o"}+++def test_get_langsmith_inheritable_metadata_from_config_uses_previous_copy_rules() -> (+ None+):+ config = ensure_config(+ cast(+ "RunnableConfig",+ {+ "something": "else",+ "metadata": {+ "foo": "bar",+ "model": "from-metadata",+ "checkpoint_ns": "from-metadata",+ },+ "configurable": {+ "baz": "qux",+ "thread_id": "th-123",+ "checkpoint_id": "ckpt-1",+ "checkpoint_ns": "from-configurable",+ "task_id": "task-1",+ "run_id": "run-456",+ "assistant_id": "asst-789",+ "graph_id": "graph-0",+ "model": "from-configurable",+ "user_id": "uid-1",+ "cron_id": "cron-1",+ "langgraph_auth_user_id": "user-1",+ "api_key": "should-not-propagate",+ "__secret_key": "should-not-propagate",+ "temperature": 0.5,+ "streaming": True,+ "custom_setting": {"nested": True},+ "none_value": None,+ },+ },+ )+ )++ assert _get_langsmith_inheritable_metadata_from_config(config) == {+ "something": "else",+ "baz": "qux",+ "thread_id": "th-123",+ "checkpoint_id": "ckpt-1",+ "task_id": "task-1",+ "run_id": "run-456",+ "assistant_id": "asst-789",+ "graph_id": "graph-0",+ "user_id": "uid-1",+ "cron_id": "cron-1",+ "langgraph_auth_user_id": "user-1",+ "temperature": 0.5,+ "streaming": True,+ }++async def test_merge_config_callbacks() -> None:manager: RunnableConfig = {"callbacks": CallbackManager(handlers=[StdOutCallbackHandler()])diff --git a/libs/core/tests/unit_tests/runnables/test_runnable.py b/libs/core/tests/unit_tests/runnables/test_runnable.pyindex b6848c2cd8..da648b0031 100644--- a/libs/core/tests/unit_tests/runnables/test_runnable.py+++ b/libs/core/tests/unit_tests/runnables/test_runnable.py@@ -1162,7 +1162,7 @@ async def test_with_config_metadata_passthrough(mocker: MockerFixture) -> None:"callbacks": None,"recursion_limit": 25,"configurable": {"hello": "there", "__secret_key": "nahnah"},- "metadata": {"hello": "there", "bye": "now"},+ "metadata": {"bye": "now"},},)spy.reset_mock()diff --git a/libs/core/tests/unit_tests/runnables/test_tracing_interops.py b/libs/core/tests/unit_tests/runnables/test_tracing_interops.pyindex b5fae902f7..c163e024ad 100644--- a/libs/core/tests/unit_tests/runnables/test_tracing_interops.py+++ b/libs/core/tests/unit_tests/runnables/test_tracing_interops.py@@ -1,7 +1,10 @@from __future__ import annotations+import asyncio+import concurrent.futuresimport jsonimport sys+import threadingimport uuidfrom inspect import isasyncgenfunctionfrom typing import TYPE_CHECKING, Any, Literal@@ -12,13 +15,15 @@ from langsmith import Client, RunTree, get_current_run_tree, traceablefrom langsmith.run_helpers import tracing_contextfrom langsmith.utils import get_env_var+from langchain_core.callbacks.base import BaseCallbackHandler+from langchain_core.callbacks.manager import CallbackManagerfrom langchain_core.runnables.base import RunnableLambda, RunnableParallelfrom langchain_core.tracers.langchain import LangChainTracerif TYPE_CHECKING:- from collections.abc import AsyncGenerator, Callable, Coroutine, Generator+ from collections.abc import AsyncGenerator, Callable, Coroutine, Generator, Mapping- from langchain_core.callbacks import BaseCallbackHandler+ from langchain_core.runnables.config import RunnableConfigdef _get_posts(client: Client) -> list[dict[str, Any]]:@@ -43,12 +48,15 @@ def _get_posts(client: Client) -> list[dict[str, Any]]:def _create_tracer_with_mocked_client(project_name: str | None = None,tags: list[str] | None = None,+ metadata: Mapping[str, str] | None = None,) -> LangChainTracer:mock_session = MagicMock()mock_client_ = Client(session=mock_session, api_key="test", auto_batch_tracing=False)- return LangChainTracer(client=mock_client_, project_name=project_name, tags=tags)+ return LangChainTracer(+ client=mock_client_, project_name=project_name, tags=tags, metadata=metadata+ )def test_tracing_context() -> None:@@ -75,6 +83,38 @@ def test_tracing_context() -> None:assert all(post["session_name"] == project_name for post in posts)+def test_inheritable_metadata_respects_explicit_metadata_with_tracing_context() -> None:+ """Tracer defaults fill missing keys while run metadata keeps precedence."""+ tracer = _create_tracer_with_mocked_client()++ @RunnableLambda+ def my_func(x: int) -> int:+ return x++ callbacks = CallbackManager.configure(+ inheritable_callbacks=[tracer],+ langsmith_inheritable_metadata={+ "tenant": "from_tracer",+ "shared": "from_tracer",+ },+ )+ with tracing_context(enabled=True, client=tracer.client):+ my_func.invoke(+ 1,+ {+ "callbacks": callbacks,+ "metadata": {"shared": "from_run", "explicit": "from_run"},+ },+ )++ posts = _get_posts(tracer.client)+ assert len(posts) == 1+ metadata = posts[0].get("extra", {}).get("metadata", {})+ assert metadata["tenant"] == "from_tracer"+ assert metadata["shared"] == "from_run"+ assert metadata["explicit"] == "from_run"++def test_config_traceable_handoff() -> None:if hasattr(get_env_var, "cache_clear"):get_env_var.cache_clear() # type: ignore[attr-defined]@@ -466,7 +506,10 @@ def test_tree_is_constructed(parent_type: Literal["ls", "lc"]) -> None:):collected: dict[str, RunTree] = {}- def collect_run(run: RunTree) -> None:+ def collect_langsmith_run(run: RunTree) -> None:+ collected[str(run.id)] = run++ def collect_tracer_run(_: LangChainTracer, run: RunTree) -> None:collected[str(run.id)] = runif parent_type == "ls":@@ -476,7 +519,8 @@ def test_tree_is_constructed(parent_type: Literal["ls", "lc"]) -> None:return child.invoke("foo")assert (- parent(langsmith_extra={"on_end": collect_run, "run_id": rid}) == "foo"+ parent(langsmith_extra={"on_end": collect_langsmith_run, "run_id": rid})+ == "foo")assert collected@@ -487,9 +531,10 @@ def test_tree_is_constructed(parent_type: Literal["ls", "lc"]) -> None:return child.invoke("foo")tracer = LangChainTracer()- tracer._persist_run = collect_run # type: ignore[method-assign]-- assert parent.invoke(..., {"run_id": rid, "callbacks": [tracer]}) == "foo" # type: ignore[attr-defined]+ with patch.object(LangChainTracer, "_persist_run", new=collect_tracer_run):+ assert (+ parent.invoke(..., {"run_id": rid, "callbacks": [tracer]}) == "foo" # type: ignore[attr-defined]+ )run = collected.get(str(rid))assert run is not None@@ -508,3 +553,643 @@ def test_tree_is_constructed(parent_type: Literal["ls", "lc"]) -> None:assert "afoo" in kitten_run.tags # type: ignore[operator]assert grandchild_run is not Noneassert kitten_run.dotted_order.startswith(grandchild_run.dotted_order)+++class TestTracerMetadataThroughInvoke:+ """Tests for tracer metadata merging through invoke calls."""++ def test_tracer_metadata_applied_to_all_runs(self) -> None:+ """Tracer metadata appears on every run when no config metadata is set."""+ tracer = _create_tracer_with_mocked_client(+ metadata={"env": "prod", "service": "api"}+ )++ @RunnableLambda+ def child(x: int) -> int:+ return x + 1++ @RunnableLambda+ def parent(x: int) -> int:+ return child.invoke(x)++ parent.invoke(1, {"callbacks": [tracer]})++ posts = _get_posts(tracer.client)+ assert len(posts) == 2+ for post in posts:+ md = post.get("extra", {}).get("metadata", {})+ assert md.get("env") == "prod", f"run {post['name']} missing env"+ assert md.get("service") == "api", f"run {post['name']} missing service"++ def test_config_metadata_takes_precedence(self) -> None:+ """Config metadata wins over tracer metadata for overlapping keys."""+ tracer = _create_tracer_with_mocked_client(+ metadata={"env": "prod", "tracer_only": "yes"}+ )++ @RunnableLambda+ def my_func(x: int) -> int:+ return x++ my_func.invoke(+ 1,+ {+ "callbacks": [tracer],+ "metadata": {"env": "staging", "config_only": "yes"},+ },+ )++ posts = _get_posts(tracer.client)+ assert len(posts) == 1+ md = posts[0].get("extra", {}).get("metadata", {})+ # Config wins for overlapping key+ assert md["env"] == "staging"+ # Both non-overlapping keys are present+ assert md["tracer_only"] == "yes"+ assert md["config_only"] == "yes"++ def test_nested_calls_inherit_config_metadata(self) -> None:+ """Child runs inherit config metadata; tracer metadata fills gaps."""+ tracer = _create_tracer_with_mocked_client(+ metadata={"tracer_key": "tracer_val"}+ )++ @RunnableLambda+ def child(x: int) -> int:+ return x + 1++ @RunnableLambda+ def parent(x: int) -> int:+ return child.invoke(x)++ parent.invoke(+ 1,+ {+ "callbacks": [tracer],+ "metadata": {"config_key": "config_val"},+ },+ )++ posts = _get_posts(tracer.client)+ assert len(posts) == 2+ name_to_md = {+ post["name"]: post.get("extra", {}).get("metadata", {}) for post in posts+ }+ # Both parent and child should have config metadata (inherited)+ # and tracer metadata (patched in)+ for name, md in name_to_md.items():+ assert md.get("config_key") == "config_val", f"{name} missing config_key"+ assert md.get("tracer_key") == "tracer_val", f"{name} missing tracer_key"++ def test_tracer_metadata_not_applied_to_sibling_handlers(self) -> None:+ """Tracer metadata is not applied to other callback handlers.++ `_patch_missing_metadata` copies the metadata dict before patching,+ so the callback manager's shared metadata dict is not mutated.+ Other handlers should only see config metadata, not tracer metadata.+ """+ tracer = _create_tracer_with_mocked_client(+ metadata={"tracer_key": "tracer_val"}+ )++ received_metadata: list[dict[str, Any]] = []++ class MetadataCapture(BaseCallbackHandler):+ """Callback handler that records metadata from chain events."""++ def on_chain_start(self, *_args: Any, **kwargs: Any) -> None:+ received_metadata.append(dict(kwargs.get("metadata", {})))++ capture = MetadataCapture()++ @RunnableLambda+ def my_func(x: int) -> int:+ return x++ my_func.invoke(+ 1,+ {+ "callbacks": [tracer, capture],+ "metadata": {"shared_key": "shared_val"},+ },+ )++ assert len(received_metadata) >= 1+ for md in received_metadata:+ assert md["shared_key"] == "shared_val"+ assert "tracer_key" not in md++ # But the posted run DOES have tracer metadata+ posts = _get_posts(tracer.client)+ assert len(posts) >= 1+ for post in posts:+ post_md = post.get("extra", {}).get("metadata", {})+ assert post_md["shared_key"] == "shared_val"+ assert post_md["tracer_key"] == "tracer_val"++ def test_tracer_metadata_with_no_config_metadata(self) -> None:+ """When no config metadata is set, tracer metadata is the sole source."""+ tracer = _create_tracer_with_mocked_client(+ metadata={"only_from_tracer": "value"}+ )++ @RunnableLambda+ def my_func(x: int) -> int:+ return x++ my_func.invoke(1, {"callbacks": [tracer]})++ posts = _get_posts(tracer.client)+ assert len(posts) == 1+ md = posts[0].get("extra", {}).get("metadata", {})+ assert md["only_from_tracer"] == "value"++ def test_empty_tracer_metadata_does_not_interfere(self) -> None:+ """Tracer with no metadata does not interfere with config metadata."""+ tracer = _create_tracer_with_mocked_client(metadata=None)++ @RunnableLambda+ def my_func(x: int) -> int:+ return x++ my_func.invoke(+ 1,+ {"callbacks": [tracer], "metadata": {"config_key": "config_val"}},+ )++ posts = _get_posts(tracer.client)+ assert len(posts) == 1+ md = posts[0].get("extra", {}).get("metadata", {})+ assert md["config_key"] == "config_val"+++def test_inheritable_metadata_nested_runs_preserve_parent_child_shape() -> None:+ """Concurrent nested runs keep parent-child linkage within each invocation."""+ tracer = _create_tracer_with_mocked_client()+ barrier = threading.Barrier(2)++ @RunnableLambda+ def child(x: int) -> int:+ barrier.wait()+ return x + 1++ @RunnableLambda+ def parent(x: int) -> int:+ return child.invoke(x)++ def invoke_for_tenant(tenant: str, value: int) -> int:+ callbacks = CallbackManager.configure(+ inheritable_callbacks=[tracer],+ langsmith_inheritable_metadata={"tenant": tenant},+ )+ return parent.invoke(value, {"callbacks": callbacks})++ threads = [+ threading.Thread(target=invoke_for_tenant, args=("alpha", 1)),+ threading.Thread(target=invoke_for_tenant, args=("beta", 2)),+ ]+ for thread in threads:+ thread.start()+ for thread in threads:+ thread.join()++ posts = _get_posts(tracer.client)+ assert len(posts) == 4+ parents = [post for post in posts if post["name"] == "parent"]+ children = [post for post in posts if post["name"] == "child"]+ assert len(parents) == 2+ assert len(children) == 2+ parent_ids = {parent["id"] for parent in parents}+ assert {child["parent_run_id"] for child in children} == parent_ids+ assert {+ post.get("extra", {}).get("metadata", {}).get("tenant") for post in posts+ } == {+ "alpha",+ "beta",+ }+++def test_inheritable_metadata_parallel_children_keep_tenant_isolation() -> None:+ """Concurrent roots with parallel child runs keep tenant metadata isolated."""+ tracer = _create_tracer_with_mocked_client()+ barrier = threading.Barrier(4)++ @RunnableLambda+ def add_one(x: int) -> int:+ barrier.wait()+ return x + 1++ @RunnableLambda+ def add_two(x: int) -> int:+ barrier.wait()+ return x + 2++ parallel = RunnableParallel(first=add_one, second=add_two)++ def invoke_for_tenant(tenant: str, value: int) -> dict[str, int]:+ callbacks = CallbackManager.configure(+ inheritable_callbacks=[tracer],+ langsmith_inheritable_metadata={"tenant": tenant},+ )+ return parallel.invoke(value, {"callbacks": callbacks})++ with concurrent.futures.ThreadPoolExecutor(max_workers=2) as executor:+ list(executor.map(invoke_for_tenant, ["alpha", "beta"], [1, 2]))++ posts = _get_posts(tracer.client)+ assert len(posts) == 6+ assert {+ post.get("extra", {}).get("metadata", {}).get("tenant") for post in posts+ } == {+ "alpha",+ "beta",+ }+ posts_by_trace: dict[str, list[dict[str, Any]]] = {}+ for post in posts:+ posts_by_trace.setdefault(post["trace_id"], []).append(post)+ assert len(posts_by_trace) == 2+ assert all(len(trace_posts) == 3 for trace_posts in posts_by_trace.values())+++ sys.version_info < (3, 11), reason="Asyncio context vars require Python 3.11+"+)+async def test_langsmith_inheritable_metadata_mixed_sync_async_managers_isolated() -> (+ None+):+ """Sync and async manager configure paths can overlap without metadata sharing."""+ tracer = _create_tracer_with_mocked_client()++ @RunnableLambda+ async def async_runnable(x: int) -> int:+ await asyncio.sleep(0)+ return x + 1++ @RunnableLambda+ def sync_runnable(x: int) -> int:+ return x + 1++ async def run_sync() -> int:+ callbacks = CallbackManager.configure(+ inheritable_callbacks=[tracer],+ langsmith_inheritable_metadata={"path": "sync"},+ )+ return await asyncio.to_thread(+ sync_runnable.invoke, 1, {"callbacks": callbacks}+ )++ async def run_async() -> int:+ callbacks = CallbackManager.configure(+ inheritable_callbacks=[tracer],+ langsmith_inheritable_metadata={"path": "async"},+ )+ return await async_runnable.ainvoke(1, {"callbacks": callbacks})++ await asyncio.gather(run_sync(), run_async())++ posts = _get_posts(tracer.client)+ assert len(posts) == 2+ assert {+ post.get("extra", {}).get("metadata", {}).get("path") for post in posts+ } == {+ "sync",+ "async",+ }+++class TestLangsmithInheritableTracingDefaultsInConfigure:+ """Tests for LangSmith inheritable tracing defaults in configure."""++ def test_langsmith_inheritable_metadata_applied_via_configure(self) -> None:+ """langsmith_inheritable_metadata flows to a copied tracer."""+ tracer = _create_tracer_with_mocked_client()+ cm = CallbackManager.configure(+ inheritable_callbacks=[tracer],+ langsmith_inheritable_metadata={"env": "prod", "service": "api"},+ )+ lc_tracers = [h for h in cm.handlers if isinstance(h, LangChainTracer)]+ assert len(lc_tracers) == 1+ assert lc_tracers[0] is not tracer+ assert lc_tracers[0].tracing_metadata == {"env": "prod", "service": "api"}+ assert tracer.tracing_metadata is None++ def test_langsmith_inheritable_metadata_does_not_overwrite_tracer_metadata(+ self,+ ) -> None:+ """Tracer metadata takes precedence over langsmith_inheritable_metadata."""+ tracer = _create_tracer_with_mocked_client(metadata={"env": "staging"})+ cm = CallbackManager.configure(+ inheritable_callbacks=[tracer],+ langsmith_inheritable_metadata={"env": "prod", "service": "api"},+ )+ lc_tracer = next(h for h in cm.handlers if isinstance(h, LangChainTracer))+ assert tracer.tracing_metadata == {"env": "staging"}+ assert lc_tracer.tracing_metadata == {"env": "staging", "service": "api"}++ def test_tracing_context_metadata_merged_into_langsmith_inheritable_metadata(+ self,+ ) -> None:+ """Tracing-context metadata merges into tracer defaults.++ LangSmith metadata keeps precedence on collisions.+ """+ tracer = _create_tracer_with_mocked_client()+ with tracing_context(+ enabled=True,+ client=tracer.client,+ metadata={"trace_only": "value", "shared": "trace"},+ ):+ cm = CallbackManager.configure(+ inheritable_callbacks=[tracer],+ langsmith_inheritable_metadata={+ "shared": "langsmith",+ "tenant": "alpha",+ },+ )++ lc_tracer = next(h for h in cm.handlers if isinstance(h, LangChainTracer))+ assert lc_tracer.tracing_metadata == {+ "trace_only": "value",+ "shared": "langsmith",+ "tenant": "alpha",+ }++ def test_langsmith_inheritable_metadata_end_to_end(self) -> None:+ """langsmith_inheritable_metadata in configure propagates to posted runs."""+ tracer = _create_tracer_with_mocked_client()++ @RunnableLambda+ def my_func(x: int) -> int:+ return x++ # Use langsmith_inheritable_metadata through the config callbacks path+ cm = CallbackManager.configure(+ inheritable_callbacks=[tracer],+ langsmith_inheritable_metadata={"env": "prod"},+ )+ my_func.invoke(1, {"callbacks": cm})++ posts = _get_posts(tracer.client)+ assert len(posts) == 1+ md = posts[0].get("extra", {}).get("metadata", {})+ assert md["env"] == "prod"++ def test_runnable_config_copies_configurable_values_to_tracing_metadata(+ self,+ ) -> None:+ tracer = _create_tracer_with_mocked_client()++ @RunnableLambda+ def my_func(x: int) -> int:+ return x++ config: RunnableConfig = {+ "callbacks": [tracer],+ "metadata": {+ "something": "else",+ "checkpoint_ns": "from-metadata",+ "model": "from-metadata",+ },+ "configurable": {+ "thread_id": "th-123",+ "checkpoint_id": "ckpt-1",+ "checkpoint_ns": "from-configurable",+ "task_id": "task-1",+ "run_id": "run-456",+ "assistant_id": "asst-789",+ "graph_id": "graph-0",+ "model": "from-configurable",+ "user_id": "uid-1",+ "cron_id": "cron-1",+ "langgraph_auth_user_id": "user-1",+ "api_key": "should-not-propagate",+ "__secret_key": "should-not-propagate",+ "temperature": 0.5,+ "streaming": True,+ "custom_setting": {"nested": True},+ "none_value": None,+ },+ }+ my_func.invoke(1, config)++ posts = _get_posts(tracer.client)+ assert len(posts) == 1+ md = posts[0].get("extra", {}).get("metadata", {})+ assert {+ key: md[key]+ for key in (+ "something",+ "thread_id",+ "checkpoint_id",+ "task_id",+ "run_id",+ "assistant_id",+ "graph_id",+ "user_id",+ "cron_id",+ "langgraph_auth_user_id",+ "temperature",+ "streaming",+ "model",+ "checkpoint_ns",+ )+ } == {+ "something": "else",+ "thread_id": "th-123",+ "checkpoint_id": "ckpt-1",+ "task_id": "task-1",+ "run_id": "run-456",+ "assistant_id": "asst-789",+ "graph_id": "graph-0",+ "user_id": "uid-1",+ "cron_id": "cron-1",+ "langgraph_auth_user_id": "user-1",+ "temperature": 0.5,+ "streaming": True,+ "model": "from-metadata",+ "checkpoint_ns": "from-metadata",+ }+ assert "api_key" not in md+ assert "__secret_key" not in md+ assert "custom_setting" not in md+ assert "none_value" not in md++ def test_langsmith_inheritable_metadata_does_not_affect_non_tracer_handlers(+ self,+ ) -> None:+ """langsmith_inheritable_metadata only applies to tracers."""+ tracer = _create_tracer_with_mocked_client()++ received_metadata: list[dict[str, Any]] = []++ class MetadataCapture(BaseCallbackHandler):+ def on_chain_start(self, *_args: Any, **kwargs: Any) -> None:+ received_metadata.append(dict(kwargs.get("metadata", {})))++ capture = MetadataCapture()+ cm = CallbackManager.configure(+ inheritable_callbacks=[tracer, capture],+ langsmith_inheritable_metadata={"tracer_only": "yes"},+ )++ @RunnableLambda+ def my_func(x: int) -> int:+ return x++ my_func.invoke(1, {"callbacks": cm})++ # Non-tracer handler should NOT see langsmith_inheritable_metadata+ assert len(received_metadata) >= 1+ for md in received_metadata:+ assert "tracer_only" not in md++ # But the tracer's posted runs SHOULD have it+ posts = _get_posts(tracer.client)+ assert len(posts) >= 1+ for post in posts:+ post_md = post.get("extra", {}).get("metadata", {})+ assert post_md["tracer_only"] == "yes"++ def test_no_langsmith_inheritable_metadata_is_noop(self) -> None:+ """Passing langsmith_inheritable_metadata=None does not alter tracer state."""+ tracer = _create_tracer_with_mocked_client()+ cm = CallbackManager.configure(+ inheritable_callbacks=[tracer],+ langsmith_inheritable_metadata=None,+ )+ lc_tracer = next(h for h in cm.handlers if isinstance(h, LangChainTracer))+ assert lc_tracer is tracer+ assert tracer.tracing_metadata is None++ def test_langsmith_inheritable_tags_applied_via_configure(self) -> None:+ """langsmith_inheritable_tags flow to a copied tracer."""+ tracer = _create_tracer_with_mocked_client()+ tracer.tags = ["existing"]+ cm = CallbackManager.configure(+ inheritable_callbacks=[tracer],+ langsmith_inheritable_tags=["tenant:alpha", "existing"],+ )+ lc_tracer = next(h for h in cm.handlers if isinstance(h, LangChainTracer))+ assert lc_tracer is not tracer+ assert lc_tracer.tags == ["existing", "tenant:alpha"]+ assert tracer.tags == ["existing"]++ def test_inheritable_tags_do_not_affect_non_tracer_handlers(self) -> None:+ """langsmith_inheritable_tags only apply to tracers."""+ tracer = _create_tracer_with_mocked_client()++ received_tags: list[list[str]] = []++ class TagCapture(BaseCallbackHandler):+ def on_chain_start(self, *_args: Any, **kwargs: Any) -> None:+ received_tags.append(list(kwargs.get("tags", [])))++ capture = TagCapture()+ cm = CallbackManager.configure(+ inheritable_callbacks=[tracer, capture],+ langsmith_inheritable_tags=["tracer-only"],+ )++ @RunnableLambda+ def my_func(x: int) -> int:+ return x++ my_func.invoke(1, {"callbacks": cm})++ assert received_tags+ assert all("tracer-only" not in tags for tags in received_tags)++ posts = _get_posts(tracer.client)+ assert posts+ assert all("tracer-only" in post.get("tags", []) for post in posts)++ def test_langsmith_inheritable_metadata_copies_handlers_without_mutating_original(+ self,+ ) -> None:+ """Configured manager copies tracers and leaves the original unchanged."""+ tracer = _create_tracer_with_mocked_client()+ cm = CallbackManager.configure(+ inheritable_callbacks=[tracer],+ langsmith_inheritable_metadata={"env": "prod"},+ )+ handler_tracer = next(h for h in cm.handlers if isinstance(h, LangChainTracer))+ inheritable_tracer = next(+ h for h in cm.inheritable_handlers if isinstance(h, LangChainTracer)+ )+ assert handler_tracer is not tracer+ assert inheritable_tracer is not tracer+ assert tracer.tracing_metadata is None++ def test_langsmith_inheritable_metadata_configure_isolated_per_manager(+ self,+ ) -> None:+ """Separate configure calls keep tracer-only defaults isolated."""+ tracer = _create_tracer_with_mocked_client()+ alpha_manager = CallbackManager.configure(+ inheritable_callbacks=[tracer],+ langsmith_inheritable_metadata={"tenant": "alpha"},+ )+ beta_manager = CallbackManager.configure(+ inheritable_callbacks=[tracer],+ langsmith_inheritable_metadata={"tenant": "beta"},+ )++ alpha_tracer = next(+ handler+ for handler in alpha_manager.handlers+ if isinstance(handler, LangChainTracer)+ )+ beta_tracer = next(+ handler+ for handler in beta_manager.handlers+ if isinstance(handler, LangChainTracer)+ )++ assert tracer.tracing_metadata is None+ assert alpha_tracer is not tracer+ assert beta_tracer is not tracer+ assert alpha_tracer is not beta_tracer+ assert alpha_tracer.tracing_metadata == {"tenant": "alpha"}+ assert beta_tracer.tracing_metadata == {"tenant": "beta"}+ assert alpha_tracer.run_map is tracer.run_map+ assert beta_tracer.run_map is tracer.run_map+ assert alpha_tracer.order_map is tracer.order_map+ assert beta_tracer.order_map is tracer.order_map++ def test_inheritable_metadata_concurrent_invocations_remain_isolated(+ self,+ ) -> None:+ """Parallel invocations through copied tracers keep metadata separated."""+ tracer = _create_tracer_with_mocked_client()+ barrier = threading.Barrier(2)++ @traceable+ def traced_leaf(x: int) -> int:+ barrier.wait()+ return x++ @RunnableLambda+ def my_func(x: int) -> int:+ return traced_leaf(x)++ def invoke_for_tenant(tenant: str, value: int) -> int:+ callbacks = CallbackManager.configure(+ inheritable_callbacks=[tracer],+ langsmith_inheritable_metadata={"tenant": tenant},+ )+ return my_func.invoke(value, {"callbacks": callbacks})++ with concurrent.futures.ThreadPoolExecutor(max_workers=2) as executor:+ list(executor.map(invoke_for_tenant, ["alpha", "beta"], [1, 2]))++ posts = _get_posts(tracer.client)+ assert len(posts) == 4+ assert {post["name"] for post in posts} == {"my_func", "traced_leaf"}+ my_func_posts = [post for post in posts if post["name"] == "my_func"]+ assert len(my_func_posts) == 2+ assert {+ post.get("extra", {}).get("metadata", {}).get("tenant")+ for post in my_func_posts+ } == {"alpha", "beta"}+ assert tracer.run_map == {}+ assert len(tracer.order_map) == 2diff --git a/libs/core/tests/unit_tests/tracers/test_langchain.py b/libs/core/tests/unit_tests/tracers/test_langchain.pyindex d2a83e655a..0e02c05986 100644--- a/libs/core/tests/unit_tests/tracers/test_langchain.py+++ b/libs/core/tests/unit_tests/tracers/test_langchain.py@@ -1,3 +1,4 @@+import concurrent.futuresimport threadingimport timeimport unittest.mock@@ -15,6 +16,7 @@ from langchain_core.outputs import ChatGeneration, LLMResultfrom langchain_core.tracers.langchain import (LangChainTracer,_get_usage_metadata_from_generations,+ _patch_missing_metadata,)from langchain_core.tracers.schemas import Run@@ -696,3 +698,206 @@ def test_on_chain_error_updates_when_not_defers_inputs() -> None:# Should call update (PATCH), not persist (POST) for normal inputsassert not persist_calledassert update_called+++class TestPatchMissingMetadata:+ """Tests for `_patch_missing_metadata` and tracer metadata behavior."""++ @staticmethod+ def _make_tracer(+ metadata: dict[str, str] | None = None,+ ) -> LangChainTracer:+ client = unittest.mock.MagicMock(spec=Client)+ client.tracing_queue = None+ return LangChainTracer(client=client, metadata=metadata)++ @staticmethod+ def _make_run(+ metadata: dict[str, Any] | None = None,+ ) -> Run:+ return Run(+ id=uuid.uuid4(),+ name="test",+ inputs={},+ run_type="chain",+ extra={"metadata": metadata or {}},+ )++ def test_adds_metadata_when_run_has_none(self) -> None:+ """Tracer metadata fills in when the run has no matching keys."""+ tracer = self._make_tracer(metadata={"env": "prod", "service": "api"})+ run = self._make_run()++ _patch_missing_metadata(tracer, run)++ assert run.metadata["env"] == "prod"+ assert run.metadata["service"] == "api"++ def test_does_not_overwrite_existing_keys(self) -> None:+ """Config metadata takes precedence over tracer metadata."""+ tracer = self._make_tracer(metadata={"env": "prod", "service": "api"})+ run = self._make_run(metadata={"env": "staging"})++ _patch_missing_metadata(tracer, run)++ assert run.metadata["env"] == "staging"+ assert run.metadata["service"] == "api"++ def test_noop_when_tracer_has_no_metadata(self) -> None:+ """No-op when the tracer has no metadata configured."""+ tracer = self._make_tracer(metadata=None)+ run = self._make_run(metadata={"existing": "value"})++ _patch_missing_metadata(tracer, run)++ assert run.metadata == {"existing": "value"}++ def test_noop_when_all_keys_already_present(self) -> None:+ """No-op when every tracer key already exists in the run."""+ tracer = self._make_tracer(metadata={"env": "prod"})+ run = self._make_run(metadata={"env": "dev"})++ _patch_missing_metadata(tracer, run)++ assert run.metadata == {"env": "dev"}++ def test_merges_disjoint_keys(self) -> None:+ """Disjoint keys from tracer and config are all present after patching."""+ tracer = self._make_tracer(metadata={"tracer_key": "tracer_val"})+ run = self._make_run(metadata={"config_key": "config_val"})++ _patch_missing_metadata(tracer, run)++ assert run.metadata == {+ "tracer_key": "tracer_val",+ "config_key": "config_val",+ }++ def test_persist_run_single_applies_tracer_metadata(self) -> None:+ """End-to-end: `_persist_run_single` calls `_patch_missing_metadata`."""+ tracer = self._make_tracer(metadata={"env": "prod"})+ run_id = UUID("9d878ab3-e5ca-4218-aef6-44cbdc90160a")+ tracer.on_chain_start(+ {"name": "test_chain"},+ {"input": "hello"},+ run_id=run_id,+ )+ run = tracer.run_map[str(run_id)]++ with unittest.mock.patch.object(Run, "post"):+ tracer._persist_run_single(run)++ assert run.metadata.get("env") == "prod"++ def test_persist_run_single_config_metadata_wins(self) -> None:+ """Config metadata is not overwritten by tracer metadata during persist."""+ tracer = self._make_tracer(metadata={"env": "prod", "extra": "from_tracer"})+ run_id = UUID("9d878ab3-e5ca-4218-aef6-44cbdc90160b")+ tracer.on_chain_start(+ {"name": "test_chain"},+ {"input": "hello"},+ run_id=run_id,+ metadata={"env": "staging"},+ )+ run = tracer.run_map[str(run_id)]++ with unittest.mock.patch.object(Run, "post"):+ tracer._persist_run_single(run)++ assert run.metadata["env"] == "staging"+ assert run.metadata["extra"] == "from_tracer"+++class TestTracerMetadataCloning:+ """Tests for LangChainTracer metadata cloning helpers."""++ @staticmethod+ def _make_tracer(+ metadata: dict[str, str] | None = None,+ ) -> LangChainTracer:+ client = unittest.mock.MagicMock(spec=Client)+ client.tracing_queue = None+ return LangChainTracer(client=client, metadata=metadata)++ def test_copy_with_metadata_defaults_copies_configuration(self) -> None:+ """Copied tracer keeps stable configuration but not identity."""+ tracer = self._make_tracer(metadata={"env": "staging"})+ tracer.project_name = "project"+ tracer.tags = ["tag"]++ copied = tracer.copy_with_metadata_defaults(metadata={"service": "api"})++ assert copied is not tracer+ assert copied.client is tracer.client+ assert copied.project_name == "project"+ assert copied.tags == ["tag"]+ assert copied.tags is tracer.tags+ assert copied.tracing_metadata == {"env": "staging", "service": "api"}+ assert copied.run_map is tracer.run_map+ assert copied.order_map is tracer.order_map+ assert copied.run_has_token_event_map == {}++ def test_copy_with_metadata_defaults_does_not_mutate_original(self) -> None:+ """Metadata-default cloning leaves the source tracer unchanged."""+ tracer = self._make_tracer(metadata={"env": "staging"})++ copied = tracer.copy_with_metadata_defaults(metadata={"service": "api"})++ assert tracer.tracing_metadata == {"env": "staging"}+ assert copied.tracing_metadata == {"env": "staging", "service": "api"}++ def test_copy_with_metadata_defaults_none_preserves_configuration(self) -> None:+ """Copying without new metadata preserves metadata and shared run state."""+ tracer = self._make_tracer(metadata={"env": "staging"})+ copied = tracer.copy_with_metadata_defaults(metadata=None)++ assert copied is not tracer+ assert copied.tracing_metadata == {"env": "staging"}+ assert copied.run_map is tracer.run_map+ assert copied.order_map is tracer.order_map++ def test_copy_with_metadata_defaults_threadsafe(self) -> None:+ """Concurrent metadata-default copies do not mutate each other or the source."""+ tracer = self._make_tracer(metadata={"env": "staging"})++ def copy_for_service(service: str) -> dict[str, str]:+ copied = tracer.copy_with_metadata_defaults(metadata={"service": service})+ assert copied is not tracer+ return copied.tracing_metadata or {}++ with concurrent.futures.ThreadPoolExecutor(max_workers=2) as executor:+ metadata_values = list(executor.map(copy_for_service, ["api", "worker"]))++ assert tracer.tracing_metadata == {"env": "staging"}+ assert {metadata["service"] for metadata in metadata_values} == {+ "api",+ "worker",+ }+ assert all(metadata["env"] == "staging" for metadata in metadata_values)++ def test_copy_with_metadata_defaults_threadsafe_with_existing_shared_state(+ self,+ ) -> None:+ """Concurrent copies preserve pre-populated shared run state."""+ tracer = self._make_tracer(metadata={"env": "staging"})+ run_id = uuid.uuid4()+ tracer.run_map["existing"] = unittest.mock.MagicMock()+ tracer.order_map[run_id] = (run_id, f"prefix.{run_id}")++ def copy_for_service(service: str) -> LangChainTracer:+ copied = tracer.copy_with_metadata_defaults(metadata={"service": service})+ assert copied.run_map is tracer.run_map+ assert copied.order_map is tracer.order_map+ return copied++ with concurrent.futures.ThreadPoolExecutor(max_workers=2) as executor:+ copied_tracers = list(executor.map(copy_for_service, ["api", "worker"]))++ assert tracer.run_map.keys() == {"existing"}+ assert tracer.order_map == {run_id: (run_id, f"prefix.{run_id}")}+ copied_services = {+ copied.tracing_metadata["service"]+ for copied in copied_tracers+ if copied.tracing_metadata is not None+ }+ assert copied_services == {"api", "worker"}diff --git a/libs/langchain_v1/Makefile b/libs/langchain_v1/Makefileindex cb14bbaba3..9367f4422e 100644--- a/libs/langchain_v1/Makefile+++ b/libs/langchain_v1/Makefile@@ -38,13 +38,13 @@ coverage_agents:--cov-report=html:htmlcov \test:- make start_services && LANGGRAPH_TEST_FAST=0 uv run --no-sync --active --group test pytest -n auto $(PYTEST_EXTRA) --disable-socket --allow-unix-socket $(TEST_FILE) --cov-report term-missing:skip-covered --snapshot-update; \+ make start_services && LANGGRAPH_TEST_FAST=0 uv run --no-sync --active --group test pytest -n auto $(PYTEST_EXTRA) --benchmark-disable --disable-socket --allow-unix-socket $(TEST_FILE) --cov-report term-missing:skip-covered --snapshot-update; \EXIT_CODE=$$?; \make stop_services; \exit $$EXIT_CODEtest_fast:- LANGGRAPH_TEST_FAST=1 uv run --group test pytest -n auto $(PYTEST_EXTRA) --disable-socket --allow-unix-socket $(TEST_FILE)+ LANGGRAPH_TEST_FAST=1 uv run --group test pytest -n auto $(PYTEST_EXTRA) --benchmark-disable --disable-socket --allow-unix-socket $(TEST_FILE)benchmark:uv run --group test pytest tests/benchmarks/test_create_agent.py -m benchmarkdiff --git a/libs/langchain_v1/tests/unit_tests/chat_models/test_chat_models.py b/libs/langchain_v1/tests/unit_tests/chat_models/test_chat_models.pyindex e51f8d3d5d..590bad566b 100644--- a/libs/langchain_v1/tests/unit_tests/chat_models/test_chat_models.py+++ b/libs/langchain_v1/tests/unit_tests/chat_models/test_chat_models.py@@ -1,5 +1,5 @@import os-from typing import TYPE_CHECKING+from typing import TYPE_CHECKING, Anyfrom unittest import mockimport pytest@@ -171,7 +171,7 @@ def test_configurable() -> None:for method in ("get_num_tokens", "get_num_tokens_from_messages"):assert hasattr(model_with_config, method)- assert model_with_config.model_dump() == { # type: ignore[attr-defined]+ expected: dict[str, Any] = {"name": None,"bound": {"name": None,@@ -234,6 +234,7 @@ def test_configurable() -> None:"custom_input_type": None,"custom_output_type": None,}+ assert model_with_config.model_dump() == expected # type: ignore[attr-defined]@pytest.mark.requires("langchain_openai", "langchain_anthropic")@@ -297,7 +298,7 @@ def test_configurable_with_default() -> None:assert model_with_config.model == "claude-sonnet-4-5-20250929" # type: ignore[attr-defined]- assert model_with_config.model_dump() == { # type: ignore[attr-defined]+ expected: dict[str, Any] = {"name": None,"bound": {"name": None,@@ -332,7 +333,7 @@ def test_configurable_with_default() -> None:"config": {"callbacks": None,"configurable": {},- "metadata": {"bar_model": "claude-sonnet-4-5-20250929"},+ "metadata": {},"recursion_limit": 25,"tags": ["foo"],},@@ -340,6 +341,7 @@ def test_configurable_with_default() -> None:"custom_input_type": None,"custom_output_type": None,}+ assert model_with_config.model_dump() == expected # type: ignore[attr-defined]prompt = ChatPromptTemplate.from_messages([("system", "foo")])chain = prompt | model_with_configassert isinstance(chain, RunnableSequence)