langgraph-api 0.0.14__py3-none-any.whl → 0.0.16__py3-none-any.whl

langgraph_api/models/run.py

@@ -191,6 +191,7 @@ async def create_valid_run(
         user_id = get_user_id(user)
         config["configurable"]["langgraph_auth_user"] = user
         config["configurable"]["langgraph_auth_user_id"] = user_id
+        config["configurable"]["langgraph_auth_permissions"] = ctx.permissions
     else:
         user_id = None
     run_coro = Runs.put(

langgraph_api/queue.py

@@ -1,33 +1,41 @@
 import asyncio
-from contextlib import AsyncExitStack
+from collections.abc import AsyncGenerator
+from contextlib import AsyncExitStack, asynccontextmanager
 from datetime import UTC, datetime
 from random import random
-from typing import cast
+from typing import TypedDict, cast
 
 import structlog
 from langgraph.pregel.debug import CheckpointPayload, TaskResultPayload
 
+from langgraph_api.auth.custom import normalize_user
 from langgraph_api.config import BG_JOB_NO_DELAY, STATS_INTERVAL_SECS
 from langgraph_api.errors import (
     UserInterrupt,
     UserRollback,
 )
 from langgraph_api.http import get_http_client
-from langgraph_api.js.remote import RemoteException
+from langgraph_api.js.errors import RemoteException
 from langgraph_api.metadata import incr_runs
 from langgraph_api.schema import Run
 from langgraph_api.stream import (
     astream_state,
     consume,
 )
-from langgraph_api.utils import AsyncConnectionProto
+from langgraph_api.utils import AsyncConnectionProto, set_auth_ctx, with_user
 from langgraph_storage.database import connect
 from langgraph_storage.ops import Runs, Threads
 from langgraph_storage.retry import RETRIABLE_EXCEPTIONS
 
+try:
+    from psycopg.errors import InFailedSqlTransaction
+except ImportError:
+    InFailedSqlTransaction = ()
+
 logger = structlog.stdlib.get_logger(__name__)
 
 WORKERS: set[asyncio.Task] = set()
+WEBHOOKS: set[asyncio.Task] = set()
 MAX_RETRY_ATTEMPTS = 3
 SHUTDOWN_GRACE_PERIOD_SECS = 5
 
@@ -45,10 +53,46 @@ async def queue(concurrency: int, timeout: float):
         WORKERS.remove(task)
         semaphore.release()
         try:
-            if exc := task.exception():
+            result: WorkerResult | None = task.result()
+            exc = task.exception()
+            if exc:
                 logger.exception("Background worker failed", exc_info=exc)
+            if result and result["webhook"]:
+                checkpoint = result["checkpoint"]
+                payload = {
+                    **result["run"],
+                    "status": result["status"],
+                    "run_started_at": result["run_started_at"],
+                    "run_ended_at": result["run_ended_at"],
+                    "webhook_sent_at": datetime.now(UTC).isoformat(),
+                    "values": checkpoint["values"] if checkpoint else None,
+                }
+                if exception := result["exception"]:
+                    payload["error"] = str(exception)
+
+                async def _call_webhook() -> None:
+                    try:
+                        await get_http_client().post(
+                            result["webhook"], json=payload, total_timeout=20
+                        )
+                    except Exception as exc:
+                        logger.exception(
+                            f"Background worker failed to call webhook {result['webhook']}",
+                            exc_info=exc,
+                            webhook=result["webhook"],
+                        )
+
+                hook_task = asyncio.create_task(
+                    _call_webhook(),
+                    name=f"webhook-{result['run']['run_id']}",
+                )
+                WEBHOOKS.add(hook_task)
+                hook_task.add_done_callback(WEBHOOKS.remove)
+
         except asyncio.CancelledError:
             pass
+        except Exception as exc:
+            logger.exception("Background worker cleanup failed", exc_info=exc)
 
     await logger.ainfo(f"Starting {concurrency} background workers")
     try:
@@ -73,9 +117,10 @@ async def queue(concurrency: int, timeout: float):
                     stats = await Runs.stats(conn)
                     await logger.ainfo("Queue stats", **stats)
                 if tup := await exit.enter_async_context(Runs.next(conn)):
+                    run_, attempt_ = tup
                     task = asyncio.create_task(
-                        worker(timeout, exit, conn, *tup),
-                        name=f"run-{tup[0]['run_id']}-attempt-{tup[1]}",
+                        worker(timeout, exit, conn, run_, attempt_),
+                        name=f"run-{run_['run_id']}-attempt-{attempt_}",
                     )
                     task.add_done_callback(cleanup)
                     WORKERS.add(task)
@@ -93,28 +138,61 @@ async def queue(concurrency: int, timeout: float):
         logger.info("Shutting down background workers")
         for task in WORKERS:
             task.cancel()
+        for task in WEBHOOKS:
+            task.cancel()
         await asyncio.wait_for(
-            asyncio.gather(*WORKERS, return_exceptions=True), SHUTDOWN_GRACE_PERIOD_SECS
+            asyncio.gather(*WORKERS, *WEBHOOKS, return_exceptions=True),
+            SHUTDOWN_GRACE_PERIOD_SECS,
         )
 
 
+class WorkerResult(TypedDict):
+    checkpoint: CheckpointPayload | None
+    status: str | None
+    exception: Exception | None
+    run: Run
+    webhook: str | None
+    run_started_at: str
+    run_ended_at: str | None
+
+
+@asynccontextmanager
+async def set_auth_ctx_for_run(run: Run) -> AsyncGenerator[None, None]:
+    try:
+        user = run["kwargs"]["config"]["configurable"]["langgraph_auth_user"]
+        permissions = run["kwargs"]["config"]["configurable"][
+            "langgraph_auth_permissions"
+        ]
+        if user is not None:
+            user = normalize_user(user)
+            async with with_user(user, permissions):
+                yield None
+        else:
+            yield None
+
+    except KeyError:
+        pass
+
+
 async def worker(
     timeout: float,
     exit: AsyncExitStack,
     conn: AsyncConnectionProto,
     run: Run,
     attempt: int,
-):
+) -> WorkerResult:
     run_id = run["run_id"]
     if attempt == 1:
         incr_runs()
-    async with Runs.enter(run_id) as done, exit:
+    checkpoint: CheckpointPayload | None = None
+    exception: Exception | None = None
+    status: str | None = None
+    webhook = run["kwargs"].pop("webhook", None)
+    run_started_at = datetime.now(UTC)
+    run_ended_at: str | None = None
+
+    async with set_auth_ctx_for_run(run), Runs.enter(run_id) as done, exit:
         temporary = run["kwargs"].get("temporary", False)
-        webhook = run["kwargs"].pop("webhook", None)
-        checkpoint: CheckpointPayload | None = None
-        exception: Exception | None = None
-        status: str | None = None
-        run_started_at = datetime.now(UTC)
         run_created_at = run["created_at"].isoformat()
         await logger.ainfo(
             "Starting background run",
@@ -154,13 +232,14 @@ async def worker(
                     on_task_result=on_task_result,
                 )
             await asyncio.wait_for(consume(stream, run_id), timeout)
+            run_ended_at = datetime.now(UTC).isoformat()
             await logger.ainfo(
                 "Background run succeeded",
                 run_id=str(run_id),
                 run_attempt=attempt,
                 run_created_at=run_created_at,
                 run_started_at=run_started_at.isoformat(),
-                run_ended_at=datetime.now().isoformat(),
+                run_ended_at=run_ended_at,
                 run_exec_ms=ms(datetime.now(UTC), run_started_at),
             )
             status = "success"
@@ -168,45 +247,62 @@ async def worker(
         except TimeoutError as e:
             exception = e
             status = "timeout"
+            run_ended_at = datetime.now(UTC).isoformat()
             await logger.awarning(
                 "Background run timed out",
                 run_id=str(run_id),
                 run_attempt=attempt,
                 run_created_at=run_created_at,
                 run_started_at=run_started_at.isoformat(),
-                run_ended_at=datetime.now().isoformat(),
+                run_ended_at=run_ended_at,
                 run_exec_ms=ms(datetime.now(UTC), run_started_at),
             )
             await Runs.set_status(conn, run_id, "timeout")
         except UserRollback as e:
             exception = e
             status = "rollback"
+            run_ended_at = datetime.now(UTC).isoformat()
             await logger.ainfo(
                 "Background run rolled back",
                 run_id=str(run_id),
                 run_attempt=attempt,
                 run_created_at=run_created_at,
                 run_started_at=run_started_at.isoformat(),
-                run_ended_at=datetime.now().isoformat(),
+                run_ended_at=run_ended_at,
                 run_exec_ms=ms(datetime.now(UTC), run_started_at),
             )
-            await Runs.delete(conn, run_id, thread_id=run["thread_id"])
+            try:
+                await Runs.delete(conn, run_id, thread_id=run["thread_id"])
+            except InFailedSqlTransaction as e:
+                await logger.ainfo(
+                    "Ignoring rollback error",
+                    run_id=str(run_id),
+                    run_attempt=attempt,
+                    run_created_at=run_created_at,
+                    exc=str(e),
+                )
+                # We need to clean up the transaction early if we want to
+                # update the thread status with the same connection
+                await exit.aclose()
+            checkpoint = None  # reset the checkpoint
         except UserInterrupt as e:
             exception = e
             status = "interrupted"
+            run_ended_at = datetime.now(UTC).isoformat()
             await logger.ainfo(
                 "Background run interrupted",
                 run_id=str(run_id),
                 run_attempt=attempt,
                 run_created_at=run_created_at,
                 run_started_at=run_started_at.isoformat(),
-                run_ended_at=datetime.now().isoformat(),
+                run_ended_at=run_ended_at,
                 run_exec_ms=ms(datetime.now(UTC), run_started_at),
             )
             await Runs.set_status(conn, run_id, "interrupted")
         except RETRIABLE_EXCEPTIONS as e:
             exception = e
             status = "retry"
+            run_ended_at = datetime.now(UTC).isoformat()
             await logger.awarning(
                 "Background run failed, will retry",
                 exc_info=True,
@@ -214,7 +310,7 @@ async def worker(
                 run_attempt=attempt,
                 run_created_at=run_created_at,
                 run_started_at=run_started_at.isoformat(),
-                run_ended_at=datetime.now().isoformat(),
+                run_ended_at=run_ended_at,
                 run_exec_ms=ms(datetime.now(UTC), run_started_at),
             )
             raise
@@ -223,6 +319,7 @@ async def worker(
         except Exception as exc:
             exception = exc
             status = "error"
+            run_ended_at = datetime.now(UTC).isoformat()
             await logger.aexception(
                 "Background run failed",
                 exc_info=not isinstance(exc, RemoteException),
@@ -230,24 +327,25 @@ async def worker(
                 run_attempt=attempt,
                 run_created_at=run_created_at,
                 run_started_at=run_started_at.isoformat(),
-                run_ended_at=datetime.now().isoformat(),
+                run_ended_at=run_ended_at,
                 run_exec_ms=ms(datetime.now(UTC), run_started_at),
             )
             await Runs.set_status(conn, run_id, "error")
+        set_auth_ctx(None, None)
         # delete or set status of thread
         if temporary:
             await Threads.delete(conn, run["thread_id"])
         else:
             await Threads.set_status(conn, run["thread_id"], checkpoint, exception)
-        if webhook:
-            # TODO add error, values to webhook payload
-            # TODO add retries for webhook calls
-            try:
-                await get_http_client().post(
-                    webhook, json={**run, "status": status}, total_timeout=5
-                )
-            except Exception as e:
-                logger.warning("Failed to send webhook", exc_info=e)
         # Note we don't handle asyncio.CancelledError here, as we want to
         # let it bubble up and rollback db transaction, thus marking the run
         # as available to be picked up by another worker
+    return {
+        "checkpoint": checkpoint,
+        "status": status,
+        "run_started_at": run_started_at.isoformat(),
+        "run_ended_at": run_ended_at,
+        "run": run,
+        "exception": exception,
+        "webhook": webhook,
+    }

langgraph_api/route.py

@@ -14,7 +14,7 @@ from starlette.routing import Route, compile_path, get_name
 from starlette.types import ASGIApp, Receive, Scope, Send
 
 from langgraph_api.serde import json_dumpb
-from langgraph_api.utils import set_auth_ctx
+from langgraph_api.utils import get_auth_ctx, with_user
 
 
 def api_request_response(
@@ -116,5 +116,10 @@ class ApiRoute(Route):
     async def handle(self, scope: Scope, receive: Receive, send: Send) -> None:
         # https://asgi.readthedocs.io/en/latest/specs/www.html#http-connection-scope
         scope["route"] = self.path
-        set_auth_ctx(scope.get("user"), scope.get("auth"))
-        return await super().handle(scope, receive, send)
+        ctx = get_auth_ctx()
+        if ctx:
+            user, auth = ctx.user, ctx.permissions
+        else:
+            user, auth = scope.get("user"), scope.get("auth")
+        async with with_user(user, auth):
+            return await super().handle(scope, receive, send)

langgraph_api/schema.py

@@ -157,7 +157,7 @@ class RunSend(TypedDict):
 
 class RunCommand(TypedDict):
     goto: str | RunSend | Sequence[RunSend | str] | None
-    update: dict[str, Any] | None
+    update: dict[str, Any] | Sequence[tuple[str, Any]] | None
     resume: Any | None
 
 

langgraph_api/stream.py

@@ -25,7 +25,7 @@ from pydantic.v1 import ValidationError as ValidationErrorLegacy
 
 from langgraph_api.asyncio import ValueEvent, wait_if_not_done
 from langgraph_api.graph import get_graph
-from langgraph_api.js.remote import RemotePregel
+from langgraph_api.js.base import BaseRemotePregel
 from langgraph_api.metadata import HOST, PLAN, incr_nodes
 from langgraph_api.schema import Run, RunCommand, StreamMode
 from langgraph_api.serde import json_dumpb
@@ -75,8 +75,15 @@ def _map_cmd(cmd: RunCommand) -> Command:
     if goto is not None and not isinstance(goto, list):
         goto = [cmd.get("goto")]
 
+    update = cmd.get("update")
+    if isinstance(update, tuple | list) and all(
+        isinstance(t, tuple | list) and len(t) == 2 and isinstance(t[0], str)
+        for t in update
+    ):
+        update = [tuple(t) for t in update]
+
     return Command(
-        update=cmd.get("update"),
+        update=update,
         goto=(
             [
                 it if isinstance(it, str) else Send(it["node"], it["input"])
@@ -133,7 +140,7 @@ async def astream_state(
     config["metadata"]["langgraph_plan"] = PLAN
     config["metadata"]["langgraph_host"] = HOST
     # attach node counter
-    if not isinstance(graph, RemotePregel):
+    if not isinstance(graph, BaseRemotePregel):
         config["configurable"]["__pregel_node_finished"] = incr_nodes
         # TODO add node tracking for JS graphs
     # attach run_id to config
@@ -142,7 +149,7 @@ async def astream_state(
     # set up state
     checkpoint: CheckpointPayload | None = None
     messages: dict[str, BaseMessageChunk] = {}
-    use_astream_events = "events" in stream_mode or isinstance(graph, RemotePregel)
+    use_astream_events = "events" in stream_mode or isinstance(graph, BaseRemotePregel)
     # yield metadata chunk
     yield "metadata", {"run_id": run_id, "attempt": attempt}
     # stream run
@@ -166,7 +173,7 @@ async def astream_state(
                     break
                 if event.get("tags") and "langsmith:hidden" in event["tags"]:
                     continue
-                if "messages" in stream_mode and isinstance(graph, RemotePregel):
+                if "messages" in stream_mode and isinstance(graph, BaseRemotePregel):
                     if event["event"] == "on_custom_event" and event["name"] in (
                         "messages/complete",
                         "messages/partial",

langgraph_api/utils.py

@@ -17,22 +17,28 @@ AuthContext = contextvars.ContextVar[Auth.types.BaseAuthContext | None](
 
 
 @asynccontextmanager
-async def with_user(user: BaseUser | None = None, auth: AuthCredentials | None = None):
+async def with_user(
+    user: BaseUser | None = None, auth: AuthCredentials | list[str] | None = None
+):
     current = get_auth_ctx()
     set_auth_ctx(user, auth)
     yield
     if current is None:
         return
-    set_auth_ctx(current.user, AuthCredentials(scopes=current.scopes))
+    set_auth_ctx(current.user, AuthCredentials(scopes=current.permissions))
 
 
-def set_auth_ctx(user: BaseUser | None, auth: AuthCredentials | None) -> None:
-    if not user or not auth:
+def set_auth_ctx(
+    user: BaseUser | None, auth: AuthCredentials | list[str] | None
+) -> None:
+    if user is None and auth is None:
         AuthContext.set(None)
     else:
         AuthContext.set(
             Auth.types.BaseAuthContext(
-                permissions=auth.scopes,
+                permissions=(
+                    auth.scopes if isinstance(auth, AuthCredentials) else (auth or [])
+                ),
                 user=user or SimpleUser(""),
             )
         )

{langgraph_api-0.0.14.dist-info → langgraph_api-0.0.16.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langgraph-api
-Version: 0.0.14
+Version: 0.0.16
 Summary: 
 License: Elastic-2.0
 Author: Nuno Campos
@@ -16,11 +16,11 @@ Requires-Dist: jsonschema-rs (>=0.25.0,<0.26.0)
 Requires-Dist: langchain-core (>=0.2.38,<0.4.0)
 Requires-Dist: langgraph (>=0.2.56,<0.3.0)
 Requires-Dist: langgraph-checkpoint (>=2.0.7,<3.0)
-Requires-Dist: langgraph-sdk (>=0.1.48,<0.2.0)
+Requires-Dist: langgraph-sdk (>=0.1.51,<0.2.0)
 Requires-Dist: langsmith (>=0.1.63,<0.3.0)
 Requires-Dist: orjson (>=3.10.1)
 Requires-Dist: pyjwt (>=2.9.0,<3.0.0)
-Requires-Dist: sse-starlette (>=2.1.0,<3.0.0)
+Requires-Dist: sse-starlette (>=2.1.0,<2.2.0)
 Requires-Dist: starlette (>=0.38.6)
 Requires-Dist: structlog (>=24.4.0,<25.0.0)
 Requires-Dist: tenacity (>=8.3.0,<9.0.0)

{langgraph_api-0.0.14.dist-info → langgraph_api-0.0.16.dist-info}/RECORD

@@ -1,15 +1,15 @@
 LICENSE,sha256=ZPwVR73Biwm3sK6vR54djCrhaRiM4cAD2zvOQZV8Xis,3859
 langgraph_api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-langgraph_api/api/__init__.py,sha256=tlMXuqnyJt99aSlUXwR-dS3w5X6sDDczJu4hbm2LP30,2057
-langgraph_api/api/assistants.py,sha256=Cxryr4K4qFeRoT0gQTu-gld_jSPzMDRZRHoazlSBZVo,11585
+langgraph_api/api/__init__.py,sha256=zAdS_0jgjmCJK6E0VwEuNcNRkaknMXfQ2C_OES5tEI4,2066
+langgraph_api/api/assistants.py,sha256=nn-0Q5FTaEbdPq-oesrpVzqu223PDSzeejFy9fd5Xjw,11599
 langgraph_api/api/meta.py,sha256=hueasWpTDQ6xYLo9Bzt2jhNH8XQRzreH8FTeFfnRoxQ,2700
 langgraph_api/api/openapi.py,sha256=AUxfnD5hlRp7s-0g2hBC5dNSNk3HTwOLeJiF489DT44,2762
 langgraph_api/api/runs.py,sha256=wAzPXi_kcYB9BcLBL4FXgkBohWwCPIpe4XERnsnWnsA,16042
-langgraph_api/api/store.py,sha256=y7VIejpsE7rpPF-tiMGBqqBwWPZ1wb3o48th6NUvb5I,3849
+langgraph_api/api/store.py,sha256=VzAJVOwO0IxosBB7km5TTf2rhlWGyPkVz_LpvbxetVY,5437
 langgraph_api/api/threads.py,sha256=taU61XPcCEhBPCYPZcMDsgVDwwWUWJs8p-PrXFXWY48,8661
-langgraph_api/asyncio.py,sha256=XiFEllu-Kg4zAO084npHPYOPnLQRire3V75XrVQYMxE,6023
+langgraph_api/asyncio.py,sha256=2fOlx-cZvuj1gQ867Kw1R_wsBsl9jdHYHcUtK2a-x-U,6264
 langgraph_api/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-langgraph_api/auth/custom.py,sha256=_BlII18X8ji_t8qA9FIUq_ip99dMQGkNscjsuEiLHus,20527
+langgraph_api/auth/custom.py,sha256=g_u7FdKm1Qj8eu_MZdnJeMsI4DlWyU5Mg0rPJzdOTSE,20913
 langgraph_api/auth/langsmith/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langgraph_api/auth/langsmith/backend.py,sha256=InScaL-HYCnxYEauhxU198gRZV9pJn9SzzBoR9Edn7g,2654
 langgraph_api/auth/langsmith/client.py,sha256=eKchvAom7hdkUXauD8vHNceBDDUijrFgdTV8bKd7x4Q,3998
@@ -17,18 +17,24 @@ langgraph_api/auth/middleware.py,sha256=qc7SbaFoeWaqxS1wbjZ2PPQ4iI2p9T0shWL7c6g0
 langgraph_api/auth/noop.py,sha256=vDJmzG2vArJxVzdHePvrJWahEa0dvGnhc2LEMMeiFz0,391
 langgraph_api/auth/studio_user.py,sha256=FzFQRROKDlA9JjtBuwyZvk6Mbwno5M9RVYjDO6FU3F8,186
 langgraph_api/cli.py,sha256=7vQQiD3F50r-8KkbuFjwIz8LLbdKUTd4xZGUJPiO3yQ,11688
-langgraph_api/config.py,sha256=JueNW95UDn7uId3atctyC9BPZTzmUqwF2Gtr2i-MZ-g,2739
+langgraph_api/config.py,sha256=HPNSCb-owhu_sU8KBLbTbKLdGIPGVLcSgdvKFKXg7uE,2816
 langgraph_api/cron_scheduler.py,sha256=CybK-9Jwopi_scObTHRyB7gyb0KjC4gqaT2GLe-WOFg,2587
 langgraph_api/errors.py,sha256=Bu_i5drgNTyJcLiyrwVE_6-XrSU50BHf9TDpttki9wQ,1690
-langgraph_api/graph.py,sha256=zjcjgtlvfPIEJws8RksC6wKvt3g-8IGaJj79ScSs6GE,16561
+langgraph_api/graph.py,sha256=FombjYQkqj8jrXJFEVkl3m2UyFcq5nSVNswR2HoRsQY,16385
 langgraph_api/http.py,sha256=XrbyxpjtfSvnaWWh5ZLGpgZmY83WoDCrP_1GPguNiXI,4712
 langgraph_api/http_logger.py,sha256=Sxo_q-65tElauRvkzVLt9lJojgNdgtcHGBYD0IRyX7M,3146
 langgraph_api/js/.gitignore,sha256=qAah3Fq0HWAlfRj5ktZyC6QRQIsAolGLRGcRukA1XJI,33
-langgraph_api/js/build.mts,sha256=v4ZJFnfBJBuLn8g0q-Uab9sgNtcssXcFEI-CmMoiOBc,1301
-langgraph_api/js/client.mts,sha256=GF34EYtjIKvl9u44PeWhWD_QCbTbrxFQ-BL-7v6P23c,24434
+langgraph_api/js/base.py,sha256=BpE8-xkUp8HFPRjSKx1tfUQubvoV4jYl6OwZdre3veI,209
+langgraph_api/js/build.mts,sha256=sAZXB3xVSoG8exJ1ZEytFyikRmEsXJ_0OlLjDDgD79o,1342
+langgraph_api/js/client.mts,sha256=ksiytm222KTUWj92ZnajqFku_y2AkRmfENmKie5LSPw,22519
+langgraph_api/js/client.new.mts,sha256=9FrArkM20IeD176Q7u5lJNruaQXqAfAdDcqJkF0TPPA,23493
+langgraph_api/js/errors.py,sha256=Cm1TKWlUCwZReDC5AQ6SgNIVGD27Qov2xcgHyf8-GXo,361
 langgraph_api/js/global.d.ts,sha256=zR_zLYfpzyPfxpEFth5RgZoyfGulIXyZYPRf7cU0K0Y,106
-langgraph_api/js/package.json,sha256=nxZ3fmuO4ZiKli087PxrK8p95ZrQKaubQa2wDKRnwsk,791
-langgraph_api/js/remote.py,sha256=rudGN-8kHVuEbnGeDMEZbn__edtqkjxXlrxIuO1xOo0,23323
+langgraph_api/js/package.json,sha256=BGnWhiMMvxocEuPciTq14fEHp5NFmHo6fYV8q62n3t4,840
+langgraph_api/js/remote.py,sha256=D9cqcEgXau-fm_trpNwCHMra5BXntgUa469lgs_a9JQ,622
+langgraph_api/js/remote_new.py,sha256=T_Vr8459bax1C9xxqz_ZYmGivq5Vhspg2Iu9TL0Qc-Q,22707
+langgraph_api/js/remote_old.py,sha256=2a-3ooAYUZs8aPsfnXafbBd4pP7lRmokoU7TiO7P9Js,22546
+langgraph_api/js/schema.py,sha256=7idnv7URlYUdSNMBXQcw7E4SxaPxCq_Oxwnlml8q5ik,408
 langgraph_api/js/server_sent_events.py,sha256=DLgXOHauemt7706vnfDUCG1GI3TidKycSizccdz9KgA,3702
 langgraph_api/js/src/graph.mts,sha256=EO1ITYoKiUykzO_8V8mnQb6NYybooR1VXIovThZzywc,2998
 langgraph_api/js/src/hooks.mjs,sha256=XtktgmIHlls_DsknAuwib-z7TqCm0haRoTXvnkgzMuo,601
@@ -38,35 +44,36 @@ langgraph_api/js/src/schema/types.mts,sha256=SUj0vpvWVbID1mnGr2SUtumDBQkJ9zjfvJd
 langgraph_api/js/src/schema/types.template.mts,sha256=c-FA0Ykzp4KvPyYA6a-hDf60KdQRMyFEjmGVJyD2OPM,2011
 langgraph_api/js/src/utils/importMap.mts,sha256=pX4TGOyUpuuWF82kXcxcv3-8mgusRezOGe6Uklm2O5A,1644
 langgraph_api/js/src/utils/pythonSchemas.mts,sha256=98IW7Z_VP7L_CHNRMb3_MsiV3BgLE2JsWQY_PQcRR3o,685
-langgraph_api/js/src/utils/serde.mts,sha256=5SO-wYPnPa8f-D6HQX5Oy3NX3nuziZM8vQMqc2tuxbk,531
-langgraph_api/js/tests/api.test.mts,sha256=ZfwWmu6RgxMBELwR5PUpGOdVFkeDWlONPx-f_huSRok,52248
-langgraph_api/js/tests/compose-postgres.yml,sha256=7VCpWUgPjCzybf6Gu6pT788sZsxUnTjhbmji6c33cVc,1639
+langgraph_api/js/src/utils/serde.mts,sha256=OuyyO9btvwWd55rU_H4x91dFEJiaPxL-lL9O6Zgo908,742
+langgraph_api/js/tests/api.test.mts,sha256=2EpDEs888pJGdZnsyc76GdMp7uuRxM_SNlHBwITU-5I,55668
+langgraph_api/js/tests/compose-postgres.yml,sha256=pbNfeqVUqhWILBuUdwAgQOYsVU_fgkCVm0YlTgU8og8,1721
 langgraph_api/js/tests/graphs/.gitignore,sha256=26J8MarZNXh7snXD5eTpV3CPFTht5Znv8dtHYCLNfkw,12
-langgraph_api/js/tests/graphs/agent.mts,sha256=i2s0GOnydW88laDGBatYkQnjUe9Q44RNHDhdEGIcT8w,3811
+langgraph_api/js/tests/graphs/agent.mts,sha256=fFHm9vW04UN_2mGcHVHqtFIvPhjyFurBg62DAW-GJd4,3889
+langgraph_api/js/tests/graphs/delay.mts,sha256=CFneKxqI4bGGK0lYjSbe80QirowPQlsRSuhDUKfydhk,703
 langgraph_api/js/tests/graphs/error.mts,sha256=l4tk89449dj1BnEF_0ZcfPt0Ikk1gl8L1RaSnRfr3xo,487
-langgraph_api/js/tests/graphs/langgraph.json,sha256=-wSU_9H2fraq7Tijq_dTuK8SBDYLHsnfrYgi2zYUK2o,155
+langgraph_api/js/tests/graphs/langgraph.json,sha256=frxd7ZWILdeMYSZgUBH6UO-IR7I2YJSOfOlx2mnO1sI,189
 langgraph_api/js/tests/graphs/nested.mts,sha256=4G7jSOSaFVQAza-_ARbK-Iai1biLlF2DIPDZXf7PLIY,1245
 langgraph_api/js/tests/graphs/package.json,sha256=kG5a7jRCnlSQMV2WXUsXegmp5cCWm9F3AOIBUUqPn8A,118
 langgraph_api/js/tests/graphs/weather.mts,sha256=A7mLK3xW8h5B-ZyJNAyX2M2fJJwzPJzXs4DYesJwreQ,1655
 langgraph_api/js/tests/graphs/yarn.lock,sha256=q-1S--E5VWLYtkSv03shqtNzeDDv-N_J-N26FszLsjs,7903
 langgraph_api/js/tests/parser.test.mts,sha256=3zAbboUNhI-cY3hj4Ssr7J-sQXCBTeeI1ItrkG0Ftuk,26257
 langgraph_api/js/tests/utils.mts,sha256=2kTybJ3O7Yfe1q3ehDouqV54ibXkNzsPZ_wBZLJvY-4,421
-langgraph_api/js/yarn.lock,sha256=roj7_0fuKEyeDgQqHIx6CDLjfX73-OsQz342QQlQo_E,65156
+langgraph_api/js/yarn.lock,sha256=JtRgt5AXlsD4qBm1Nrtzxg-TLtZkFWtRKCvyS-V8CLg,103690
 langgraph_api/lifespan.py,sha256=Uj7NV-NqxxD1fgx_umM9pVqclcy-VlqrIxDljyj2he0,1820
 langgraph_api/logging.py,sha256=tiDNrEFwqaIdL5ywZv908OXlzzfXsPCws9GXeoFtBV8,3367
 langgraph_api/metadata.py,sha256=mih2G7ScQxiqyUlbksVXkqR3Oo-pM1b6lXtzOsgR1sw,3044
 langgraph_api/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-langgraph_api/models/run.py,sha256=qGTcgQjnzmXrxer5VPaGHoGwifV1nyE4ZCXtBiZH1bc,9546
+langgraph_api/models/run.py,sha256=qBN_w8mUpSbAZNVL1683_DfZHQ0zvYMNyqGg-g1sz6Y,9625
 langgraph_api/patch.py,sha256=94ddcTSZJe22JcpjxiSNjFZdYVnmeoWjk4IX4iBSoyk,1249
-langgraph_api/queue.py,sha256=7tsbDgv4GlUYieJsrvIJDMQUEok4Eu-n_PIQ93rwKjk,9810
-langgraph_api/route.py,sha256=HnAcWeStCrWNe37YUXIqEsjsrCPCIPGijHG7pM9ga28,4251
-langgraph_api/schema.py,sha256=EiCWRR2GmGrBrOYcuK9SeVQS5b98SdaJlKaqOL7t-WQ,5263
+langgraph_api/queue.py,sha256=nYtcjbqjwvELK5OXxD2aw5BWAlSJ-VPyCXSODMMXIj0,13353
+langgraph_api/route.py,sha256=fM4qYCGbmH0a3_cV8uKocb1sLklehxO6HhdRXqLK6OM,4421
+langgraph_api/schema.py,sha256=4aZCFY-dxd_nTot71bdcd9S8QCIgKajuRyj0p2QfgJ4,5291
 langgraph_api/serde.py,sha256=VoJ7Z1IuqrQGXFzEP1qijAITtWCrmjtVqlCRuScjXJI,3533
 langgraph_api/server.py,sha256=afHDnL6b_fAIu_q4icnK60a74lHTTZOMIe1egdhRXIk,1522
 langgraph_api/sse.py,sha256=2wNodCOP2eg7a9mpSu0S3FQ0CHk2BBV_vv0UtIgJIcc,4034
 langgraph_api/state.py,sha256=8jx4IoTCOjTJuwzuXJKKFwo1VseHjNnw_CCq4x1SW14,2284
-langgraph_api/stream.py,sha256=uK1MFr3hp08o3yE-W5V36CljaPmo97VfpDtexa5eqOQ,11663
-langgraph_api/utils.py,sha256=o7TFlY25IjujeKdXgtyE2mMLPETIlrbOc3w6giYBq2Y,2509
+langgraph_api/stream.py,sha256=Uygx6zcY5Wi9lBhRjtxqVDyLZSF1bsaqxg6mYoYVYcY,11900
+langgraph_api/utils.py,sha256=fMl3DHOQEwAqkFtrnP0Alfbrqw1UvwZ_JVLm-WTSQJk,2654
 langgraph_api/validation.py,sha256=McizHlz-Ez8Jhdbc79mbPSde7GIuf2Jlbjx2yv_l6dA,4475
 langgraph_license/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langgraph_license/middleware.py,sha256=_ODIYzQkymr6W9_Fp9wtf1kAQspnpsmr53xuzyF2GA0,612
@@ -74,15 +81,15 @@ langgraph_license/validation.py,sha256=Uu_G8UGO_WTlLsBEY0gTVWjRR4czYGfw5YAD3HLZo
 langgraph_storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langgraph_storage/checkpoint.py,sha256=V4t2GwYEJdPCHbhq_4Udhlv0TWKDzlMu_rlNPdTDc50,3589
 langgraph_storage/database.py,sha256=Nr5zE9Fur3-tESkqe7xNXMf2QlBuw3H0CUie7jVa6Q4,6003
-langgraph_storage/ops.py,sha256=l6sL3wq9vp2OJwhRbdNkPozi-bi2ma-yXHBNGRbmQzk,67985
+langgraph_storage/ops.py,sha256=7kmfm7EO7YbP_ItEjMvFPKPsM0a2X6RMhjaKof63HaQ,68206
 langgraph_storage/queue.py,sha256=6cTZ0ubHu3S1T43yxHMVOwsQsDaJupByiU0sTUFFls8,3261
 langgraph_storage/retry.py,sha256=uvYFuXJ-T6S1QY1ZwkZHyZQbsvS-Ab68LSbzbUUSI2E,696
 langgraph_storage/store.py,sha256=D-p3cWc_umamkKp-6Cz3cAriSACpvM5nxUIvND6PuxE,2710
 langgraph_storage/ttl_dict.py,sha256=FlpEY8EANeXWKo_G5nmIotPquABZGyIJyk6HD9u6vqY,1533
 logging.json,sha256=3RNjSADZmDq38eHePMm1CbP6qZ71AmpBtLwCmKU9Zgo,379
-openapi.json,sha256=gh6FxpyQqspAuQQH3O22qqGW5owtFj45gyR15QAcS9k,124729
-langgraph_api-0.0.14.dist-info/LICENSE,sha256=ZPwVR73Biwm3sK6vR54djCrhaRiM4cAD2zvOQZV8Xis,3859
-langgraph_api-0.0.14.dist-info/METADATA,sha256=mmOzz3Y5VWe7rlFtMozGNTuOOmiWm5QFn_SCYH8OxAU,4041
-langgraph_api-0.0.14.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-langgraph_api-0.0.14.dist-info/entry_points.txt,sha256=3EYLgj89DfzqJHHYGxPH4A_fEtClvlRbWRUHaXO7hj4,77
-langgraph_api-0.0.14.dist-info/RECORD,,
+openapi.json,sha256=qf2Rw3ieawlAcSJu4mGonh9mNOb6solBD70CGL3w24A,124699
+langgraph_api-0.0.16.dist-info/LICENSE,sha256=ZPwVR73Biwm3sK6vR54djCrhaRiM4cAD2zvOQZV8Xis,3859
+langgraph_api-0.0.16.dist-info/METADATA,sha256=HLMkdfTmxuTMN59uOzDQ4VCRILZvgslETZShl2Mdruw,4041
+langgraph_api-0.0.16.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+langgraph_api-0.0.16.dist-info/entry_points.txt,sha256=3EYLgj89DfzqJHHYGxPH4A_fEtClvlRbWRUHaXO7hj4,77
+langgraph_api-0.0.16.dist-info/RECORD,,

langgraph_storage/ops.py

@@ -1325,7 +1325,10 @@ class Runs(Authenticated):
             thread = Thread(
                 thread_id=thread_id,
                 status="busy",
-                metadata={"graph_id": assistant["graph_id"]},
+                metadata={
+                    "graph_id": assistant["graph_id"],
+                    "assistant_id": str(assistant_id),
+                },
                 config=Runs._merge_jsonb(
                     assistant["config"],
                     config,
@@ -1345,7 +1348,11 @@ class Runs(Authenticated):
             if existing_thread["status"] != "busy":
                 existing_thread["status"] = "busy"
                 existing_thread["metadata"] = Runs._merge_jsonb(
-                    existing_thread["metadata"], {"graph_id": assistant["graph_id"]}
+                    existing_thread["metadata"],
+                    {
+                        "graph_id": assistant["graph_id"],
+                        "assistant_id": str(assistant_id),
+                    },
                 )
                 existing_thread["config"] = Runs._merge_jsonb(
                     assistant["config"],

openapi.json

@@ -22,7 +22,7 @@
       "description": "A run is an invocation of a graph / assistant, with no state or memory persistence."
     },
     {
-      "name": "Crons (Enterprise-only)",
+      "name": "Crons (Plus tier)",
       "description": "A cron is a periodic run that recurs on a given schedule. The repeats can be isolated, or share state in a thread"
     },
     {
@@ -1473,7 +1473,7 @@
     "/threads/{thread_id}/runs/crons": {
       "post": {
         "tags": [
-          "Crons (Enterprise-only)"
+          "Crons (Plus tier)"
         ],
         "summary": "Create Thread Cron",
         "description": "Create a cron to schedule runs on a thread.",
@@ -2058,7 +2058,7 @@
     "/runs/crons": {
       "post": {
         "tags": [
-          "Crons (Enterprise-only)"
+          "Crons (Plus tier)"
         ],
         "summary": "Create Cron",
         "description": "Create a cron to schedule runs on new threads.",
@@ -2110,7 +2110,7 @@
     "/runs/crons/search": {
       "post": {
         "tags": [
-          "Crons (Enterprise-only)"
+          "Crons (Plus tier)"
         ],
         "summary": "Search Crons",
         "description": "Search all active crons",
@@ -2399,7 +2399,7 @@
     "/runs/crons/{cron_id}": {
       "delete": {
         "tags": [
-          "Crons (Enterprise-only)"
+          "Crons (Plus tier)"
         ],
         "summary": "Delete Cron",
         "description": "Delete a cron by ID.",