langgraph-api 0.18.0.dev13__tar.gz → 0.18.0.dev14__tar.gz

{langgraph_api-0.18.0.dev13 → langgraph_api-0.18.0.dev14}/Makefile

@@ -108,9 +108,11 @@ endif
 
 REVISION ?= $(shell git rev-parse --short HEAD)
 LANGGRAPH_ENCRYPTION ?=
+# The servers' priority callback, off by default; tests/graphs/custom_priority.py to test it.
+LANGGRAPH_PRIORITY ?=
 
 test-license-oss:
-	LANGGRAPH_RUNTIME_EDITION=inmem LANGGRAPH_WEBHOOKS='$(LANGGRAPH_WEBHOOKS)' LANGGRAPH_HTTP='$(HTTP_CONFIG)' LANGGRAPH_STORE='$(STORE_CONFIG)' LANGGRAPH_CHECKPOINTER='$(CHECKPOINTER_CONFIG)' LANGGRAPH_ENCRYPTION='$(LANGGRAPH_ENCRYPTION)' REDIS_URI=_FAKE DATABASE_URI=:memory: MIGRATIONS_PATH=__inmem__ uv run pytest -v $(PYTEST_ROOT_ARGS) $(XDIST_ARGS) $(TEST)
+	LANGGRAPH_PRIORITY='$(LANGGRAPH_PRIORITY)' LANGGRAPH_RUNTIME_EDITION=inmem LANGGRAPH_WEBHOOKS='$(LANGGRAPH_WEBHOOKS)' LANGGRAPH_HTTP='$(HTTP_CONFIG)' LANGGRAPH_STORE='$(STORE_CONFIG)' LANGGRAPH_CHECKPOINTER='$(CHECKPOINTER_CONFIG)' LANGGRAPH_ENCRYPTION='$(LANGGRAPH_ENCRYPTION)' REDIS_URI=_FAKE DATABASE_URI=:memory: MIGRATIONS_PATH=__inmem__ uv run pytest -v $(PYTEST_ROOT_ARGS) $(XDIST_ARGS) $(TEST)
 
 test-watch-oss:
 	LANGGRAPH_RUNTIME_EDITION=inmem LANGGRAPH_WEBHOOKS='$(LANGGRAPH_WEBHOOKS)' LANGGRAPH_HTTP='$(HTTP_CONFIG)' LANGGRAPH_ENCRYPTION='$(LANGGRAPH_ENCRYPTION)' REDIS_URI=_FAKE DATABASE_URI=:memory: MIGRATIONS_PATH=__inmem__ uv run --no-sync ptw . -- -x -vv --ff --capture=no $(TEST)
@@ -200,6 +202,7 @@ LANGSMITH_TRACING ?= false
 start:
 	LANGGRAPH_DISABLE_FILE_PERSISTENCE=$(LANGGRAPH_DISABLE_FILE_PERSISTENCE) \
 	LANGGRAPH_WEBHOOKS='$(LANGGRAPH_WEBHOOKS)' \
+	LANGGRAPH_PRIORITY='$(LANGGRAPH_PRIORITY)' \
 	LANGGRAPH_HTTP='$(HTTP_CONFIG)' \
 	LANGGRAPH_RUNTIME_EDITION=inmem \
 	LANGGRAPH_AES_KEY='$(LANGGRAPH_AES_KEY)' \

