theoretically more backwards compat

docs/_scripts/notebook_hooks.py

@@ -129,25 +129,11 @@ REDIRECT_MAP = {
     "how-tos/human_in_the_loop/edit-graph-state.ipynb": "https://docs.langchain.com/oss/python/langgraph/use-time-travel",
 
     # LGP mintlify migration redirects
-    "examples/index.md": "https://docs.langchain.com/oss/python/learn",
-    "guides/index.md": "https://docs.langchain.com/oss/python/langgraph/overview",
-    "concepts/index.md": "https://docs.langchain.com/oss/python/langgraph/overview",
-    "tutorials/index.md": "https://docs.langchain.com/oss/python/learn",
-    "llms-txt-overview.md": "https://docs.langchain.com/llms.txt",
-    "tutorials/rag/langgraph_adaptive_rag.md": "https://docs.langchain.com/oss/python/langgraph/agentic-rag",
-    "tutorials/multi_agent/multi-agent-collaboration.ipynb": "https://docs.langchain.com/oss/python/langchain/multi-agent",
-    "how-tos/create-react-agent-manage-message-history.ipynb": "https://docs.langchain.com/oss/python/langgraph/add-memory",
-    "how-tos/many-tools.ipynb": "https://docs.langchain.com/oss/python/langchain/tools",
-    "tutorials/customer-support/customer-support.ipynb": "https://docs.langchain.com/oss/python/langgraph/agentic-rag",
-    "how-tos/react-agent-structured-output.ipynb": "https://docs.langchain.com/oss/python/langchain/agents#structured-output",
-    "tutorials/code_assistant/langgraph_code_assistant.ipynb": "https://docs.langchain.com/oss/python/langgraph/agentic-rag",
-    "tutorials/multi_agent/hierarchical_agent_teams.ipynb": "https://docs.langchain.com/oss/python/langchain/supervisor",
     "tutorials/auth/getting_started.md": "https://docs.langchain.com/langsmith/auth",
     "tutorials/auth/resource_auth.md": "https://docs.langchain.com/langsmith/resource-auth",
     "tutorials/auth/add_auth_server.md": "https://docs.langchain.com/langsmith/add-auth-server",
     "how-tos/use-remote-graph.md": "https://docs.langchain.com/langsmith/use-remote-graph",
     "how-tos/autogen-integration.md": "https://docs.langchain.com/langsmith/autogen-integration",
-    "how-tos/human_in_the_loop/wait-user-input.ipynb": "https://docs.langchain.com/oss/python/langgraph/interrupts",
     "cloud/how-tos/use_stream_react.md": "https://docs.langchain.com/langsmith/use-stream-react",
     "cloud/how-tos/generative_ui_react.md": "https://docs.langchain.com/langsmith/generative-ui-react",
     "concepts/langgraph_platform.md": "https://docs.langchain.com/langsmith/deployments",
@@ -233,15 +219,12 @@ REDIRECT_MAP = {
     "tutorials/get-started/6-time-travel.md": "https://docs.langchain.com/oss/python/langgraph/quickstart",
     "tutorials/langsmith/local-server.md": "https://docs.langchain.com/oss/python/langgraph/local-server",
     "tutorials/workflows.md": "https://docs.langchain.com/oss/python/langgraph/workflows-agents",
-    "tutorials/plan-and-execute/plan-and-execute.ipynb": "https://docs.langchain.com/oss/python/langchain/middleware/built-in#to-do-list",
-    "tutorials/langgraph-platform/local-server/local-server.md": "https://docs.langchain.com/langsmith/local-server",
     "concepts/agentic_concepts.md": "https://docs.langchain.com/oss/python/langgraph/workflows-agents",
     "guides/index.md": "https://docs.langchain.com/oss/python/langchain/overview",
     "agents/overview.md": "https://docs.langchain.com/oss/python/langchain/agents",
     "agents/run_agents.md": "https://docs.langchain.com/oss/python/langgraph/quickstart",
     "concepts/low_level.md": "https://docs.langchain.com/oss/python/langgraph/graph-api",
     "how-tos/graph-api.md": "https://docs.langchain.com/oss/python/langgraph/graph-api",
-    "how-tos/react-agent-from-scratch.ipynb": "https://docs.langchain.com/oss/python/langchain/quickstart",
     "concepts/functional_api.md": "https://docs.langchain.com/oss/python/langgraph/functional-api",
     "how-tos/use-functional-api.md": "https://docs.langchain.com/oss/python/langgraph/functional-api",
     "concepts/pregel.md": "https://docs.langchain.com/oss/python/langgraph/pregel",
@@ -299,8 +282,8 @@ REDIRECT_MAP = {
     "reference/supervisor.md": "https://reference.langchain.com/python/langgraph/supervisor/",
     "reference/swarm.md": "https://reference.langchain.com/python/langgraph/swarm/",
     "reference/mcp.md": "https://reference.langchain.com/python/langgraph/mcp/",
-    "cloud/reference/sdk/python_sdk_ref.md": "https://reference.langchain.com/python/langsmith/deployment/sdk/",
-    "reference/remote_graph.md": "https://reference.langchain.com/python/langsmith/deployment/remote_graph/",
+    "cloud/reference/sdk/python_sdk_ref.md": "https://reference.langchain.com/python/platform/python_sdk/",
+    "reference/remote_graph.md": "https://reference.langchain.com/python/platform/remote_graph/",
 
     # additional exclude-search entries from mkdocs.yml
     "additional-resources/index.md": "https://docs.langchain.com/oss/python/langchain/overview",
@@ -810,17 +793,6 @@ def on_post_build(config):
     # Track which paths have explicit redirects
     redirected_paths = set()
 
-    # Collect all existing HTML files in the site
-    all_html_files = set()
-    for root, dirs, files in os.walk(site_dir):
-        for file in files:
-            if file.endswith(".html"):
-                # Get relative path from site_dir
-                html_path = os.path.relpath(os.path.join(root, file), site_dir)
-                # Normalize path separators to forward slashes
-                html_path = html_path.replace(os.sep, "/")
-                all_html_files.add(html_path)
-
     # Process explicit redirects from REDIRECT_MAP
     for page_old, page_new in REDIRECT_MAP.items():
         # Convert .ipynb to .md for path calculation
@@ -875,24 +847,6 @@ def on_post_build(config):
 
             _write_html(site_dir, old_html_path, new_html_path)
 
-    # Create catch-all redirects for any HTML files not explicitly redirected
-    catchall_url = "https://docs.langchain.com/oss/python/langgraph/overview"
-    for html_file in all_html_files:
-        # Skip if this file is already explicitly redirected
-        if html_file in redirected_paths:
-            continue
-
-        # Skip the root index.html (we handle that separately)
-        if html_file == "index.html":
-            continue
-
-        # Skip reference documentation (keep those accessible)
-        if html_file.startswith("reference/"):
-            continue
-
-        # Create redirect for this unmapped file
-        _write_html(site_dir, html_file, catchall_url)
-
     # Create root index.html redirect
     root_redirect_html = """<!doctype html>
 <html lang="en">

libs/langgraph/.claude/settings.local.json

@@ -0,0 +1,16 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(rg:*)",
+      "Bash(python:*)",
+      "Bash(grep:*)",
+      "Bash(sed:*)",
+      "Bash(awk:*)",
+      "Bash(uv run mypy:*)",
+      "Bash(uv run:*)",
+      "Bash(make test:*)",
+      "Bash(make test_parallel:*)"
+    ],
+    "deny": []
+  }
+}

libs/langgraph/langgraph/_internal/_runnable.py

@@ -316,7 +316,10 @@ class RunnableCallable(Runnable):
                 continue
 
             # If the kwarg is accepted by the function, store the key / runtime attribute to inject
-            self.func_accepts[kw] = (runtime_key, default)
+            # Use the actual parameter default from the function signature if available,
+            # otherwise fall back to the default from KWARGS_CONFIG_KEYS
+            param_default = p.default if p.default is not inspect.Parameter.empty else default
+            self.func_accepts[kw] = (runtime_key, param_default)
 
     def __repr__(self) -> str:
         repr_args = {

libs/langgraph/langgraph/pregel/_algo.py

@@ -258,11 +258,9 @@ def apply_writes(
         next_version = None
     else:
         next_version = get_next_version(
-            (
-                max(checkpoint["channel_versions"].values())
-                if checkpoint["channel_versions"]
-                else None
-            ),
+            max(checkpoint["channel_versions"].values())
+            if checkpoint["channel_versions"]
+            else None,
             None,
         )
 
@@ -493,11 +491,6 @@ def prepare_next_tasks(
 PUSH_TRIGGER = (PUSH,)
 
 
-class _TaskIDFn(Protocol):
-    def __call__(self, namespace: bytes, *parts: str | bytes) -> str:
-        pass
-
-
 def prepare_single_task(
     task_path: tuple[Any, ...],
     task_id_checksum: str | None,
@@ -527,50 +520,250 @@ def prepare_single_task(
     task_id_func = _xxhash_str if checkpoint["v"] > 1 else _uuid5_str
 
     if task_path[0] == PUSH and isinstance(task_path[-1], Call):
-        return prepare_push_task_functional(
-            cast(tuple[str, tuple, int, str, Call], task_path),
-            task_id_checksum,
-            checkpoint=checkpoint,
-            checkpoint_id_bytes=checkpoint_id_bytes,
-            pending_writes=pending_writes,
-            channels=channels,
-            managed=managed,
-            config=config,
-            step=step,
-            stop=stop,
-            for_execution=for_execution,
-            store=store,
-            checkpointer=checkpointer,
-            manager=manager,
-            cache_policy=cache_policy,
-            retry_policy=retry_policy,
-            parent_ns=parent_ns,
-            task_id_func=task_id_func,
+        # (PUSH, parent task path, idx of PUSH write, id of parent task, Call)
+        task_path_t = cast(tuple[str, tuple, int, str, Call], task_path)
+        call = task_path_t[-1]
+        proc_ = get_runnable_for_task(call.func)
+        name = proc_.name
+        if name is None:
+            raise ValueError("`call` functions must have a `__name__` attribute")
+        # create task id
+        triggers: Sequence[str] = PUSH_TRIGGER
+        checkpoint_ns = f"{parent_ns}{NS_SEP}{name}" if parent_ns else name
+        task_id = task_id_func(
+            checkpoint_id_bytes,
+            checkpoint_ns,
+            str(step),
+            name,
+            PUSH,
+            task_path_str(task_path[1]),
+            str(task_path[2]),
         )
-
+        task_checkpoint_ns = f"{checkpoint_ns}:{task_id}"
+        # we append True to the task path to indicate that a call is being
+        # made, so we should not return interrupts from this task (responsibility lies with the parent)
+        task_path = (*task_path[:3], True)
+        metadata = {
+            "langgraph_step": step,
+            "langgraph_node": name,
+            "langgraph_triggers": triggers,
+            "langgraph_path": task_path,
+            "langgraph_checkpoint_ns": task_checkpoint_ns,
+        }
+        if task_id_checksum is not None:
+            assert task_id == task_id_checksum, f"{task_id} != {task_id_checksum}"
+        if for_execution:
+            writes: deque[tuple[str, Any]] = deque()
+            cache_policy = call.cache_policy or cache_policy
+            if cache_policy:
+                args_key = cache_policy.key_func(*call.input[0], **call.input[1])
+                cache_key: CacheKey | None = CacheKey(
+                    (
+                        CACHE_NS_WRITES,
+                        (identifier(call.func) or "__dynamic__"),
+                    ),
+                    xxh3_128_hexdigest(
+                        args_key.encode() if isinstance(args_key, str) else args_key,
+                    ),
+                    cache_policy.ttl,
+                )
+            else:
+                cache_key = None
+            scratchpad = _scratchpad(
+                config[CONF].get(CONFIG_KEY_SCRATCHPAD),
+                pending_writes,
+                task_id,
+                xxh3_128_hexdigest(task_checkpoint_ns.encode()),
+                config[CONF].get(CONFIG_KEY_RESUME_MAP),
+                step,
+                stop,
+            )
+            runtime = cast(
+                Runtime, configurable.get(CONFIG_KEY_RUNTIME, DEFAULT_RUNTIME)
+            )
+            runtime = runtime.override(store=store)
+            return PregelExecutableTask(
+                name,
+                call.input,
+                proc_,
+                writes,
+                patch_config(
+                    merge_configs(config, {"metadata": metadata}),
+                    run_name=name,
+                    callbacks=call.callbacks
+                    or (manager.get_child(f"graph:step:{step}") if manager else None),
+                    configurable={
+                        CONFIG_KEY_TASK_ID: task_id,
+                        # deque.extend is thread-safe
+                        CONFIG_KEY_SEND: writes.extend,
+                        CONFIG_KEY_READ: partial(
+                            local_read,
+                            scratchpad,
+                            channels,
+                            managed,
+                            PregelTaskWrites(task_path, name, writes, triggers),
+                        ),
+                        CONFIG_KEY_CHECKPOINTER: (
+                            checkpointer or configurable.get(CONFIG_KEY_CHECKPOINTER)
+                        ),
+                        CONFIG_KEY_CHECKPOINT_MAP: {
+                            **configurable.get(CONFIG_KEY_CHECKPOINT_MAP, {}),
+                            parent_ns: checkpoint["id"],
+                        },
+                        CONFIG_KEY_CHECKPOINT_ID: None,
+                        CONFIG_KEY_CHECKPOINT_NS: task_checkpoint_ns,
+                        CONFIG_KEY_SCRATCHPAD: scratchpad,
+                        CONFIG_KEY_RUNTIME: runtime,
+                    },
+                ),
+                triggers,
+                call.retry_policy or retry_policy,
+                cache_key,
+                task_id,
+                task_path,
+            )
+        else:
+            return PregelTask(task_id, name, task_path)
     elif task_path[0] == PUSH:
-        return prepare_push_task_send(
-            cast(tuple[str, tuple], task_path),
-            task_id_checksum,
-            checkpoint=checkpoint,
-            checkpoint_id_bytes=checkpoint_id_bytes,
-            pending_writes=pending_writes,
-            channels=channels,
-            managed=managed,
-            config=config,
-            step=step,
-            processes=processes,
-            stop=stop,
-            for_execution=for_execution,
-            store=store,
-            checkpointer=checkpointer,
-            manager=manager,
-            cache_policy=cache_policy,
-            retry_policy=retry_policy,
-            parent_ns=parent_ns,
-            task_id_func=task_id_func,
-        )
+        if len(task_path) == 2:
+            # SEND tasks, executed in superstep n+1
+            # (PUSH, idx of pending send)
+            idx = cast(int, task_path[1])
+            if not channels[TASKS].is_available():
+                return
+            sends: Sequence[Send] = channels[TASKS].get()
+            if idx < 0 or idx >= len(sends):
+                return
+            packet = sends[idx]
+            if not isinstance(packet, Send):
+                logger.warning(
+                    f"Ignoring invalid packet type {type(packet)} in pending sends"
+                )
+                return
 
+            if packet.node not in processes:
+                logger.warning(
+                    f"Ignoring unknown node name {packet.node} in pending sends"
+                )
+                return
+            # find process
+            proc = processes[packet.node]
+            proc_node = proc.node
+            if proc_node is None:
+                return
+            # create task id
+            triggers = PUSH_TRIGGER
+            checkpoint_ns = (
+                f"{parent_ns}{NS_SEP}{packet.node}" if parent_ns else packet.node
+            )
+            task_id = task_id_func(
+                checkpoint_id_bytes,
+                checkpoint_ns,
+                str(step),
+                packet.node,
+                PUSH,
+                str(idx),
+            )
+        else:
+            logger.warning(f"Ignoring invalid PUSH task path {task_path}")
+            return
+        task_checkpoint_ns = f"{checkpoint_ns}:{task_id}"
+        # we append False to the task path to indicate that a call is not being made
+        # so we should return interrupts from this task
+        task_path = (*task_path[:3], False)
+        metadata = {
+            "langgraph_step": step,
+            "langgraph_node": packet.node,
+            "langgraph_triggers": triggers,
+            "langgraph_path": task_path,
+            "langgraph_checkpoint_ns": task_checkpoint_ns,
+        }
+        if task_id_checksum is not None:
+            assert task_id == task_id_checksum, f"{task_id} != {task_id_checksum}"
+        if for_execution:
+            if proc.metadata:
+                metadata.update(proc.metadata)
+            writes = deque()
+            cache_policy = proc.cache_policy or cache_policy
+            if cache_policy:
+                args_key = cache_policy.key_func(packet.arg)
+                cache_key = CacheKey(
+                    (
+                        CACHE_NS_WRITES,
+                        (identifier(proc) or "__dynamic__"),
+                        packet.node,
+                    ),
+                    xxh3_128_hexdigest(
+                        args_key.encode() if isinstance(args_key, str) else args_key,
+                    ),
+                    cache_policy.ttl,
+                )
+            else:
+                cache_key = None
+            scratchpad = _scratchpad(
+                config[CONF].get(CONFIG_KEY_SCRATCHPAD),
+                pending_writes,
+                task_id,
+                xxh3_128_hexdigest(task_checkpoint_ns.encode()),
+                config[CONF].get(CONFIG_KEY_RESUME_MAP),
+                step,
+                stop,
+            )
+            runtime = cast(
+                Runtime, configurable.get(CONFIG_KEY_RUNTIME, DEFAULT_RUNTIME)
+            )
+            runtime = runtime.override(
+                store=store, previous=checkpoint["channel_values"].get(PREVIOUS, None)
+            )
+            additional_config: RunnableConfig = {
+                "metadata": metadata,
+                "tags": proc.tags,
+            }
+            return PregelExecutableTask(
+                packet.node,
+                packet.arg,
+                proc_node,
+                writes,
+                patch_config(
+                    merge_configs(config, additional_config),
+                    run_name=packet.node,
+                    callbacks=(
+                        manager.get_child(f"graph:step:{step}") if manager else None
+                    ),
+                    configurable={
+                        CONFIG_KEY_TASK_ID: task_id,
+                        # deque.extend is thread-safe
+                        CONFIG_KEY_SEND: writes.extend,
+                        CONFIG_KEY_READ: partial(
+                            local_read,
+                            scratchpad,
+                            channels,
+                            managed,
+                            PregelTaskWrites(task_path, packet.node, writes, triggers),
+                        ),
+                        CONFIG_KEY_CHECKPOINTER: (
+                            checkpointer or configurable.get(CONFIG_KEY_CHECKPOINTER)
+                        ),
+                        CONFIG_KEY_CHECKPOINT_MAP: {
+                            **configurable.get(CONFIG_KEY_CHECKPOINT_MAP, {}),
+                            parent_ns: checkpoint["id"],
+                        },
+                        CONFIG_KEY_CHECKPOINT_ID: None,
+                        CONFIG_KEY_CHECKPOINT_NS: task_checkpoint_ns,
+                        CONFIG_KEY_SCRATCHPAD: scratchpad,
+                        CONFIG_KEY_RUNTIME: runtime,
+                    },
+                ),
+                triggers,
+                proc.retry_policy or retry_policy,
+                cache_key,
+                task_id,
+                task_path,
+                writers=proc.flat_writers,
+                subgraphs=proc.subgraphs,
+            )
+        else:
+            return PregelTask(task_id, packet.node, task_path)
     elif task_path[0] == PULL:
         # (PULL, node name)
         name = cast(str, task_path[1])
@@ -641,7 +834,7 @@ def prepare_single_task(
                 if node := proc.node:
                     if proc.metadata:
                         metadata.update(proc.metadata)
-                    writes: deque[tuple[str, Any]] = deque()
+                    writes = deque()
                     cache_policy = proc.cache_policy or cache_policy
                     if cache_policy:
                         args_key = cache_policy.key_func(val)
@@ -652,11 +845,9 @@ def prepare_single_task(
                                 name,
                             ),
                             xxh3_128_hexdigest(
-                                (
-                                    args_key.encode()
-                                    if isinstance(args_key, str)
-                                    else args_key
-                                ),
+                                args_key.encode()
+                                if isinstance(args_key, str)
+                                else args_key,
                             ),
                             cache_policy.ttl,
                         )
@@ -679,9 +870,7 @@ def prepare_single_task(
                         node,
                         writes,
                         patch_config(
-                            merge_configs(
-                                config, cast(RunnableConfig, additional_config)
-                            ),
+                            merge_configs(config, additional_config),
                             run_name=name,
                             callbacks=(
                                 manager.get_child(f"graph:step:{step}")
@@ -730,297 +919,6 @@ def prepare_single_task(
                 return PregelTask(task_id, name, task_path[:3])
 
 
-def prepare_push_task_functional(
-    task_path: tuple[str, tuple, int, str, Call],
-    # (PUSH, parent task path, idx of PUSH write, id of parent task, Call)
-    task_id_checksum: str | None,
-    *,
-    checkpoint: Checkpoint,
-    checkpoint_id_bytes: bytes,
-    pending_writes: list[PendingWrite],
-    channels: Mapping[str, BaseChannel],
-    managed: ManagedValueMapping,
-    config: RunnableConfig,
-    step: int,
-    stop: int,
-    for_execution: bool,
-    store: BaseStore | None = None,
-    checkpointer: BaseCheckpointSaver | None = None,
-    manager: None | ParentRunManager | AsyncParentRunManager = None,
-    cache_policy: CachePolicy | None = None,
-    retry_policy: Sequence[RetryPolicy] = (),
-    parent_ns: str,
-    # namespace: bytes, *parts: str | bytes
-    task_id_func: _TaskIDFn,
-) -> PregelTask | PregelExecutableTask:
-    """Prepare a push task with an attached caller. Used for the functional API."""
-    configurable = config.get(CONF, {})
-
-    call = task_path[-1]
-    proc_ = get_runnable_for_task(call.func)
-    name = proc_.name
-    if name is None:
-        raise ValueError("`call` functions must have a `__name__` attribute")
-    # create task id
-    triggers: Sequence[str] = PUSH_TRIGGER
-    checkpoint_ns = f"{parent_ns}{NS_SEP}{name}" if parent_ns else name
-    task_id = task_id_func(
-        checkpoint_id_bytes,
-        checkpoint_ns,
-        str(step),
-        name,
-        PUSH,
-        task_path_str(task_path[1]),
-        str(task_path[2]),
-    )
-    task_checkpoint_ns = f"{checkpoint_ns}:{task_id}"
-    # we append True to the task path to indicate that a call is being
-    # made, so we should not return interrupts from this task (responsibility lies with the parent)
-    in_progress_task_path = (*task_path[:3], True)
-    metadata = {
-        "langgraph_step": step,
-        "langgraph_node": name,
-        "langgraph_triggers": triggers,
-        "langgraph_path": in_progress_task_path,
-        "langgraph_checkpoint_ns": task_checkpoint_ns,
-    }
-    if task_id_checksum is not None:
-        assert task_id == task_id_checksum, f"{task_id} != {task_id_checksum}"
-    if for_execution:
-        writes: deque[tuple[str, Any]] = deque()
-        cache_policy = call.cache_policy or cache_policy
-        if cache_policy:
-            args_key = cache_policy.key_func(*call.input[0], **call.input[1])
-            cache_key: CacheKey | None = CacheKey(
-                (
-                    CACHE_NS_WRITES,
-                    (identifier(call.func) or "__dynamic__"),
-                ),
-                xxh3_128_hexdigest(
-                    args_key.encode() if isinstance(args_key, str) else args_key,
-                ),
-                cache_policy.ttl,
-            )
-        else:
-            cache_key = None
-        scratchpad = _scratchpad(
-            configurable.get(CONFIG_KEY_SCRATCHPAD),
-            pending_writes,
-            task_id,
-            xxh3_128_hexdigest(task_checkpoint_ns.encode()),
-            configurable.get(CONFIG_KEY_RESUME_MAP),
-            step,
-            stop,
-        )
-        runtime = cast(Runtime, configurable.get(CONFIG_KEY_RUNTIME, DEFAULT_RUNTIME))
-        runtime = runtime.override(store=store)
-        return PregelExecutableTask(
-            name,
-            call.input,
-            proc_,
-            writes,
-            patch_config(
-                merge_configs(config, {"metadata": metadata}),
-                run_name=name,
-                callbacks=call.callbacks
-                or (manager.get_child(f"graph:step:{step}") if manager else None),
-                configurable={
-                    CONFIG_KEY_TASK_ID: task_id,
-                    # deque.extend is thread-safe
-                    CONFIG_KEY_SEND: writes.extend,
-                    CONFIG_KEY_READ: partial(
-                        local_read,
-                        scratchpad,
-                        channels,
-                        managed,
-                        PregelTaskWrites(in_progress_task_path, name, writes, triggers),
-                    ),
-                    CONFIG_KEY_CHECKPOINTER: (
-                        checkpointer or configurable.get(CONFIG_KEY_CHECKPOINTER)
-                    ),
-                    CONFIG_KEY_CHECKPOINT_MAP: {
-                        **configurable.get(CONFIG_KEY_CHECKPOINT_MAP, {}),
-                        parent_ns: checkpoint["id"],
-                    },
-                    CONFIG_KEY_CHECKPOINT_ID: None,
-                    CONFIG_KEY_CHECKPOINT_NS: task_checkpoint_ns,
-                    CONFIG_KEY_SCRATCHPAD: scratchpad,
-                    CONFIG_KEY_RUNTIME: runtime,
-                },
-            ),
-            triggers,
-            call.retry_policy or retry_policy,
-            cache_key,
-            task_id,
-            in_progress_task_path,
-        )
-    else:
-        return PregelTask(task_id, name, in_progress_task_path)
-
-
-def prepare_push_task_send(
-    task_path: tuple[str, tuple],
-    # (PUSH, parent task path)
-    task_id_checksum: str | None,
-    *,
-    checkpoint: Checkpoint,
-    checkpoint_id_bytes: bytes,
-    pending_writes: list[PendingWrite],
-    channels: Mapping[str, BaseChannel],
-    managed: ManagedValueMapping,
-    config: RunnableConfig,
-    step: int,
-    stop: int,
-    for_execution: bool,
-    store: BaseStore | None = None,
-    checkpointer: BaseCheckpointSaver | None = None,
-    manager: None | ParentRunManager | AsyncParentRunManager = None,
-    cache_policy: CachePolicy | None = None,
-    retry_policy: Sequence[RetryPolicy] = (),
-    parent_ns: str,
-    task_id_func: _TaskIDFn,
-    processes: Mapping[str, PregelNode],
-) -> PregelTask | PregelExecutableTask | None:
-    if len(task_path) == 2:
-        # SEND tasks, executed in superstep n+1
-        # (PUSH, idx of pending send)
-        idx = cast(int, task_path[1])
-        if not channels[TASKS].is_available():
-            return
-        sends: Sequence[Send] = channels[TASKS].get()
-        if idx < 0 or idx >= len(sends):
-            return
-        packet = sends[idx]
-        if not isinstance(packet, Send):
-            logger.warning(
-                f"Ignoring invalid packet type {type(packet)} in pending sends"
-            )
-            return
-
-        if packet.node not in processes:
-            logger.warning(f"Ignoring unknown node name {packet.node} in pending sends")
-            return
-        # find process
-        proc = processes[packet.node]
-        proc_node = proc.node
-        if proc_node is None:
-            return
-        # create task id
-        triggers = PUSH_TRIGGER
-        checkpoint_ns = (
-            f"{parent_ns}{NS_SEP}{packet.node}" if parent_ns else packet.node
-        )
-        task_id = task_id_func(
-            checkpoint_id_bytes,
-            checkpoint_ns,
-            str(step),
-            packet.node,
-            PUSH,
-            str(idx),
-        )
-    else:
-        logger.warning(f"Ignoring invalid PUSH task path {task_path}")
-        return
-    configurable = config.get(CONF, {})
-    task_checkpoint_ns = f"{checkpoint_ns}:{task_id}"
-    # we append False to the task path to indicate that a call is not being made
-    # so we should return interrupts from this task
-    translated_task_path = (*task_path[:3], False)
-    metadata = {
-        "langgraph_step": step,
-        "langgraph_node": packet.node,
-        "langgraph_triggers": triggers,
-        "langgraph_path": translated_task_path,
-        "langgraph_checkpoint_ns": task_checkpoint_ns,
-    }
-    if task_id_checksum is not None:
-        assert task_id == task_id_checksum, f"{task_id} != {task_id_checksum}"
-    if for_execution:
-        if proc.metadata:
-            metadata.update(proc.metadata)
-        writes: deque[tuple[str, Any]] = deque()
-        cache_policy = proc.cache_policy or cache_policy
-        if cache_policy:
-            args_key = cache_policy.key_func(packet.arg)
-            cache_key = CacheKey(
-                (
-                    CACHE_NS_WRITES,
-                    (identifier(proc) or "__dynamic__"),
-                    packet.node,
-                ),
-                xxh3_128_hexdigest(
-                    args_key.encode() if isinstance(args_key, str) else args_key,
-                ),
-                cache_policy.ttl,
-            )
-        else:
-            cache_key = None
-        scratchpad = _scratchpad(
-            config[CONF].get(CONFIG_KEY_SCRATCHPAD),
-            pending_writes,
-            task_id,
-            xxh3_128_hexdigest(task_checkpoint_ns.encode()),
-            config[CONF].get(CONFIG_KEY_RESUME_MAP),
-            step,
-            stop,
-        )
-        runtime = cast(Runtime, configurable.get(CONFIG_KEY_RUNTIME, DEFAULT_RUNTIME))
-        runtime = runtime.override(
-            store=store, previous=checkpoint["channel_values"].get(PREVIOUS, None)
-        )
-        additional_config: RunnableConfig = {
-            "metadata": metadata,
-            "tags": proc.tags,
-        }
-        return PregelExecutableTask(
-            packet.node,
-            packet.arg,
-            proc_node,
-            writes,
-            patch_config(
-                merge_configs(config, additional_config),
-                run_name=packet.node,
-                callbacks=(
-                    manager.get_child(f"graph:step:{step}") if manager else None
-                ),
-                configurable={
-                    CONFIG_KEY_TASK_ID: task_id,
-                    # deque.extend is thread-safe
-                    CONFIG_KEY_SEND: writes.extend,
-                    CONFIG_KEY_READ: partial(
-                        local_read,
-                        scratchpad,
-                        channels,
-                        managed,
-                        PregelTaskWrites(
-                            translated_task_path, packet.node, writes, triggers
-                        ),
-                    ),
-                    CONFIG_KEY_CHECKPOINTER: (
-                        checkpointer or configurable.get(CONFIG_KEY_CHECKPOINTER)
-                    ),
-                    CONFIG_KEY_CHECKPOINT_MAP: {
-                        **configurable.get(CONFIG_KEY_CHECKPOINT_MAP, {}),
-                        parent_ns: checkpoint["id"],
-                    },
-                    CONFIG_KEY_CHECKPOINT_ID: None,
-                    CONFIG_KEY_CHECKPOINT_NS: task_checkpoint_ns,
-                    CONFIG_KEY_SCRATCHPAD: scratchpad,
-                    CONFIG_KEY_RUNTIME: runtime,
-                },
-            ),
-            triggers,
-            proc.retry_policy or retry_policy,
-            cache_key,
-            task_id,
-            translated_task_path,
-            writers=proc.flat_writers,
-            subgraphs=proc.subgraphs,
-        )
-    else:
-        return PregelTask(task_id, packet.node, translated_task_path)
-
-
 def checkpoint_null_version(
     checkpoint: Checkpoint,
 ) -> V | None:

libs/langgraph/pyproject.toml

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

libs/langgraph/uv.lock

@@ -1,5 +1,5 @@
 version = 1
-revision = 2
+revision = 3
 requires-python = ">=3.10"
 resolution-markers = [
     "python_full_version >= '3.14'",
@@ -1345,7 +1345,7 @@ wheels = [
 
 [[package]]
 name = "langgraph"
-version = "1.0.3"
+version = "1.0.2"
 source = { editable = "." }
 dependencies = [
     { name = "langchain-core" },
@@ -1710,7 +1710,7 @@ test = [
 
 [[package]]
 name = "langgraph-prebuilt"
-version = "1.0.4"
+version = "1.0.2"
 source = { editable = "../prebuilt" }
 dependencies = [
     { name = "langchain-core" },

libs/prebuilt/.claude/settings.local.json

@@ -1,21 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(make test:*)",
-      "Bash(uv run pytest:*)",
-      "Bash(LANGGRAPH_TEST_FAST=0 make start-services:*)",
-      "Bash(LANGGRAPH_TEST_FAST=0 uv run:*)",
-      "Bash(EXIT_CODE=$?)",
-      "Bash(make stop-services:*)",
-      "Bash(exit $EXIT_CODE)",
-      "Read(//Users/sydney_runkle/oss/langgraph/**)",
-      "Bash(python3:*)",
-      "Bash(find:*)",
-      "Bash(python -m pytest:*)",
-      "Bash(python:*)",
-      "Read(//tmp/**)"
-    ],
-    "deny": [],
-    "ask": []
-  }
-}

libs/prebuilt/langgraph/prebuilt/chat_agent_executor.py

@@ -63,7 +63,7 @@ class AgentState(TypedDict):
 
 
 @deprecated(
-    "AgentStatePydantic has been deprecated in favor of AgentState in `langchain.agents`.",
+    "AgentStatePydantic has been moved to `langchain.agents`. Please update your import to `from langchain.agents import AgentStatePydantic`.",
     category=LangGraphDeprecatedSinceV10,
 )
 class AgentStatePydantic(BaseModel):
@@ -78,11 +78,11 @@ with warnings.catch_warnings():
     warnings.filterwarnings(
         "ignore",
         category=LangGraphDeprecatedSinceV10,
-        message="AgentState has been moved to `langchain.agents`.*",
+        message="AgentState has been moved to langchain.agents.*",
     )
 
     @deprecated(
-        "AgentStateWithStructuredResponse has been deprecated in favor of AgentState in `langchain.agents`.",
+        "AgentStateWithStructuredResponse has been moved to `langchain.agents`. Please update your import to `from langchain.agents import AgentStateWithStructuredResponse`.",
         category=LangGraphDeprecatedSinceV10,
     )
     class AgentStateWithStructuredResponse(AgentState):
@@ -95,11 +95,11 @@ with warnings.catch_warnings():
     warnings.filterwarnings(
         "ignore",
         category=LangGraphDeprecatedSinceV10,
-        message="AgentStatePydantic has been deprecated in favor of AgentState in `langchain.agents`.",
+        message="AgentStatePydantic has been moved to langchain.agents.*",
     )
 
     @deprecated(
-        "AgentStateWithStructuredResponsePydantic has been deprecated in favor of AgentState in `langchain.agents`.",
+        "AgentStateWithStructuredResponsePydantic has been moved to `langchain.agents`. Please update your import to `from langchain.agents import AgentStateWithStructuredResponsePydantic`.",
         category=LangGraphDeprecatedSinceV10,
     )
     class AgentStateWithStructuredResponsePydantic(AgentStatePydantic):

libs/prebuilt/langgraph/prebuilt/tool_node.py

@@ -84,6 +84,7 @@ from langchain_core.tools.base import (
 from langgraph._internal._runnable import RunnableCallable
 from langgraph.errors import GraphBubbleUp
 from langgraph.graph.message import REMOVE_ALL_MESSAGES
+from langgraph.runtime import DEFAULT_RUNTIME
 from langgraph.store.base import BaseStore  # noqa: TC002
 from langgraph.types import Command, Send, StreamWriter
 from pydantic import BaseModel, ValidationError
@@ -142,25 +143,6 @@ class ToolCallRequest:
     state: Any
     runtime: ToolRuntime
 
-    def __setattr__(self, name: str, value: Any) -> None:
-        """Raise deprecation warning when setting attributes directly.
-
-        Direct attribute assignment is deprecated. Use the `override()` method instead.
-        """
-        import warnings
-
-        # Allow setting attributes during initialization
-        if not hasattr(self, "__dataclass_fields__") or not hasattr(self, name):
-            object.__setattr__(self, name, value)
-        else:
-            warnings.warn(
-                f"Setting attribute '{name}' on ToolCallRequest is deprecated. "
-                "Use the override() method instead to create a new instance with modified values.",
-                DeprecationWarning,
-                stacklevel=2,
-            )
-            object.__setattr__(self, name, value)
-
     def override(
         self, **overrides: Unpack[_ToolCallRequestOverrides]
     ) -> ToolCallRequest:
@@ -221,9 +203,8 @@ Examples:
 
     ```python
     def handler(request, execute):
-        modified_call = {**request.tool_call, "args": {**request.tool_call["args"], "value": request.tool_call["args"]["value"] * 2}}
-        modified_request = request.override(tool_call=modified_call)
-        return execute(modified_request)
+        request.tool_call["args"]["value"] *= 2
+        return execute(request)
     ```
 
     Retry on error (execute multiple times):
@@ -722,7 +703,7 @@ class ToolNode(RunnableCallable):
         self,
         input: list[AnyMessage] | dict[str, Any] | BaseModel,
         config: RunnableConfig,
-        runtime: Runtime,
+        runtime: Runtime = DEFAULT_RUNTIME,
     ) -> Any:
         tool_calls, input_type = self._parse_input(input)
         config_list = get_config_list(config, len(tool_calls))
@@ -754,7 +735,7 @@ class ToolNode(RunnableCallable):
         self,
         input: list[AnyMessage] | dict[str, Any] | BaseModel,
         config: RunnableConfig,
-        runtime: Runtime,
+        runtime: Runtime = DEFAULT_RUNTIME,
     ) -> Any:
         tool_calls, input_type = self._parse_input(input)
         config_list = get_config_list(config, len(tool_calls))

libs/prebuilt/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "langgraph-prebuilt"
-version = "1.0.4"
+version = "1.0.2"
 description = "Library with high-level APIs for creating and executing LangGraph agents and tools."
 authors = []
 requires-python = ">=3.10"

libs/prebuilt/tests/test_on_tool_call.py

@@ -130,17 +130,11 @@ def test_modify_arguments() -> None:
         execute: Callable[[ToolCallRequest], ToolMessage | Command],
     ) -> ToolMessage | Command:
         """Handler that doubles the input arguments."""
-        # Modify the arguments using override method
-        modified_call = {
-            **request.tool_call,
-            "args": {
-                **request.tool_call["args"],
-                "a": request.tool_call["args"]["a"] * 2,
-                "b": request.tool_call["args"]["b"] * 2,
-            },
-        }
-        modified_request = request.override(tool_call=modified_call)
-        return execute(modified_request)
+        # Modify the arguments
+        request.tool_call["args"]["a"] *= 2
+        request.tool_call["args"]["b"] *= 2
+
+        return execute(request)
 
     tool_node = ToolNode([add], wrap_tool_call=modify_args_handler)
 
@@ -368,17 +362,10 @@ async def test_handler_with_async_execution() -> None:
         execute: Callable[[ToolCallRequest], ToolMessage | Command],
     ) -> ToolMessage | Command:
         """Handler that modifies arguments."""
-        # Add 10 to both arguments using override method
-        modified_call = {
-            **request.tool_call,
-            "args": {
-                **request.tool_call["args"],
-                "a": request.tool_call["args"]["a"] + 10,
-                "b": request.tool_call["args"]["b"] + 10,
-            },
-        }
-        modified_request = request.override(tool_call=modified_call)
-        return execute(modified_request)
+        # Add 10 to both arguments
+        request.tool_call["args"]["a"] += 10
+        request.tool_call["args"]["b"] += 10
+        return execute(request)
 
     tool_node = ToolNode([async_add], wrap_tool_call=modifying_handler)
 
@@ -1318,64 +1305,3 @@ async def test_state_extraction_with_tool_call_with_context_async() -> None:
     assert state_seen[0] == actual_state
     assert "__type" not in state_seen[0]
     assert "tool_call" not in state_seen[0]
-
-
-def test_tool_call_request_is_frozen() -> None:
-    """Test that ToolCallRequest raises deprecation warnings on direct attribute reassignment."""
-    tool_call: ToolCall = {"name": "add", "args": {"a": 1, "b": 2}, "id": "call_1"}
-    state: dict = {"messages": []}
-    runtime = None
-
-    request = ToolCallRequest(
-        tool_call=tool_call, tool=add, state=state, runtime=runtime
-    )  # type: ignore[arg-type]
-
-    # Test that direct attribute reassignment raises DeprecationWarning
-    with pytest.warns(
-        DeprecationWarning,
-        match="Setting attribute 'tool_call' on ToolCallRequest is deprecated",
-    ):
-        request.tool_call = {"name": "other", "args": {}, "id": "call_2"}  # type: ignore[misc]
-
-    with pytest.warns(
-        DeprecationWarning,
-        match="Setting attribute 'tool' on ToolCallRequest is deprecated",
-    ):
-        request.tool = None  # type: ignore[misc]
-
-    with pytest.warns(
-        DeprecationWarning,
-        match="Setting attribute 'state' on ToolCallRequest is deprecated",
-    ):
-        request.state = {}  # type: ignore[misc]
-
-    with pytest.warns(
-        DeprecationWarning,
-        match="Setting attribute 'runtime' on ToolCallRequest is deprecated",
-    ):
-        request.runtime = None  # type: ignore[misc]
-
-    # Test that override method works correctly
-    new_tool_call: ToolCall = {
-        "name": "multiply",
-        "args": {"x": 5, "y": 10},
-        "id": "call_3",
-    }
-
-    # Original request should be unchanged (note: it was modified by the warnings tests above)
-    # So we create a fresh request to test override properly
-    fresh_request = ToolCallRequest(
-        tool_call=tool_call, tool=add, state=state, runtime=runtime
-    )  # type: ignore[arg-type]
-    fresh_new_request = fresh_request.override(tool_call=new_tool_call)
-
-    # Original request should be unchanged
-    assert fresh_request.tool_call == tool_call
-    assert fresh_request.tool_call["name"] == "add"
-
-    # New request should have the updated tool_call
-    assert fresh_new_request.tool_call == new_tool_call
-    assert fresh_new_request.tool_call["name"] == "multiply"
-    assert fresh_new_request.tool == add  # Other fields should remain the same
-    assert fresh_new_request.state == state
-    assert fresh_new_request.runtime is None

libs/prebuilt/tests/test_tool_node.py

@@ -9,7 +9,6 @@ from typing import (
     NoReturn,
     TypeVar,
 )
-from unittest.mock import Mock
 
 import pytest
 from langchain_core.messages import (
@@ -51,27 +50,26 @@ from .model import FakeToolCallingModel
 pytestmark = pytest.mark.anyio
 
 
-def _create_mock_runtime(store: BaseStore | None = None) -> Mock:
-    """Create a mock Runtime object for testing ToolNode outside of graph context.
-
-    This helper is needed because ToolNode._func expects a Runtime parameter
-    which is injected by RunnableCallable from config["configurable"]["__pregel_runtime"].
-    When testing ToolNode directly (outside a graph), we need to provide this manually.
-    """
-    mock_runtime = Mock()
-    mock_runtime.store = store
-    mock_runtime.context = None
-    mock_runtime.stream_writer = lambda *args, **kwargs: None
-    return mock_runtime
-
-
 def _create_config_with_runtime(store: BaseStore | None = None) -> RunnableConfig:
-    """Create a RunnableConfig with mock Runtime for testing ToolNode.
+    """Create a RunnableConfig for testing ToolNode.
+
+    Since ToolNode now has a default Runtime, this helper can be simplified.
+    It only needs to inject a store if one is provided, otherwise an empty config works.
+
+    Args:
+        store: Optional store to inject via runtime. If None, no runtime is needed.
 
     Returns:
-        RunnableConfig with __pregel_runtime in configurable dict.
+        RunnableConfig, optionally with __pregel_runtime if store is provided.
     """
-    return {"configurable": {"__pregel_runtime": _create_mock_runtime(store)}}
+    if store is None:
+        # No runtime needed - ToolNode will use DEFAULT_RUNTIME
+        return {}
+
+    # Create a mock runtime only when we need to inject a store
+    from langgraph.runtime import Runtime
+    runtime = Runtime(context=None, store=store, stream_writer=lambda *args, **kwargs: None)
+    return {"configurable": {"__pregel_runtime": runtime}}
 
 
 def tool1(some_val: int, some_other_val: str) -> str:
@@ -1610,65 +1608,3 @@ def test_tool_node_stream_writer() -> None:
             },
         ),
     ]
