langgraph-api 0.19.0.dev3__tar.gz → 0.19.0.dev4__tar.gz

{langgraph_api-0.19.0.dev3 → langgraph_api-0.19.0.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langgraph-api
-Version: 0.19.0.dev3
+Version: 0.19.0.dev4
 Author-email: Will Fu-Hinthorn <will@langchain.dev>, Josh Rogers <josh@langchain.dev>, Parker Rule <parker@langchain.dev>
 License: Elastic-2.0
 License-File: LICENSE
@@ -10,7 +10,7 @@ Requires-Dist: cloudpickle>=3.0.0
 Requires-Dist: cryptography>=50.0.0
 Requires-Dist: grpcio-health-checking<1.82.0,>=1.81.0
 Requires-Dist: grpcio-tools==1.81.1
-Requires-Dist: grpcio<1.82.0,>=1.81.0
+Requires-Dist: grpcio<1.86.0,>=1.85.0
 Requires-Dist: httptools>=0.5.0; platform_system != 'Windows'
 Requires-Dist: httpx>=0.25.0
 Requires-Dist: jsonschema-rs<0.45,>=0.35.0

{langgraph_api-0.19.0.dev3 → langgraph_api-0.19.0.dev4}/constraints.txt

@@ -18,7 +18,7 @@ structlog>=24.1.0
 cloudpickle>=3.0.0
 truststore>=0.1
 protobuf>=6.32.1,<7.0.0
-grpcio>=1.81.0,<1.82.0
+grpcio>=1.85.0,<1.86.0
 grpcio-tools>=1.81.0,<1.82.0
 grpcio-health-checking>=1.81.0,<1.82.0
 opentelemetry-api>=0.0.1

langgraph_api-0.19.0.dev4/langgraph_api/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.19.0.dev4"

{langgraph_api-0.19.0.dev3 → langgraph_api-0.19.0.dev4}/langgraph_api/api/meta.py

@@ -9,6 +9,7 @@ from langgraph_api.feature_flags import IS_POSTGRES_OR_GRPC_BACKEND
 from langgraph_api.http_metrics import HTTP_METRICS_COLLECTOR
 from langgraph_api.route import ApiRequest
 from langgraph_api.schema import PoolStats, PostgresPoolStats, RedisPoolStats
+from langgraph_api.tracing_session import ADDRESS_SUPPORT
 from langgraph_runtime.database import connect, pool_stats
 from langgraph_runtime.metrics import get_metrics
 
@@ -81,6 +82,7 @@ async def meta_info(request: ApiRequest):
                 and bool(config.TRACING),
                 "langsmith_tracing_replicas": True,
                 "langsmith_tracing_session_on_runs": True,
+                "langsmith_tracing_address": ADDRESS_SUPPORT,
                 "mcp": MCP_SERVED,
             },
             "host": {

{langgraph_api-0.19.0.dev3 → langgraph_api-0.19.0.dev4}/langgraph_api/api/runs.py

@@ -631,9 +631,9 @@ async def join_run_stream(request: ApiRequest):
     ]
 
     last_event_id = request.headers.get("last-event-id") or None
+    sub = await Runs.Stream.subscribe(run_id, thread_id)
 
     async def body():
-        sub = await Runs.Stream.subscribe(run_id, thread_id)
         try:
             async for event, message, stream_id in Runs.Stream.join(
                 run_id,
@@ -658,6 +658,7 @@ async def join_run_stream(request: ApiRequest):
             "Location": location,
             "Content-Location": f"/threads/{thread_id}/runs/{run_id}",
         },
+        on_close=lambda: sub.__aexit__(None, None, None),
     )
 
 

{langgraph_api-0.19.0.dev3 → langgraph_api-0.19.0.dev4}/langgraph_api/api/store.py

@@ -78,12 +78,16 @@ async def put_item(request: ApiRequest):
     namespace = tuple(payload["namespace"]) if payload.get("namespace") else ()
     if err := _validate_namespace(namespace):
         return err