{langgraph_api-0.18.0.dev13 → langgraph_api-0.18.0.dev14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langgraph-api
-Version: 0.18.0.dev13
+Version: 0.18.0.dev14
 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
@@ -13,7 +13,7 @@ Requires-Dist: grpcio-tools==1.81.1
 Requires-Dist: grpcio<1.82.0,>=1.81.0
 Requires-Dist: httptools>=0.5.0; platform_system != 'Windows'
 Requires-Dist: httpx>=0.25.0
-Requires-Dist: jsonschema-rs<0.45,>=0.23.0
+Requires-Dist: jsonschema-rs<0.45,>=0.35.0
 Requires-Dist: langchain-core>=0.3.64
 Requires-Dist: langchain-protocol<0.1,>=0.0.18
 Requires-Dist: langgraph-checkpoint<5,>=3.0.1

{langgraph_api-0.18.0.dev13 → langgraph_api-0.18.0.dev14}/constraints.txt

@@ -13,7 +13,7 @@ uvicorn>=0.29.0
 sse-starlette>=2.1.3,<4.0.0
 uvloop>=0.18.0
 httptools>=0.5.0
-jsonschema-rs>=0.23.0
+jsonschema-rs>=0.35.0
 structlog>=24.1.0
 cloudpickle>=3.0.0
 truststore>=0.1

langgraph_api-0.18.0.dev14/langgraph_api/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.18.0.dev14"

{langgraph_api-0.18.0.dev13 → langgraph_api-0.18.0.dev14}/langgraph_api/api/mcp/_elicitation.py

@@ -3,18 +3,20 @@ from __future__ import annotations
 import re
 from collections import Counter
 from contextlib import contextmanager
-from dataclasses import dataclass, replace
-from typing import TYPE_CHECKING, Literal, Protocol
+from dataclasses import dataclass, field, replace
+from typing import TYPE_CHECKING, Literal, NoReturn, Protocol, TypeGuard
 from urllib.parse import urlsplit
 
+import jsonschema_rs
 import mcp_types as types
 import orjson
+import structlog
 from mcp.shared.exceptions import MCPError
 from pydantic import TypeAdapter, ValidationError
 
 from langgraph_api.api.mcp._constants import UNASKABLE_INPUT_MESSAGE
 from langgraph_api.api.mcp._digest import digest
-from langgraph_api.api.mcp._forms import FormSchema, UnsupportedSchema
+from langgraph_api.api.mcp._forms import FormSchema, FormTooLarge, UnsupportedSchema
 from langgraph_api.api.mcp._origins import LOOPBACK_HOSTS
 from langgraph_api.api.mcp._outcome import Failed
 
@@ -24,6 +26,9 @@ if TYPE_CHECKING:
     from pydantic import JsonValue
 
     from langgraph_api.schema import Interrupt
+    from langgraph_api.validation import SchemaValidator
+
+logger = structlog.stdlib.get_logger(__name__)
 
 TEXT_ANSWER: dict[str, JsonValue] = {"type": "string"}
 ELICIT_PARAMS: TypeAdapter[types.ElicitRequestParams] = TypeAdapter(
@@ -39,6 +44,25 @@ Refusal = Literal["decline", "cancel"]
 Mode = Literal["form", "url"]
 ENDED: dict[Refusal, str] = {"decline": "declined", "cancel": "cancelled"}
 Results = dict[str, types.ElicitResult]
+DECISION_TITLES: dict[str, str] = {
+    "approve": "Approve",
+    "edit": "Edit the arguments",
+    "reject": "Reject",
+    "respond": "Answer for the tool",
+}
+MESSAGE_DECISIONS = frozenset({"reject", "respond"})
+REVIEW_MESSAGE: dict[str, JsonValue] = {
+    "type": "string",
+    "title": "Message",
+    "description": "Why you reject the call, or the answer to send in its place",
+}
+REVIEW_ARGS: dict[str, JsonValue] = {
+    "type": "string",
+    "title": "Arguments",
+    "description": "The arguments to run the tool with, as a JSON object",
+}
+DECISION_TYPE_PATH: list[str | int] = ["type"]
+ANY_DECISION = jsonschema_rs.validator_for({})
 
 
 class UnaskableInterrupt(ValueError):
@@ -199,6 +223,163 @@ class RelayedRequests:
         }
 
 
+@dataclass(frozen=True, slots=True)
+class ReviewDialect:
+    allowed_decisions: str
+    edited_action: str
+
+    def decisions_of(self, config: JsonValue) -> JsonValue:
+        return config.get(self.allowed_decisions) if isinstance(config, dict) else None
+
+    def edit(self, name: str, args: dict[str, JsonValue]) -> dict[str, JsonValue]:
+        return {"type": "edit", self.edited_action: {"name": name, "args": args}}
+
+
+SNAKE_CASE = ReviewDialect("allowed_decisions", "edited_action")
+CAMEL_CASE = ReviewDialect("allowedDecisions", "editedAction")
+
+
+@dataclass(slots=True)
+class ReviewKeys:
+    asked: Counter[str] = field(default_factory=Counter)
+
+    def next(self, *action: JsonValue) -> str:
+        reviewed = digest(*action)
+        self.asked[reviewed] += 1
+        return f"review-{reviewed}.{self.asked[reviewed]}"
+
+
+@dataclass(frozen=True, slots=True)
+class ReviewedAction:
+    name: str
+    decisions: tuple[str, ...]
+    question: FormQuestion
+    dialect: ReviewDialect
+
+    @classmethod
+    def of(
+        cls,
+        request: JsonValue,
+        decisions: JsonValue,
+        dialect: ReviewDialect,
+        *,
+        keys: ReviewKeys,
+    ) -> ReviewedAction:
+        match request:
+            case {
+                "name": str() as name,
+                "args": dict() as args,
+                **rest,
+            } if _are_decisions(decisions):
+                allowed = tuple(dict.fromkeys(decisions))
+                message = _text(rest.get("description")) or f"Run {name}?"
+                key = keys.next(name, args, message, allowed)
+                question = FormQuestion(key, message, _review_form(args, allowed))
+                return cls(name, allowed, question, dialect)
+            case _:
+                raise UnaskableInterrupt(
+                    "A review needs a tool name, its arguments and its decisions"
+                )
+
+    def refusal(self, results: Results) -> EndCall | None:
+        match results[self.question.key].action:
+            case "cancel":
+                return EndCall("cancel")
+            case "decline" if "reject" not in self.decisions:
+                return EndCall("decline")
+            case _:
+                return None
+
+    def decision(self, results: Results) -> dict[str, JsonValue]:
+        result = results[self.question.key]
+        if result.action == "decline":
+            return {"type": "reject"}
+        return _decision(self.name, self.question.answer(result), self.dialect)
+
+
+@dataclass(frozen=True, slots=True)
+class ReviewPrompt:
+    actions: tuple[ReviewedAction, ...]
+
+    @classmethod
+    def of(
+        cls,
+        requests: Sequence[JsonValue],
+        configs: Sequence[JsonValue],
+        dialect: ReviewDialect,
+        *,
+        keys: ReviewKeys,
+    ) -> ReviewPrompt:
+        if len(requests) != len(configs):
+            raise UnaskableInterrupt("A review needs one review config per action")
+        return cls(
+            tuple(
+                ReviewedAction.of(
+                    request, dialect.decisions_of(config), dialect, keys=keys
+                )
+                for request, config in zip(requests, configs, strict=True)
+            )
+        )
+
+    @property
+    def questions(self) -> tuple[FormQuestion, ...]:
+        return tuple(action.question for action in self.actions)
+
+    def scoped(self, scope: str) -> ReviewPrompt:
+        return self
+
+    def refusal(self, results: Results) -> EndCall | None:
+        for action in self.actions:
+            if (refusal := action.refusal(results)) is not None:
+                return refusal
+        return None
+
+    def resume_value(self, results: Results) -> JsonValue:
+        return {"decisions": [action.decision(results) for action in self.actions]}
+
+
+@dataclass(frozen=True, slots=True)
+class DecisionSchema:
+    schema: JsonValue
+
+    def checked(self, decision: dict[str, JsonValue]) -> dict[str, JsonValue]:
+        validator = _decision_validator(self.schema)
+        try:
+            validator.validate(decision)
+        except jsonschema_rs.ValidationError as error:
+            raise InvalidAnswer(
+                f"The decision does not fit the tool: {_reason(error)}"
+            ) from None
+        return decision
+
+
+@dataclass(frozen=True, slots=True)
+class ToolApprovalPrompt:
+    action: ReviewedAction
+    schema: DecisionSchema
+
+    @classmethod
+    def of(
+        cls, approval: JsonValue, schema: JsonValue, *, keys: ReviewKeys
+    ) -> ToolApprovalPrompt:
+        decisions = _approval_decisions(schema)
+        action = ReviewedAction.of(approval, decisions, SNAKE_CASE, keys=keys)
+        return cls(action, DecisionSchema(schema))
+
+    @property
+    def questions(self) -> tuple[FormQuestion]:
+        return (self.action.question,)
+
+    def scoped(self, scope: str) -> ToolApprovalPrompt:
+        return self
+
+    def refusal(self, results: Results) -> EndCall | None:
+        return self.action.refusal(results)
+
+    def resume_value(self, results: Results) -> JsonValue:
+        return self.schema.checked(self.action.decision(results))
+
+
 @dataclass(frozen=True, slots=True)
 class Round:
     prompts: Mapping[str, Prompt]
@@ -206,8 +387,10 @@ class Round:
 
     @classmethod
     def of(cls, interrupts: Sequence[Interrupt]) -> Round:
+        keys = ReviewKeys()
         prompts = {
-            _interrupt_id(interrupt): _prompt(interrupt) for interrupt in interrupts
+            _interrupt_id(interrupt): _prompt(interrupt, keys)
+            for interrupt in interrupts
         }
         if len(prompts) > 1:
             scopes = _scopes(interrupts)
@@ -260,7 +443,7 @@ class Round:
                 return Resume(resumed)
 
 
-def _prompt(interrupt: Interrupt) -> Prompt:
+def _prompt(interrupt: Interrupt, keys: ReviewKeys) -> Prompt:
     match interrupt["value"]:
         case {"type": "mcp_elicitation", "requests": [_, *_] as listed}:
             return RelayedRequests(tuple(map(_listed_question, listed)))
@@ -270,6 +453,19 @@ def _prompt(interrupt: Interrupt) -> Prompt:
             )
         case {"type": "mcp_elicitation"}:
             raise UnaskableInterrupt("An mcp_elicitation interrupt needs a request")