-
-
-def test_tool_call_request_setattr_deprecation_warning():
-    """Test that ToolCallRequest raises a deprecation warning on direct attribute modification."""
-    import warnings
-
-    from langgraph.prebuilt.tool_node import ToolCallRequest
-
-    # Create a mock ToolCall
-    tool_call = {"name": "test", "args": {"a": 1}, "id": "call_1", "type": "tool_call"}
-
-    # Create a ToolCallRequest
-    request = ToolCallRequest(
-        tool_call=tool_call,
-        tool=None,
-        state={"messages": []},
-        runtime=None,
-    )
-
-    # Test 1: Direct attribute assignment should raise deprecation warning but still work
-    with pytest.warns(DeprecationWarning, match="deprecated.*override"):
-        request.tool_call = {"name": "other", "args": {}, "id": "call_2"}
-
-    # Verify the attribute was actually modified
-    assert request.tool_call == {"name": "other", "args": {}, "id": "call_2"}
-
-    # Reset for further tests
-    with warnings.catch_warnings():
-        warnings.simplefilter("ignore")
-        request.tool_call = tool_call
-
-    # Test 2: override method should work without warnings
-    with warnings.catch_warnings(record=True) as w:
-        warnings.simplefilter("always")
-        new_tool_call = {
-            "name": "new_tool",
-            "args": {"b": 2},
-            "id": "call_3",
-            "type": "tool_call",
-        }
-        new_request = request.override(tool_call=new_tool_call)
-
-        # Verify no warning was raised
-        assert len(w) == 0
-
-    # Verify original is unchanged
-    assert request.tool_call == tool_call
-
-    # Verify new request has updated values
-    assert new_request.tool_call == new_tool_call
-
-    # Test 3: Initialization should not trigger warning
-    with warnings.catch_warnings(record=True) as w:
-        warnings.simplefilter("always")
-        ToolCallRequest(
-            tool_call=tool_call,
-            tool=None,
-            state={"messages": []},
-            runtime=None,
-        )
-        # Verify no warning was raised during initialization
-        assert len(w) == 0

libs/prebuilt/uv.lock

@@ -1,5 +1,5 @@
 version = 1
-revision = 2
+revision = 3
 requires-python = ">=3.10"
 
 [[package]]
@@ -246,7 +246,7 @@ wheels = [
 
 [[package]]
 name = "langgraph"
-version = "1.0.3"
+version = "1.0.2"
 source = { editable = "../langgraph" }
 dependencies = [
     { name = "langchain-core" },
@@ -467,7 +467,7 @@ test = [
 
 [[package]]
 name = "langgraph-prebuilt"
-version = "1.0.4"
+version = "1.0.2"
 source = { editable = "." }
 dependencies = [
     { name = "langchain-core" },