Merge branch 'main' into langster/remove-stale-debugger-pull

Keep one-second health probes active for slower graph imports so Compose does not stall for the steady-state interval.

Co-authored-by: open-swe[bot] <open-swe@users.noreply.github.com>

.github/scripts/run_langgraph_cli_test.py

@@ -32,8 +32,6 @@ def test(config: pathlib.Path, port: int, tag: str, verbose: bool):
             docker_compose=None,
             port=port,
             watch=False,
-            debugger_port=None,
-            debugger_base_url=f"http://127.0.0.1:{port}",
             postgres_uri=None,
             api_version=None,
             image=tag,
@@ -173,5 +171,5 @@ if __name__ == "__main__":
     except BaseException:
         logger.exception("Test failed")
         raise
-    
+
     logger.info("Test execution finished")

libs/checkpoint-conformance/langgraph/checkpoint/conformance/spec/test_delta_channel_history.py

@@ -267,61 +267,6 @@ async def test_history_seed_ancestor_own_writes_are_replayed(
     )
 
 
-# Every uuid4 `build_delta_chain` tags its own writes with sorts between these
-# two, so task_id order is fixed and always disagrees with task_path order.
-TASK_ID_SORTS_FIRST = "00000000-0000-0000-0000-000000000000"
-TASK_ID_SORTS_LAST = "ffffffff-ffff-ffff-ffff-ffffffffffff"
-
-
-async def test_history_orders_parallel_writes_by_task_path(
-    saver: BaseCheckpointSaver,
-) -> None:
-    """Writes from parallel tasks replay in task_path order, not task_id order."""
-    configs = await build_delta_chain(
-        saver,
-        thread_id=str(uuid4()),
-        channel="ch",
-        snapshots_at_steps=[0],
-        total_steps=3,
-    )
-    step_1, head = configs[1], configs[2]
-    await saver.aput_writes(
-        step_1, [("ch", "second")], TASK_ID_SORTS_FIRST, "~pull, 02"
-    )
-    await saver.aput_writes(step_1, [("ch", "first")], TASK_ID_SORTS_LAST, "~pull, 01")
-
-    result = await saver.aget_delta_channel_history(config=head, channels=["ch"])
-    values = [w[2] for w in result["ch"]["writes"]]
-    assert values == [1, "first", "second"], (
-        f"Expected task_path order [1, 'first', 'second'], got {values}. "
-        "Ordering by (task_id, idx) alone yields [1, 'second', 'first']."
-    )
-
-
-async def test_history_orders_pathless_writes_first(
-    saver: BaseCheckpointSaver,
-) -> None:
-    """Writes stored without a task_path (graph input) replay before task writes."""
-    configs = await build_delta_chain(
-        saver,
-        thread_id=str(uuid4()),
-        channel="ch",
-        snapshots_at_steps=[0],
-        total_steps=3,
-    )
-    step_1, head = configs[1], configs[2]
-    await saver.aput_writes(
-        step_1, [("ch", "from_node")], TASK_ID_SORTS_FIRST, "~pull, a"
-    )
-    await saver.aput_writes(step_1, [("ch", "from_input")], TASK_ID_SORTS_LAST)
-
-    result = await saver.aget_delta_channel_history(config=head, channels=["ch"])
-    values = [w[2] for w in result["ch"]["writes"]]
-    assert values == [1, "from_input", "from_node"], (
-        f"Expected pathless writes first, got {values}"
-    )
-
-
 ALL_DELTA_CHANNEL_HISTORY_TESTS = [
     test_history_returns_writes_oldest_first,
     test_history_seed_is_nearest_snapshot,
@@ -331,8 +276,6 @@ ALL_DELTA_CHANNEL_HISTORY_TESTS = [
     test_history_walk_to_root_no_seed,
     test_history_migration_plain_value_as_seed,
     test_history_seed_ancestor_own_writes_are_replayed,
-    test_history_orders_parallel_writes_by_task_path,
-    test_history_orders_pathless_writes_first,
 ]
 
 

libs/checkpoint-postgres/langgraph/checkpoint/postgres/base.py

@@ -168,7 +168,6 @@ class _DeltaStage2Row(TypedDict, total=False):
     type: str | None
     blob: bytes | None
     task_id: str | None  # "w" rows only
-    task_path: str | None  # "w" rows only
     idx: int | None  # "w" rows only
     version: str | None  # "b" rows only
 
@@ -320,7 +319,7 @@ def _build_delta_stage2_sql(
         branches.append(
             "SELECT 'w'::text AS _kind, "
             "checkpoint_id, channel, "
-            "type, blob, task_id, task_path, idx, NULL::text AS version "
+            "type, blob, task_id, idx, NULL::text AS version "
             "FROM checkpoint_writes "
             "WHERE thread_id = %s AND checkpoint_ns = %s AND channel = %s "
             "AND checkpoint_id = ANY(%s)"
@@ -328,8 +327,7 @@ def _build_delta_stage2_sql(
     for _ in channels_with_seed:
         branches.append(
             "SELECT 'b'::text AS _kind, NULL::text AS checkpoint_id, channel, "
-            "type, blob, NULL::text AS task_id, NULL::text AS task_path, "
-            "NULL::int AS idx, version "
+            "type, blob, NULL::text AS task_id, NULL::int AS idx, version "
             "FROM checkpoint_blobs "
             "WHERE thread_id = %s AND checkpoint_ns = %s AND channel = %s "
             "AND version = %s"
@@ -494,11 +492,10 @@ class BasePostgresSaver(BaseCheckpointSaver[str]):
         stored value, or when the seed blob is sentinel "empty" — in both cases
         the consumer treats absence as "start empty".
         """
-        # writes_by_ch_by_cid[channel][cid] = list of
-        # (type, blob, task_id, idx, task_path)
-        writes_by_ch_by_cid: dict[
-            str, dict[str, list[tuple[str, bytes, str, int, str]]]
-        ] = {ch: {} for ch in channels}
+        # writes_by_ch_by_cid[channel][cid] = list of (type, blob, task_id, idx)
+        writes_by_ch_by_cid: dict[str, dict[str, list[tuple[str, bytes, str, int]]]] = {
+            ch: {} for ch in channels
+        }
         # seed_blob_by_ver[(channel, version)] = (type, blob)
         seed_blob_by_ver: dict[tuple[str, str], tuple[str, bytes]] = {}
 
@@ -509,14 +506,8 @@ class BasePostgresSaver(BaseCheckpointSaver[str]):
                 cid = cast(str, r["checkpoint_id"])
                 writes_by_ch_by_cid.setdefault(ch, {}).setdefault(cid, []).append(
                     cast(
-                        "tuple[str, bytes, str, int, str]",
-                        (
-                            r["type"],
-                            r["blob"],
-                            r["task_id"],
-                            r["idx"],
-                            r["task_path"],
-                        ),
+                        "tuple[str, bytes, str, int]",
+                        (r["type"], r["blob"], r["task_id"], r["idx"]),
                     )
                 )
             else:  # kind == "b"
@@ -525,10 +516,10 @@ class BasePostgresSaver(BaseCheckpointSaver[str]):
                     "tuple[str, bytes]", (r["type"], r["blob"])
                 )
 
-        # Sort writes per (channel, cid) newest-first by (task_path, task_id, idx)
+        # Sort writes per (channel, cid) newest-first by (task_id, idx)
         for cid_map in writes_by_ch_by_cid.values():
             for ws in cid_map.values():
-                ws.sort(key=lambda w: (w[4], w[2], w[3]), reverse=True)
+                ws.sort(key=lambda w: (w[2], w[3]), reverse=True)
 
         result: dict[str, DeltaChannelHistory] = {}
         for ch in channels:
@@ -538,9 +529,7 @@ class BasePostgresSaver(BaseCheckpointSaver[str]):
             collected: list[PendingWrite] = []
             cid_writes = writes_by_ch_by_cid.get(ch, {})
             for cid in chain_cids:
-                for type_tag, write_blob, task_id, _idx, _path in cid_writes.get(
-                    cid, []
-                ):
+                for type_tag, write_blob, task_id, _idx in cid_writes.get(cid, []):
                     val = self.serde.loads_typed((type_tag, write_blob))
                     collected.append((task_id, ch, val))
             collected.reverse()

libs/checkpoint-sqlite/langgraph/checkpoint/sqlite/__init__.py

@@ -81,7 +81,6 @@ class SqliteSaver(BaseCheckpointSaver[str]):
 
     conn: sqlite3.Connection
     is_setup: bool
-    _has_task_path: bool = True
 
     def __init__(
         self,
@@ -155,7 +154,6 @@ class SqliteSaver(BaseCheckpointSaver[str]):
                 checkpoint_ns TEXT NOT NULL DEFAULT '',
                 checkpoint_id TEXT NOT NULL,
                 task_id TEXT NOT NULL,
-                task_path TEXT NOT NULL DEFAULT '',
                 idx INTEGER NOT NULL,
                 channel TEXT NOT NULL,
                 type TEXT,
@@ -164,19 +162,6 @@ class SqliteSaver(BaseCheckpointSaver[str]):
             );
             """
         )
-        # sqlite has no ADD COLUMN IF NOT EXISTS; this migrates databases
-        # created before `task_path` existed and is a no-op on the rest.
-        try:
-            self.conn.execute(
-                "ALTER TABLE writes ADD COLUMN task_path TEXT NOT NULL DEFAULT ''"
-            )
-        except sqlite3.OperationalError as e:
-            # A read-only database from before the column can still be read;
-            # its rows would all read back as '' anyway.
-            if "readonly database" in str(e):
-                self._has_task_path = False
-            elif "duplicate column name" not in str(e):
-                raise
 
         self.is_setup = True
 
@@ -475,9 +460,9 @@ class SqliteSaver(BaseCheckpointSaver[str]):
             task_path: Path of the task creating the writes.
         """
         query = (
-            "INSERT OR REPLACE INTO writes (thread_id, checkpoint_ns, checkpoint_id, task_id, task_path, idx, channel, type, value) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)"
+            "INSERT OR REPLACE INTO writes (thread_id, checkpoint_ns, checkpoint_id, task_id, idx, channel, type, value) VALUES (?, ?, ?, ?, ?, ?, ?, ?)"
             if all(w[0] in WRITES_IDX_MAP for w in writes)
-            else "INSERT OR IGNORE INTO writes (thread_id, checkpoint_ns, checkpoint_id, task_id, task_path, idx, channel, type, value) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)"
+            else "INSERT OR IGNORE INTO writes (thread_id, checkpoint_ns, checkpoint_id, task_id, idx, channel, type, value) VALUES (?, ?, ?, ?, ?, ?, ?, ?)"
         )
         with self.cursor() as cur:
             cur.executemany(
@@ -488,7 +473,6 @@ class SqliteSaver(BaseCheckpointSaver[str]):
                         str(config["configurable"]["checkpoint_ns"]),
                         str(config["configurable"]["checkpoint_id"]),
                         task_id,
-                        task_path,
                         WRITES_IDX_MAP.get(channel, idx),
                         channel,
                         *self.serde.dumps_typed(value),
@@ -574,7 +558,6 @@ class SqliteSaver(BaseCheckpointSaver[str]):
 
             channels_with_chain = [ch for ch in channels if chain_by_ch[ch]]
             stage2_sql = build_delta_stage2_sql(
-                has_task_path=self._has_task_path,
                 chain_lens=[len(chain_by_ch[ch]) for ch in channels_with_chain],
             )
             if stage2_sql:
@@ -585,7 +568,7 @@ class SqliteSaver(BaseCheckpointSaver[str]):
                     )
                 cur.execute(stage2_sql, stage2_params)
                 stage2_rows = cast(
-                    "list[tuple[str, str, str, int, str, bytes, str]]", cur.fetchall()
+                    "list[tuple[str, str, str, int, str, bytes]]", cur.fetchall()
                 )
             else:
                 stage2_rows = []

libs/checkpoint-sqlite/langgraph/checkpoint/sqlite/_delta.py

@@ -39,9 +39,7 @@ DELTA_STAGE1_SQL = (
 )
 
 
-def build_delta_stage2_sql(
-    *, chain_lens: Sequence[int], has_task_path: bool = True
-) -> str:
+def build_delta_stage2_sql(*, chain_lens: Sequence[int]) -> str:
     """Stage-2 per-channel UNION ALL fetching writes from `writes`.
 
     One branch per channel with a non-empty chain. Each branch inlines its
@@ -55,12 +53,11 @@ def build_delta_stage2_sql(
     of a single `channel = ANY(channels)` filter when channels have
     different chain depths — same rationale as postgres.
     """
-    task_path = "task_path" if has_task_path else "''"
     branches: list[str] = []
     for n in chain_lens:
         cid_placeholders = ",".join("?" * n)
         branches.append(
-            f"SELECT checkpoint_id, channel, task_id, idx, type, value, {task_path} "
+            "SELECT checkpoint_id, channel, task_id, idx, type, value "
             "FROM writes "
             "WHERE thread_id = ? AND checkpoint_ns = ? AND channel = ? "
             f"AND checkpoint_id IN ({cid_placeholders})"
@@ -133,31 +130,29 @@ def build_delta_channels_writes_history(
     chain_by_ch: Mapping[str, list[str]],
     seed_val_by_ch: Mapping[str, Any],
     seeded: set[str],
-    stage2_rows: Sequence[tuple[str, str, str, int, str, bytes, str]],
+    stage2_rows: Sequence[tuple[str, str, str, int, str, bytes]],
     serde: Any,
 ) -> dict[str, DeltaChannelHistory]:
     """Demux stage-2 rows per channel; produce per-channel histories.
 
-    Stage-2 rows are
-    `(checkpoint_id, channel, task_id, idx, type, value, task_path)`.
-    Final write order is oldest→newest globally and
-    `(task_path, task_id, idx)` within a checkpoint, matching the contract
-    on `DeltaChannelHistory.writes`.
+    Stage-2 rows are `(checkpoint_id, channel, task_id, idx, type, value)`.
+    Final write order is oldest→newest globally and `(task_id, idx)` within
+    a checkpoint, matching the contract on `DeltaChannelHistory.writes`.
 
     `seed` is omitted when the walk reached a true root with no snapshot
     found (channel never entered `seeded`); consumers treat absence as
     "start empty".
     """
-    writes_by_ch_by_cid: dict[
-        str, dict[str, list[tuple[str, bytes, str, int, str]]]
-    ] = {ch: {} for ch in channels}
-    for cid, ch, task_id, idx, type_tag, value_blob, task_path in stage2_rows:
+    writes_by_ch_by_cid: dict[str, dict[str, list[tuple[str, bytes, str, int]]]] = {
+        ch: {} for ch in channels
+    }
+    for cid, ch, task_id, idx, type_tag, value_blob in stage2_rows:
         writes_by_ch_by_cid.setdefault(ch, {}).setdefault(cid, []).append(
-            (type_tag, value_blob, task_id, idx, task_path)
+            (type_tag, value_blob, task_id, idx)
         )
     for cid_map in writes_by_ch_by_cid.values():
         for ws in cid_map.values():
-            ws.sort(key=lambda w: (w[4], w[2], w[3]))
+            ws.sort(key=lambda w: (w[2], w[3]))
 
     result: dict[str, DeltaChannelHistory] = {}
     for ch in channels:
@@ -166,7 +161,7 @@ def build_delta_channels_writes_history(
         collected: list[PendingWrite] = []
         # Chain is newest-first; iterate oldest-first for the public order.
         for cid in reversed(chain_cids):
-            for type_tag, value_blob, task_id, _idx, _path in cid_writes.get(cid, []):
+            for type_tag, value_blob, task_id, _idx in cid_writes.get(cid, []):
                 collected.append(
                     (task_id, ch, serde.loads_typed((type_tag, value_blob)))
                 )

libs/checkpoint-sqlite/langgraph/checkpoint/sqlite/aio.py

@@ -114,7 +114,6 @@ class AsyncSqliteSaver(BaseCheckpointSaver[str]):
 
     lock: asyncio.Lock
     is_setup: bool
-    _has_task_path: bool = True
 
     def __init__(
         self,
@@ -332,7 +331,6 @@ class AsyncSqliteSaver(BaseCheckpointSaver[str]):
                     checkpoint_ns TEXT NOT NULL DEFAULT '',
                     checkpoint_id TEXT NOT NULL,
                     task_id TEXT NOT NULL,
-                    task_path TEXT NOT NULL DEFAULT '',
                     idx INTEGER NOT NULL,
                     channel TEXT NOT NULL,
                     type TEXT,
@@ -343,21 +341,6 @@ class AsyncSqliteSaver(BaseCheckpointSaver[str]):
             ):
                 await self.conn.commit()
 
-            # sqlite has no ADD COLUMN IF NOT EXISTS; this migrates databases
-            # created before `task_path` existed and is a no-op on the rest.
-            try:
-                await self.conn.execute(
-                    "ALTER TABLE writes ADD COLUMN task_path TEXT NOT NULL DEFAULT ''"
-                )
-                await self.conn.commit()
-            except aiosqlite.OperationalError as e:
-                # A read-only database from before the column can still be read;
-                # its rows would all read back as '' anyway.
-                if "readonly database" in str(e):
-                    self._has_task_path = False
-                elif "duplicate column name" not in str(e):
-                    raise
-
             self.is_setup = True
 
     async def aget_tuple(self, config: RunnableConfig) -> CheckpointTuple | None:
@@ -593,9 +576,9 @@ class AsyncSqliteSaver(BaseCheckpointSaver[str]):
             task_path: Path of the task creating the writes.
         """
         query = (
-            "INSERT OR REPLACE INTO writes (thread_id, checkpoint_ns, checkpoint_id, task_id, task_path, idx, channel, type, value) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)"
+            "INSERT OR REPLACE INTO writes (thread_id, checkpoint_ns, checkpoint_id, task_id, idx, channel, type, value) VALUES (?, ?, ?, ?, ?, ?, ?, ?)"
             if all(w[0] in WRITES_IDX_MAP for w in writes)
-            else "INSERT OR IGNORE INTO writes (thread_id, checkpoint_ns, checkpoint_id, task_id, task_path, idx, channel, type, value) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)"
+            else "INSERT OR IGNORE INTO writes (thread_id, checkpoint_ns, checkpoint_id, task_id, idx, channel, type, value) VALUES (?, ?, ?, ?, ?, ?, ?, ?)"
         )
         await self.setup()
         async with self.lock, self.conn.cursor() as cur:
@@ -607,7 +590,6 @@ class AsyncSqliteSaver(BaseCheckpointSaver[str]):
                         str(config["configurable"]["checkpoint_ns"]),
                         str(config["configurable"]["checkpoint_id"]),
                         task_id,
-                        task_path,
                         WRITES_IDX_MAP.get(channel, idx),
                         channel,
                         *self.serde.dumps_typed(value),
@@ -689,7 +671,6 @@ class AsyncSqliteSaver(BaseCheckpointSaver[str]):
 
             channels_with_chain = [ch for ch in channels if chain_by_ch[ch]]
             stage2_sql = build_delta_stage2_sql(
-                has_task_path=self._has_task_path,
                 chain_lens=[len(chain_by_ch[ch]) for ch in channels_with_chain],
             )
             if stage2_sql:
@@ -700,7 +681,7 @@ class AsyncSqliteSaver(BaseCheckpointSaver[str]):
                     )
                 await cur.execute(stage2_sql, stage2_params)
                 stage2_rows = cast(
-                    "list[tuple[str, str, str, int, str, bytes, str]]",
+                    "list[tuple[str, str, str, int, str, bytes]]",
                     await cur.fetchall(),
                 )
             else:

libs/checkpoint-sqlite/tests/test_writes_task_path_migration.py

@@ -1,128 +0,0 @@
-import sqlite3
-from pathlib import Path
-
-import aiosqlite
-import pytest
-from langgraph.checkpoint.base import empty_checkpoint
-
-from langgraph.checkpoint.sqlite import SqliteSaver
-from langgraph.checkpoint.sqlite.aio import AsyncSqliteSaver
-
-WRITES_BEFORE_TASK_PATH = """
-CREATE TABLE writes (
-    thread_id TEXT NOT NULL,
-    checkpoint_ns TEXT NOT NULL DEFAULT '',
-    checkpoint_id TEXT NOT NULL,
-    task_id TEXT NOT NULL,
-    idx INTEGER NOT NULL,
-    channel TEXT NOT NULL,
-    type TEXT,
-    value BLOB,
-    PRIMARY KEY (thread_id, checkpoint_ns, checkpoint_id, task_id, idx)
-);
-INSERT INTO writes VALUES ('t', '', 'c', 'old-task', 0, 'ch', 'null', X'');
-"""
-
-
-@pytest.fixture
-def legacy_db(tmp_path: Path) -> Path:
-    db = tmp_path / "legacy.sqlite"
-    with sqlite3.connect(db) as conn:
-        conn.executescript(WRITES_BEFORE_TASK_PATH)
-    return db
-
-
-def test_setup_migrates_legacy_writes_table_repeatably(legacy_db: Path) -> None:
-    for _ in range(2):
-        with SqliteSaver.from_conn_string(str(legacy_db)) as saver:
-            saver.setup()
-            rows = saver.conn.execute(
-                "SELECT task_id, task_path FROM writes"
-            ).fetchall()
-            assert rows == [("old-task", "")]
-
-
-@pytest.mark.parametrize("fresh", [True, False], ids=["fresh", "legacy"])
-def test_put_writes_persists_task_path(
-    tmp_path: Path, legacy_db: Path, fresh: bool
-) -> None:
-    db = tmp_path / "fresh.sqlite" if fresh else legacy_db
-    with SqliteSaver.from_conn_string(str(db)) as saver:
-        config = saver.put(
-            {"configurable": {"thread_id": "t", "checkpoint_ns": ""}},
-            empty_checkpoint(),
-            {},
-            {},
-        )
-        saver.put_writes(config, [("ch", "v")], "task-1", "~__pregel_pull, node")
-        stored = saver.conn.execute(
-            "SELECT task_path FROM writes WHERE task_id = 'task-1'"
-        ).fetchall()
-    assert stored == [("~__pregel_pull, node",)]
-
-
-async def test_async_setup_migrates_legacy_writes_table_repeatably(
-    legacy_db: Path,
-) -> None:
-    for _ in range(2):
-        async with AsyncSqliteSaver.from_conn_string(str(legacy_db)) as saver:
-            await saver.setup()
-            config = await saver.aput(
-                {"configurable": {"thread_id": "t", "checkpoint_ns": ""}},
-                empty_checkpoint(),
-                {},
-                {},
-            )
-            await saver.aput_writes(
-                config, [("ch", "v")], "task-1", "~__pregel_pull, node"
-            )
-
-    async with aiosqlite.connect(legacy_db) as conn:
-        async with conn.execute(
-            "SELECT DISTINCT task_id, task_path FROM writes ORDER BY task_id"
-        ) as cur:
-            assert await cur.fetchall() == [
-                ("old-task", ""),
-                ("task-1", "~__pregel_pull, node"),
-            ]
-
-
-def _legacy_database_with_history(db: Path) -> dict:
-    root = empty_checkpoint()
-    root["channel_values"] = {"ch": "seed"}
-    root["channel_versions"] = {"ch": 1}
-    with SqliteSaver.from_conn_string(str(db)) as saver:
-        root_config = saver.put(
-            {"configurable": {"thread_id": "t", "checkpoint_ns": ""}},
-            root,
-            {},
-            {"ch": 1},
-        )
-        saver.put_writes(root_config, [("ch", "write")], "task", "~__pregel_pull, n")
-        child = saver.put(root_config, empty_checkpoint(), {}, {})
-        saver.conn.execute("ALTER TABLE writes DROP COLUMN task_path")
-        saver.conn.commit()
-    return child
-
-
-def test_read_only_legacy_database_still_reads_delta_history(tmp_path: Path) -> None:
-    db = tmp_path / "legacy.sqlite"
-    child = _legacy_database_with_history(db)
-
-    saver = SqliteSaver(sqlite3.connect(f"file:{db}?mode=ro", uri=True))
-    got = saver.get_delta_channel_history(config=child, channels=["ch"])
-
-    assert got["ch"] == {"seed": "seed", "writes": [("task", "ch", "write")]}
-
-
-async def test_async_read_only_legacy_database_still_reads_delta_history(
-    tmp_path: Path,
-) -> None:
-    db = tmp_path / "legacy.sqlite"
-    child = _legacy_database_with_history(db)
-
-    async with aiosqlite.connect(f"file:{db}?mode=ro", uri=True) as conn:
-        saver = AsyncSqliteSaver(conn)
-        got = await saver.aget_delta_channel_history(config=child, channels=["ch"])
-
-    assert got["ch"] == {"seed": "seed", "writes": [("task", "ch", "write")]}

libs/checkpoint/langgraph/checkpoint/base/__init__.py

@@ -162,14 +162,6 @@ class DeltaChannelHistory(TypedDict):
       Always present; possibly empty. Already filtered to one channel.
       Writes stored at the target checkpoint itself are pending for the
       next super-step and are excluded.
-
-      Within a single checkpoint, writes are ordered by
-      `(task_path, task_id, idx)`, which is the order live execution applies
-      a super-step's task writes in. `task_id` is a hash of the path, so
-      ordering by it permutes parallel tasks writing one channel, and
-      reducers need not be order-invariant. Writes stored without a
-      `task_path` (graph input, `update_state` updates, exit-durability runs,
-      rows predating the column) sort first, by `task_id`.
     * `seed` — the stored value at the nearest ancestor whose
       `channel_values[ch]` is populated. Omitted if the walk reached the
       root without finding any stored value (consumer treats absence as
@@ -619,11 +611,6 @@ class BaseCheckpointSaver(Generic[V]):
         `PostgresSaver`) override for performance; the return contract is
         fixed here.
 
-        `PendingWrite` carries no `task_path`, so this default replays each
-        checkpoint's writes in `get_tuple`'s `pending_writes` order. Savers
-        that do not return `pending_writes` ordered by
-        `(task_path, task_id, idx)` must override it.
-
         Args:
             config: Configuration identifying the target checkpoint.
             channels: Channel names to walk for. Empty → empty mapping.

libs/checkpoint/langgraph/checkpoint/memory/__init__.py

@@ -199,8 +199,8 @@ class InMemorySaver(
                     terminated_here.add(ch)
 
             step_writes = self.writes.get((thread_id, checkpoint_ns, cp_id), {})
-            for _, (tid, ch, serialized, _) in sorted(
-                step_writes.items(), key=lambda kv: (kv[1][3], kv[0]), reverse=True
+            for (_task_id, _idx), (tid, ch, serialized, _) in sorted(
+                step_writes.items(), reverse=True
             ):
                 if ch not in remaining:
                     continue

libs/cli/README.md

@@ -103,8 +103,6 @@ The CLI uses a `langgraph.json` configuration file with these key settings:
 }
 ```
 
-Git dependencies should use credential-free URLs. The CLI conservatively scans direct `langgraph.json` dependencies, common Python package files, uv project and lock files, and common Node.js package and lock files for HTTP Git URLs with userinfo. This check is not exhaustive: generated Docker builds can copy other files, including nested requirement or constraint files, into image layers without scanning them. For private dependencies, provide short-lived credentials through your build environment's secret-backed Git credential helper. Do not store credentials in copied files such as `langgraph.json` or `pip_config_file`.
-
 See the [full documentation](https://reference.langchain.com/python/langgraph-cli) for detailed configuration options.
 
 ## Development

libs/cli/langgraph_cli/analytics.py

@@ -48,9 +48,6 @@ def get_anonymized_params(
     if kwargs.get("docker_compose"):
         params["docker_compose"] = True
 
-    if kwargs.get("debugger_port"):
-        params["debugger_port"] = True
-
     if kwargs.get("postgres_uri"):
         params["postgres_uri"] = True
 

libs/cli/langgraph_cli/cli.py

@@ -5,6 +5,7 @@ import pathlib
 import shutil
 import sys
 from collections.abc import Sequence
+from urllib.parse import SplitResult, urlencode, urlsplit, urlunsplit
 
 import click
 import click.exceptions
@@ -140,17 +141,6 @@ OPT_VERBOSE = click.option(
     help="Show more output from the server logs",
 )
 OPT_WATCH = click.option("--watch", is_flag=True, help="Restart on file changes")
-OPT_DEBUGGER_PORT = click.option(
-    "--debugger-port",
-    type=int,
-    help="Pull the debugger image locally and serve the UI on specified port",
-)
-OPT_DEBUGGER_BASE_URL = click.option(
-    "--debugger-base-url",
-    type=str,
-    help="URL used by the debugger to access LangGraph API. Defaults to http://127.0.0.1:[PORT]",
-)
-
 OPT_POSTGRES_URI = click.option(
     "--postgres-uri",
     help="Postgres URI to use for the database. Defaults to launching a local database",
@@ -242,18 +232,94 @@ cli.add_command(deploy)
 # ---------------------------------------------------------------------------
 
 
+def _validated_http_url(value: str, option_name: str) -> SplitResult:
+    try:
+        parsed = urlsplit(value)
+        hostname = parsed.hostname
+        _ = parsed.port
+    except ValueError as exc:
+        raise click.UsageError(
+            f"{option_name} must be a valid HTTP(S) URL without credentials."
+        ) from exc
+
+    if (
+        value != value.strip()
+        or parsed.scheme not in {"http", "https"}
+        or not parsed.netloc
+        or not hostname
+        or parsed.username is not None
+        or parsed.password is not None
+    ):
+        raise click.UsageError(
+            f"{option_name} must be a valid HTTP(S) URL without credentials."
+        )
+    return parsed
+
+
+def _studio_link(
+    *,
+    port: int,
+    studio_url: str | None,
+    api_url: str | None,
+    debugger_base_url: str | None,
+) -> str:
+    if debugger_base_url is not None:
+        if api_url is not None and api_url != debugger_base_url:
+            raise click.UsageError(
+                "--api-url and --debugger-base-url cannot specify different URLs."
+            )
+        click.echo(
+            "Warning: --debugger-base-url is deprecated; use --api-url instead.",
+            err=True,
+        )
+        api_url = debugger_base_url
+
+    studio_url = "https://smith.langchain.com" if studio_url is None else studio_url
+    api_url = f"http://127.0.0.1:{port}" if api_url is None else api_url
+    studio_parts = _validated_http_url(studio_url, "--studio-url")
+    _validated_http_url(api_url, "--api-url")
+    if studio_parts.query or studio_parts.fragment:
+        raise click.UsageError(
+            "--studio-url must not include a query string or fragment."
+        )
+
+    studio_path = f"{studio_parts.path.rstrip('/')}/studio/"
+    return urlunsplit(
+        studio_parts._replace(
+            path=studio_path,
+            query=urlencode({"baseUrl": api_url}),
+        )
+    )
+
+
 @OPT_RECREATE
 @OPT_PULL
 @OPT_PORT
 @OPT_DOCKER_COMPOSE
 @OPT_CONFIG
 @OPT_VERBOSE
-@OPT_DEBUGGER_PORT
-@OPT_DEBUGGER_BASE_URL
 @OPT_WATCH
 @OPT_POSTGRES_URI
 @OPT_API_VERSION
 @OPT_ENGINE_RUNTIME_MODE
+@click.option(
+    "--studio-url",
+    type=str,
+    default=None,
+    help="URL of the LangGraph Studio instance. Defaults to https://smith.langchain.com",
+)
+@click.option(
+    "--api-url",
+    type=str,
+    default=None,
+    help="URL that LangGraph Studio uses to access the API. Defaults to http://127.0.0.1:[PORT]",
+)
+@click.option(
+    "--debugger-base-url",
+    type=str,
+    default=None,
+    hidden=True,
+)
 @click.option(
     "--image",
     type=str,
@@ -284,14 +350,21 @@ def up(
     watch: bool,
     wait: bool,
     verbose: bool,
-    debugger_port: int | None,
-    debugger_base_url: str | None,
     postgres_uri: str | None,
     api_version: str | None,
     engine_runtime_mode: str,
+    studio_url: str | None,
+    api_url: str | None,
+    debugger_base_url: str | None,
     image: str | None,
     base_image: str | None,
 ):
+    studio_link = _studio_link(
+        port=port,
+        studio_url=studio_url,
+        api_url=api_url,
+        debugger_base_url=debugger_base_url,
+    )
     click.secho("Starting LangGraph API server...", fg="green")
     click.secho(
         """For local dev, requires env var LANGSMITH_API_KEY with access to LangSmith Deployment.
@@ -308,8 +381,6 @@ For production use, requires a license key in env var LANGGRAPH_CLOUD_LICENSE_KE
             pull=pull,
             watch=watch,
             verbose=verbose,
-            debugger_port=debugger_port,
-            debugger_base_url=debugger_base_url,
             postgres_uri=postgres_uri,
             api_version=api_version,
             engine_runtime_mode=engine_runtime_mode,
@@ -337,20 +408,12 @@ For production use, requires a license key in env var LANGGRAPH_CLOUD_LICENSE_KE
             if "unpacking to docker.io" in line:
                 set("Starting...")
             elif "Application startup complete" in line:
-                debugger_origin = (
-                    f"http://localhost:{debugger_port}"
-                    if debugger_port
-                    else "https://smith.langchain.com"
-                )
-                debugger_base_url_query = (
-                    debugger_base_url or f"http://127.0.0.1:{port}"
-                )
                 set("")
                 sys.stdout.write(
                     f"""Ready!
 - API: http://localhost:{port}
 - Docs: http://localhost:{port}/docs
-- LangGraph Studio: {debugger_origin}/studio/?baseUrl={debugger_base_url_query}
+- LangGraph Studio: {studio_link}
 """
                 )
                 sys.stdout.flush()
@@ -935,8 +998,6 @@ def prepare_args_and_stdin(
     docker_compose: pathlib.Path | None,
     port: int,
     watch: bool,
-    debugger_port: int | None = None,
-    debugger_base_url: str | None = None,
     postgres_uri: str | None = None,
     api_version: str | None = None,
     engine_runtime_mode: str = "combined_queue_worker",
@@ -950,8 +1011,6 @@ def prepare_args_and_stdin(
     stdin = langgraph_cli.docker.compose(
         capabilities,
         port=port,
-        debugger_port=debugger_port,
-        debugger_base_url=debugger_base_url,
         postgres_uri=postgres_uri,
         image=image,
         base_image=base_image,
@@ -989,8 +1048,6 @@ def prepare(
     pull: bool,
     watch: bool,
     verbose: bool,
-    debugger_port: int | None = None,
-    debugger_base_url: str | None = None,
     postgres_uri: str | None = None,
     api_version: str | None = None,
     engine_runtime_mode: str = "combined_queue_worker",
@@ -1032,8 +1089,6 @@ def prepare(
         docker_compose=docker_compose,
         port=port,
         watch=watch,
-        debugger_port=debugger_port,
-        debugger_base_url=debugger_base_url or f"http://127.0.0.1:{port}",
         postgres_uri=postgres_uri,
         api_version=api_version,
         engine_runtime_mode=engine_runtime_mode,

libs/cli/langgraph_cli/config.py

@@ -6,7 +6,6 @@ import re
 import shlex
 import textwrap
 from collections import Counter
-from collections.abc import Iterable
 from typing import Literal, NamedTuple
 
 import click
@@ -37,10 +36,6 @@ DISALLOWED_BUILD_COMMAND_CHARS = [
 # This blocks background execution (cmd &) while allowing command
 # chaining (cmd1 && cmd2) which is common in build commands.
 _SINGLE_AMPERSAND_RE = re.compile(r"(?<!&)&(?:&&)*(?!&)")
-_GIT_HTTP_AUTHORITY_RES = (
-    re.compile(r"git\+https?://(?P<authority>[^/\s\"']+)", re.I),
-    re.compile(r"\bgit\s*=\s*[\"']https?://(?P<authority>[^/\s\"']+)", re.I),
-)
 _API_VERSION_PATTERN = re.compile(
     r"^(?P<major>\d+)"
     r"(?:\.(?P<minor>\d+))?"
@@ -83,62 +78,6 @@ def has_disallowed_build_command_content(command: str) -> bool:
     return False
 
 
-def _has_git_http_url_userinfo(dependency: str) -> bool:
-    """Check whether a Git HTTP URL contains userinfo."""
-    return any(
-        "@" in match.group("authority")
-        for pattern in _GIT_HTTP_AUTHORITY_RES
-        for match in pattern.finditer(dependency)
-    )
-
-
-def _validate_git_http_url_userinfo(
-    values: Iterable[str], *, source: pathlib.Path | None = None
-) -> None:
-    """Reject credential-bearing Git HTTP URLs without echoing their values."""
-    if not any(_has_git_http_url_userinfo(value) for value in values):
-        return
-    message = (
-        "Git dependency URLs must not contain credentials or other URL "
-        "userinfo because generated Dockerfiles and image layers can retain "
-        "them. Use a credential-free Git URL and provide short-lived "
-        "credentials through your build environment's secret-backed Git "
-        "credential helper."
-    )
-    if source is not None:
-        message += f" Found in: {source}"
-    raise click.UsageError(message)
-
-
-def _validate_git_http_url_userinfo_files(paths: Iterable[pathlib.Path]) -> None:
-    """Reject credential-bearing Git HTTP URLs in dependency files."""
-    for path in paths:
-        path = path.resolve()
-        if not path.is_file():
-            continue
-        try:
-            contents = path.read_text(encoding="utf-8", errors="replace")
-        except OSError:
-            raise click.UsageError(
-                f"Could not inspect dependency file for embedded credentials: {path}"
-            ) from None
-        _validate_git_http_url_userinfo([contents], source=path)
-
-
-def _validate_local_dependency_files(config_path: pathlib.Path, config: Config) -> None:
-    """Validate dependency files copied into a non-uv Python image."""
-    paths: list[pathlib.Path] = []
-    for dependency in config["dependencies"]:
-        if not isinstance(dependency, str) or not dependency.startswith("."):
-            continue
-        root = (config_path.parent / dependency).resolve()
-        paths.extend(
-            root / name
-            for name in ("requirements.txt", "pyproject.toml", "setup.py", "setup.cfg")
-        )
-    _validate_git_http_url_userinfo_files(paths)
-
-
 MIN_PYTHON_VERSION = "3.11"
 DEFAULT_PYTHON_VERSION = "3.11"
 
@@ -381,9 +320,7 @@ def _get_source_kind(config: Config) -> str | None:
     return kind if isinstance(kind, str) else None
 
 
-def validate_config(
-    config: Config, *, source_path: pathlib.Path | None = None
-) -> Config:
+def validate_config(config: Config) -> Config:
     """Validate a configuration dictionary."""
 
     graphs = config.get("graphs", {})
@@ -478,15 +415,6 @@ def validate_config(
                 '  "source": {"kind": "uv", "root": ".."}'
             )
 
-    _validate_git_http_url_userinfo(
-        (
-            dependency
-            for dependency in config["dependencies"]
-            if isinstance(dependency, str)
-        ),
-        source=source_path,
-    )
-
     source = config.get("source")
     source_kind = _get_source_kind(config)
     if source is not None and not isinstance(source, dict):
@@ -681,7 +609,7 @@ def validate_config_file(config_path: pathlib.Path) -> Config:
     """Load and validate a configuration file."""
     with open(config_path) as f:
         config = json.load(f)
-    validated = validate_config(config, source_path=config_path.resolve())
+    validated = validate_config(config)
     # Enforce the package.json doesn't enforce an
     # incompatible Node.js version
     if validated.get("node_version"):
@@ -1352,7 +1280,6 @@ def python_config_to_docker(
             api_version=api_version,
             build_tools_to_uninstall=build_tools_to_uninstall,
         )
-    _validate_local_dependency_files(config_path, config)
     if pip_installer == "auto":
         if _image_supports_uv(base_image):
             pip_installer = "uv"
@@ -1563,18 +1490,7 @@ def node_config_to_docker(
 ) -> tuple[str, dict[str, str]]:
     # Calculate paths for monorepo support
     install_root = (
-        pathlib.Path(build_context).resolve()
-        if build_context
-        else config_path.parent.resolve()
-    )
-    config_root = config_path.parent.resolve()
-    dependency_roots = (
-        (install_root, config_root) if install_root != config_root else (install_root,)
-    )
-    _validate_git_http_url_userinfo_files(
-        root / name
-        for root in dependency_roots
-        for name in ("package.json", "package-lock.json", "yarn.lock", "pnpm-lock.yaml")
+        pathlib.Path(build_context).resolve() if build_context else config_path.parent
     )
     install_cmd = install_command or _get_node_pm_install_cmd(install_root)
     if build_context:

libs/cli/langgraph_cli/docker.py

@@ -142,29 +142,6 @@ def check_capabilities(runner) -> DockerCapabilities:
     )
 
 
-def debugger_compose(*, port: int | None = None, base_url: str | None = None) -> dict:
-    if port is None:
-        return ""
-
-    config = {
-        "langgraph-debugger": {
-            "image": "langchain/langgraph-debugger",
-            "restart": "on-failure",
-            "depends_on": {
-                "langgraph-postgres": {"condition": "service_healthy"},
-            },
-            "ports": [f'"{port}:3968"'],
-        }
-    }
-
-    if base_url:
-        config["langgraph-debugger"]["environment"] = {
-            "VITE_STUDIO_LOCAL_GRAPH_URL": base_url
-        }
-
-    return config
-
-
 # Function to convert dictionary to YAML
 def dict_to_yaml(d: dict, *, indent: int = 0) -> str:
     """Convert a dictionary to a YAML string."""
@@ -191,8 +168,6 @@ def compose_as_dict(
     capabilities: DockerCapabilities,
     *,
     port: int,
-    debugger_port: int | None = None,
-    debugger_base_url: str | None = None,
     # postgres://user:password@host:port/database?option=value
     postgres_uri: str | None = None,
     # If you are running against an already-built image, you can pass it here
@@ -253,12 +228,6 @@ def compose_as_dict(
         else:
             services["langgraph-postgres"]["healthcheck"]["interval"] = "5s"
 
-    # Add optional debugger service if debugger_port is specified
-    if debugger_port:
-        services["langgraph-debugger"] = debugger_compose(
-            port=debugger_port, base_url=debugger_base_url
-        )["langgraph-debugger"]
-
     # Add langgraph-api service
     api_environment = {
         "REDIS_URI": "redis://langgraph-redis:6379",
@@ -289,7 +258,7 @@ def compose_as_dict(
             "test": "python /api/healthcheck.py",
             "interval": "60s",
             "start_interval": "1s",
-            "start_period": "10s",
+            "start_period": "60s",
         }
 
     # Final compose dictionary with volumes included if needed
@@ -305,8 +274,6 @@ def compose(
     capabilities: DockerCapabilities,
     *,
     port: int,
-    debugger_port: int | None = None,
-    debugger_base_url: str | None = None,
     # postgres://user:password@host:port/database?option=value
     postgres_uri: str | None = None,
     image: str | None = None,
@@ -318,8 +285,6 @@ def compose(
     compose_content = compose_as_dict(
         capabilities,
         port=port,
-        debugger_port=debugger_port,
-        debugger_base_url=debugger_base_url,
         postgres_uri=postgres_uri,
         image=image,
         base_image=base_image,

libs/cli/langgraph_cli/schemas.py

@@ -650,8 +650,7 @@ class Config(TypedDict, total=False):
 
     pip_config_file: str | None
     """Optional. Path to a pip config file (e.g., "/etc/pip.conf" or "pip.ini") for controlling
-    package installation (custom indices, timeouts, etc.). The file is copied into the
-    generated image, so it must not contain credentials or other secrets.
+    package installation (custom indices, credentials, etc.).
 
     Only relevant if Python dependencies are installed via pip. If omitted, default pip settings are used.
     """
@@ -690,9 +689,6 @@ class Config(TypedDict, total=False):
       - "." or "./src" if you have a local Python package
       - str (aka "anthropic") for a PyPI package
       - "git+https://github.com/org/repo.git@main" for a Git-based package
-    Git HTTP URLs must not contain userinfo such as a username or token. For private
-    dependencies, provide short-lived credentials through the build environment's
-    secret-backed Git credential helper.
     Defaults to an empty list, meaning no additional packages installed beyond your base environment.
 
     This field is not supported when `source.kind` is `uv`.

libs/cli/langgraph_cli/uv_lock.py

@@ -880,7 +880,6 @@ def python_config_to_docker_uv_lock(
         _get_node_pm_install_cmd,
         _get_pip_cleanup_lines,
         _image_supports_uv,
-        _validate_git_http_url_userinfo_files,
         docker_tag,
     )
 
@@ -891,20 +890,11 @@ def python_config_to_docker_uv_lock(
         )
 
     config_root = config_path.parent.resolve()
-    source_root = config["source"].get("root", ".")
-    project_root = (config_root / source_root).resolve()
-    _validate_git_http_url_userinfo_files(
-        [project_root / "pyproject.toml", project_root / "uv.lock"]
-    )
-
     install_cmd = "uv pip install --system"
     _, global_reqs_pip_install, pip_config_file_str = _build_python_install_commands(
         config, install_cmd
     )
     plan = _plan_uv_lock_workspace(config_path, config)
-    _validate_git_http_url_userinfo_files(
-        package.pyproject_path for package in plan.install_order
-    )
 
     _update_uv_lock_graph_paths(config_path, config, plan)
     for section, key in [

libs/cli/schemas/schema.json

@@ -28,7 +28,7 @@
                   "type": "null"
                 }
               ],
-              "description": "Optional. Path to a pip config file (e.g., \"/etc/pip.conf\" or \"pip.ini\") for controlling\npackage installation (custom indices, timeouts, etc.). The file is copied into the\ngenerated image, so it must not contain credentials or other secrets.\n\nOnly relevant if Python dependencies are installed via pip. If omitted, default pip settings are used.\n"
+              "description": "Optional. Path to a pip config file (e.g., \"/etc/pip.conf\" or \"pip.ini\") for controlling\npackage installation (custom indices, credentials, etc.).\n\nOnly relevant if Python dependencies are installed via pip. If omitted, default pip settings are used.\n"
             },
             "_INTERNAL_docker_tag": {
               "anyOf": [
@@ -270,7 +270,7 @@
                   "type": "null"
                 }
               ],
-              "description": "Optional. Path to a pip config file (e.g., \"/etc/pip.conf\" or \"pip.ini\") for controlling\npackage installation (custom indices, timeouts, etc.). The file is copied into the\ngenerated image, so it must not contain credentials or other secrets.\n\nOnly relevant if Python dependencies are installed via pip. If omitted, default pip settings are used.\n"
+              "description": "Optional. Path to a pip config file (e.g., \"/etc/pip.conf\" or \"pip.ini\") for controlling\npackage installation (custom indices, credentials, etc.).\n\nOnly relevant if Python dependencies are installed via pip. If omitted, default pip settings are used.\n"
             },
             "_INTERNAL_docker_tag": {
               "anyOf": [

libs/cli/schemas/schema.v0.json

@@ -28,7 +28,7 @@
                   "type": "null"
                 }
               ],
-              "description": "Optional. Path to a pip config file (e.g., \"/etc/pip.conf\" or \"pip.ini\") for controlling\npackage installation (custom indices, timeouts, etc.). The file is copied into the\ngenerated image, so it must not contain credentials or other secrets.\n\nOnly relevant if Python dependencies are installed via pip. If omitted, default pip settings are used.\n"
+              "description": "Optional. Path to a pip config file (e.g., \"/etc/pip.conf\" or \"pip.ini\") for controlling\npackage installation (custom indices, credentials, etc.).\n\nOnly relevant if Python dependencies are installed via pip. If omitted, default pip settings are used.\n"
             },
             "_INTERNAL_docker_tag": {
               "anyOf": [
@@ -270,7 +270,7 @@
                   "type": "null"
                 }
               ],
-              "description": "Optional. Path to a pip config file (e.g., \"/etc/pip.conf\" or \"pip.ini\") for controlling\npackage installation (custom indices, timeouts, etc.). The file is copied into the\ngenerated image, so it must not contain credentials or other secrets.\n\nOnly relevant if Python dependencies are installed via pip. If omitted, default pip settings are used.\n"
+              "description": "Optional. Path to a pip config file (e.g., \"/etc/pip.conf\" or \"pip.ini\") for controlling\npackage installation (custom indices, credentials, etc.).\n\nOnly relevant if Python dependencies are installed via pip. If omitted, default pip settings are used.\n"
             },
             "_INTERNAL_docker_tag": {
               "anyOf": [

libs/cli/tests/unit_tests/cli/test_cli.py

@@ -8,10 +8,11 @@ from contextlib import contextmanager
 from pathlib import Path
 
 import click
+import pytest
 from click.testing import CliRunner
 
 import langgraph_cli.deploy as deploy_module
-from langgraph_cli.cli import cli, prepare_args_and_stdin
+from langgraph_cli.cli import _studio_link, cli, prepare_args_and_stdin
 from langgraph_cli.config import Config, _get_pip_cleanup_lines, validate_config
 from langgraph_cli.docker import DEFAULT_POSTGRES_URI, DockerCapabilities, Version
 from langgraph_cli.util import clean_empty_lines
@@ -56,8 +57,6 @@ def test_prepare_args_and_stdin() -> None:
         Config(dependencies=[".", "../../.."], graphs={"agent": "agent.py:graph"})
     )
     port = 8000
-    debugger_port = 8001
-    debugger_graph_url = f"http://127.0.0.1:{port}"
 
     actual_args, actual_stdin = prepare_args_and_stdin(
         capabilities=DEFAULT_DOCKER_CAPABILITIES,
@@ -65,8 +64,6 @@ def test_prepare_args_and_stdin() -> None:
         config=config,
         docker_compose=pathlib.Path("custom-docker-compose.yml"),
         port=port,
-        debugger_port=debugger_port,
-        debugger_base_url=debugger_graph_url,
         watch=True,
     )
 
@@ -110,16 +107,6 @@ services:
             retries: 5
             interval: 60s
             start_interval: 1s
-    langgraph-debugger:
-        image: langchain/langgraph-debugger
-        restart: on-failure
-        depends_on:
-            langgraph-postgres:
-                condition: service_healthy
-        ports:
-            - "{debugger_port}:3968"
-        environment:
-            VITE_STUDIO_LOCAL_GRAPH_URL: {debugger_graph_url}
     langgraph-api:
         ports:
             - "8000:8000"
@@ -135,7 +122,7 @@ services:
             test: python /api/healthcheck.py
             interval: 60s
             start_interval: 1s
-            start_period: 10s
+            start_period: 60s
         
         pull_policy: build
         build:
@@ -178,8 +165,6 @@ def test_prepare_args_and_stdin_with_image() -> None:
         Config(dependencies=[".", "../../.."], graphs={"agent": "agent.py:graph"})
     )
     port = 8000
-    debugger_port = 8001
-    debugger_graph_url = f"http://127.0.0.1:{port}"
 
     actual_args, actual_stdin = prepare_args_and_stdin(
         capabilities=DEFAULT_DOCKER_CAPABILITIES,
@@ -187,8 +172,6 @@ def test_prepare_args_and_stdin_with_image() -> None:
         config=config,
         docker_compose=pathlib.Path("custom-docker-compose.yml"),
         port=port,
-        debugger_port=debugger_port,
-        debugger_base_url=debugger_graph_url,
         watch=True,
         image="my-cool-image",
     )
@@ -233,16 +216,6 @@ services:
             retries: 5
             interval: 60s
             start_interval: 1s
-    langgraph-debugger:
-        image: langchain/langgraph-debugger
-        restart: on-failure
-        depends_on:
-            langgraph-postgres:
-                condition: service_healthy
-        ports:
-            - "{debugger_port}:3968"
-        environment:
-            VITE_STUDIO_LOCAL_GRAPH_URL: {debugger_graph_url}
     langgraph-api:
         ports:
             - "8000:8000"
@@ -259,7 +232,7 @@ services:
             test: python /api/healthcheck.py
             interval: 60s
             start_interval: 1s
-            start_period: 10s
+            start_period: 60s
         
         
         develop:
@@ -289,6 +262,82 @@ def test_version_option() -> None:
     )
 
 
+def test_up_help_shows_hosted_studio_options() -> None:
+    result = CliRunner().invoke(cli, ["up", "--help"])
+
+    assert result.exit_code == 0, result.output
+    assert "--studio-url" in result.output
+    assert "--api-url" in result.output
+    assert "--debugger-port" not in result.output
+    assert "--debugger-base-url" not in result.output
+
+
+def test_studio_link_defaults_to_hosted_studio() -> None:
+    assert _studio_link(
+        port=8123,
+        studio_url=None,
+        api_url=None,
+        debugger_base_url=None,
+    ) == ("https://smith.langchain.com/studio/?baseUrl=http%3A%2F%2F127.0.0.1%3A8123")
+
+
+def test_studio_link_supports_self_hosted_and_remote_urls() -> None:
+    assert _studio_link(
+        port=8123,
+        studio_url="https://langsmith.example.com/prefix/",
+        api_url="https://api.example.com/graph?tenant=a&region=eu",
+        debugger_base_url=None,
+    ) == (
+        "https://langsmith.example.com/prefix/studio/"
+        "?baseUrl=https%3A%2F%2Fapi.example.com%2Fgraph%3Ftenant%3Da%26region%3Deu"
+    )
+
+
+def test_studio_link_supports_deprecated_debugger_base_url(capsys) -> None:
+    assert _studio_link(
+        port=8123,
+        studio_url=None,
+        api_url=None,
+        debugger_base_url="https://api.example.com",
+    ).endswith("?baseUrl=https%3A%2F%2Fapi.example.com")
+    assert "--debugger-base-url is deprecated; use --api-url" in capsys.readouterr().err
+
+
+@pytest.mark.parametrize(
+    ("studio_url", "api_url"),
+    [
+        ("javascript:alert(1)", None),
+        ("https://user:password@example.com", None),
+        ("https://smith.langchain.com?workspace=test", None),
+        (None, "file:///tmp/langgraph.sock"),
+        (None, "https://user:password@example.com"),
+    ],
+)
+def test_studio_link_rejects_unsafe_urls(
+    studio_url: str | None, api_url: str | None
+) -> None:
+    with pytest.raises(click.UsageError):
+        _studio_link(
+            port=8123,
+            studio_url=studio_url,
+            api_url=api_url,
+            debugger_base_url=None,
+        )
+
+
+def test_studio_link_rejects_conflicting_api_url_aliases() -> None:
+    with pytest.raises(
+        click.UsageError,
+        match="cannot specify different URLs",
+    ):
+        _studio_link(
+            port=8123,
+            studio_url=None,
+            api_url="https://api.example.com",
+            debugger_base_url="https://other.example.com",
+        )
+
+
 def test_top_level_help_shows_deploy_subcommands() -> None:
     runner = CliRunner()
 

libs/cli/tests/unit_tests/test_config.py

@@ -255,243 +255,6 @@ def test_validate_config():
         )
 
 
-@pytest.mark.parametrize(
-    "dependency",
-    [
-        "git+https://user:secret-token@github.com/org/private.git@main",
-        "private-package @ git+http://token@github.com/org/private.git",
-        "git+HTTPS://user%40example.com:secret%2Ftoken@github.com/org/private.git",
-        "git+https://${GIT_TOKEN}@github.com/org/private.git",
-    ],
-)
-def test_validate_config_rejects_git_http_url_userinfo(dependency: str):
-    with pytest.raises(click.UsageError) as exc_info:
-        validate_config(
-            {
-                "python_version": "3.11",
-                "dependencies": [dependency],
-                "graphs": {"agent": "./agent.py:graph"},
-            }
-        )
-
-    message = str(exc_info.value)
-    assert "must not contain credentials or other URL userinfo" in message
-    assert "secret-token" not in message
-    assert "secret%2Ftoken" not in message
-
-
-def test_validate_config_file_reports_source_for_git_http_url_userinfo(
-    tmp_path: pathlib.Path,
-):
-    config_path = tmp_path / "langgraph.json"
-    config_path.write_text(
-        json.dumps(
-            {
-                "python_version": "3.11",
-                "dependencies": ["git+https://secret-token@github.com/org/private.git"],
-                "graphs": {"agent": "./agent.py:graph"},
-            }
-        )
-    )
-
-    with pytest.raises(click.UsageError) as exc_info:
-        validate_config_file(config_path)
-
-    message = str(exc_info.value)
-    assert "secret-token" not in message
-    assert f"Found in: {config_path.resolve()}" in message
-
-
-@pytest.mark.parametrize(
-    "manifest", ["package.json", "package-lock.json", "yarn.lock", "pnpm-lock.yaml"]
-)
-def test_config_to_docker_rejects_git_http_url_userinfo_in_node_files(
-    tmp_path: pathlib.Path, manifest: str
-):
-    config_path = tmp_path / "langgraph.json"
-    config_path.write_text("{}\n")
-    (tmp_path / "agent.js").write_text("export const graph = {};\n")
-    (tmp_path / "package.json").write_text('{"name":"agent"}\n')
-    (tmp_path / manifest).write_text(
-        '"priv": "git+https://user:secret-token@github.com/org/private.git"\n'
-    )
-    config = validate_config(
-        {
-            "node_version": "20",
-            "graphs": {"agent": "./agent.js:graph"},
-        }
-    )
-
-    with pytest.raises(click.UsageError) as exc_info:
-        config_to_docker(
-            config_path,
-            config,
-            base_image="langchain/langgraphjs-api",
-        )
-
-    message = str(exc_info.value)
-    assert "must not contain credentials or other URL userinfo" in message
-    assert "secret-token" not in message
-    assert f"Found in: {(tmp_path / manifest).resolve()}" in message
-
-
-def test_config_to_docker_allows_node_git_urls_without_http_userinfo(
-    tmp_path: pathlib.Path,
-):
-    config_path = tmp_path / "langgraph.json"
-    config_path.write_text("{}\n")
-    (tmp_path / "agent.js").write_text("export const graph = {};\n")
-    (tmp_path / "package.json").write_text(
-        '{"dependencies":{"public":"git+https://github.com/org/public.git"}}\n'
-    )
-    config = validate_config(
-        {
-            "node_version": "20",
-            "graphs": {"agent": "./agent.js:graph"},
-        }
-    )
-
-    docker, _ = config_to_docker(
-        config_path,
-        config,
-        base_image="langchain/langgraphjs-api",
-    )
-
-    assert f"ADD . /deps/{tmp_path.name}" in docker
-
-
-def test_config_to_docker_rejects_git_http_url_userinfo_in_node_workspace(
-    tmp_path: pathlib.Path,
-):
-    config_root = tmp_path / "apps" / "agent"
-    config_root.mkdir(parents=True)
-    config_path = config_root / "langgraph.json"
-    config_path.write_text("{}\n")
-    (config_root / "agent.js").write_text("export const graph = {};\n")
-    (config_root / "package.json").write_text(
-        '{"dependencies":{"priv":"git+https://secret-token@github.com/org/private.git"}}\n'
-    )
-    (tmp_path / "package.json").write_text('{"name":"workspace"}\n')
-    config = validate_config(
-        {
-            "node_version": "20",
-            "graphs": {"agent": "./agent.js:graph"},
-        }
-    )
-
-    with pytest.raises(click.UsageError) as exc_info:
-        config_to_docker(
-            config_path,
-            config,
-            base_image="langchain/langgraphjs-api",
-            build_context=str(tmp_path),
-        )
-
-    message = str(exc_info.value)
-    assert "secret-token" not in message
-    assert f"Found in: {(config_root / 'package.json').resolve()}" in message
-
-
-@pytest.mark.parametrize(
-    "dependency",
-    [
-        "git+https://github.com/org/public.git@main",
-        "private-package @ git+https://github.com/org/private.git@main",
-        "git+ssh://git@github.com/org/private.git@main",
-    ],
-)
-def test_validate_config_allows_git_urls_without_http_userinfo(dependency: str):
-    config = validate_config(
-        {
-            "python_version": "3.11",
-            "dependencies": [dependency],
-            "graphs": {"agent": "./agent.py:graph"},
-        }
-    )
-
-    assert config["dependencies"] == [dependency]
-
-
-def test_config_to_docker_rejects_git_http_url_userinfo_in_requirements(
-    tmp_path: pathlib.Path,
-):
-    config_path = tmp_path / "langgraph.json"
-    config_path.write_text("{}\n")
-    (tmp_path / "agent.py").write_text("graph = object()\n")
-    (tmp_path / "requirements.txt").write_text(
-        "private @ git+https://secret-token@github.com/org/private.git\n"
-    )
-    config = validate_config(
-        {
-            "python_version": "3.11",
-            "dependencies": ["."],
-            "graphs": {"agent": "./agent.py:graph"},
-        }
-    )
-
-    with pytest.raises(click.UsageError) as exc_info:
-        config_to_docker(
-            config_path,
-            config,
-            base_image="langchain/langgraph-api:0.2.47",
-        )
-
-    message = str(exc_info.value)
-    assert "must not contain credentials or other URL userinfo" in message
-    assert "secret-token" not in message
-    assert f"Found in: {(tmp_path / 'requirements.txt').resolve()}" in message
-
-
-@pytest.mark.parametrize("manifest", ["pyproject.toml", "uv.lock"])
-def test_config_to_docker_rejects_git_http_url_userinfo_in_uv_files(
-    tmp_path: pathlib.Path, manifest: str
-):
-    config_path = tmp_path / "langgraph.json"
-    config_path.write_text("{}\n")
-    (tmp_path / "src").mkdir()
-    (tmp_path / "src" / "agent.py").write_text("graph = object()\n")
-    pyproject = textwrap.dedent(
-        """
-        [project]
-        name = "agent"
-        version = "0.1.0"
-        dependencies = ["private"]
-
-        [tool.uv.sources]
-        private = { git = "https://github.com/org/private.git" }
-        """
-    ).strip()
-    uv_lock = "# uv lock file\n"
-    if manifest == "pyproject.toml":
-        pyproject = pyproject.replace(
-            "https://github.com", "https://secret-token@github.com"
-        )
-    else:
-        uv_lock += (
-            'source = { git = "https://secret-token@github.com/org/private.git" }\n'
-        )
-    (tmp_path / "pyproject.toml").write_text(pyproject + "\n")
-    (tmp_path / "uv.lock").write_text(uv_lock)
-    config = validate_config(
-        {
-            "python_version": "3.11",
-            "graphs": {"agent": "./src/agent.py:graph"},
-            "source": {"kind": "uv"},
-        }
-    )
-
-    with pytest.raises(click.UsageError) as exc_info:
-        config_to_docker(
-            config_path,
-            config,
-            base_image="langchain/langgraph-api:0.2.47",
-        )
-
-    message = str(exc_info.value)
-    assert "must not contain credentials or other URL userinfo" in message
-    assert "secret-token" not in message
-
-
 def test_validate_config_image_distro():
     """Test validation of image_distro field."""
     # Valid image_distro values should work

libs/cli/tests/unit_tests/test_docker.py

@@ -16,7 +16,7 @@ DEFAULT_DOCKER_CAPABILITIES = DockerCapabilities(
 )
 
 
-def test_compose_with_no_debugger_and_custom_db():
+def test_compose_with_custom_db():
     port = 8123
     custom_postgres_uri = "custom_postgres_uri"
     actual_compose_str = compose(
@@ -42,7 +42,7 @@ def test_compose_with_no_debugger_and_custom_db():
     assert clean_empty_lines(actual_compose_str) == expected_compose_str
 
 
-def test_compose_with_no_debugger_and_custom_db_with_healthcheck():
+def test_compose_with_custom_db_and_healthcheck():
     port = 8123
     custom_postgres_uri = "custom_postgres_uri"
     actual_compose_str = compose(
@@ -71,39 +71,11 @@ def test_compose_with_no_debugger_and_custom_db_with_healthcheck():
             test: python /api/healthcheck.py
             interval: 60s
             start_interval: 1s
-            start_period: 10s"""
+            start_period: 60s"""
     assert clean_empty_lines(actual_compose_str) == expected_compose_str
 
 
-def test_compose_with_debugger_and_custom_db():
-    port = 8123
-    custom_postgres_uri = "custom_postgres_uri"
-    actual_compose_str = compose(
-        DEFAULT_DOCKER_CAPABILITIES,
-        port=port,
-        postgres_uri=custom_postgres_uri,
-    )
-    expected_compose_str = f"""services:
-    langgraph-redis:
-        image: redis:6
-        healthcheck:
-            test: redis-cli ping
-            interval: 5s
-            timeout: 1s
-            retries: 5
-    langgraph-api:
-        ports:
-            - "{port}:8000"
-        depends_on:
-            langgraph-redis:
-                condition: service_healthy
-        environment:
-            REDIS_URI: redis://langgraph-redis:6379
-            POSTGRES_URI: {custom_postgres_uri}"""
-    assert clean_empty_lines(actual_compose_str) == expected_compose_str
-
-
-def test_compose_with_debugger_and_default_db():
+def test_compose_with_default_db():
     port = 8123
     actual_compose_str = compose(DEFAULT_DOCKER_CAPABILITIES, port=port)
     expected_compose_str = f"""volumes:
@@ -302,72 +274,6 @@ def test_compose_with_api_version_and_custom_postgres():
     assert clean_empty_lines(actual_compose_str) == expected_compose_str
 
 
-def test_compose_with_api_version_and_debugger():
-    """Test compose function with api_version and debugger port."""
-    port = 8123
-    debugger_port = 8001
-    api_version = "0.2.74"
-
-    actual_compose_str = compose(
-        DEFAULT_DOCKER_CAPABILITIES,
-        port=port,
-        api_version=api_version,
-        debugger_port=debugger_port,
-    )
-
-    expected_compose_str = f"""volumes:
-    langgraph-data:
-        driver: local
-services:
-    langgraph-redis:
-        image: redis:6
-        healthcheck:
-            test: redis-cli ping
-            interval: 5s
-            timeout: 1s
-            retries: 5
-    langgraph-postgres:
-        image: pgvector/pgvector:pg16
-        ports:
-            - "5433:5432"
-        environment:
-            POSTGRES_DB: postgres
-            POSTGRES_USER: postgres
-            POSTGRES_PASSWORD: postgres
-        command:
-            - postgres
-            - -c
-            - shared_preload_libraries=vector
-        volumes:
-            - langgraph-data:/var/lib/postgresql/data
-        healthcheck:
-            test: pg_isready -U postgres
-            start_period: 10s
-            timeout: 1s
-            retries: 5
-            interval: 5s
-    langgraph-debugger:
-        image: langchain/langgraph-debugger
-        restart: on-failure
-        depends_on:
-            langgraph-postgres:
-                condition: service_healthy
-        ports:
-            - "{debugger_port}:3968"
-    langgraph-api:
-        ports:
-            - "{port}:8000"
-        depends_on:
-            langgraph-redis:
-                condition: service_healthy
-            langgraph-postgres:
-                condition: service_healthy
-        environment:
-            REDIS_URI: redis://langgraph-redis:6379
-            POSTGRES_URI: {DEFAULT_POSTGRES_URI}"""
-    assert clean_empty_lines(actual_compose_str) == expected_compose_str
-
-
 def test_compose_distributed_mode_with_custom_db():
     """Test compose with engine_runtime_mode='distributed' adds N_JOBS_PER_WORKER=0."""
     port = 8123

libs/langgraph/langgraph/pregel/_checkpoint.py

@@ -47,16 +47,6 @@ def exit_delta_task_id(step: int, task_id: str) -> str:
     return f"{step:08d}-{parts[1]}-{parts[2]}-{parts[3]}-{parts[4]}"
 
 
-def exit_delta_late_task_id(step: int, task_id: str) -> str:
-    """Synthetic task id for exit-mode writes of a superstep after the anchor's own.
-
-    Sorts after every real task id, in step order, so replay keeps them after
-    the anchor's own superstep whether a saver orders by task path or task id.
-    """
-    parts = str(uuid.UUID(task_id)).split("-")
-    return f"ffffffff-{step >> 16:04x}-{step & 0xFFFF:04x}-{parts[3]}-{parts[4]}"
-
-
 def delta_channels_to_snapshot(
     channels: Mapping[str, BaseChannel],
     counters_since_delta_snapshot: Mapping[str, tuple[int, int]],

libs/langgraph/langgraph/pregel/_loop.py

@@ -103,7 +103,6 @@ from langgraph.pregel._checkpoint import (
     create_checkpoint,
     delta_channels_to_snapshot,
     empty_checkpoint,
-    exit_delta_late_task_id,
     exit_delta_task_id,
 )
 from langgraph.pregel._executor import (
@@ -218,15 +217,10 @@ class PregelLoop:
     # `after_tick`). At exit, `_put_exit_delta_writes` filters out channels
     # that will snapshot, then persists the rest under an anchor parent.
     # `None` when not in exit mode (so the capture sites are no-ops).
-    # Each tuple is `(step, task_id, task_path, channel, value)`; see
-    # `_put_exit_delta_writes` for how they are ordered.
-    _exit_delta_writes: list[tuple[int, str, str, str, Any]] | None = None
-
-    # The pending writes loaded with the checkpoint, already stored on it, kept
-    # alive so their ids stay unique; and the checkpoint's own superstep, the
-    # first one this run ticks.
-    _loaded_write_ids: dict[int, tuple[str, str, Any]]
-    _exit_first_step: int | None = None
+    # Each tuple is `(step, task_id, channel, value)` — `step` drives the
+    # synthetic step-prefixed task_id used to preserve chronological order
+    # under the saver's `ORDER BY task_id, idx` sorting.
+    _exit_delta_writes: list[tuple[int, str, str, Any]] | None = None
 
     # Delta channels that saw an Overwrite since the last checkpoint. These
     # channels must snapshot after live update applies overwrite semantics so
@@ -713,18 +707,9 @@ class PregelLoop:
             )
         # capture delta-channel writes for exit-mode accumulator before clearing
         if self._exit_delta_writes is not None:
-            if self._exit_first_step is None:
-                self._exit_first_step = self.step
-            for w in self.checkpoint_pending_writes:
-                tid, ch, v = w
-                if not isinstance(self.specs.get(ch), DeltaChannel):
-                    continue
-                if id(w) in self._loaded_write_ids:
-                    continue
-                task = self.tasks.get(tid)
-                path = task_path_str(task.path) if task else ""
-                self._exit_delta_writes.append((self.step, tid, path, ch, v))
-        self._loaded_write_ids = {}
+            for tid, ch, v in self.checkpoint_pending_writes:
+                if isinstance(self.specs.get(ch), DeltaChannel):
+                    self._exit_delta_writes.append((self.step, tid, ch, v))
         # clear pending writes
         self.checkpoint_pending_writes.clear()
         # only replay (re-execute) done tasks on the first tick
@@ -863,7 +848,6 @@ class PregelLoop:
     def _first(
         self, *, input_keys: str | Sequence[str], updated_channels: set[str] | None
     ) -> set[str] | None:
-        self._loaded_write_ids = {id(w): w for w in self.checkpoint_pending_writes}
         # Resuming from a previous checkpoint requires two things:
         # 1. A prior checkpoint exists (channel_versions is non-empty)
         # 2. The input signals continuation (not a fresh run with new input)
@@ -1033,9 +1017,7 @@ class PregelLoop:
             if self._exit_delta_writes is not None:
                 for c, v in input_writes:
                     if isinstance(self.specs.get(c), DeltaChannel):
-                        self._exit_delta_writes.append(
-                            (self.step, NULL_TASK_ID, "", c, v)
-                        )
+                        self._exit_delta_writes.append((self.step, NULL_TASK_ID, c, v))
             # Persist delta-channel input writes so sub-freq inputs are
             # recoverable via ancestor walk (mirrors the Command input path).
             if self.durability != "exit":
@@ -1261,7 +1243,9 @@ class PregelLoop:
         )
 
         pending = [
-            w for w in self._exit_delta_writes if w[3] not in channels_to_snapshot
+            (step, tid, ch, v)
+            for (step, tid, ch, v) in self._exit_delta_writes
+            if ch not in channels_to_snapshot
         ]
         if not pending:
             return
@@ -1296,19 +1280,11 @@ class PregelLoop:
             # sees the stub as its parent.
             self.checkpoint_config = anchor_config
 
-        # The checkpoint's own superstep is stored as sync durability stores
-        # it, so it interleaves with the writes a resume loaded from it. Later
-        # supersteps sort after every real task path and task id, in step
-        # order, so this holds whether a saver orders by path or by id.
-        grouped: dict[tuple[str, str], list[tuple[str, Any]]] = {}
-        for step, tid, path, ch, v in pending:
-            if tid == NULL_TASK_ID:
-                key = (exit_delta_task_id(step, tid), "")
-            elif step == self._exit_first_step:
-                key = (tid, path)
-            else:
-                key = (exit_delta_late_task_id(step, tid), f"~~{step:010d}{path}")
-            grouped.setdefault(key, []).append((ch, v))
+        # Step-prefixed synthetic task_id preserves chronological superstep
+        # order under the saver's ORDER BY task_id, idx sorting.
+        grouped: dict[tuple[int, str], list[tuple[str, Any]]] = {}
+        for step, tid, ch, v in pending:
+            grouped.setdefault((step, tid), []).append((ch, v))
         anchor_write_config = patch_configurable(
             anchor_config,
             {
@@ -1318,21 +1294,22 @@ class PregelLoop:
                 CONFIG_KEY_CHECKPOINT_ID: anchor_config[CONF][CONFIG_KEY_CHECKPOINT_ID],
             },
         )
-        for (tid, path), entries in grouped.items():
+        for (step, tid), entries in grouped.items():
+            synth_tid = exit_delta_task_id(step, tid)
             if self.checkpointer_put_writes_accepts_task_path:
                 fut = self.submit(
                     self.checkpointer_put_writes,
                     anchor_write_config,
                     entries,
-                    tid,
-                    path,
+                    synth_tid,
+                    "",
                 )
             else:
                 fut = self.submit(
                     self.checkpointer_put_writes,
                     anchor_write_config,
                     entries,
-                    tid,
+                    synth_tid,
                 )
             if self._delta_write_futs is not None:
                 self._delta_write_futs.append(fut)

libs/langgraph/tests/test_delta_channel_exit_mode.py

@@ -6,13 +6,11 @@ channel), lazy stub creation when no parent exists, and proper read-path
 reconstruction via ancestor walks.
 """
 
-import operator
 import uuid
 from typing import Annotated, Any
 
 import pytest
 from langchain_core.messages import AIMessage, HumanMessage
-from langgraph.checkpoint.base import BaseCheckpointSaver
 from langgraph.checkpoint.memory import InMemorySaver
 from langgraph.checkpoint.serde.types import _DeltaSnapshot
 from typing_extensions import TypedDict
@@ -21,7 +19,6 @@ from langgraph.channels.delta import DeltaChannel
 from langgraph.graph import START, StateGraph
 from langgraph.graph.message import _messages_delta_reducer
 from langgraph.pregel._checkpoint import exit_delta_task_id
-from langgraph.types import Command, Durability, interrupt
 
 pytestmark = pytest.mark.anyio
 
@@ -392,112 +389,3 @@ async def test_exit_snapshot_then_tail_deltas() -> None:
     assert "seed-msg" in contents
     assert "tail-msg" in contents
     assert contents.index("seed-msg") < contents.index("tail-msg")
-
-
-def _append(current: list, writes: list) -> list:
-    out = list(current)
-    for write in writes:
-        out.extend(write)
-    return out
-
-
-class _ResumeState(TypedDict):
-    log: Annotated[list, DeltaChannel(_append)]
-    plain: Annotated[list, operator.add]
-
-
-def _both(marker: str) -> dict:
-    return {"log": [marker], "plain": [marker]}
-
-
-def _ask(marker: str) -> Any:
-    def ask(state: _ResumeState) -> dict:
-        interrupt("approve?")
-        return _both(marker)
-
-    return ask
-
-
-@pytest.mark.parametrize("addressed", [False, True])
-def test_resume_after_a_parallel_interrupt_replays_in_live_order(
-    sync_checkpointer: BaseCheckpointSaver, durability: Durability, addressed: bool
-) -> None:
-    builder = StateGraph(_ResumeState)
-    builder.add_node("done", lambda state: _both("done"))
-    builder.add_node("ask", _ask("ask"))
-    builder.add_node("after", lambda state: _both("after"))
-    builder.add_edge(START, "done")
-    builder.add_edge(START, "ask")
-    builder.add_edge("ask", "after")
-    graph = builder.compile(checkpointer=sync_checkpointer)
-    config = {"configurable": {"thread_id": "t"}}
-    graph.invoke(_both("in"), config, durability=durability)
-    head = graph.get_state(config).config
-
-    graph.invoke(
-        Command(resume="yes"), head if addressed else config, durability=durability
-    )
-
-    state = graph.get_state(config)
-    assert state.values["log"] == state.values["plain"]
-    assert sorted(state.values["log"]) == ["after", "ask", "done", "in"]
-
-
-def test_resume_interleaves_the_resumed_superstep_by_task_path(
-    sync_checkpointer: BaseCheckpointSaver, durability: Durability
-) -> None:
-    builder = StateGraph(_ResumeState)
-    builder.add_node("z_done", lambda state: _both("z"))
-    builder.add_node("a_asks", _ask("a"))
-    builder.add_edge(START, "z_done")
-    builder.add_edge(START, "a_asks")
-    graph = builder.compile(checkpointer=sync_checkpointer)
-    config = {"configurable": {"thread_id": "t"}}
-    graph.invoke(_both("in"), config, durability=durability)
-
-    graph.invoke(Command(resume="yes"), config, durability=durability)
-
-    state = graph.get_state(config)
-    assert state.values["log"] == state.values["plain"] == ["in", "a", "z"]
-
-
-class _TaskIdOrderSaver(InMemorySaver):
-    """Replays each checkpoint's writes by task id, as savers without task path
-    ordering do."""
-
-    def get_tuple(self, config: Any) -> Any:
-        tup = super().get_tuple(config)
-        if tup and tup.pending_writes:
-            tup = tup._replace(pending_writes=sorted(tup.pending_writes))
-        return tup
-
-    get_delta_channel_history = BaseCheckpointSaver.get_delta_channel_history
-
-
-def test_exit_run_replays_supersteps_in_order_on_a_task_id_ordered_saver() -> None:
-    builder = StateGraph(_ResumeState)
-    builder.add_node("a", lambda state: _both("a"))
-    builder.add_node("b", lambda state: _both("b"))
-    builder.add_edge(START, "a")
-    builder.add_edge("a", "b")
-    graph = builder.compile(checkpointer=_TaskIdOrderSaver())
-    config = {"configurable": {"thread_id": "t"}}
-
-    graph.invoke(_both("in"), config, durability="exit")
-
-    assert graph.get_state(config).values["log"] == ["in", "a", "b"]
-
-
-def test_exit_resume_replays_supersteps_in_order_on_a_task_id_ordered_saver() -> None:
-    builder = StateGraph(_ResumeState)
-    builder.add_node("ask", _ask("ask"))
-    builder.add_node("after", lambda state: _both("after"))
-    builder.add_edge(START, "ask")
-    builder.add_edge("ask", "after")
-    graph = builder.compile(checkpointer=_TaskIdOrderSaver())
-    config = {"configurable": {"thread_id": "t"}}
-    graph.invoke(_both("in"), config, durability="exit")
-
-    graph.invoke(Command(resume="yes"), config, durability="exit")
-
-    assert graph.get_state(config).values["log"] == ["in", "ask", "after"]

libs/langgraph/tests/test_delta_channel_parallel_order.py

@@ -1,113 +0,0 @@
-"""`DeltaChannel` replay must apply parallel writes in the order `invoke` did."""
-
-from typing import Annotated, Any
-
-import pytest
-from langgraph.checkpoint.base import BaseCheckpointSaver
-from typing_extensions import TypedDict
-
-from langgraph.channels.delta import DeltaChannel
-from langgraph.graph import END, START, StateGraph
-from langgraph.types import Send
-
-pytestmark = pytest.mark.anyio
-
-# Sorted, because live execution applies PULL tasks in node-name order.
-FAN_OUT_NAMES = ["a", "b", "c", "d", "e", "f", "g", "h"]
-SEND_ARGS = [f"send-{i:02d}" for i in range(12)]
-
-
-def _append_reducer(current: list, updates: list) -> list:
-    return [*current, *(x for u in updates for x in u)]
-
-
-def _build_fan_out_graph(checkpointer: BaseCheckpointSaver) -> Any:
-    class State(TypedDict):
-        items: Annotated[
-            list, DeltaChannel(_append_reducer, list, snapshot_frequency=10_000)
-        ]
-
-    def make_node(label: str) -> Any:
-        return lambda state: {"items": [label]}
-
-    builder = StateGraph(State)
-    for name in FAN_OUT_NAMES:
-        builder.add_node(name, make_node(name))
-        builder.add_edge(START, name)
-        builder.add_edge(name, END)
-    return builder.compile(checkpointer=checkpointer)
-
-
-def _build_send_fan_out_graph(checkpointer: BaseCheckpointSaver) -> Any:
-    class State(TypedDict):
-        items: Annotated[
-            list, DeltaChannel(_append_reducer, list, snapshot_frequency=10_000)
-        ]
-
-    builder = StateGraph(State)
-    builder.add_node("worker", lambda arg: {"items": [arg]})
-    builder.add_conditional_edges(
-        START, lambda state: [Send("worker", n) for n in SEND_ARGS]
-    )
-    builder.add_edge("worker", END)
-    return builder.compile(checkpointer=checkpointer)
-
-
-async def test_get_state_matches_live_send_order(
-    async_checkpointer: BaseCheckpointSaver,
-) -> None:
-    graph = _build_send_fan_out_graph(async_checkpointer)
-    config = {"configurable": {"thread_id": "1"}}
-
-    live = (await graph.ainvoke({"items": []}, config))["items"]
-    replayed = (await graph.aget_state(config)).values["items"]
-
-    assert live == SEND_ARGS
-    assert replayed == live
-
-
-async def test_get_state_matches_live_invoke_order(
-    async_checkpointer: BaseCheckpointSaver,
-) -> None:
-    graph = _build_fan_out_graph(async_checkpointer)
-    config = {"configurable": {"thread_id": "1"}}
-
-    live = (await graph.ainvoke({"items": []}, config))["items"]
-    replayed = (await graph.aget_state(config)).values["items"]
-
-    assert live == FAN_OUT_NAMES
-    assert replayed == live
-
-
-async def test_continuing_thread_preserves_committed_prefix(
-    async_checkpointer: BaseCheckpointSaver,
-) -> None:
-    graph = _build_fan_out_graph(async_checkpointer)
-    config = {"configurable": {"thread_id": "1"}}
-
-    first = (await graph.ainvoke({"items": []}, config))["items"]
-    second = (await graph.ainvoke({"items": []}, config))["items"]
-
-    assert second == first + first
-    assert (await graph.aget_state(config)).values["items"] == second
-
-
-async def test_state_history_reports_live_order_at_every_step(
-    async_checkpointer: BaseCheckpointSaver,
-) -> None:
-    runs = 3
-    graph = _build_fan_out_graph(async_checkpointer)
-    config = {"configurable": {"thread_id": "1"}}
-    for _ in range(runs):
-        await graph.ainvoke({"items": []}, config)
-    live = FAN_OUT_NAMES * runs
-
-    seen = [
-        s.values["items"]
-        async for s in graph.aget_state_history(config)
-        if "items" in s.values
-    ]
-
-    assert max(map(len, seen)) == len(live)
-    for values in seen:
-        assert values == live[: len(values)], f"{values} is not a prefix of {live}"