+    ttl = payload.get("ttl")
+    if "ttl" not in payload:
+        store = await get_store()
+        ttl = (store.ttl_config or {}).get("default_ttl")
     handler_payload: dict[str, Any] = {
         "namespace": namespace,
         "key": payload["key"],
         "value": payload["value"],
         "index": payload.get("index"),
-        "ttl": payload.get("ttl"),
+        "ttl": ttl,
     }
     await handle_event("put", handler_payload)
     if err := _validate_namespace(handler_payload["namespace"]):

{langgraph_api-0.19.0.dev3 → langgraph_api-0.19.0.dev4}/langgraph_api/api/threads.py

@@ -534,8 +534,13 @@ async def delete_thread(request: ApiRequest):
     """Delete a thread by ID."""
     thread_id = request.path_params["thread_id"]
     validate_uuid(thread_id, "Invalid thread ID: must be a UUID")
+    sync_checkpoint_delete = (
+        request.query_params.get("sync_checkpoint_delete", "").lower() == "true"
+    )
     async with connect() as conn:
-        tid = await Threads.delete(conn, thread_id)
+        tid = await Threads.delete(
+            conn, thread_id, sync_checkpoint_delete=sync_checkpoint_delete
+        )
     await fetchone(tid)
     return Response(status_code=204)
 
@@ -565,6 +570,7 @@ async def prune_threads(request: ApiRequest):
     pruned_count = await Threads.prune(
         thread_ids=thread_ids,
         strategy=strategy,
+        sync_checkpoint_delete=payload.get("sync_checkpoint_delete", False),
     )
 
     return ApiResponse({"pruned_count": pruned_count})

{langgraph_api-0.19.0.dev3 → langgraph_api-0.19.0.dev4}/langgraph_api/event_streaming/service.py

@@ -46,6 +46,7 @@ from langgraph_api.event_streaming.session import (
 from langgraph_api.event_streaming.types import Subscription
 from langgraph_api.feature_flags import FF_V2_EVENT_STREAMING, PREFER_GRPC_CHECKPOINTER
 from langgraph_api.schema import MultitaskStrategy
+from langgraph_api.tracing_session import tracer_destination
 from langgraph_api.validation import sanitize_reserved_keys
 
 logger = structlog.stdlib.get_logger(__name__)
@@ -101,20 +102,21 @@ def validate_checkpoint_id_from_runnable_config(params: dict[str, Any]) -> str |
 
 def _langsmith_tracer_from_run_start(
     params: dict[str, Any],
-) -> dict[str, str] | None:
+) -> dict[str, Any] | None:
     tracer = params.get("langsmith_tracer")
     if tracer is None:
         return None
     if not _is_record(tracer):
         raise ValueError("langsmith_tracer must be an object.")
-    unknown = tracer.keys() - {"project_name", "example_id"}
+    unknown = tracer.keys() - {"project_name", "example_id", "address"}
     if unknown:
         raise ValueError(
             f"langsmith_tracer has unsupported fields: {sorted(unknown)!r}."
         )
     for key, value in tracer.items():
-        if not isinstance(value, str):
+        if key != "address" and not isinstance(value, str):
             raise ValueError(f"langsmith_tracer.{key} must be a string.")
+    tracer_destination({"langsmith_tracer": tracer})
     return dict(tracer)
 
 

{langgraph_api-0.19.0.dev3 → langgraph_api-0.19.0.dev4}/langgraph_api/graph.py