+        case {"type": "tool_approval"} as approval:
+            schema = interrupt.get("response_schema")
+            return ToolApprovalPrompt.of(approval, schema, keys=keys)
+        case {
+            "action_requests": [_, *_] as requests,
+            "review_configs": list() as configs,
+        }:
+            return ReviewPrompt.of(requests, configs, SNAKE_CASE, keys=keys)
+        case {
+            "actionRequests": [_, *_] as requests,
+            "reviewConfigs": list() as configs,
+        }:
+            return ReviewPrompt.of(requests, configs, CAMEL_CASE, keys=keys)
         case _:
             return AnswerPrompt.of(interrupt)
 
@@ -314,6 +510,123 @@ def _elicit_params(request: JsonValue) -> types.ElicitRequestParams | None:
         return None
 
 
+def _are_decisions(values: JsonValue) -> TypeGuard[list[str]]:
+    return (
+        isinstance(values, list)
+        and bool(values)
+        and all(isinstance(value, str) and value in DECISION_TITLES for value in values)
+    )
+
+
+def _approval_decisions(schema: JsonValue) -> JsonValue:
+    match schema:
+        case {"discriminator": {"mapping": dict() as mapping}}:
+            return list(mapping)
+        case {"oneOf": [*branches]} | {"anyOf": [*branches]}:
+            return [_decision_type(branch) for branch in branches]
+        case _:
+            return [_decision_type(schema)]
+
+
+def _decision_type(branch: JsonValue) -> JsonValue:
+    match branch:
+        case {"properties": {"type": {"const": str() as decision}}}:
+            return decision
+        case _:
+            return None
+
+
+def _decision_validator(schema: JsonValue) -> SchemaValidator:
+    try:
+        return jsonschema_rs.validator_for(
+            schema, retriever=_never_fetch, validate_formats=False
+        )
+    except jsonschema_rs.ValidationError as error:
+        logger.warning(
+            "A tool approval's response_schema does not compile, "
+            "so this answer is not checked",
+            error=error.message,
+        )
+        return ANY_DECISION
+
+
+def _never_fetch(uri: str) -> NoReturn:
+    raise ValueError(f"The server never fetches {uri}")
+
+
+def _reason(error: jsonschema_rs.ValidationError) -> str:
+    match error.kind:
+        case (
+            jsonschema_rs.ValidationErrorKind.OneOfNotValid(context=branches)
+            | jsonschema_rs.ValidationErrorKind.AnyOf(context=branches)
+        ):
+            for errors in branches:
+                if not _rejects_the_type(errors):
+                    return errors[0].message
+    return error.message
+
+
+def _rejects_the_type(errors: list[jsonschema_rs.ValidationError]) -> bool:
+    return any(error.instance_path == DECISION_TYPE_PATH for error in errors)
+
+
+def _review_form(args: dict[str, JsonValue], decisions: tuple[str, ...]) -> FormSchema:
+    with _unaskable_schemas():
+        try:
+            return FormSchema.of(_review_schema(args, decisions))
+        except FormTooLarge:
+            uneditable = tuple(decision for decision in decisions if decision != "edit")
+            if not uneditable:
+                raise
+            return FormSchema.of(_review_schema(args, uneditable))
+
+
+def _review_schema(
+    args: dict[str, JsonValue], decisions: tuple[str, ...]
+) -> dict[str, JsonValue]:
+    choices = [
+        {"const": decision, "title": DECISION_TITLES[decision]}
+        for decision in decisions
+    ]
+    fields: dict[str, JsonValue] = {
+        "decision": {"type": "string", "title": "Decision", "oneOf": choices}
+    }
+    if MESSAGE_DECISIONS.intersection(decisions):
+        fields["message"] = REVIEW_MESSAGE
+    if "edit" in decisions:
+        fields["args"] = {**REVIEW_ARGS, "default": orjson.dumps(args).decode()}
+    return {"type": "object", "properties": fields, "required": ["decision"]}
+
+
+def _decision(
+    name: str, answer: JsonValue, dialect: ReviewDialect
+) -> dict[str, JsonValue]:
+    match answer:
+        case {"decision": "approve"}:
+            return {"type": "approve"}
+        case {"decision": "reject", **rest}:
+            reason = _text(rest.get("message"))
+            return (
+                {"type": "reject", "message": reason} if reason else {"type": "reject"}
+            )
+        case {"decision": "respond", "message": str() as message} if _text(message):
+            return {"type": "respond", "message": message}
+        case {"decision": "edit", "args": str() as args}:
+            return dialect.edit(name, _json_object(args))
+        case _:
+            raise InvalidAnswer("A decision needs its message or its arguments")
+
+
+def _json_object(text: str) -> dict[str, JsonValue]:
+    try:
+        value = orjson.loads(text)
+    except orjson.JSONDecodeError:
+        value = None
+    if not isinstance(value, dict):
+        raise InvalidAnswer("Edited arguments must be a JSON object")
+    return value
+
+
 def _safe_url(url: str) -> str:
     try:
         parsed = urlsplit(url)

