fix(langgraph): keep only name, description and forked in __subagents

libs/cli/README.md

@@ -86,47 +86,6 @@ langgraph dockerfile SAVE_PATH [OPTIONS]
   -c, --config FILE       Config file path
 ```
 
-### `langgraph deploy metrics`
-
-Fetch deployment monitoring time series as JSON through the LangSmith control plane.
-Use `langgraph deploy list` to find the deployment ID. Authentication uses the same
-API key and workspace configuration as the other deployment commands.
-
-```bash
-langgraph deploy metrics DEPLOYMENT_ID \
-  --start-time 2026-10-28T00:00:00Z \
-  --end-time 2026-10-28T01:00:00Z \
-  --metrics cpu_usage,memory_usage,worker_count
-```
-
-Omit `--metrics` to fetch all available metrics. Time bounds default to the start of
-the current hour through now, and the backend picks the resolution from the time
-range. Output contains
-charts and their time-series data, not traces. This command never prompts; for an
-organization-scoped key, set `LANGSMITH_TENANT_ID` to the workspace ID.
-
-### `langgraph deploy scale`
-
-Change a deployment's compute tier, dedicated Postgres tier, or both. Omitted
-settings remain unchanged. The backend enforces deployment permissions, supported
-tiers, and platform restrictions.
-
-```bash
-langgraph deploy scale DEPLOYMENT_ID \
-  --compute-tier DEDICATED_M --database-tier DEDICATED_L
-```
-
-Compute tiers are `SERVERLESS_S`, `SERVERLESS_M`, `SERVERLESS_L`, `DEDICATED_S`,
-`DEDICATED_M`, and `DEDICATED_L`. Database tiers are available only for dedicated
-deployments: `DEDICATED_S`, `DEDICATED_M`, and `DEDICATED_L`. Availability depends
-on the deployment's platform and enabled features.
-
-Scaling prompts for confirmation because it creates a revision, may interrupt
-service, and may change billing. Pass `--yes` to confirm without prompting, with
-credentials and workspace configured for non-interactive use. The command reports
-that scaling was requested; it does not wait for the revision to become healthy.
-Arbitrary worker replica overrides are not supported by this command.
-
 ## Configuration
 
 The CLI uses a `langgraph.json` configuration file with these key settings:

libs/cli/js-monorepo-example/yarn.lock

@@ -2148,6 +2148,6 @@ yocto-queue@^0.1.0:
   integrity sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==
 
 "zod@^3.25.76 || ^4":
-  version "4.6.7"
-  resolved "https://registry.yarnpkg.com/zod/-/zod-4.6.7.tgz#e806cf64a7f4e37635ce9f2f52c04c3766f75e5b"
-  integrity sha512-g8W2D2kU6a8untc053fX1uVBKzM7yqAxW/3zwk83+6RyF2+SKOuV+c0wBDhUwzV1PaGapmZH+rmcUzPf+3CGwg==
+  version "4.3.6"
+  resolved "https://registry.yarnpkg.com/zod/-/zod-4.3.6.tgz#89c56e0aa7d2b05107d894412227087885ab112a"
+  integrity sha512-rftlrkhHZOcjDwkGlnUtZZkvaPHCsDATp4pGpuOOMDaTdDDXF91wuVDJoWoPsKX/3YPQ5fHuF3STjcYyKr+Qhg==

libs/cli/langgraph_cli/deploy.py

@@ -13,7 +13,6 @@ from contextlib import contextmanager
 from dataclasses import asdict, dataclass, field
 from datetime import datetime, timezone
 from typing import Generic, Protocol, TypeVar
-from uuid import UUID
 
 import click
 import click.exceptions
@@ -2636,109 +2635,6 @@ def deploy_list(
 # ---------------------------------------------------------------------------
 
 
-@OPT_HOST_API_KEY
-@OPT_HOST_URL
-@click.argument("deployment_id", type=click.UUID)
-@click.option(
-    "--start-time",
-    help="ISO8601 start time. Defaults to the start of the current hour.",
-)
-@click.option("--end-time", help="ISO8601 end time. Defaults to now.")
-@click.option(
-    "--metrics", help="Comma-separated metric names. Defaults to all metrics."
-)
-@deploy.command(
-    "metrics", help="[Beta] Fetch deployment monitoring time series as JSON."
-)
-def deploy_metrics(
-    api_key: str | None,
-    host_url: str | None,
-    deployment_id: UUID,
-    start_time: str | None,
-    end_time: str | None,
-    metrics: str | None,
-) -> None:
-    params = {
-        key: value
-        for key, value in {
-            "start_time": start_time,
-            "end_time": end_time,
-            "metrics": metrics,
-        }.items()
-        if value is not None
-    }
-    client = _create_host_backend_client(host_url, api_key, no_input=True)
-    result = _call_host_backend_with_optional_tenant(
-        client,
-        lambda c: c.get_deployment_metrics(str(deployment_id), params),
-        no_input=True,
-    )
-    click.echo(json_mod.dumps(result))
-
-
-@OPT_HOST_API_KEY
-@OPT_HOST_URL
-@click.argument("deployment_id", type=click.UUID)
-@click.option(
-    "--compute-tier",
-    type=click.Choice(
-        [
-            "SERVERLESS_S",
-            "SERVERLESS_M",
-            "SERVERLESS_L",
-            "DEDICATED_S",
-            "DEDICATED_M",
-            "DEDICATED_L",
-        ]
-    ),
-    help="Compute resource tier. Omit to leave compute unchanged.",
-)
-@click.option(
-    "--database-tier",
-    type=click.Choice(["DEDICATED_S", "DEDICATED_M", "DEDICATED_L"]),
-    help="Postgres resource tier for dedicated deployments. Omit to leave unchanged.",
-)
-@click.option(
-    "--yes", is_flag=True, help="Confirm the scaling change without prompting."
-)
-@deploy.command(
-    "scale",
-    help="[Beta] Change compute or Postgres tiers. Creates a revision and may change billing.",
-)
-def deploy_scale(
-    api_key: str | None,
-    host_url: str | None,
-    deployment_id: UUID,
-    compute_tier: str | None,
-    database_tier: str | None,
-    yes: bool,
-) -> None:
-    payload = {
-        key: value
-        for key, value in {
-            "compute_tier": compute_tier,
-            "database_tier": database_tier,
-        }.items()
-        if value is not None
-    }
-    if not payload:
-        raise click.UsageError("Specify --compute-tier or --database-tier.")
-    if not yes:
-        changes = ", ".join(f"{key}={value}" for key, value in payload.items())
-        click.confirm(
-            f"Scale deployment {deployment_id} ({changes})? "
-            "This creates a revision and may change billing or interrupt service.",
-            abort=True,
-        )
-    client = _create_host_backend_client(host_url, api_key, no_input=yes)
-    _call_host_backend_with_optional_tenant(
-        client,
-        lambda c: c.scale_deployment(str(deployment_id), payload),
-        no_input=yes,
-    )
-    click.echo(f"Scaling requested for deployment {deployment_id}.")
-
-
 @deploy.group(
     "listeners",
     cls=NestedHelpGroup,

libs/cli/langgraph_cli/host_backend.py

@@ -362,18 +362,6 @@ class HostBackendClient:
             f"/v2/deployments/{deployment_id}/revisions/{revision_id}",
         )
 
-    def get_deployment_metrics(
-        self, deployment_id: str, params: dict[str, Any]
-    ) -> dict[str, Any]:
-        return self._request(
-            "GET", f"/v2/deployments/{deployment_id}/metrics", params=params
-        )
-
-    def scale_deployment(self, deployment_id: str, payload: dict[str, str]) -> None:
-        self._request(
-            "PATCH", f"/v2/deployments/{deployment_id}/resource-tiers", payload
-        )
-
     def get_build_logs(
         self, project_id: str, revision_id: str, payload: dict[str, Any]
     ) -> Any:

libs/cli/tests/unit_tests/cli/test_deploy_monitoring.py

@@ -1,130 +0,0 @@
-import json
-
-import httpx
-import pytest
-from click.testing import CliRunner
-
-import langgraph_cli.deploy as deploy_module
-from langgraph_cli.cli import cli
-from langgraph_cli.host_backend import HostBackendClient
-
-DEPLOYMENT_ID = "019a0000-0000-7000-8000-000000000001"
-
-
-def invoke(monkeypatch, args, handler, input=None):
-    client = HostBackendClient(
-        "https://api.example.com",
-        "key",
-        tenant_id="workspace-id",
-        transport=httpx.MockTransport(handler),
-    )
-    monkeypatch.setattr(deploy_module, "HostBackendClient", lambda *a, **kw: client)
-    return CliRunner().invoke(
-        cli,
-        ["deploy", *args, "--api-key", "key"],
-        input=input,
-    )
-
-
-@pytest.mark.parametrize("filtered", [False, True])
-def test_metrics(monkeypatch, filtered):
-    charts = {"id": "metrics", "charts": [], "sub_sections": []}
-    params = (
-        {
-            "start_time": "2026-10-28T00:00:00Z",
-            "end_time": "2026-10-28T01:00:00Z",
-            "metrics": "cpu_usage,memory_usage",
-        }
-        if filtered
-        else {}
-    )
-
-    def handler(request):
-        assert request.method == "GET"
-        assert request.url.path == f"/v2/deployments/{DEPLOYMENT_ID}/metrics"
-        assert dict(request.url.params) == params
-        assert request.headers["x-tenant-id"] == "workspace-id"
-        assert request.headers["x-api-key"] == "key"
-        return httpx.Response(200, json=charts)
-
-    args = ["metrics", DEPLOYMENT_ID]
-    for key, value in params.items():
-        args.extend([f"--{key.replace('_', '-')}", value])
-    result = invoke(monkeypatch, args, handler)
-    assert result.exit_code == 0, result.output
-    assert json.loads(result.output) == charts
-
-
-@pytest.mark.parametrize(
-    "tiers",
-    [
-        {"compute_tier": "SERVERLESS_M"},
-        {"database_tier": "DEDICATED_L"},
-        {"compute_tier": "DEDICATED_M", "database_tier": "DEDICATED_L"},
-    ],
-)
-def test_scale(monkeypatch, tiers):
-    def handler(request):
-        assert request.method == "PATCH"
-        assert request.url.path == f"/v2/deployments/{DEPLOYMENT_ID}/resource-tiers"
-        assert request.headers["x-tenant-id"] == "workspace-id"
-        assert json.loads(request.content) == tiers
-        return httpx.Response(200, json={"secrets": [{"value": "secret-value"}]})
-
-    args = ["scale", DEPLOYMENT_ID, "--yes"]
-    for key, value in tiers.items():
-        args.extend([f"--{key.replace('_', '-')}", value])
-    result = invoke(monkeypatch, args, handler)
-    assert result.exit_code == 0, result.output
-    assert "Scaling requested" in result.output
-    assert "secret-value" not in result.output
-
-
-@pytest.mark.parametrize("answer,expected_code", [("y\n", 0), ("n\n", 1)])
-def test_scale_confirmation(monkeypatch, answer, expected_code):
-    requests = []
-
-    def handler(request):
-        requests.append(request)
-        return httpx.Response(200, json={})
-
-    result = invoke(
-        monkeypatch,
-        ["scale", DEPLOYMENT_ID, "--compute-tier", "DEDICATED_S"],
-        handler,
-        input=answer,
-    )
-    assert result.exit_code == expected_code, result.output
-    assert len(requests) == (1 if expected_code == 0 else 0)
-    assert "may change billing or interrupt service" in result.output
-
-
-@pytest.mark.parametrize(
-    "args",
-    [
-        ["scale", DEPLOYMENT_ID, "--yes"],
-        ["scale", DEPLOYMENT_ID, "--database-tier", "SERVERLESS_M", "--yes"],
-        ["metrics", DEPLOYMENT_ID, "--step-seconds", "60"],
-        ["metrics", "invalid-id"],
-    ],
-)
-def test_invalid_options_do_not_send_requests(monkeypatch, args):
-    def handler(request):
-        pytest.fail("Invalid options must not send a request")
-
-    result = invoke(monkeypatch, args, handler)
-    assert result.exit_code == 2, result.output
-
-
-@pytest.mark.parametrize("command", ["metrics", "scale"])
-@pytest.mark.parametrize("status", [403, 422, 429])
-def test_backend_errors(monkeypatch, command, status):
-    def handler(request):
-        return httpx.Response(status, json={"detail": "Operation rejected"})
-
-    args = [command, DEPLOYMENT_ID]
-    if command == "scale":
-        args.extend(["--compute-tier", "DEDICATED_M", "--yes"])
-    result = invoke(monkeypatch, args, handler)
-    assert result.exit_code == 1
-    assert "Operation rejected" in result.output

libs/langgraph/langgraph/pregel/_draw.py

@@ -232,6 +232,8 @@ def draw_graph(
         tools_by_name = getattr(node.bound, "tools_by_name", None)
         if isinstance(tools_by_name, Mapping) and tools_by_name:
             metadata["__tools"] = list(tools_by_name)
+            if subagents := _get_tool_subagents(tools_by_name):
+                metadata["__subagents"] = subagents
         graph.add_node(node.bound, name, metadata=metadata or None)
     # add start node
     if START not in nodes:
@@ -281,6 +283,38 @@ def draw_graph(
     return graph
 
 
+def _get_tool_subagents(
+    tools_by_name: Mapping[str, Any],
+) -> dict[str, list[dict[str, Any]]]:
+    """Collect the subagents each tool can run, keyed by tool name."""
+    subagents: dict[str, list[dict[str, Any]]] = {}
+    for tool_name, tool in tools_by_name.items():
+        tool_subagents = getattr(tool, "subagents", None)
+        if (
+            isinstance(tool_subagents, Sequence)
+            and not isinstance(tool_subagents, str)
+            and tool_subagents
+            and all(
+                isinstance(subagent, Mapping) and isinstance(subagent.get("name"), str)
+                for subagent in tool_subagents
+            )
+        ):
+            subagents[tool_name] = [
+                _subagent_entry(subagent) for subagent in tool_subagents
+            ]
+    return subagents
+
+
+def _subagent_entry(subagent: Mapping[str, Any]) -> dict[str, Any]:
+    """Keep only the subagent fields graph viewers display."""
+    entry: dict[str, Any] = {"name": subagent["name"]}
+    if isinstance(description := subagent.get("description"), str):
+        entry["description"] = description
+    if subagent.get("forked") is True:
+        entry["forked"] = True
+    return entry
+
+
 def add_edge(
     graph: Graph,
     source: str,

libs/langgraph/langgraph/pregel/_messages.py

@@ -216,7 +216,7 @@ class StreamMessagesHandler(BaseCallbackHandler, _StreamingCallbackHandler):
             ns = tuple(cast(str, metadata["langgraph_checkpoint_ns"]).split(NS_SEP))[
                 :-1
             ]
-            if not self.subgraphs and len(ns) > 0 and ns != self.parent_ns:
+            if not self.subgraphs and len(ns) > 0:
                 return
             self.metadata[run_id] = (ns, metadata)
             for value in _state_values(inputs):

libs/langgraph/langgraph/pregel/remote.py

@@ -847,11 +847,6 @@ class RemoteGraph(PregelProtocol):
             # filter for what was actually requested
             if mode not in requested:
                 continue
-            # subgraph events may have been requested only for the parent stream.
-            # messages are exempt: the server dedupes them across namespaces, so
-            # dropping them here would also drop the root-level message
-            if not subgraphs and NS_SEP in chunk.event and mode != "messages":
-                continue
 
             if chunk.event.startswith("messages"):
                 chunk = chunk._replace(data=tuple(chunk.data))
@@ -1002,11 +997,6 @@ class RemoteGraph(PregelProtocol):
             # filter for what was actually requested
             if mode not in requested:
                 continue
-            # subgraph events may have been requested only for the parent stream.
-            # messages are exempt: the server dedupes them across namespaces, so
-            # dropping them here would also drop the root-level message
-            if not subgraphs and NS_SEP in chunk.event and mode != "messages":
-                continue
 
             if chunk.event.startswith("messages"):
                 chunk = chunk._replace(data=tuple(chunk.data))

libs/langgraph/tests/test_pregel.py

@@ -36,7 +36,7 @@ from langchain_core.runnables import (
     RunnablePassthrough,
 )
 from langchain_core.runnables.graph import Edge
-from langchain_core.tools import tool
+from langchain_core.tools import StructuredTool, tool
 from langchain_core.version import VERSION as LANGCHAIN_CORE_VERSION
 from langgraph.cache.base import BaseCache
 from langgraph.checkpoint.base import (
@@ -3105,6 +3105,49 @@ def test_simple_multi_edge(snapshot: SnapshotAssertion) -> None:
     )
 
 
+def test_tool_node_lists_tool_subagents_in_graph_metadata() -> None:
+    class TaskTool(StructuredTool):
+        subagents: list[dict[str, Any]] = []
+
+    def run_task(description: str, subagent_type: str) -> str:
+        return subagent_type
+
+    task = TaskTool.from_function(run_task, name="task", description="Run a subagent.")
+    task.subagents = [
+        {"name": "researcher", "description": "Researches a topic."},
+        {
+            "name": "critic",
+            "description": "Reviews drafts.",
+            "forked": True,
+            "system_prompt": "You are a critic.",
+            "runnable": object(),
+        },
+        {"name": "planner", "description": None, "forked": "yes"},
+    ]
+
+    @tool
+    def search(query: str) -> str:
+        """Search the web."""
+        return query
+
+    builder = StateGraph(MessagesState)
+    builder.add_node("agent", lambda state: state)
+    builder.add_node("tools", ToolNode([search, task]))
+    builder.add_edge(START, "agent")
+    builder.add_edge("agent", "tools")
+    graph = builder.compile().get_graph().to_json()
+    nodes = {node["id"]: node for node in graph["nodes"]}
+
+    assert nodes["tools"]["metadata"]["__subagents"] == {
+        "task": [
+            {"name": "researcher", "description": "Researches a topic."},
+            {"name": "critic", "description": "Reviews drafts.", "forked": True},
+            {"name": "planner"},
+        ]
+    }
+    assert "__subagents" not in (nodes["agent"].get("metadata") or {})
+
+
 def test_nested_graph_xray(snapshot: SnapshotAssertion) -> None:
     class State(TypedDict):
         my_key: Annotated[str, operator.add]
@@ -8950,39 +8993,6 @@ def test_subgraph_streaming_sync() -> None:
     assert result["num_chunks"] == 9
 
 
-def test_subgraph_streaming_node_output_messages_sync() -> None:
-    """Messages returned by a node (not streamed by an LLM) are emitted when a
-    graph is explicitly streamed with `stream_mode="messages"` inside a node."""
-
-    def respond(state: MessagesState) -> dict:
-        return {"messages": [AIMessage("hi there", id="ai1")]}
-
-    subgraph = (
-        StateGraph(MessagesState)
-        .add_node("respond", respond)
-        .add_edge(START, "respond")
-        .compile()
-    )
-    msgs = {"messages": [("user", "hello")]}
-
-    top_level = [msg for msg, _ in subgraph.stream(msgs, stream_mode="messages")]
-
-    def parent_node(state: MessagesState, config: RunnableConfig) -> dict:
-        nonlocal in_node
-        in_node = [
-            msg for msg, _ in subgraph.stream(msgs, config, stream_mode="messages")
-        ]
-        return {}
-
-    in_node: list = []
-    StateGraph(MessagesState).add_node("parent", parent_node).add_edge(
-        START, "parent"
-    ).compile().invoke(msgs)
-
-    assert [m.content for m in top_level] == ["hi there"]
-    assert [m.content for m in in_node] == ["hi there"]
-
-
 def test_get_graph_nonterminal_last_step_source(snapshot: SnapshotAssertion) -> None:
     class State(TypedDict):
         messages: list[str]

libs/langgraph/tests/test_pregel_async.py

@@ -9503,44 +9503,6 @@ async def test_subgraph_streaming_async() -> None:
     assert result["num_chunks"] == 9
 
 
-async def test_subgraph_streaming_node_output_messages_async() -> None:
-    """Messages returned by a node (not streamed by an LLM) are emitted when a
-    graph is explicitly streamed with `stream_mode="messages"` inside a node."""
-
-    async def respond(state: MessagesState) -> dict:
-        return {"messages": [AIMessage("hi there", id="ai1")]}
-
-    subgraph = (
-        StateGraph(MessagesState)
-        .add_node("respond", respond)
-        .add_edge(START, "respond")
-        .compile()
-    )
-    msgs = {"messages": [("user", "hello")]}
-
-    top_level = [msg async for msg, _ in subgraph.astream(msgs, stream_mode="messages")]
-
-    async def parent_node(state: MessagesState, config: RunnableConfig) -> dict:
-        nonlocal in_node
-        in_node = [
-            msg
-            async for msg, _ in subgraph.astream(msgs, config, stream_mode="messages")
-        ]
-        return {}
-
-    in_node: list = []
-    await (
-        StateGraph(MessagesState)
-        .add_node("parent", parent_node)
-        .add_edge(START, "parent")
-        .compile()
-        .ainvoke(msgs)
-    )
-
-    assert [m.content for m in top_level] == ["hi there"]
-    assert [m.content for m in in_node] == ["hi there"]
-
-
 @NEEDS_CONTEXTVARS
 async def test_null_resume_disallowed_with_multiple_interrupts(
     async_checkpointer: BaseCheckpointSaver,

libs/langgraph/tests/test_remote_graph.py

@@ -16,11 +16,9 @@ from langgraph_sdk.schema import StreamPart
 from pydantic import BaseModel
 from typing_extensions import TypedDict
 
-from langgraph._internal._constants import CONFIG_KEY_STREAM
 from langgraph.errors import GraphInterrupt
 from langgraph.graph import END, START, MessagesState, StateGraph, add_messages
 from langgraph.pregel import Pregel
-from langgraph.pregel.protocol import StreamProtocol
 from langgraph.pregel.remote import RemoteGraph
 from langgraph.types import Interrupt, StateSnapshot
 from tests.any_str import AnyStr
@@ -865,87 +863,6 @@ async def test_astream_subgraphs_keeps_caller_namespace():
     assert stream_parts == _CALLER_PREFIXED
 
 
-# Subgraph events requested only on behalf of a streaming parent graph
-_PARENT_STREAMED_PARTS = [
-    StreamPart(event="updates|sub:abc", data={"inner": {"chunk": "inner"}}),
-    StreamPart(event="messages|sub:abc", data=[{"content": "token"}, {}]),
-    StreamPart(event="updates", data={"sub": {"chunk": "root"}}),
-]
-
-
-def _parent_streamed_config(parent_parts: list) -> RunnableConfig:
-    return {
-        "configurable": {
-            "thread_id": "thread_1",
-            "checkpoint_ns": "outer:123",
-            CONFIG_KEY_STREAM: StreamProtocol(
-                parent_parts.append, {"updates", "messages"}
-            ),
-        }
-    }
-
-
-def test_stream_without_subgraphs_skips_parent_requested_subgraph_events():
-    mock_sync_client = MagicMock()
-    mock_sync_client.runs.stream.return_value = _PARENT_STREAMED_PARTS
-    remote_pregel = RemoteGraph("test_graph_id", sync_client=mock_sync_client)
-
-    for stream_mode, expected in [
-        ("updates", [{"sub": {"chunk": "root"}}]),
-        # messages are not filtered: the server dedupes them across namespaces
-        ("messages", [({"content": "token"}, {})]),
-    ]:
-        parent_parts: list = []
-        stream_parts = list(
-            remote_pregel.stream(
-                {"input": "data"},
-                _parent_streamed_config(parent_parts),
-                stream_mode=stream_mode,
-            )
-        )
-
-        assert stream_parts == expected
-        # subgraph events are still requested and forwarded to the parent
-        assert mock_sync_client.runs.stream.call_args.kwargs["stream_subgraphs"]
-        assert [ns for ns, _, _ in parent_parts] == [
-            ("outer:123", "sub:abc"),
-            ("outer:123", "sub:abc"),
-            ("outer:123",),
-        ]
-
-
-async def test_astream_without_subgraphs_skips_parent_requested_subgraph_events():
-    mock_async_client = MagicMock()
-    async_iter = MagicMock()
-    async_iter.__aiter__.return_value = _PARENT_STREAMED_PARTS
-    mock_async_client.runs.stream.return_value = async_iter
-    remote_pregel = RemoteGraph("test_graph_id", client=mock_async_client)
-
-    for stream_mode, expected in [
-        ("updates", [{"sub": {"chunk": "root"}}]),
-        # messages are not filtered: the server dedupes them across namespaces
-        ("messages", [({"content": "token"}, {})]),
-    ]:
-        parent_parts: list = []
-        stream_parts = [
-            part
-            async for part in remote_pregel.astream(
-                {"input": "data"},
-                _parent_streamed_config(parent_parts),
-                stream_mode=stream_mode,
-            )
-        ]
-
-        assert stream_parts == expected
-        # subgraph events are still requested and forwarded to the parent
-        assert mock_async_client.runs.stream.call_args.kwargs["stream_subgraphs"]
-        assert [ns for ns, _, _ in parent_parts] == [
-            ("outer:123", "sub:abc"),
-            ("outer:123", "sub:abc"),
-            ("outer:123",),
-        ]
-
-
 def test_invoke():
     # set up test
     mock_sync_client = MagicMock()

libs/langgraph/uv.lock

@@ -3419,11 +3419,11 @@ wheels = [
 
 [[package]]
 name = "setuptools"
-version = "84.1.0"
+version = "83.0.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/73/eb/7e5f628ee2eb168fecbf8026de7856b2543d6d609cc85f086b9a91ac93d6/setuptools-84.1.0.tar.gz", hash = "sha256:23657205b63d4d31395ab917815247f694aafad28cd21316bf5fd45a51048ea0", size = 1171783, upload-time = "2026-10-19T20:11:43.489Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/34/26/f5d29e25ffdb535afef2d35cdb55b325298f96debd670da4c325e08d70f4/setuptools-83.0.0.tar.gz", hash = "sha256:025bccbbf0fa05b6192bc64ae1e7b16e001fd6d6d4d5de03c97b1c1ade523bef", size = 1154254, upload-time = "2026-07-04T15:31:22.699Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/18/02/b4bbb90f8f29e334898ff45c6d9b1fffaa6f378017052b3023a06262b5f7/setuptools-84.1.0-py3-none-any.whl", hash = "sha256:5231689c6ac8156cd155cfb98c3fd6fb252c3e7e9bd3d78b64d3c55f132624c9", size = 819380, upload-time = "2026-10-19T20:11:41.684Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/40/e1e72872c6354b306daef1703549e8e83b4d43cfea356311bf722a043752/setuptools-83.0.0-py3-none-any.whl", hash = "sha256:29b23c360f22f414dc7336bb39178cc7bcbf6021ed2733cde173f09dba19abb3", size = 1008090, upload-time = "2026-07-04T15:31:20.885Z" },
 ]
 
 [[package]]

libs/sdk-py/langgraph_sdk/_async/http.py

@@ -14,14 +14,9 @@ import orjson
 
 from langgraph_sdk._shared.utilities import (
     _orjson_default,
-    _reconnect_delay,
     _validate_reconnect_location,
 )
-from langgraph_sdk.errors import (
-    InternalServerError,
-    RateLimitError,
-    _araise_for_status_typed,
-)
+from langgraph_sdk.errors import _araise_for_status_typed
 from langgraph_sdk.schema import QueryParamTypes, StreamPart
 from langgraph_sdk.sse import SSEDecoder, aiter_lines_raw
 
@@ -235,80 +230,65 @@ class HttpClient:
             current_content = content if reconnect_path is None else None
             current_params = params if reconnect_path is None else None
 
-            reconnect_cause: httpx.HTTPError | None = None
-            try:
-                async with self.client.stream(
-                    current_method,
-                    reconnect_path or path,
-                    headers=current_headers,
-                    content=current_content,
-                    params=current_params,
-                ) as res:
-                    if reconnect_path is None and on_response:
-                        on_response(res)
-                    # check status
-                    await _araise_for_status_typed(res)
-                    # check content type
-                    content_type = res.headers.get("content-type", "").partition(";")[0]
-                    if "text/event-stream" not in content_type:
-                        raise httpx.TransportError(
-                            "Expected response header Content-Type to contain 'text/event-stream', "
-                            f"got {content_type!r}"
-                        )
+            retry = False
+            async with self.client.stream(
+                current_method,
+                reconnect_path or path,
+                headers=current_headers,
+                content=current_content,
+                params=current_params,
+            ) as res:
+                if reconnect_path is None and on_response:
+                    on_response(res)
+                # check status
+                await _araise_for_status_typed(res)
+                # check content type
+                content_type = res.headers.get("content-type", "").partition(";")[0]
+                if "text/event-stream" not in content_type:
+                    raise httpx.TransportError(
+                        "Expected response header Content-Type to contain 'text/event-stream', "
+                        f"got {content_type!r}"
+                    )
 
-                    reconnect_location = res.headers.get("location")
-                    if reconnect_location:
-                        _validate_reconnect_location(
-                            self.client.base_url, reconnect_location
-                        )
-                        reconnect_path = reconnect_location
+                reconnect_location = res.headers.get("location")
+                if reconnect_location:
+                    _validate_reconnect_location(
+                        self.client.base_url, reconnect_location
+                    )
+                    reconnect_path = reconnect_location
 
-                    # parse SSE
-                    decoder = SSEDecoder(last_event_id=last_event_id)
-                    try:
-                        async for line in aiter_lines_raw(res):
-                            sse = decoder.decode(line=cast("bytes", line).rstrip(b"\n"))
-                            if sse is not None:
-                                if decoder.last_event_id is not None:
-                                    last_event_id = decoder.last_event_id
-                                if sse.event or decoder.has_data:
-                                    # Progress since the last drop earns a fresh
-                                    # set of reconnect attempts.
-                                    reconnect_attempts = 0
-                                    yield sse
-                    except httpx.HTTPError as err:
-                        # httpx.TransportError inherits from HTTPError, so transient
-                        # disconnects during streaming land here.
-                        if reconnect_path is None:
-                            raise
-                        reconnect_cause = err
-                    else:
-                        if sse := decoder.decode(b""):
+                # parse SSE
+                decoder = SSEDecoder()
+                try:
+                    async for line in aiter_lines_raw(res):
+                        sse = decoder.decode(line=cast("bytes", line).rstrip(b"\n"))
+                        if sse is not None:
                             if decoder.last_event_id is not None:
                                 last_event_id = decoder.last_event_id
-                            if sse.event or decoder.has_data:
-                                # decoder.decode(b"") flushes the in-flight event and may
-                                # return an empty placeholder when there is no pending
-                                # message. Skip these no-op events so the stream doesn't
-                                # emit a trailing blank item after reconnects.
+                            if sse.event or sse.data is not None:
                                 yield sse
-            except (httpx.TransportError, RateLimitError, InternalServerError) as err:
-                # A reconnect that can't open (connection refused, 429, 5xx or a
-                # non-SSE body) usually means the server is restarting or
-                # mid-deploy, so retry it like a drop. Before the server sends a
-                # Location there is nothing to reconnect to, so raise.
-                if reconnect_path is None:
-                    raise
-                reconnect_cause = err
-            if reconnect_cause is not None:
+                except httpx.HTTPError:
+                    # httpx.TransportError inherits from HTTPError, so transient
+                    # disconnects during streaming land here.
+                    if reconnect_path is None:
+                        raise
+                    retry = True
+                else:
+                    if sse := decoder.decode(b""):
+                        if decoder.last_event_id is not None:
+                            last_event_id = decoder.last_event_id
+                        if sse.event or sse.data is not None:
+                            # decoder.decode(b"") flushes the in-flight event and may
+                            # return an empty placeholder when there is no pending
+                            # message. Skip these no-op events so the stream doesn't
+                            # emit a trailing blank item after reconnects.
+                            yield sse
+            if retry:
                 reconnect_attempts += 1
                 if reconnect_attempts > max_reconnect_attempts:
                     raise httpx.TransportError(
                         "Exceeded maximum SSE reconnection attempts"
-                    ) from reconnect_cause
-                await asyncio.sleep(
-                    _reconnect_delay(reconnect_attempts - 1, base=1.0, cap=5.0)
-                )
+                    )
                 continue
             break
 

libs/sdk-py/langgraph_sdk/_async/stream.py

@@ -16,6 +16,7 @@ from __future__ import annotations
 import asyncio
 import contextlib
 import logging
+import random
 from collections.abc import AsyncGenerator, AsyncIterator, Generator, Mapping
 from dataclasses import dataclass, field
 from typing import Any, Literal, TypedDict, cast
@@ -24,7 +25,7 @@ from langchain_core.language_models.chat_model_stream import AsyncChatModelStrea
 from langchain_protocol import Event, SubscribeParams
 
 from langgraph_sdk._async.http import HttpClient
-from langgraph_sdk._shared.utilities import _quote_path_param, _reconnect_delay
+from langgraph_sdk._shared.utilities import _quote_path_param
 from langgraph_sdk.schema import LangSmithTracing, QueryParamTypes
 from langgraph_sdk.stream.controller import _SeenEventIds
 from langgraph_sdk.stream.decoders import (
@@ -1690,13 +1691,11 @@ class AsyncThreadStream:
 
     async def _reconnect_sleep(self, attempt: int) -> None:
         """Sleep with exponential backoff and jitter for reconnect attempt `attempt`."""
-        await asyncio.sleep(
-            _reconnect_delay(
-                attempt,
-                base=self._shared_reconnect_backoff_base,
-                cap=self._shared_reconnect_backoff_cap,
-            )
-        )
+        base = self._shared_reconnect_backoff_base
+        cap = self._shared_reconnect_backoff_cap
+        delay = min(cap, base * (2**attempt))
+        jitter = random.uniform(0, delay * 0.25)
+        await asyncio.sleep(delay + jitter)
 
     async def _reconnect_shared_stream(self) -> bool:
         """Attempt to reopen the shared stream after a post-ready transport drop.

libs/sdk-py/langgraph_sdk/_shared/utilities.py

@@ -4,7 +4,6 @@ from __future__ import annotations
 
 import functools
 import os
-import random
 import re
 from collections.abc import Mapping
 from datetime import tzinfo
@@ -195,15 +194,6 @@ def _validate_reconnect_location(base_url: httpx.URL, location: str) -> str:
     return location
 
 
-def _reconnect_delay(attempt: int, *, base: float, cap: float) -> float:
-    """Seconds to wait before reconnect attempt `attempt` (0-based).
-
-    Exponential backoff capped at `cap`, plus up to 25% jitter.
-    """
-    delay = min(cap, base * (2**attempt))
-    return delay + random.uniform(0, delay * 0.25)
-
-
 def _provided_vals(d: Mapping[str, Any]) -> dict[str, Any]:
     return {k: v for k, v in d.items() if v is not None}
 

libs/sdk-py/langgraph_sdk/_sync/http.py

@@ -4,7 +4,6 @@ from __future__ import annotations
 
 import logging
 import sys
-import time
 import warnings
 from collections.abc import Callable, Iterator, Mapping
 from typing import Any, cast
@@ -14,14 +13,9 @@ import orjson
 
 from langgraph_sdk._shared.utilities import (
     _orjson_default,
-    _reconnect_delay,
     _validate_reconnect_location,
 )
-from langgraph_sdk.errors import (
-    InternalServerError,
-    RateLimitError,
-    _raise_for_status_typed,
-)
+from langgraph_sdk.errors import _raise_for_status_typed
 from langgraph_sdk.schema import QueryParamTypes, StreamPart
 from langgraph_sdk.sse import SSEDecoder, iter_lines_raw
 
@@ -238,75 +232,62 @@ class SyncHttpClient:
             current_content = content if reconnect_path is None else None
             current_params = params if reconnect_path is None else None
 
-            reconnect_cause: httpx.HTTPError | None = None
-            try:
-                with self.client.stream(
-                    current_method,
-                    reconnect_path or path,
-                    headers=current_headers,
-                    content=current_content,
-                    params=current_params,
-                ) as res:
-                    if reconnect_path is None and on_response:
-                        on_response(res)
-                    # check status
-                    _raise_for_status_typed(res)
-                    # check content type
-                    content_type = res.headers.get("content-type", "").partition(";")[0]
-                    if "text/event-stream" not in content_type:
-                        raise httpx.TransportError(
-                            "Expected response header Content-Type to contain 'text/event-stream', "
-                            f"got {content_type!r}"
-                        )
+            retry = False
+            with self.client.stream(
+                current_method,
+                reconnect_path or path,
+                headers=current_headers,
+                content=current_content,
+                params=current_params,
+            ) as res:
+                if reconnect_path is None and on_response:
+                    on_response(res)
+                # check status
+                _raise_for_status_typed(res)
+                # check content type
+                content_type = res.headers.get("content-type", "").partition(";")[0]
+                if "text/event-stream" not in content_type:
+                    raise httpx.TransportError(
+                        "Expected response header Content-Type to contain 'text/event-stream', "
+                        f"got {content_type!r}"
+                    )
 
-                    reconnect_location = res.headers.get("location")
-                    if reconnect_location:
-                        _validate_reconnect_location(
-                            self.client.base_url, reconnect_location
-                        )
-                        reconnect_path = reconnect_location
+                reconnect_location = res.headers.get("location")
+                if reconnect_location:
+                    _validate_reconnect_location(
+                        self.client.base_url, reconnect_location
+                    )
+                    reconnect_path = reconnect_location
 
-                    decoder = SSEDecoder(last_event_id=last_event_id)
-                    try:
-                        for line in iter_lines_raw(res):
-                            sse = decoder.decode(cast(bytes, line).rstrip(b"\n"))
-                            if sse is not None:
-                                if decoder.last_event_id is not None:
-                                    last_event_id = decoder.last_event_id
-                                if sse.event or decoder.has_data:
-                                    # Progress since the last drop earns a fresh
-                                    # set of reconnect attempts.
-                                    reconnect_attempts = 0
-                                    yield sse
-                    except httpx.HTTPError as err:
-                        # httpx.TransportError inherits from HTTPError, so transient
-                        # disconnects during streaming land here.
-                        if reconnect_path is None:
-                            raise
-                        reconnect_cause = err
-                    else:
-                        if sse := decoder.decode(b""):
+                decoder = SSEDecoder()
+                try:
+                    for line in iter_lines_raw(res):
+                        sse = decoder.decode(cast(bytes, line).rstrip(b"\n"))
+                        if sse is not None:
                             if decoder.last_event_id is not None:
                                 last_event_id = decoder.last_event_id
-                            if sse.event or decoder.has_data:
-                                # See async stream implementation for rationale on
-                                # skipping empty flush events.
+                            if sse.event or sse.data is not None:
                                 yield sse
-            except (httpx.TransportError, RateLimitError, InternalServerError) as err:
-                # A reconnect that can't open (connection refused, 429, 5xx or a
-                # non-SSE body) usually means the server is restarting or
-                # mid-deploy, so retry it like a drop. Before the server sends a
-                # Location there is nothing to reconnect to, so raise.
-                if reconnect_path is None:
-                    raise
-                reconnect_cause = err
-            if reconnect_cause is not None:
+                except httpx.HTTPError:
+                    # httpx.TransportError inherits from HTTPError, so transient
+                    # disconnects during streaming land here.
+                    if reconnect_path is None:
+                        raise
+                    retry = True
+                else:
+                    if sse := decoder.decode(b""):
+                        if decoder.last_event_id is not None:
+                            last_event_id = decoder.last_event_id
+                        if sse.event or sse.data is not None:
+                            # See async stream implementation for rationale on
+                            # skipping empty flush events.
+                            yield sse
+            if retry:
                 reconnect_attempts += 1
                 if reconnect_attempts > max_reconnect_attempts:
                     raise httpx.TransportError(
                         "Exceeded maximum SSE reconnection attempts"
-                    ) from reconnect_cause
-                time.sleep(_reconnect_delay(reconnect_attempts - 1, base=1.0, cap=5.0))
+                    )
                 continue
             break
 

libs/sdk-py/langgraph_sdk/auth/__init__.py

@@ -811,7 +811,7 @@ class _On:
     def __call__(
         self,
         *,
-        resources: str | Sequence[str] | None = None,
+        resources: str | Sequence[str],
         actions: str | Sequence[str] | None = None,
     ) -> Callable[[AHO], AHO]: ...
 

libs/sdk-py/langgraph_sdk/sse.py

@@ -30,14 +30,18 @@ class BytesLineDecoder:
         # See https://docs.python.org/3/glossary.html#term-universal-newlines
         NEWLINE_CHARS = b"\n\r"
 
-        if not text:
-            return []
-        if self.trailing_cr and text.startswith(b"\n"):
-            text = text[1:]
-        self.trailing_cr = text.endswith(b"\r")
+        # We always push a trailing `\r` into the next decode iteration.
+        if self.trailing_cr:
+            text = b"\r" + text
+            self.trailing_cr = False
+        if text.endswith(b"\r"):
+            self.trailing_cr = True
+            text = text[:-1]
 
         if not text:
-            return []
+            # NOTE: the edge case input of empty text doesn't occur in practice,
+            # because other httpx internals filter out this value
+            return []  # pragma: no cover
 
         trailing_newline = text[-1] in NEWLINE_CHARS
         lines = cast(list[BytesLike], text.splitlines())
@@ -62,7 +66,7 @@ class BytesLineDecoder:
         return lines
 
     def flush(self) -> list[BytesLike]:
-        if not self.buffer:
+        if not self.buffer and not self.trailing_cr:
             return []
 
         lines: list[BytesLike] = [self.buffer]
@@ -72,25 +76,18 @@ class BytesLineDecoder:
 
 
 class SSEDecoder:
-    def __init__(self, *, last_event_id: str | None = None) -> None:
+    def __init__(self) -> None:
         self._event = ""
         self._data = bytearray()
-        self._last_event_id = last_event_id
+        self._last_event_id: str | None = None
         self._retry: int | None = None
         self._at_stream_start = True
-        self._has_data = False
-        self._id_changed = False
-
-    @property
-    def has_data(self) -> bool:
-        """Whether the last decoded block contained a data field."""
-        return self._has_data
 
     @property
     def last_event_id(self) -> str | None:
         """Return the last event identifier that was seen.
 
-        `None` until an ID is supplied or received, and `""` after an empty
+        `None` until the stream sends an `id` field, and `""` after an empty
         one, which resets the reconnect cursor.
         """
 
@@ -104,26 +101,17 @@ class SSEDecoder:
             line = line.removeprefix(b"\xef\xbb\xbf")
 
         if not line:
-            self._has_data = bool(self._data)
             if (
                 not self._event
                 and not self._data
-                and not self._id_changed
+                and self._last_event_id is None
                 and self._retry is None
             ):
                 return None
 
-            body = self._data[:-1]
-            data = None
-            if body and not body.isspace():
-                try:
-                    data = orjson.loads(body)
-                except orjson.JSONDecodeError:
-                    data = orjson.loads(body.decode(errors="replace"))
-
             sse = StreamPart(
                 event=self._event,
-                data=data,  # ty: ignore[invalid-argument-type]
+                data=orjson.loads(self._data) if self._data else None,  # ty: ignore[invalid-argument-type]
                 id=self._last_event_id or None,
             )
 
@@ -131,7 +119,6 @@ class SSEDecoder:
             self._event = ""
             self._data = bytearray()
             self._retry = None
-            self._id_changed = False
 
             return sse
 
@@ -144,16 +131,16 @@ class SSEDecoder:
             value = value[1:]
 
         if fieldname == b"event":
-            self._event = value.decode(errors="replace")
+            self._event = value.decode()
         elif fieldname == b"data":
+            if self._data:
+                self._data.extend(b"\n")
             self._data.extend(value)
-            self._data.extend(b"\n")
         elif fieldname == b"id":
             if b"\0" in value:
                 pass
             else:
-                self._last_event_id = value.decode(errors="replace")
-                self._id_changed = True
+                self._last_event_id = value.decode()
         elif fieldname == b"retry":
             with contextlib.suppress(TypeError, ValueError):
                 self._retry = int(value)

libs/sdk-py/langgraph_sdk/stream/controller.py

@@ -15,6 +15,7 @@ from __future__ import annotations
 import asyncio
 import contextlib
 import logging
+import random
 from collections import OrderedDict
 from collections.abc import AsyncGenerator, AsyncIterator, Awaitable, Callable
 from dataclasses import dataclass, field
@@ -22,7 +23,6 @@ from typing import Any
 
 from langchain_protocol import Event, SubscribeParams
 
-from langgraph_sdk._shared.utilities import _reconnect_delay
 from langgraph_sdk.stream.transport import AsyncProtocolTransport, EventStreamHandle
 
 # ---------------------------------------------------------------------------
@@ -275,13 +275,11 @@ class StreamController:
 
     async def _reconnect_sleep(self, attempt: int) -> None:
         """Sleep with exponential backoff and jitter for reconnect attempt *attempt*."""
-        await asyncio.sleep(
-            _reconnect_delay(
-                attempt,
-                base=self._reconnect_backoff_base,
-                cap=self._reconnect_backoff_cap,
-            )
-        )
+        base = self._reconnect_backoff_base
+        cap = self._reconnect_backoff_cap
+        delay = min(cap, base * (2**attempt))
+        jitter = random.uniform(0, delay * 0.25)
+        await asyncio.sleep(delay + jitter)
 
     async def _reconnect_shared_stream(self) -> bool:
         """Attempt to reopen the shared stream after a transport drop.

libs/sdk-py/langgraph_sdk/stream/sync_controller.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import contextlib
 import logging
+import random
 import threading
 import time
 from dataclasses import dataclass, field
@@ -12,7 +13,6 @@ from typing import Any
 
 from langchain_protocol import Event, SubscribeParams
 
-from langgraph_sdk._shared.utilities import _reconnect_delay
 from langgraph_sdk.stream.errors import (
     is_non_retryable_stream_error,
     stream_error_frame,
@@ -282,13 +282,11 @@ class SyncStreamController:
 
     def _reconnect_sleep(self, attempt: int) -> None:
         """Sleep with exponential backoff + jitter before a reconnect attempt."""
-        time.sleep(
-            _reconnect_delay(
-                attempt,
-                base=self._reconnect_backoff_base,
-                cap=self._reconnect_backoff_cap,
-            )
-        )
+        base = self._reconnect_backoff_base
+        cap = self._reconnect_backoff_cap
+        delay = min(cap, base * (2**attempt))
+        jitter = random.uniform(0, delay * 0.25)
+        time.sleep(delay + jitter)
 
     def _reconnect_shared_stream(self) -> bool:
         """Attempt to reopen the shared stream after a transport drop.

libs/sdk-py/tests/test_auth.py

@@ -1,49 +1,8 @@
-import ast
-import inspect
-
 import pytest
 
 from langgraph_sdk import Auth
 
 
-@pytest.mark.parametrize(
-    "kwargs",
-    [{}, {"actions": "read"}, {"resources": None}],
-)
-def test_global_handler_factory_accepts_optional_resources(kwargs) -> None:
-    auth = Auth()
-    tree = ast.parse(inspect.getsource(type(auth.on)))
-    cls = tree.body[0]
-    assert isinstance(cls, ast.ClassDef)
-    factory_overload = next(
-        node
-        for node in cls.body
-        if isinstance(node, ast.FunctionDef)
-        and node.name == "__call__"
-        and node.decorator_list
-        and any(arg.arg == "resources" for arg in node.args.kwonlyargs)
-    )
-    resources = next(
-        arg for arg in factory_overload.args.kwonlyargs if arg.arg == "resources"
-    )
-    assert resources.annotation is not None
-    assert ast.unparse(resources.annotation) == "str | Sequence[str] | None"
-    default = factory_overload.args.kw_defaults[0]
-    assert isinstance(default, ast.Constant) and default.value is None
-
-    @auth.on(**kwargs)
-    async def handler(ctx, value):
-        del ctx, value
-        return None
-
-    if kwargs.get("actions"):
-        assert auth._handlers == {("*", "read"): [handler]}
-        assert auth._global_handlers == []
-    else:
-        assert auth._global_handlers == [handler]
-        assert auth._handlers == {}
-
-
 def test_handler_multiple_resources_and_actions() -> None:
     auth = Auth()
 

libs/sdk-py/tests/test_client_stream.py

@@ -1,8 +1,6 @@
 from __future__ import annotations
 
-import asyncio
-import time
-from collections.abc import Callable, Iterator, Sequence
+from collections.abc import Iterator, Sequence
 from pathlib import Path
 from typing import Any
 
@@ -15,7 +13,6 @@ from langgraph_sdk._async.runs import _wrap_stream_v2
 from langgraph_sdk._shared.utilities import _sse_to_v2_dict
 from langgraph_sdk._sync.runs import _wrap_stream_v2_sync
 from langgraph_sdk.client import HttpClient, SyncHttpClient
-from langgraph_sdk.errors import InternalServerError, NotFoundError
 from langgraph_sdk.schema import (
     CheckpointPayload,
     CheckpointsStreamPart,
@@ -70,19 +67,6 @@ class ListByteStream(httpx.ByteStream):
         return None
 
 
-@pytest.fixture
-def no_sleep(monkeypatch):
-    """Record backoff sleeps without actually waiting."""
-    sleeps: list[float] = []
-
-    async def fake_async_sleep(d):
-        sleeps.append(d)
-
-    monkeypatch.setattr(asyncio, "sleep", fake_async_sleep)
-    monkeypatch.setattr(time, "sleep", lambda d: sleeps.append(d))
-    return sleeps
-
-
 def iter_lines_raw(payload: list[bytes]) -> Iterator[BytesLike]:
     decoder = BytesLineDecoder()
     for part in payload:
@@ -146,110 +130,6 @@ def test_sse_decoder_strips_a_leading_bom():
     assert decoder.decode(b"") == StreamPart(event="values", data=1, id=None)  # ty: ignore[invalid-argument-type]
 
 
-def test_control_blocks_do_not_repeat_after_a_cursor_update():
-    decoder = SSEDecoder()
-    decoder.decode(b"id: cursor")
-    assert decoder.decode(b"") == StreamPart(event="", data=None, id="cursor")  # ty: ignore[invalid-argument-type]
-    decoder.decode(b": heartbeat")
-    assert decoder.decode(b"") is None
-    assert decoder.decode(b"") is None
-    decoder.decode(b"id:")
-    assert decoder.decode(b"") == StreamPart(event="", data=None, id=None)  # ty: ignore[invalid-argument-type]
-    assert decoder.last_event_id == ""
-    assert decoder.decode(b"") is None
-
-
-def test_cr_lines_are_emitted_without_waiting_for_another_chunk():
-    decoder = BytesLineDecoder()
-    assert decoder.decode(b"data: 1\r\r") == [b"data: 1", b""]
-    assert decoder.decode(b"\n") == []
-    assert decoder.decode(b"data: 2\r") == [b"data: 2"]
-    assert decoder.decode(b"") == []
-    assert decoder.decode(b"\n\r") == [b""]
-    assert decoder.flush() == []
-
-
-def test_empty_data_lines_preserve_their_newlines():
-    decoder = SSEDecoder()
-    for line in (b"data", b"data: 1", b"data:"):
-        decoder.decode(line)
-    assert decoder._data == b"\n1\n\n"
-    assert decoder.decode(b"") == StreamPart(event="", data=1, id=None)  # ty: ignore[invalid-argument-type]
-    decoder.decode(b"data:")
-    decoder.decode(b"data:")
-    assert decoder.decode(b"") == StreamPart(event="", data=None, id=None)  # ty: ignore[invalid-argument-type]
-    assert decoder.has_data
-    assert decoder.decode(b"") is None
-    assert not decoder.has_data
-
-
-def test_malformed_utf8_is_replaced_in_fields_and_json_strings():
-    decoder = SSEDecoder()
-    for line in (b"event: \xff", b"id: \xff", b'data: "\xff"'):
-        decoder.decode(line)
-    assert decoder.decode(b"") == StreamPart(event="\ufffd", data="\ufffd", id="\ufffd")  # ty: ignore[invalid-argument-type]
-
-
-@pytest.mark.parametrize("asynchronous", [False, True])
-async def test_null_and_empty_data_are_not_dropped(asynchronous: bool):
-    def handler(_request: httpx.Request) -> httpx.Response:
-        return httpx.Response(
-            200,
-            headers={"Content-Type": "text/event-stream"},
-            content=b"data: null\n\ndata:\n\n",
-        )
-
-    transport = httpx.MockTransport(handler)
-    if asynchronous:
-        async with httpx.AsyncClient(
-            transport=transport, base_url="https://example.com"
-        ) as client:
-            parts = [part async for part in HttpClient(client).stream("/stream", "GET")]
-    else:
-        with httpx.Client(
-            transport=transport, base_url="https://example.com"
-        ) as client:
-            parts = list(SyncHttpClient(client).stream("/stream", "GET"))
-    assert parts == [StreamPart(event="", data=None), StreamPart(event="", data=None)]  # ty: ignore[invalid-argument-type]
-
-
-@pytest.mark.parametrize("asynchronous", [False, True])
-async def test_cursor_is_inherited_after_reconnect(asynchronous: bool):
-    requests: list[httpx.Request] = []
-
-    def handler(request: httpx.Request) -> httpx.Response:
-        requests.append(request)
-        if len(requests) == 1:
-            stream_cls = AsyncListByteStream if asynchronous else ListByteStream
-            return httpx.Response(
-                200,
-                headers={"Content-Type": "text/event-stream", "Location": "/reconnect"},
-                stream=stream_cls(
-                    [b"id: cursor\nevent: values\ndata: 1\n\n"],
-                    httpx.RemoteProtocolError("incomplete chunked read"),
-                ),
-            )
-        assert (b"Last-Event-ID", b"cursor") in request.headers.raw
-        return httpx.Response(
-            200,
-            headers={"Content-Type": "text/event-stream"},
-            content=b"event: values\ndata: 2\n\n",
-        )
-
-    transport = httpx.MockTransport(handler)
-    if asynchronous:
-        async with httpx.AsyncClient(
-            transport=transport, base_url="https://example.com"
-        ) as client:
-            parts = [part async for part in HttpClient(client).stream("/stream", "GET")]
-    else:
-        with httpx.Client(
-            transport=transport, base_url="https://example.com"
-        ) as client:
-            parts = list(SyncHttpClient(client).stream("/stream", "GET"))
-    assert [part.id for part in parts] == ["cursor", "cursor"]
-
-
 # --- HTTP client streaming ---
 
 
@@ -296,7 +176,6 @@ def test_sync_http_client_stream_flushes_trailing_event():
     assert parts == [StreamPart(event="foo", data={"bar": 1})]
 
 
-@pytest.mark.usefixtures("no_sleep")
 def test_sync_http_client_stream_recovers_after_disconnect():
     reconnect_path = "/reconnect"
     first_chunks = [
@@ -362,7 +241,6 @@ def test_sync_http_client_stream_recovers_after_disconnect():
 
 
 @pytest.mark.asyncio
-@pytest.mark.usefixtures("no_sleep")
 async def test_http_client_stream_recovers_after_disconnect():
     reconnect_path = "/reconnect"
     first_chunks = [
@@ -497,7 +375,6 @@ _CALLER_CURSORS = pytest.mark.parametrize(
 
 @_EMPTY_IDS
 @_CALLER_CURSORS
-@pytest.mark.usefixtures("no_sleep")
 def test_sync_stream_reconnects_without_a_cursor_after_an_empty_id(
     empty_id: bytes, headers: dict[str, str] | None
 ):
@@ -510,7 +387,6 @@ def test_sync_stream_reconnects_without_a_cursor_after_an_empty_id(
 
 @_EMPTY_IDS
 @_CALLER_CURSORS
-@pytest.mark.usefixtures("no_sleep")
 async def test_async_stream_reconnects_without_a_cursor_after_an_empty_id(
     empty_id: bytes, headers: dict[str, str] | None
 ):
@@ -521,7 +397,6 @@ async def test_async_stream_reconnects_without_a_cursor_after_an_empty_id(
     assert "last-event-id" not in reconnect.headers
 
 
-@pytest.mark.usefixtures("no_sleep")
 def test_sync_stream_id_replaces_a_lowercase_caller_cursor():
     reconnect = _sync_reconnect(
         [b"id: 1\nevent: values\ndata: 1\n\n"], {"last-event-id": "5"}
@@ -530,7 +405,6 @@ def test_sync_stream_id_replaces_a_lowercase_caller_cursor():
     assert reconnect.headers.get_list("last-event-id") == ["1"]
 
 
-@pytest.mark.usefixtures("no_sleep")
 async def test_async_stream_id_replaces_a_lowercase_caller_cursor():
     reconnect = await _async_reconnect(
         [b"id: 1\nevent: values\ndata: 1\n\n"], {"last-event-id": "5"}
@@ -539,14 +413,12 @@ async def test_async_stream_id_replaces_a_lowercase_caller_cursor():
     assert reconnect.headers.get_list("last-event-id") == ["1"]
 
 
-@pytest.mark.usefixtures("no_sleep")
 def test_sync_stream_keeps_the_caller_cursor_until_the_stream_sends_an_id():
     reconnect = _sync_reconnect([b"event: values\ndata: 1\n\n"], {"Last-Event-ID": "5"})
 
     assert reconnect.headers.get_list("last-event-id") == ["5"]
 
 
-@pytest.mark.usefixtures("no_sleep")
 async def test_async_stream_keeps_the_caller_cursor_until_the_stream_sends_an_id():
     reconnect = await _async_reconnect(
         [b"event: values\ndata: 1\n\n"], {"Last-Event-ID": "5"}
@@ -555,236 +427,6 @@ async def test_async_stream_keeps_the_caller_cursor_until_the_stream_sends_an_id
     assert reconnect.headers.get_list("last-event-id") == ["5"]
 
 
-# --- reconnects survive a server restart or a deploy ---
-
-SSE = {"Content-Type": "text/event-stream"}
-DROP = httpx.RemoteProtocolError("incomplete chunked read")
-
-
-def _event(i: int) -> bytes:
-    return f"id: {i}\nevent: values\ndata: {i}\n\n".encode()
-
-
-def _scripted(steps: list[Callable[[httpx.Request], httpx.Response]]):
-    """Handler that plays one step per request and records each request."""
-    seen: list[httpx.Request] = []
-
-    def handler(request: httpx.Request) -> httpx.Response:
-        seen.append(request)
-        if len(seen) > len(steps):
-            raise AssertionError("unexpected request")
-        return steps[len(seen) - 1](request)
-
-    return handler, seen
-
-
-def _ok(stream_cls, chunks, *, drop=False, location=None):
-    headers = dict(SSE)
-    if location:
-        headers["Location"] = location
-
-    def step(_request):
-        return httpx.Response(
-            200, headers=headers, stream=stream_cls(chunks, DROP if drop else None)
-        )
-
-    return step
-
-
-def _status(code):
-    return lambda request: httpx.Response(
-        code, json={"detail": "upstream"}, request=request
-    )
-
-
-def _connect_error(request):
-    raise httpx.ConnectError("[Errno 61] Connection refused", request=request)
-
-
-def _not_sse(request):
-    return httpx.Response(
-        200, headers={"Content-Type": "text/html"}, text="<html>", request=request
-    )
-
-
-def _transient_steps(stream_cls, failure):
-    """POST drops after event 1; first reconnect fails; second succeeds."""
-    return [
-        _ok(stream_cls, [_event(1)], drop=True, location="/reconnect"),
-        failure,
-        _ok(stream_cls, [_event(2), b"event: end\ndata: null\n\n"]),
-    ]
-
-
-def _long_stream_steps(stream_cls, drops):
-    """POST + `drops` reconnects, each delivering one event then dropping."""
-    steps = [_ok(stream_cls, [_event(0)], drop=True, location="/reconnect")]
-    for i in range(1, drops):
-        steps.append(_ok(stream_cls, [_event(i)], drop=True))
-    steps.append(_ok(stream_cls, [_event(drops), b"event: end\ndata: null\n\n"]))
-    return steps
-
-
-def _run_sync(steps):
-    handler, seen = _scripted(steps)
-    with httpx.Client(
-        transport=httpx.MockTransport(handler), base_url="https://example.com"
-    ) as client:
-        parts = list(SyncHttpClient(client).stream("/stream", "POST", json={}))
-    return parts, seen
-
-
-async def _run_async(steps):
-    sync_handler, seen = _scripted(steps)
-
-    async def handler(request):
-        return sync_handler(request)
-
-    async with httpx.AsyncClient(
-        transport=httpx.MockTransport(handler), base_url="https://example.com"
-    ) as client:
-        parts = [p async for p in HttpClient(client).stream("/stream", "POST", json={})]
-    return parts, seen
-
-
-FAILURES = {
-    "429": _status(429),
-    "502": _status(502),
-    "503": _status(503),
-    "connect_error": _connect_error,
-    "not_sse": _not_sse,
-}
-
-
-# A reconnect that hits a 429 / 502 / 503 / connect error / non-SSE body, then
-# succeeds, should recover.
-
-
-@pytest.mark.usefixtures("no_sleep")
-@pytest.mark.parametrize("failure", FAILURES.values(), ids=FAILURES.keys())
-def test_sync_reconnect_recovers_from_transient_failure(failure):
-    parts, seen = _run_sync(_transient_steps(ListByteStream, failure))
-    assert [p.event for p in parts] == ["values", "values", "end"]
-    assert len(seen) == 3
-
-
-@pytest.mark.usefixtures("no_sleep")
-@pytest.mark.parametrize("failure", FAILURES.values(), ids=FAILURES.keys())
-async def test_async_reconnect_recovers_from_transient_failure(failure):
-    parts, seen = await _run_async(_transient_steps(AsyncListByteStream, failure))
-    assert [p.event for p in parts] == ["values", "values", "end"]
-    assert len(seen) == 3
-
-
-# Any other 4xx on a reconnect won't go away by retrying, so it raises.
-
-
-def _client_error_steps(stream_cls):
-    return [
-        _ok(stream_cls, [_event(1)], drop=True, location="/reconnect"),
-        _status(404),
-    ]
-
-
-@pytest.mark.usefixtures("no_sleep")
-def test_sync_reconnect_does_not_retry_a_client_error():
-    with pytest.raises(NotFoundError):
-        _run_sync(_client_error_steps(ListByteStream))
-
-
-@pytest.mark.usefixtures("no_sleep")
-async def test_async_reconnect_does_not_retry_a_client_error():
-    with pytest.raises(NotFoundError):
-        await _run_async(_client_error_steps(AsyncListByteStream))
-
-
-# The first request isn't a reconnect, so it raises even when it names a Location.
-
-
-def _first_request_503(request):
-    return httpx.Response(
-        503,
-        headers={"Location": "/reconnect"},
-        json={"detail": "upstream"},
-        request=request,
-    )
-
-
-@pytest.mark.usefixtures("no_sleep")
-def test_sync_first_request_failure_is_not_retried():
-    with pytest.raises(InternalServerError):
-        _run_sync([_first_request_503])
-
-
-@pytest.mark.usefixtures("no_sleep")
-async def test_async_first_request_failure_is_not_retried():
-    with pytest.raises(InternalServerError):
-        await _run_async([_first_request_503])
-
-
-# A server that stays down gets five reconnects, backing off 1, 2, 4, 5 and 5s
-# (each plus up to 25% jitter), so about 20s, before the stream gives up. The
-# error it gives up with is caused by the last failure, so callers see why.
-
-GIVE_UP = "Exceeded maximum SSE reconnection attempts"
-
-
-def _server_down_steps(stream_cls):
-    return [
-        _ok(stream_cls, [_event(1)], drop=True, location="/reconnect"),
-        *[_status(502)] * 5,
-    ]
-
-
-def _assert_backed_off_for_about_20s(sleeps: list[float]) -> None:
-    assert len(sleeps) == 5
-    for slept, delay in zip(sleeps, [1, 2, 4, 5, 5], strict=True):
-        assert delay <= slept <= delay * 1.25
-
-
-def test_sync_reconnect_gives_up_after_five_backed_off_attempts(no_sleep):
-    with pytest.raises(httpx.TransportError, match=GIVE_UP) as exc_info:
-        _run_sync(_server_down_steps(ListByteStream))
-    assert isinstance(exc_info.value.__cause__, InternalServerError)
-    _assert_backed_off_for_about_20s(no_sleep)
-
-
-async def test_async_reconnect_gives_up_after_five_backed_off_attempts(no_sleep):
-    with pytest.raises(httpx.TransportError, match=GIVE_UP) as exc_info:
-        await _run_async(_server_down_steps(AsyncListByteStream))
-    assert isinstance(exc_info.value.__cause__, InternalServerError)
-    _assert_backed_off_for_about_20s(no_sleep)
-
-
-# A long stream that drops 6 times, each reconnect succeeding and making
-# progress, should not run out of attempts.
-
-
-@pytest.mark.usefixtures("no_sleep")
-def test_sync_long_stream_survives_many_spaced_out_drops():
-    parts, _ = _run_sync(_long_stream_steps(ListByteStream, drops=6))
-    assert [p.data for p in parts] == [0, 1, 2, 3, 4, 5, 6, None]
-
-
-@pytest.mark.usefixtures("no_sleep")
-async def test_async_long_stream_survives_many_spaced_out_drops():
-    parts, _ = await _run_async(_long_stream_steps(AsyncListByteStream, drops=6))
-    assert [p.data for p in parts] == [0, 1, 2, 3, 4, 5, 6, None]
-
-
-# Reconnects should back off rather than hammer the server.
-
-
-def test_sync_reconnect_backs_off(no_sleep):
-    _run_sync(_long_stream_steps(ListByteStream, drops=2))
-    assert len(no_sleep) == 2 and all(d > 0 for d in no_sleep)
-
-
-async def test_async_reconnect_backs_off(no_sleep):
-    await _run_async(_long_stream_steps(AsyncListByteStream, drops=2))
-    assert len(no_sleep) == 2 and all(d > 0 for d in no_sleep)
-
-
 # --- _sse_to_v2_dict conversion ---