@@ -424,7 +424,16 @@ async def get_graph(
             if graph_obj.name == "LangGraph":
                 update["name"] = graph_id
             if isinstance(graph_obj, BaseRemotePregel):
-                update["config"] = config
+                # JS factories run in the sidecar and only see this config, so they
+                # get the same read-vs-run signal as Python factories here.
+                config = config or {}
+                update["config"] = {
+                    **config,
+                    "configurable": {
+                        **(config.get("configurable") or {}),
+                        "__is_for_execution__": is_for_execution(access_context),
+                    },
+                }
             yield graph_obj.copy(update=update)
     finally:
         var_child_runnable_config.set(None)

{langgraph_api-0.19.0.dev3 → langgraph_api-0.19.0.dev4}/langgraph_api/grpc/ops/runs.py

@@ -39,7 +39,7 @@ from langgraph_grpc_common.proto import (
 from langgraph_sdk import Auth
 from starlette.exceptions import HTTPException
 
-from langgraph_api.asyncio import ValueEvent
+from langgraph_api.asyncio import ValueEvent, create_task
 from langgraph_api.auth.custom import handle_event as auth_handle_event
 from langgraph_api.config import (
     STREAM_PUBLISH_RETRY_BACKOFF_FACTOR,
@@ -229,6 +229,7 @@ class GrpcStreamHandler:
     def __init__(self, run_id: UUID, thread_id: UUID):
         self.run_id = run_id
         self.thread_id = thread_id
+        self.join_requested = False
         self._stream = None
         self._closed = False
 
@@ -304,6 +305,8 @@ class GrpcStreamHandler:
         # Send JoinRunRequest
         join_msg = pb.StreamRunClientMessage(join=pb.JoinRunRequest(**join_kwargs))
         await self._stream.write(join_msg)
+        # Only after the write: a write cancelled midway may never reach the core.
+        self.join_requested = True
 
         # Half-close: signal we're done sending client messages.
         # Required for bidirectional streaming so the server knows to stop
@@ -348,6 +351,36 @@ class GrpcStreamHandler:
         await self.close()
 
 
+async def _cancel_dropped_join(
+    run_id: UUID,
+    thread_id: UUID,
+    ctx: Any,
+    filters: list[pb.AuthFilter] | None,
+) -> None:
+    # Same filters and reason as the core's own cancel when a joined stream drops.
+    # No filters means the drop interrupted the stream's own read check.
+    if filters is None:
+        filters = await Runs.Stream.handle_event(
+            ctx, "read", Auth.types.ThreadsRead(run_id=run_id, thread_id=thread_id)
+        )
+    client = await get_shared_client()
+    try:
+        await client.runs.Cancel(
+            pb.CancelRunRequest(
+                filters=filters,
+                action=enum_cancel_run_action.interrupt,
+                reason="client disconnected from the run stream (on_disconnect=cancel)",
+                run_ids=pb.CancelRunIdsTarget(
+                    thread_id=pb.UUID(value=str(thread_id)),
+                    run_ids=[pb.UUID(value=str(run_id))],
+                ),
+            )
+        )
+    except AioRpcError as e:
+        if e.code() != StatusCode.NOT_FOUND:
+            raise
+
+
 def _map_multitask_strategy(
     strategy: MultitaskStrategy | None,
 ) -> enum_multitask_strategy.MultitaskStrategy | None:
@@ -1135,15 +1168,15 @@ class Runs(Authenticated):
             Yields tuples of (event_bytes, message_bytes, stream_id_bytes|None).
             """
             handler: GrpcStreamHandler = stream_channel
-            auth_filters = await Runs.Stream.handle_event(
-                ctx,
-                "read",
-                Auth.types.ThreadsRead(run_id=run_id, thread_id=thread_id),
-            )
-
             stream_modes_pb = _map_stream_modes(stream_mode)
+            auth_filters: list[pb.AuthFilter] | None = None
 
             try:
+                auth_filters = await Runs.Stream.handle_event(
+                    ctx,
+                    "read",
+                    Auth.types.ThreadsRead(run_id=run_id, thread_id=thread_id),
+                )
                 async for event_bytes, message_bytes, stream_id_bytes in handler.join(
                     auth_filters=auth_filters,
                     stream_modes=stream_modes_pb or None,
@@ -1158,6 +1191,14 @@ class Runs(Authenticated):
                     return  # Return empty stream
                 # Convert all other gRPC errors to HTTP exceptions
                 _handle_grpc_error(e)
+            except asyncio.CancelledError:
+                # The core can cancel on disconnect only after it receives the join request.
+                if cancel_on_disconnect and not handler.join_requested:
+                    create_task(
+                        _cancel_dropped_join(run_id, thread_id, ctx, auth_filters),
+                        ignore_exceptions=(HTTPException,),
+                    )
+                raise
             finally:
                 await handler.close()
 
@@ -1198,6 +1239,8 @@ class Runs(Authenticated):
             thread_id: UUID | str,
             *,
             resumable: bool = False,
+            publisher_id: str | None = None,
+            seq: int | None = None,
         ) -> None:
             """Publish a message to the run stream via gRPC.
 
@@ -1207,6 +1250,11 @@ class Runs(Authenticated):
                 message: Event payload (serialized JSON or raw bytes)
                 thread_id: The thread ID
                 resumable: If true, message will be cached with TTL for resumable streaming
+                publisher_id: With `seq`, lets the Lua publish scripts drop a
+                    retried publish instead of adding it twice; publishes outside
+                    those scripts, such as a plain Pub/Sub publish, ignore both.
+                    Pass both or neither.
+                seq: The event's number within the publisher; retries resend it
             """
             run_id_pb = (
                 None if run_id is None or run_id == "*" else pb.UUID(value=str(run_id))
@@ -1218,6 +1266,8 @@ class Runs(Authenticated):
                 event_type=event,
                 message=message,
                 resumable=resumable,
+                publisher_id=publisher_id,
+                seq=seq,
             )
             max_duration_secs = max(0.0, STREAM_PUBLISH_RETRY_MAX_DURATION_SECS)
             initial_interval_secs = max(

{langgraph_api-0.19.0.dev3 → langgraph_api-0.19.0.dev4}/langgraph_api/grpc/ops/threads.py

@@ -53,6 +53,7 @@ from langgraph_api.state import (
     state_snapshot_to_thread_state,
 )
 from langgraph_api.utils import fetchone
+from langgraph_api.utils.uuids import uuid7
 
 if TYPE_CHECKING:
     from collections.abc import AsyncIterator
@@ -618,6 +619,8 @@ class Threads(Authenticated):
         conn,  # Not used
         thread_id: UUID | str,
         ctx: Any = None,
+        *,
+        sync_checkpoint_delete: bool = False,
     ) -> AsyncIterator[UUID]:
         auth_filters = await Threads.handle_event(
             ctx,
@@ -630,6 +633,7 @@ class Threads(Authenticated):
         request = pb.DeleteThreadRequest(
             thread_id=pb.UUID(value=_normalize_uuid(thread_id)),
             filters=auth_filters,
+            sync_checkpoint_delete=sync_checkpoint_delete,
         )
 
         client = await get_shared_client()
@@ -655,6 +659,8 @@ class Threads(Authenticated):
         strategy: Literal["delete", "keep_latest"] = "delete",
         batch_size: int = 100,
         ctx: Any = None,
+        *,
+        sync_checkpoint_delete: bool = False,
     ) -> int:
         """Prune threads via gRPC.
 
@@ -663,6 +669,8 @@ class Threads(Authenticated):
             strategy: "delete" to remove entirely, "keep_latest" to prune checkpoints
             batch_size: Batch size for operations
             ctx: Auth context for permission checks
+            sync_checkpoint_delete: Delete checkpoints before returning instead
+                of deferring to the background deletion queue
 
         Returns:
             Number of threads successfully pruned
@@ -709,6 +717,7 @@ class Threads(Authenticated):
                         pb.DeleteThreadRequest(
                             thread_id=pb.UUID(value=_normalize_uuid(tid)),
                             filters=auth_filters,
+                            sync_checkpoint_delete=sync_checkpoint_delete,
                         )
                     )
                 except Exception:
@@ -739,6 +748,7 @@ class Threads(Authenticated):
                     request = checkpointer_pb2.PruneRequest(
                         thread_ids=batch,
                         strategy=checkpointer_pb2.PruneRequest.PruneStrategy.KEEP_LATEST,
+                        sync_checkpoint_delete=sync_checkpoint_delete,
                     )
                     await stub.Prune(request)
                     processed += len(batch)
@@ -1241,6 +1251,8 @@ class Threads(Authenticated):
                         json_dumpb(event_data),
                         thread_id=thread_id,
                         resumable=True,
+                        publisher_id=uuid7().hex,
+                        seq=0,
                     )
 
                     return {
@@ -1346,6 +1358,8 @@ class Threads(Authenticated):
                         json_dumpb(event_data),
                         thread_id=thread_id,
                         resumable=True,
+                        publisher_id=uuid7().hex,
+                        seq=0,
                     )
 
                     return ThreadUpdateResponse(checkpoint=next_config["configurable"])

{langgraph_api-0.19.0.dev3 → langgraph_api-0.19.0.dev4}/langgraph_api/js/remote.py

@@ -304,7 +304,7 @@ class RemotePregel(BaseRemotePregel):
             "graph_config": self.config,
             "graph_name": self.name,
             "command" if isinstance(input, Command) else "input": input,
-            "config": config,
+            "config": self._with_execution_signal(config),
             **kwargs,
         }
 
