langgraph 1.2.3__tar.gz → 1.2.4__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langgraph
-Version: 1.2.3
+Version: 1.2.4
 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/

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

@@ -2835,7 +2835,9 @@ class Pregel(
                 config[CONF][CONFIG_KEY_DURABILITY] = durability_
 
             # build server_info from metadata + parent runtime
-            parent_runtime = config[CONF].get(CONFIG_KEY_RUNTIME, DEFAULT_RUNTIME)
+            parent_runtime = _coerce_parent_runtime(
+                config[CONF].get(CONFIG_KEY_RUNTIME, DEFAULT_RUNTIME)
+            )
             server_info = _build_server_info(config, parent_runtime)
 
             runtime = Runtime(
@@ -3276,7 +3278,9 @@ class Pregel(
                 config[CONF][CONFIG_KEY_DURABILITY] = durability_
 
             # build server_info from metadata + parent runtime
-            parent_runtime = config[CONF].get(CONFIG_KEY_RUNTIME, DEFAULT_RUNTIME)
+            parent_runtime = _coerce_parent_runtime(
+                config[CONF].get(CONFIG_KEY_RUNTIME, DEFAULT_RUNTIME)
+            )
             server_info = _build_server_info(config, parent_runtime)
 
             runtime = Runtime(
@@ -4253,6 +4257,23 @@ def _resolve_parent_ns(
     return tuple(ns.split(NS_SEP))
 
 
+def _coerce_parent_runtime(value: Any) -> Runtime[Any]:
+    """Normalize the value stored under `CONFIG_KEY_RUNTIME` into a `Runtime`.
+
+    During a graph run this is always a `Runtime` the framework created and
+    published for child tasks to inherit. Layers outside the run (for example a
+    server's graph-factory path) may instead seed an object that only carries
+    `context`/`store`. Adopt its `context` so context set at the graph level
+    plumbs through (`merge` lets the run's own `context` take precedence when
+    one is provided). `store` is resolved separately (passed to the graph
+    directly), so it is not read off here. `merge` then combines this with the
+    run's own runtime, including the framework's `control`.
+    """
+    if isinstance(value, Runtime):
+        return value
+    return Runtime(context=getattr(value, "context", None))
+
+
 def _build_server_info(
     config: RunnableConfig, parent_runtime: Runtime[Any]
 ) -> ServerInfo | None:

{langgraph-1.2.3 → langgraph-1.2.4}/langgraph/stream/transformers.py

@@ -419,6 +419,11 @@ class _TasksLifecycleBase(StreamTransformer):
         # `node:<task_id>` shares this task_id, so a subagent recovers the tool
         # call that spawned it (cross-payload).
         self._pending_tool_calls: dict[str, str] = {}
+        # `cause` for the current `_on_started` dispatch, set immediately before
+        # the call and read by overrides that surface it. Keeping `cause` off the
+        # `_on_started` signature means overrides predating it (e.g. deepagents'
+        # `SubagentTransformer`) don't break.
+        self._pending_cause: LifecycleCause | None = None
 
     # --- Template-method hooks (subclass overrides) ---
 
@@ -431,10 +436,11 @@ class _TasksLifecycleBase(StreamTransformer):
         ns: tuple[str, ...],
         graph_name: str | None,
         trigger_call_id: str | None,
-        *,
-        cause: LifecycleCause | None = None,
     ) -> None:
-        """Fired once per discovered namespace (first observed task event)."""
+        """Fired once per discovered namespace (first observed task event).
+
+        The triggering `cause` (if any) is available as `self._pending_cause`.
+        """
         raise NotImplementedError
 
     def _on_terminal(
@@ -532,7 +538,10 @@ class _TasksLifecycleBase(StreamTransformer):
             tool_call_id = self._pending_tool_calls.get(trigger_call_id)
             if tool_call_id:
                 cause = {"type": "toolCall", "tool_call_id": str(tool_call_id)}
-        self._on_started(ns, graph_name, trigger_call_id, cause=cause)
+        # Deliver `cause` via instance state, not the call signature, so
+        # `_on_started` stays backward-compatible with overrides predating it.
+        self._pending_cause = cause
+        self._on_started(ns, graph_name, trigger_call_id)
         if trigger_call_id is not None:
             self._open[ns] = trigger_call_id
 
@@ -631,8 +640,6 @@ class LifecycleTransformer(_TasksLifecycleBase):
         ns: tuple[str, ...],
         graph_name: str | None,
         trigger_call_id: str | None,
-        *,
-        cause: LifecycleCause | None = None,
     ) -> None:
         if trigger_call_id is None:
             # Without a task id we can't correlate a parent-result
@@ -643,6 +650,7 @@ class LifecycleTransformer(_TasksLifecycleBase):
         if graph_name:
             payload["graph_name"] = graph_name
         payload["trigger_call_id"] = trigger_call_id
+        cause = self._pending_cause
         if cause is not None:
             payload["cause"] = cause
         self._channel.push(payload)
@@ -707,8 +715,6 @@ class SubgraphTransformer(_TasksLifecycleBase):
         ns: tuple[str, ...],
         graph_name: str | None,
         trigger_call_id: str | None,
-        *,
-        cause: LifecycleCause | None = None,
     ) -> None:
         if self._mux is None:
             return
@@ -717,10 +723,9 @@ class SubgraphTransformer(_TasksLifecycleBase):
         except RuntimeError:
             return
         handle_cls = AsyncSubgraphRunStream if child_mux.is_async else SubgraphRunStream
-        # `cause` is intentionally ignored here: it is a wire/lifecycle-channel
-        # concern (carried on `LifecyclePayload`), not something the in-process
-        # subgraph navigation handle exposes. The argument is accepted only to
-        # keep the `_on_started` template signature uniform across transformers.
+        # The triggering `cause` (on `self._pending_cause`) is a wire/lifecycle
+        # concern carried on `LifecyclePayload`; the in-process subgraph
+        # navigation handle does not expose it.
         handle = handle_cls(
             mux=child_mux,
             path=ns,

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "langgraph"
-version = "1.2.3"
+version = "1.2.4"
 description = "Building stateful, multi-actor applications with LLMs"
 authors = []
 requires-python = ">=3.10"

{langgraph-1.2.3 → langgraph-1.2.4}/tests/test_runtime.py

@@ -1164,3 +1164,57 @@ def test_execution_info_inherited_by_subgraph() -> None:
     # task_id appears in its own namespace segment
     assert main_info.task_id in main_info.checkpoint_ns
     assert sub_info.task_id in sub_info.checkpoint_ns
+
+
+def test_foreign_object_in_runtime_slot_is_coerced() -> None:
+    """A non-`Runtime` under `CONFIG_KEY_RUNTIME` is adopted, not crashed on,
+    and the `context` it carries is plumbed through.
+
+    Layers outside a run (e.g. a server's graph-factory path, like LangGraph
+    API) seed an object carrying `context`/`store` into the runtime slot. The
+    run must still execute (regression for `AttributeError: '...' object has no
+    attribute 'control'`), and `context` set at that level must reach nodes via
+    `merge` when no per-run `context` is provided. `store` is resolved
+    separately, so it is not read off the foreign object in the coercion.
+    """
+    from langgraph.store.memory import InMemoryStore
+
+    from langgraph._internal._constants import CONFIG_KEY_RUNTIME
+
+    store = InMemoryStore()
+    graph_level_context = {"source": "graph-level"}
+
+    class _ServerLikeRuntime:
+        """Carries context/store but is not a `Runtime` (no control/merge)."""
+
+        def __init__(self) -> None:
+            self.context = graph_level_context
+            self.store = store
+
+    seen: dict[str, Any] = {}
+
+    class State(TypedDict, total=False):
+        text: str
+
+    def echo(state: State, runtime: Runtime) -> State:
+        seen["context"] = runtime.context
+        seen["store"] = runtime.store
+        return {"text": (state.get("text") or "") + " echoed"}
+
+    builder = StateGraph(State)
+    builder.add_node("echo", echo)
+    builder.add_edge(START, "echo")
+    builder.add_edge("echo", END)
+    graph = builder.compile()
+
+    # No per-run `context=`: the graph-level context on the slot must plumb through.
+    result = graph.invoke(
+        {"text": "hi"},
+        {"configurable": {CONFIG_KEY_RUNTIME: _ServerLikeRuntime()}},
+    )
+
+    assert result == {"text": "hi echoed"}
+    # context set at the graph level is plumbed through to the node via merge
+    assert seen["context"] == graph_level_context
+    # store still reaches the node (resolved separately, not via the coercion)
+    assert seen["store"] is store

{langgraph-1.2.3 → langgraph-1.2.4}/tests/test_stream_lifecycle_transformer.py

@@ -25,6 +25,7 @@ from langgraph.stream._mux import StreamMux
 from langgraph.stream.transformers import (
     LifecyclePayload,
     LifecycleTransformer,
+    _TasksLifecycleBase,
 )
 
 TS = int(time.time() * 1000)
@@ -678,3 +679,34 @@ def test_lifecycle_subagent_terminal_roundtrip() -> None:
     started, _completed = subagent
     assert started["graph_name"] == "weather_agent"
     assert started["cause"] == {"type": "toolCall", "tool_call_id": "call_w"}
+
+
+def test_on_started_override_without_cause_is_backward_compatible() -> None:
+    """An `_on_started` override with the original 3-arg signature must work.
+
+    `cause` is delivered via `self._pending_cause`, not the call signature, so
+    older/third-party subclasses (e.g. deepagents' `SubagentTransformer`) that
+    override `_on_started(self, ns, graph_name, trigger_call_id)` keep working —
+    no `TypeError: _on_started() got an unexpected keyword argument 'cause'`.
+    """
+    seen: list[tuple] = []
+
+    class _LegacyTransformer(_TasksLifecycleBase):
+        def init(self) -> dict[str, Any]:
+            return {}
+
+        def _should_track(self, ns: tuple[str, ...]) -> bool:
+            return len(ns) == 1  # direct child of the root scope
+
+        # Deliberately omits `cause` — mirrors a pre-`cause` override.
+        def _on_started(self, ns, graph_name, trigger_call_id) -> None:  # type: ignore[override]
+            seen.append((ns, graph_name, trigger_call_id))
+
+        def _on_terminal(self, ns, status, error) -> None:
+            pass
+
+    transformer = _LegacyTransformer(scope=())
+    # Must not raise: the base calls `_on_started` without a `cause` kwarg.
+    transformer.process(_tasks_start(["agent:abc123"], task_id="abc123", name="agent"))
+
+    assert seen == [(("agent:abc123",), "agent", "abc123")]

{langgraph-1.2.3 → langgraph-1.2.4}/uv.lock

@@ -1382,7 +1382,7 @@ wheels = [
 
 [[package]]
 name = "langgraph"
-version = "1.2.3"
+version = "1.2.4"
 source = { editable = "." }
 dependencies = [
     { name = "langchain-core" },