{langgraph_api-0.18.0.dev13 → langgraph_api-0.18.0.dev14}/langgraph_api/api/mcp/_forms.py

@@ -37,6 +37,10 @@ class UnsupportedSchema(ValueError):
     pass
 
 
+class FormTooLarge(UnsupportedSchema):
+    pass
+
+
 @dataclass(frozen=True, slots=True)
 class Definitions:
     schemas: Mapping[str, JsonValue]
@@ -71,7 +75,7 @@ class FormSize:
     def plus(self, value: JsonValue) -> Self:
         encoded = _encoded(value)
         if encoded is None or self.used + len(encoded) > MAX_FORM_BYTES:
-            raise UnsupportedSchema(f"A form can't be over {MAX_FORM_BYTES} bytes")
+            raise FormTooLarge(f"A form can't be over {MAX_FORM_BYTES} bytes")
         return replace(self, used=self.used + len(encoded))
 
 

{langgraph_api-0.18.0.dev13 → langgraph_api-0.18.0.dev14}/langgraph_api/api/runs.py

@@ -40,7 +40,7 @@ from langgraph_api.validation import (
     RunsCancel,
     ThreadCronCreate,
 )
-from langgraph_api.webhook import validate_webhook_url_or_raise
+from langgraph_api.webhook import validate_or_drop_webhook
 from langgraph_runtime.database import connect
 from langgraph_runtime.retry import retry_db
 