@@ -339,7 +339,7 @@ class RemotePregel(BaseRemotePregel):
             "graph_config": self.config,
             "graph_name": self.name,
             "command" if isinstance(input, Command) else "input": input,
-            "config": config,
+            "config": self._with_execution_signal(config),
             "stream_protocol": "v3",
             **kwargs,
         }
@@ -564,6 +564,24 @@ class RemotePregel(BaseRemotePregel):
         attrs = {**self.__dict__, **(update or {})}
         return self.__class__(**attrs)
 
+    def _with_execution_signal(
+        self, config: RunnableConfig | None
+    ) -> RunnableConfig | None:
+        # The sidecar builds a run's graph from the run config, not graph_config.
+        signal = ((self.config or {}).get("configurable") or {}).get(
+            "__is_for_execution__"
+        )
+        if signal is None:
+            return config
+        config = config or {}
+        return {
+            **config,
+            "configurable": {
+                **(config.get("configurable") or {}),
+                "__is_for_execution__": signal,
+            },
+        }
+
     async def fetch_nodes_executed(self):
         result = await _client_invoke("getNodesExecuted", {"graph_id": self.graph_id})
         await logger.adebug(

{langgraph_api-0.19.0.dev3 → langgraph_api-0.19.0.dev4}/langgraph_api/metadata.py

@@ -57,8 +57,14 @@ elif PROJECT_ID:
     HOST = "byoc"
 else:
     HOST = "self-hosted"
-PLAN = "enterprise" if plus_features_enabled() else "developer"
 USER_API_URL = os.getenv("LANGGRAPH_API_URL", None)
+
+
+def current_plan() -> str:
+    # Read after license validation, which decides whether plus features are on.
+    return "enterprise" if plus_features_enabled() else "developer"
+
+
 DEPENDENCY_VERSION_DISTRIBUTIONS = {
     "langgraph.python.version": "langgraph",
     "langgraph_checkpoint.version": "langgraph-checkpoint",
@@ -220,7 +226,7 @@ async def metadata_loop() -> None:
             "langgraph.platform.host": HOST,
             "langgraph.platform.tenant_id": TENANT_ID or "",
             "langgraph.platform.project_id": PROJECT_ID or "",
-            "langgraph.platform.plan": PLAN,
+            "langgraph.platform.plan": current_plan(),
             # user app features
             "user_app.uses_indexing": USES_INDEXING or "",
             "user_app.uses_custom_app": USES_CUSTOM_APP or "",

{langgraph_api-0.19.0.dev3 → langgraph_api-0.19.0.dev4}/langgraph_api/middleware/ensure_store.py

@@ -13,6 +13,10 @@ class EnsureStoreAccessible:
         self.app = app
 
     async def __call__(self, scope: Scope, receive: Receive, send: Send):
+        # The store isn't ready until the lifespan has started.
+        if scope["type"] not in ("http", "websocket"):
+            await self.app(scope, receive, send)
+            return
         global _CONFIG
         if _CONFIG is None:
             _CONFIG = await _get_partial_conf()

{langgraph_api-0.19.0.dev3 → langgraph_api-0.19.0.dev4}/langgraph_api/models/run.py

@@ -32,7 +32,10 @@ from langgraph_api.schema import (
     RunCommand,
     StreamMode,
 )
-from langgraph_api.tracing_session import resolve_tracing_session_name
+from langgraph_api.tracing_session import (
+    resolve_tracing_session_name,
+    tracer_destination,
+)
 from langgraph_api.utils import AsyncConnectionProto, get_auth_ctx, get_user_id
 from langgraph_api.utils.headers import get_configurable_headers
 from langgraph_api.utils.uuids import uuid7
@@ -55,6 +58,7 @@ class LangSmithTracer(TypedDict, total=False):
 
     example_id: str | None
     project_name: str | None
+    address: Mapping[str, str] | None
 
 
 class RunCreateDict(TypedDict):
@@ -289,7 +293,12 @@ async def create_valid_run(
     if not configurable.get("langgraph_request_id"):
         configurable["langgraph_request_id"] = request_id
     if ls_tracing := payload.get("langsmith_tracer"):
-        configurable["__langsmith_project__"] = ls_tracing.get("project_name")
+        try:
+            ls_project, ls_address = tracer_destination(payload) or (None, None)
+        except ValueError as exc:
+            raise HTTPException(status_code=422, detail=str(exc)) from None
+        configurable["__langsmith_project__"] = ls_project
+        configurable["__langsmith_address__"] = ls_address
         configurable["__langsmith_example_id__"] = ls_tracing.get("example_id")
     if request_start_time:
         configurable["__request_start_time_ms__"] = request_start_time

{langgraph_api-0.19.0.dev3 → langgraph_api-0.19.0.dev4}/langgraph_api/priority_settings.py

@@ -138,7 +138,8 @@ def _int_in_range(
 
 def validate_priority_settings(result: Any) -> ThreadPrioritySettings:
     """The settings to store for the callback's result, with defaults for what it left out.
-    An empty fairness_group is the default group, like a missing one.
+    An empty fairness_group is the default group, like a missing one, and a fairness_weight
+    is dropped with a warning.
 
     Raises:
         HTTPException(500): the result isn't a dict or None, has an unknown key, or has a
@@ -148,6 +149,16 @@ def validate_priority_settings(result: Any) -> ThreadPrioritySettings:
         result = {}
     if not isinstance(result, dict):
         raise _invalid(f"a {type(result).__name__}, not a dict or None")
+    if "fairness_weight" in result:
+        # langgraph-sdk 0.4.9 to 0.4.11 type the result with a fairness_weight, which the
+        # server never stores, so callbacks written against them may still return it.
+        result = {
+            key: value for key, value in result.items() if key != "fairness_weight"
+        }
+        logger.warning(
+            "Priority callback returned fairness_weight, which has no effect and is"
+            " ignored; remove it from the callback's result"
+        )
     unknown = sorted(set(result) - set(ThreadPrioritySettings.__annotations__))
     if unknown:
         raise _invalid(f"unknown keys {unknown}")

{langgraph_api-0.19.0.dev3 → langgraph_api-0.19.0.dev4}/langgraph_api/serde.py

@@ -14,6 +14,7 @@ from ipaddress import (
     IPv6Interface,
     IPv6Network,
 )
+from itertools import pairwise
 from pathlib import Path
 from re import Pattern
 from typing import Any, Literal, NamedTuple, cast, overload
@@ -184,7 +185,15 @@ def json_dumpb(obj) -> bytes:
     # Replace with U+FFFD (replacement character) instead of stripping,
     # so that "key\x00" becomes "key\uFFFD" rather than "key" — preventing
     # a poisoned key from projecting onto a legitimate one.
-    return dumped.replace(rb"\\u0000", rb"\\ufffd").replace(rb"\u0000", rb"\ufffd")
+    parts = dumped.split(rb"\u0000")
+    out = [parts[0]]
+    for before, after in pairwise(parts):
+        # After an odd run of backslashes, \u0000 is the text "\u0000" (its
+        # backslash escaped), not a NUL character.
+        backslashes = len(before) - len(before.rstrip(b"\\"))
+        out.append(rb"\u0000" if backslashes % 2 else rb"\ufffd")
+        out.append(after)
+    return b"".join(out)
 
 
 def json_loads(content: bytes | Fragment | dict) -> Any: