fix(langchain): prefer runnable name over langgraph_node for chain step names

langgraph_node is inherited by every run nested inside a node, so preferring it
over the runnable's own name relabelled all of a node's internal LCEL runs
(RunnableSequence/Prompt/...) — and nested sub-graphs — with the parent node's
name, collapsing the trace tree. Flip the precedence to
`name or langgraph_node or id` to match the TS handler; LangGraph already sets
`name` to the node name at node boundaries, so nodes stay identifiable while the
inner structure keeps its real names.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: viniciusdsmello

src/openlayer/lib/integrations/langchain_callback.py

@@ -758,12 +758,20 @@ def _handle_chain_start(
         serialized = serialized or {}
         metadata = metadata or {}
 
-        # LangGraph injects ``metadata["langgraph_node"]`` for each graph node.
-        # Prefer it so graph nodes are identifiable in the trace rather than
-        # showing the generic chain/runnable name.
+        # Resolve the chain's display name. Prefer the runnable's own ``name``
+        # (e.g. a node's name like "callAgent", or "RunnableSequence"/"Prompt"
+        # for nested LCEL runs), then fall back to LangGraph's injected
+        # ``metadata["langgraph_node"]`` only when no name is available, then the
+        # serialized id. This mirrors the TS handler's ``name ?? langgraph_node
+        # ?? id`` precedence. ``langgraph_node`` is inherited by *every* run
+        # nested inside a node, so preferring it over ``name`` would relabel all
+        # of a node's internal LCEL runs (RunnableSequence/Prompt/...) — and even
+        # nested sub-graphs — with the parent node's name. LangGraph already sets
+        # ``name`` to the node name at node boundaries, so this keeps nodes
+        # identifiable while preserving the inner structure's real names.
         langgraph_node = metadata.get("langgraph_node")
         chain_name = (
-            langgraph_node or name or (serialized.get("id", [])[-1] if serialized.get("id") else None) or "Chain"
+            name or langgraph_node or (serialized.get("id", [])[-1] if serialized.get("id") else None) or "Chain"
         )
 
         # Skip chains marked as hidden (e.g., internal LangGraph chains)

tests/lib/integrations/test_langchain_callback.py

@@ -448,19 +448,37 @@ def test_chat_model_step_named_from_ls_provider(self) -> None:
 # Item 3: LangGraph metadata (langgraph_node + thread_id -> session_id)
 # --------------------------------------------------------------------------- #
 class TestLangGraphMetadata:
-    def test_langgraph_node_names_chain_step(self) -> None:
+    def test_langgraph_node_names_chain_step_when_no_explicit_name(self) -> None:
+        # When the runnable carries no name, fall back to langgraph_node so graph
+        # nodes stay identifiable.
         handler = OpenlayerHandler()
         run_id = uuid.uuid4()
         handler.on_chain_start(
             serialized={"id": ["langgraph", "utils", "RunnableCallable"]},
             inputs={"messages": []},
             run_id=run_id,
-            name="RunnableCallable",
             metadata={"langgraph_node": "agent"},
         )
         step = handler.steps[run_id]
         assert step.name == "agent"
 
+    def test_explicit_name_wins_over_langgraph_node(self) -> None:
+        # An explicit runnable name takes precedence over langgraph_node (matches
+        # the TS handler's `name ?? langgraph_node ?? id`). langgraph_node is
+        # inherited by every run nested inside a node, so preferring it would
+        # relabel a node's internal LCEL runs with the node name.
+        handler = OpenlayerHandler()
+        run_id = uuid.uuid4()
+        handler.on_chain_start(
+            serialized={"id": ["langchain_core", "runnables", "RunnableSequence"]},
+            inputs={"messages": []},
+            run_id=run_id,
+            name="RunnableSequence",
+            metadata={"langgraph_node": "agent"},
+        )
+        step = handler.steps[run_id]
+        assert step.name == "RunnableSequence"
+
     def test_chain_name_unchanged_without_langgraph_node(self) -> None:
         handler = OpenlayerHandler()
         run_id = uuid.uuid4()