@@ -294,7 +294,9 @@ async def create_stateless_run(request: ApiRequest):
         )
     return ApiResponse(
         run,
-        headers={"Content-Location": f"/runs/{run['run_id']}"},
+        headers={
+            "Content-Location": f"/threads/{run['thread_id']}/runs/{run['run_id']}"
+        },
     )
 
 
@@ -415,8 +417,8 @@ async def stream_run_stateless(
     return EventSourceResponse(
         body(),
         headers={
-            "Location": f"/runs/{run['run_id']}/stream",
-            "Content-Location": f"/runs/{run['run_id']}",
+            "Location": f"/threads/{run['thread_id']}/runs/{run['run_id']}/stream",
+            "Content-Location": f"/threads/{run['thread_id']}/runs/{run['run_id']}",
         },
         on_close=lambda: sub.__aexit__(None, None, None),
     )
@@ -598,11 +600,15 @@ async def join_run(request: ApiRequest):
         fallback=_thread_values_fallback(thread_id),
     )
 
+    # Clients reconnect to Location as-is, so it keeps the request's query.
+    query = f"?{request.url.query}" if request.url.query else ""
+    location = f"/threads/{thread_id}/runs/{run_id}/join{query}"
+
     return StreamingResponse(
         body(),
         media_type="application/json",
         headers={
-            "Location": f"/threads/{thread_id}/runs/{run_id}/join",
+            "Location": location,
             "Content-Location": f"/threads/{thread_id}/runs/{run_id}",
         },
     )
@@ -618,8 +624,11 @@ async def join_run_stream(request: ApiRequest):
     validate_uuid(thread_id, "Invalid thread ID: must be a UUID")
     validate_uuid(run_id, "Invalid run ID: must be a UUID")
 
-    stream_mode_param = request.query_params.get("stream_mode")
-    stream_mode = parse_stream_mode_param(stream_mode_param)
+    stream_mode = [
+        mode
+        for value in request.query_params.getlist("stream_mode")
+        for mode in parse_stream_mode_param(value)
+    ]
 
     last_event_id = request.headers.get("last-event-id") or None
 
@@ -639,10 +648,14 @@ async def join_run_stream(request: ApiRequest):
             # Clean up the stream handler
             await sub.__aexit__(None, None, None)
 
+    # Clients reconnect to Location as-is, so it keeps the request's query.
+    query = f"?{request.url.query}" if request.url.query else ""
+    location = f"/threads/{thread_id}/runs/{run_id}/stream{query}"
+
     return EventSourceResponse(
         body(),
         headers={
-            "Location": f"/threads/{thread_id}/runs/{run_id}/stream",
+            "Location": location,
             "Content-Location": f"/threads/{thread_id}/runs/{run_id}",
         },
     )
@@ -766,8 +779,7 @@ async def delete_run(request: ApiRequest):
 async def create_cron(request: ApiRequest):
     """Create a cron with new thread."""
     payload = await request.json(CronCreate)
-    if webhook := payload.get("webhook"):
-        await validate_webhook_url_or_raise(str(webhook))
+    await validate_or_drop_webhook(payload)
     _validate_assistant_id(payload.get("assistant_id"))
     timezone = validate_timezone(payload.get("timezone"))
 
@@ -798,8 +810,7 @@ async def create_thread_cron(request: ApiRequest):
     thread_id = request.path_params["thread_id"]
     validate_uuid(thread_id, "Invalid thread ID: must be a UUID")
     payload = await request.json(ThreadCronCreate)
-    if webhook := payload.get("webhook"):
-        await validate_webhook_url_or_raise(str(webhook))
+    await validate_or_drop_webhook(payload)
     _validate_assistant_id(payload.get("assistant_id"))
     timezone = validate_timezone(payload.get("timezone"))
 
@@ -842,8 +853,14 @@ async def patch_cron(request: ApiRequest):
         raise HTTPException(status_code=400, detail="Request body cannot be empty")
     timezone = validate_timezone(payload.get("timezone"))
 
-    if webhook := payload.get("webhook"):
-        await validate_webhook_url_or_raise(str(webhook))
+    await validate_or_drop_webhook(payload)
+    # The body was non-empty above, so it is empty here only when its sole field
+    # was a webhook dropped because webhooks are disabled.
+    if not payload:
+        raise HTTPException(
+            status_code=422,
+            detail="Webhooks are disabled on this server, so `webhook` can't be updated",
+        )
 
     # An explicit `end_time: null` clears the end time; an absent key leaves it unchanged.
     clear_end_time = "end_time" in payload and payload["end_time"] is None

{langgraph_api-0.18.0.dev13 → langgraph_api-0.18.0.dev14}/langgraph_api/api/threads.py

@@ -585,9 +585,9 @@ async def join_thread_stream(request: ApiRequest):
     """Join a thread stream."""
     thread_id = request.path_params["thread_id"]
     validate_uuid(thread_id, "Invalid thread ID: must be a UUID")
-    last_event_id = request.headers.get("last-event-id") or None
-    validate_stream_id(
-        last_event_id, "Invalid last-event-id: must be a valid Redis stream ID"
+    last_event_id = validate_stream_id(
+        request.headers.get("last-event-id") or None,
+        "Invalid last-event-id: must be a valid Redis stream ID",
     )
 
     # The SDKs send ``stream_mode``: once per mode, or as one JSON array from

{langgraph_api-0.18.0.dev13 → langgraph_api-0.18.0.dev14}/langgraph_api/asyncio.py

@@ -1,5 +1,6 @@
 import asyncio
 import concurrent.futures
+import sys
 from collections.abc import AsyncIterator, Coroutine, Generator
 from contextlib import (
     AbstractAsyncContextManager,
@@ -13,6 +14,11 @@ from typing import Any, Generic, TypeVar
 import structlog
 import uvicorn
 
+if sys.platform == "win32":
+    _MAIN_LOOP_FACTORY = None
+else:
+    from uvloop import new_event_loop as _MAIN_LOOP_FACTORY
+
 T = TypeVar("T")
 
 logger = structlog.stdlib.get_logger(__name__)
@@ -50,6 +56,11 @@ def get_event_loop() -> asyncio.AbstractEventLoop:
     return _MAIN_LOOP
 
 
+def run_main_loop(main: Coroutine[object, object, T]) -> T:
+    with asyncio.Runner(loop_factory=_MAIN_LOOP_FACTORY) as runner:
+        return runner.run(main)
+
+
 async def sleep_if_not_done(delay: float, done: asyncio.Event) -> None:
     with suppress(TimeoutError):
         await asyncio.wait_for(done.wait(), delay)

{langgraph_api-0.18.0.dev13 → langgraph_api-0.18.0.dev14}/langgraph_api/cli.py

@@ -19,7 +19,12 @@ from typing import Literal
 if typing.TYPE_CHECKING:
     from packaging.version import Version
 
-    from langgraph_api.config import AuthConfig, HttpConfig, StoreConfig
+    from langgraph_api.config import (
+        AuthConfig,
+        HttpConfig,
+        PriorityConfig,
+        StoreConfig,
+    )
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
@@ -184,6 +189,7 @@ def run_server(
     reload_excludes: Sequence[str] | None = None,
     store: typing.Optional["StoreConfig"] = None,
     auth: typing.Optional["AuthConfig"] = None,
+    priority: typing.Optional["PriorityConfig"] = None,
     http: typing.Optional["HttpConfig"] = None,
     ui: dict | None = None,
     webhooks: dict | None = None,
@@ -270,6 +276,7 @@ def run_server(
         LANGSERVE_GRAPHS=json.dumps(graphs) if graphs else None,
         LANGSMITH_LANGGRAPH_API_VARIANT="local_dev",
         LANGGRAPH_AUTH=json.dumps(auth) if auth else None,
+        LANGGRAPH_PRIORITY=json.dumps(priority) if priority else None,
         LANGGRAPH_HTTP=json.dumps(http) if http else None,
         LANGGRAPH_UI=json.dumps(ui) if ui else None,
         LANGGRAPH_WEBHOOKS=json.dumps(webhooks) if webhooks else None,

{langgraph_api-0.18.0.dev13 → langgraph_api-0.18.0.dev14}/langgraph_api/config/__init__.py

@@ -18,6 +18,7 @@ from langgraph_api.config.schemas import (
     CorsConfig,
     EncryptionConfig,
     HttpConfig,
+    PriorityConfig,
     SerdeConfig,
     StoreConfig,
     ThreadTTLConfig,
@@ -611,6 +612,14 @@ LANGGRAPH_AUTH = env(
 LANGGRAPH_ENCRYPTION = env(
     "LANGGRAPH_ENCRYPTION", cast=_parse.parse_schema(EncryptionConfig), default=None
 )
+# Not in public docs: populated by langgraph.json config, not set as env var directly
+LANGGRAPH_PRIORITY = env(
+    "LANGGRAPH_PRIORITY", cast=_parse.parse_schema(PriorityConfig), default=None
+)
+# Whether the deployment has a priority callback, the one source of run priority levels.
+# Per-level queue stats and metric labels are reported only then, so a deployment without
+# one keeps its metrics as they were.
+PRIORITY_CALLBACK_CONFIGURED = bool(LANGGRAPH_PRIORITY)
 # Not in public docs: set by SaaS control plane, not user-configurable
 LANGSMITH_TENANT_ID = env("LANGSMITH_TENANT_ID", cast=str, default=None)
 LANGSMITH_HOST_PROJECT_ID = env("LANGSMITH_HOST_PROJECT_ID", cast=str, default=None)
@@ -882,6 +891,7 @@ __all__ = [
     "LANGGRAPH_METRICS_ENDPOINT",
     "LANGGRAPH_METRICS_EXPORT_INTERVAL_MS",
     "LANGGRAPH_POSTGRES_EXTENSIONS",
+    "LANGGRAPH_PRIORITY",
     "LANGSMITH_API_KEY",
     "LANGSMITH_AUTH_ENDPOINT",
     "LANGSMITH_AUTH_VERIFY_TENANT_ID",
@@ -900,6 +910,7 @@ __all__ = [
     "N_JOBS_PER_WORKER",
     "OTEL_ENABLED",
     "POSTGRES_POOL_MAX_SIZE",
+    "PRIORITY_CALLBACK_CONFIGURED",
     "PYTHON_GRPC_BIND_HOST",
     "PYTHON_GRPC_SERVER_ENABLED",
     "PYTHON_GRPC_SERVER_PORT",