langgraph-api 0.0.11__py3-none-any.whl → 0.0.13__py3-none-any.whl

langgraph_api/api/assistants.py

@@ -121,28 +121,27 @@ async def get_assistant_graph(
         assistant_ = await Assistants.get(conn, assistant_id)
     assistant = await fetchone(assistant_)
     config = await ajson_loads(assistant["config"])
-    graph = await get_graph(assistant["graph_id"], config)
-
-    xray: bool | int = False
-    xray_query = request.query_params.get("xray")
-    if xray_query:
-        if xray_query in ("true", "True"):
-            xray = True
-        elif xray_query in ("false", "False"):
-            xray = False
-        else:
-            try:
-                xray = int(xray_query)
-            except ValueError:
-                raise HTTPException(422, detail="Invalid xray value") from None
-
-            if xray <= 0:
-                raise HTTPException(422, detail="Invalid xray value") from None
-
-    if isinstance(graph, RemotePregel):
-        drawable_graph = await graph.fetch_graph(xray=xray)
-        return ApiResponse(drawable_graph.to_json())
-    return ApiResponse(graph.get_graph(xray=xray).to_json())
+    async with get_graph(assistant["graph_id"], config) as graph:
+        xray: bool | int = False
+        xray_query = request.query_params.get("xray")
+        if xray_query:
+            if xray_query in ("true", "True"):
+                xray = True
+            elif xray_query in ("false", "False"):
+                xray = False
+            else:
+                try:
+                    xray = int(xray_query)
+                except ValueError:
+                    raise HTTPException(422, detail="Invalid xray value") from None
+
+                if xray <= 0:
+                    raise HTTPException(422, detail="Invalid xray value") from None
+
+        if isinstance(graph, RemotePregel):
+            drawable_graph = await graph.fetch_graph(xray=xray)
+            return ApiResponse(drawable_graph.to_json())
+        return ApiResponse(graph.get_graph(xray=xray).to_json())
 
 
 @retry_db
@@ -156,29 +155,29 @@ async def get_assistant_subgraphs(
         assistant_ = await Assistants.get(conn, assistant_id)
     assistant = await fetchone(assistant_)
     config = await ajson_loads(assistant["config"])
-    graph = await get_graph(assistant["graph_id"], config)
-    namespace = request.path_params.get("namespace")
+    async with get_graph(assistant["graph_id"], config) as graph:
+        namespace = request.path_params.get("namespace")
+
+        if isinstance(graph, RemotePregel):
+            return ApiResponse(
+                await graph.fetch_subgraphs(
+                    namespace=namespace,
+                    recurse=request.query_params.get("recurse", "False")
+                    in ("true", "True"),
+                )
+            )
 
-    if isinstance(graph, RemotePregel):
         return ApiResponse(
-            await graph.fetch_subgraphs(
-                namespace=namespace,
-                recurse=request.query_params.get("recurse", "False")
-                in ("true", "True"),
-            )
+            {
+                ns: _graph_schemas(subgraph)
+                async for ns, subgraph in graph.aget_subgraphs(
+                    namespace=namespace,
+                    recurse=request.query_params.get("recurse", "False")
+                    in ("true", "True"),
+                )
+            }
         )
 
-    return ApiResponse(
-        {
-            ns: _graph_schemas(subgraph)
-            async for ns, subgraph in graph.aget_subgraphs(
-                namespace=namespace,
-                recurse=request.query_params.get("recurse", "False")
-                in ("true", "True"),
-            )
-        }
-    )
-
 
 @retry_db
 async def get_assistant_schemas(
@@ -191,48 +190,47 @@ async def get_assistant_schemas(
         assistant_ = await Assistants.get(conn, assistant_id)
     assistant = await fetchone(assistant_)
     config = await ajson_loads(assistant["config"])
-    graph = await get_graph(assistant["graph_id"], config)
+    async with get_graph(assistant["graph_id"], config) as graph:
+        if isinstance(graph, RemotePregel):
+            schemas = await graph.fetch_state_schema()
+            return ApiResponse(
+                {
+                    "graph_id": assistant["graph_id"],
+                    "input_schema": schemas.get("input"),
+                    "output_schema": schemas.get("output"),
+                    "state_schema": schemas.get("state"),
+                    "config_schema": schemas.get("config"),
+                }
+            )
+
+        try:
+            input_schema = graph.get_input_schema().schema()
+        except Exception:
+            input_schema = None
+        try:
+            output_schema = graph.get_output_schema().schema()
+        except Exception:
+            output_schema = None
 
-    if isinstance(graph, RemotePregel):
-        schemas = await graph.fetch_state_schema()
+        state_schema = _state_jsonschema(graph)
+        try:
+            config_schema = (
+                graph.config_schema().__fields__["configurable"].annotation.schema()
+                if "configurable" in graph.config_schema().__fields__
+                else {}
+            )
+        except Exception:
+            config_schema = None
         return ApiResponse(
             {
                 "graph_id": assistant["graph_id"],
-                "input_schema": schemas.get("input"),
-                "output_schema": schemas.get("output"),
-                "state_schema": schemas.get("state"),
-                "config_schema": schemas.get("config"),
+                "input_schema": input_schema,
+                "output_schema": output_schema,
+                "state_schema": state_schema,
+                "config_schema": config_schema,
             }
         )
 
-    try:
-        input_schema = graph.get_input_schema().schema()
-    except Exception:
-        input_schema = None
-    try:
-        output_schema = graph.get_output_schema().schema()
-    except Exception:
-        output_schema = None
-
-    state_schema = _state_jsonschema(graph)
-    try:
-        config_schema = (
-            graph.config_schema().__fields__["configurable"].annotation.schema()
-            if "configurable" in graph.config_schema().__fields__
-            else {}
-        )
-    except Exception:
-        config_schema = None
-    return ApiResponse(
-        {
-            "graph_id": assistant["graph_id"],
-            "input_schema": input_schema,
-            "output_schema": output_schema,
-            "state_schema": state_schema,
-            "config_schema": config_schema,
-        }
-    )
-
 
 @retry_db
 async def patch_assistant(

langgraph_api/api/openapi.py

@@ -32,7 +32,7 @@ def get_openapi_spec() -> str:
         openapi["components"]["securitySchemes"] = {
             "x-api-key": {"type": "apiKey", "in": "header", "name": "x-api-key"}
         }
-    elif LANGGRAPH_AUTH_TYPE == "custom":
+    if LANGGRAPH_AUTH:
         # Allow user to specify OpenAPI security configuration
         if isinstance(LANGGRAPH_AUTH, dict) and "openapi" in LANGGRAPH_AUTH:
             openapi_config = LANGGRAPH_AUTH["openapi"]

langgraph_api/auth/custom.py

@@ -24,7 +24,8 @@ from starlette.requests import HTTPConnection, Request
 from starlette.responses import Response
 
 from langgraph_api.auth.langsmith.backend import LangsmithAuthBackend
-from langgraph_api.config import LANGGRAPH_AUTH
+from langgraph_api.auth.studio_user import StudioUser
+from langgraph_api.config import LANGGRAPH_AUTH, LANGGRAPH_AUTH_TYPE
 
 logger = structlog.stdlib.get_logger(__name__)
 
@@ -91,12 +92,23 @@ async def handle_event(
     handler = _get_handler(auth, ctx)
     if not handler:
         return
-
-    result = await handler(ctx=ctx, value=value)
+    try:
+        result = await handler(ctx=ctx, value=value)
+    except Auth.exceptions.HTTPException as e:
+        raise HTTPException(
+            status_code=e.status_code,
+            detail=e.detail,
+            headers=dict(e.headers) if e.headers else None,
+        ) from e
+    except AssertionError as e:
+        raise HTTPException(
+            status_code=403,
+            detail=str(e),
+        ) from e
 
     if result in (None, True):
         return
-    if result is True:
+    if result is False:
         raise HTTPException(403, "Forbidden")
 
     if not isinstance(result, dict):
@@ -111,30 +123,31 @@ async def handle_event(
 class CustomAuthBackend(AuthenticationBackend):
     def __init__(
         self,
-        fn: (
-            Callable[
-                [Request],
-                Awaitable[tuple[list[str], Any]],
-            ]
-            | None
-        ) = None,
+        fn: Callable[
+            [Request],
+            Awaitable[tuple[list[str], Any]],
+        ],
         disable_studio_auth: bool = False,
     ):
-        if fn is None:
-            self.fn = None
-        elif not inspect.iscoroutinefunction(fn):
+        if not inspect.iscoroutinefunction(fn):
             self.fn = functools.partial(run_in_threadpool, fn)
         else:
             self.fn = fn
         self._param_names = (
-            get_named_arguments(fn, supported_params=SUPPORTED_PARAMETERS)
+            _get_named_arguments(fn, supported_params=SUPPORTED_PARAMETERS)
             if fn
             else None
         )
+        self.ls_auth = None
         if not disable_studio_auth:
-            self.ls_auth = LangsmithAuthBackend()
-        else:
-            self.ls_auth = None
+            if LANGGRAPH_AUTH_TYPE == "langsmith":
+                self.ls_auth = LangsmithAuthBackend()
+            elif (
+                LANGGRAPH_AUTH_TYPE == "noop"
+                and (auth_type := os.environ.get("LANGSMITH_LANGGRAPH_API_VARIANT"))
+                and auth_type == "local_dev"
+            ):
+                self.ls_auth = StudioNoopAuthBackend()
 
     def __str__(self):
         return (
@@ -160,8 +173,24 @@ class CustomAuthBackend(AuthenticationBackend):
             )
             response = await self.fn(**args)
             return _normalize_auth_response(response)
+        except (AuthenticationError, HTTPException):
+            raise
+        except Auth.exceptions.HTTPException as e:
+            raise HTTPException(
+                status_code=e.status_code,
+                detail=e.detail,
+                headers=dict(e.headers) if e.headers else None,
+            ) from None
         except AssertionError as e:
             raise AuthenticationError(str(e)) from None
+        except Exception as e:
+            await logger.aerror("Error authenticating request", exc_info=e)
+            status_code = getattr(e, "status_code", 401)
+            detail = getattr(e, "detail", "Unauthorized")
+            headers = getattr(e, "headers", None)
+            raise HTTPException(
+                status_code=status_code, detail=detail, headers=headers
+            ) from None
 
 
 def _get_custom_auth_middleware(
@@ -174,8 +203,26 @@ def _get_custom_auth_middleware(
         path = config.get("path")
         disable_studio_auth = config.get("disable_studio_auth", disable_studio_auth)
     auth_instance = _get_auth_instance(path)
+    if auth_instance is None:
+        raise ValueError(
+            f"Custom Auth object not found at path: {path}. "
+            "Check that the path is correct and the file is available."
+            "Auth objects are created like:\n"
+            "from langgraph_sdk import Auth\n"
+            "auth = Auth()"
+        )
+    if auth_instance._authenticate_handler is None:
+        raise ValueError(
+            f"Custom Auth object at path: {path} does not have an authenticate handler."
+            "Please define one like:\n"
+            "from langgraph_sdk import Auth\n"
+            "auth = Auth()\n"
+            "@auth.authenticate\n"
+            "async def authenticate(request):\n"
+            '    return "my-user-id"'
+        )
     result = CustomAuthBackend(
-        auth_instance._authenticate_handler if auth_instance else None,
+        auth_instance._authenticate_handler,
         disable_studio_auth,
     )
     logger.info(f"Loaded custom auth middleware: {str(result)}")
@@ -288,7 +335,7 @@ def _solve_fastapi_dependencies(
 
     _param_names = {
         k
-        for k in get_named_arguments(
+        for k in _get_named_arguments(
             fn, supported_params=SUPPORTED_PARAMETERS | dict(deps)
         )
         if k not in dependents
@@ -535,7 +582,14 @@ def _get_handler(auth: Auth, ctx: Auth.types.AuthContext) -> Auth.types.Handler
     return None
 
 
-def get_named_arguments(fn: Callable, supported_params: dict) -> set[str]:
+class StudioNoopAuthBackend(AuthenticationBackend):
+    async def authenticate(
+        self, conn: HTTPConnection
+    ) -> tuple[AuthCredentials, BaseUser] | None:
+        return AuthCredentials(), StudioUser("langgraph-studio-user")
+
+
+def _get_named_arguments(fn: Callable, supported_params: dict) -> set[str]:
     """Get the named arguments that a function accepts, ensuring they're supported."""
     sig = inspect.signature(fn)
     # Check for unsupported required parameters

langgraph_api/auth/langsmith/backend.py

@@ -5,11 +5,11 @@ from starlette.authentication import (
     AuthenticationBackend,
     AuthenticationError,
     BaseUser,
-    SimpleUser,
 )
 from starlette.requests import HTTPConnection
 
 from langgraph_api.auth.langsmith.client import auth_client
+from langgraph_api.auth.studio_user import StudioUser
 from langgraph_api.config import (
     LANGSMITH_AUTH_VERIFY_TENANT_ID,
     LANGSMITH_TENANT_ID,
@@ -64,4 +64,6 @@ class LangsmithAuthBackend(AuthenticationBackend):
                 if auth_dict["tenant_id"] != LANGSMITH_TENANT_ID:
                     raise AuthenticationError("Invalid tenant ID")
 
-        return AuthCredentials(["authenticated"]), SimpleUser(auth_dict.get("user_id"))
+        return AuthCredentials(["authenticated"]), StudioUser(
+            auth_dict.get("user_id"), is_authenticated=True
+        )

langgraph_api/auth/middleware.py

@@ -8,23 +8,23 @@ from starlette.requests import HTTPConnection
 from starlette.responses import JSONResponse
 from starlette.types import Receive, Scope, Send
 
-from langgraph_api.config import LANGGRAPH_AUTH_TYPE
+from langgraph_api.config import LANGGRAPH_AUTH, LANGGRAPH_AUTH_TYPE
 
 logger = structlog.stdlib.get_logger(__name__)
 
 
 def get_auth_backend():
     logger.info(f"Using auth of type={LANGGRAPH_AUTH_TYPE}")
+    if LANGGRAPH_AUTH:
+        from langgraph_api.auth.custom import get_custom_auth_middleware
+
+        return get_custom_auth_middleware()
+
     if LANGGRAPH_AUTH_TYPE == "langsmith":
         from langgraph_api.auth.langsmith.backend import LangsmithAuthBackend
 
         return LangsmithAuthBackend()
 
-    if LANGGRAPH_AUTH_TYPE == "custom":
-        from langgraph_api.auth.custom import get_custom_auth_middleware
-
-        return get_custom_auth_middleware()
-
     from langgraph_api.auth.noop import NoopAuthBackend
 
     return NoopAuthBackend()

langgraph_api/auth/studio_user.py

@@ -0,0 +1,6 @@
+from langgraph_sdk.auth.types import StudioUser as StudioUserBase
+from starlette.authentication import BaseUser
+
+
+class StudioUser(StudioUserBase, BaseUser):
+    """StudioUser class."""

langgraph_api/config.py

@@ -51,9 +51,6 @@ LANGSMITH_AUTH_VERIFY_TENANT_ID = env(
     default=LANGSMITH_TENANT_ID is not None,
 )
 
-if LANGGRAPH_AUTH:
-    LANGGRAPH_AUTH_TYPE = "custom"
-
 
 if LANGGRAPH_AUTH_TYPE == "langsmith":
     LANGSMITH_AUTH_ENDPOINT = env("LANGSMITH_AUTH_ENDPOINT", cast=str)

langgraph_api/graph.py

@@ -6,10 +6,11 @@ import inspect
 import json
 import os
 import sys
-from collections.abc import Callable
+from collections.abc import AsyncIterator, Callable
+from contextlib import asynccontextmanager
 from itertools import filterfalse
 from random import choice
-from typing import TYPE_CHECKING, NamedTuple
+from typing import TYPE_CHECKING, Any, NamedTuple
 from uuid import UUID, uuid5
 
 import structlog
@@ -59,39 +60,58 @@ async def register_graph(graph_id: str, graph: GraphValue, config: dict | None)
         )
 
 
+@asynccontextmanager
+async def _generate_graph(value: Any) -> AsyncIterator[Any]:
+    """Yield a graph object regardless of its type."""
+    if isinstance(value, Pregel | RemotePregel):
+        yield value
+    elif hasattr(value, "__aenter__") and hasattr(value, "__aexit__"):
+        async with value as ctx_value:
+            yield ctx_value
+    elif hasattr(value, "__enter__") and hasattr(value, "__exit__"):
+        with value as ctx_value:
+            yield ctx_value
+    elif asyncio.iscoroutine(value):
+        yield await value
+    else:
+        yield value
+
+
+@asynccontextmanager
 async def get_graph(
     graph_id: str,
     config: Config,
     *,
     checkpointer: BaseCheckpointSaver | None = None,
     store: BaseStore | None = None,
-) -> Pregel:
+) -> AsyncIterator[Pregel]:
     """Return the runnable."""
     assert_graph_exists(graph_id)
     value = GRAPHS[graph_id]
     if graph_id in FACTORY_ACCEPTS_CONFIG:
         value = value(config) if FACTORY_ACCEPTS_CONFIG[graph_id] else value()
-        if asyncio.iscoroutine(value):
-            value = await value
-    if isinstance(value, Graph):
-        value = value.compile()
-    if not isinstance(value, Pregel) and not isinstance(value, RemotePregel):
-        raise HTTPException(
-            status_code=424,
-            detail=f"Graph '{graph_id}' is not valid. Review graph registration.",
-        )
-    if isinstance(value, RemotePregel):
-        value.checkpointer = checkpointer
-        value.name = graph_id
-        return value
-
-    update = {
-        "checkpointer": checkpointer,
-        "store": store,
-    }
-    if value.name == "LangGraph":
-        update["name"] = graph_id
-    return value.copy(update=update)
+
+    async with _generate_graph(value) as graph_obj:
+        if isinstance(graph_obj, Graph):
+            graph_obj = graph_obj.compile()
+        if not isinstance(graph_obj, Pregel | RemotePregel):
+            raise HTTPException(
+                status_code=424,
+                detail=f"Graph '{graph_id}' is not valid. Review graph registration.",
+            )
+        if isinstance(graph_obj, RemotePregel):
+            graph_obj.checkpointer = checkpointer
+            graph_obj.name = graph_id
+            yield graph_obj
+            return
+
+        update = {
+            "checkpointer": checkpointer,
+            "store": store,
+        }
+        if graph_obj.name == "LangGraph":
+            update["name"] = graph_id
+        yield graph_obj.copy(update=update)
 
 
 def graph_exists(graph_id: str) -> bool:

langgraph_api/stream.py

@@ -77,11 +77,14 @@ def _map_cmd(cmd: RunCommand) -> Command:
 
     return Command(
         update=cmd.get("update"),
-        goto=[
-            it if isinstance(it, str) else Send(it["node"], it["input"]) for it in goto
-        ]
-        if goto
-        else None,
+        goto=(
+            [
+                it if isinstance(it, str) else Send(it["node"], it["input"])
+                for it in goto
+            ]
+            if goto
+            else None
+        ),
         resume=cmd.get("resume"),
     )
 
@@ -104,11 +107,13 @@ async def astream_state(
     subgraphs = kwargs.get("subgraphs", False)
     temporary = kwargs.pop("temporary", False)
     config = kwargs.pop("config")
-    graph = await get_graph(
-        config["configurable"]["graph_id"],
-        config,
-        store=Store(),
-        checkpointer=None if temporary else Checkpointer(conn),
+    graph = await stack.enter_async_context(
+        get_graph(
+            config["configurable"]["graph_id"],
+            config,
+            store=Store(),
+            checkpointer=None if temporary else Checkpointer(conn),
+        )
     )
     input = kwargs.pop("input")
     if cmd := kwargs.pop("command"):

{langgraph_api-0.0.11.dist-info → langgraph_api-0.0.13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langgraph-api
-Version: 0.0.11
+Version: 0.0.13
 Summary: 
 License: Elastic-2.0
 Author: Nuno Campos
@@ -16,7 +16,7 @@ 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.47,<0.2.0)
+Requires-Dist: langgraph-sdk (>=0.1.48,<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)

{langgraph_api-0.0.11.dist-info → langgraph_api-0.0.13.dist-info}/RECORD

@@ -1,25 +1,26 @@
 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=3v4v7kLmlb2meSAnNt73toijnaSikbJgH9Jhb6IL04g,11270
+langgraph_api/api/assistants.py,sha256=Cxryr4K4qFeRoT0gQTu-gld_jSPzMDRZRHoazlSBZVo,11585
 langgraph_api/api/meta.py,sha256=hueasWpTDQ6xYLo9Bzt2jhNH8XQRzreH8FTeFfnRoxQ,2700
-langgraph_api/api/openapi.py,sha256=3eRo3V6Pni8DjqHI_MNLn8F5CEOOGVBMXPEffft8Ubo,2781
+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/threads.py,sha256=taU61XPcCEhBPCYPZcMDsgVDwwWUWJs8p-PrXFXWY48,8661
 langgraph_api/asyncio.py,sha256=XiFEllu-Kg4zAO084npHPYOPnLQRire3V75XrVQYMxE,6023
 langgraph_api/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-langgraph_api/auth/custom.py,sha256=8jyZz-HOC4NwpDASVAD2fP8priQSw8uEjZ8VPJNC5EE,18225
+langgraph_api/auth/custom.py,sha256=_BlII18X8ji_t8qA9FIUq_ip99dMQGkNscjsuEiLHus,20527
 langgraph_api/auth/langsmith/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-langgraph_api/auth/langsmith/backend.py,sha256=uHeb5-h13NIjrX_LDAvfWYr3zpbJvlvbdUffch48hbM,2571
+langgraph_api/auth/langsmith/backend.py,sha256=InScaL-HYCnxYEauhxU198gRZV9pJn9SzzBoR9Edn7g,2654
 langgraph_api/auth/langsmith/client.py,sha256=eKchvAom7hdkUXauD8vHNceBDDUijrFgdTV8bKd7x4Q,3998
-langgraph_api/auth/middleware.py,sha256=eHj4D2p2ASpMKzoTgMkEUXMhuubQdg9Jnq0gQS9qbvE,1637
+langgraph_api/auth/middleware.py,sha256=qc7SbaFoeWaqxS1wbjZ2PPQ4iI2p9T0shWL7c6g0ed4,1636
 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=m3cf13AS9HVF84deJ3-9mmNTJ5GSVqcukES-FNbDbvo,2794
+langgraph_api/config.py,sha256=JueNW95UDn7uId3atctyC9BPZTzmUqwF2Gtr2i-MZ-g,2739
 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=LXTo2lGnku3KPBiC9ssh4NcSvieT4Ks2vJuhPaqBCpY,15807
+langgraph_api/graph.py,sha256=zjcjgtlvfPIEJws8RksC6wKvt3g-8IGaJj79ScSs6GE,16561
 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
@@ -64,7 +65,7 @@ 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=u0gjbCrmYvVw8Ux6DgsYTojLCHSwM4Pi-0LhSLGY4HM,11546
+langgraph_api/stream.py,sha256=uK1MFr3hp08o3yE-W5V36CljaPmo97VfpDtexa5eqOQ,11663
 langgraph_api/utils.py,sha256=o7TFlY25IjujeKdXgtyE2mMLPETIlrbOc3w6giYBq2Y,2509
 langgraph_api/validation.py,sha256=McizHlz-Ez8Jhdbc79mbPSde7GIuf2Jlbjx2yv_l6dA,4475
 langgraph_license/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -73,15 +74,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=W3NcQbY1Q8EpsIs4HjGY5Yx2In0TYc9_D4SKdZYPaDQ,67679
+langgraph_storage/ops.py,sha256=vinc095b_eZYSWAfK_trZbmb_IIGcp55lWJEzqRwTPU,67967
 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=UxAGHZYM4PgNd48TSZt7f2lVuyPUkDadxBBhRy5jcmk,124512
-langgraph_api-0.0.11.dist-info/LICENSE,sha256=ZPwVR73Biwm3sK6vR54djCrhaRiM4cAD2zvOQZV8Xis,3859
-langgraph_api-0.0.11.dist-info/METADATA,sha256=dIfDLkeyakteByG5V-curloWZyMGWy77SUf1J3gtBok,4041
-langgraph_api-0.0.11.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-langgraph_api-0.0.11.dist-info/entry_points.txt,sha256=3EYLgj89DfzqJHHYGxPH4A_fEtClvlRbWRUHaXO7hj4,77
-langgraph_api-0.0.11.dist-info/RECORD,,
+openapi.json,sha256=gh6FxpyQqspAuQQH3O22qqGW5owtFj45gyR15QAcS9k,124729
+langgraph_api-0.0.13.dist-info/LICENSE,sha256=ZPwVR73Biwm3sK6vR54djCrhaRiM4cAD2zvOQZV8Xis,3859
+langgraph_api-0.0.13.dist-info/METADATA,sha256=F_D67LIP0IP8jFVJ5wUwieyIqFuAP_mtrDNe8uZS8Rs,4041
+langgraph_api-0.0.13.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+langgraph_api-0.0.13.dist-info/entry_points.txt,sha256=3EYLgj89DfzqJHHYGxPH4A_fEtClvlRbWRUHaXO7hj4,77
+langgraph_api-0.0.13.dist-info/RECORD,,

langgraph_storage/ops.py

@@ -976,17 +976,17 @@ class Threads(Authenticated):
             if graph_id := metadata.get("graph_id"):
                 # format latest checkpoint for response
                 checkpointer.latest_iter = checkpoint
-                graph = await get_graph(
+                async with get_graph(
                     graph_id, thread_config, checkpointer=checkpointer
-                )
-                result = await graph.aget_state(config, subgraphs=subgraphs)
-                if (
-                    result.metadata is not None
-                    and "checkpoint_ns" in result.metadata
-                    and result.metadata["checkpoint_ns"] == ""
-                ):
-                    result.metadata.pop("checkpoint_ns")
-                return result
+                ) as graph:
+                    result = await graph.aget_state(config, subgraphs=subgraphs)
+                    if (
+                        result.metadata is not None
+                        and "checkpoint_ns" in result.metadata
+                        and result.metadata["checkpoint_ns"] == ""
+                    ):
+                        result.metadata.pop("checkpoint_ns")
+                    return result
             else:
                 return StateSnapshot(
                     values={},
@@ -1034,32 +1034,36 @@ class Threads(Authenticated):
                 config["configurable"].setdefault("graph_id", graph_id)
 
                 checkpointer.latest_iter = checkpoint
-                graph = await get_graph(
+                async with get_graph(
                     graph_id, thread_config, checkpointer=checkpointer
-                )
-                update_config = config.copy()
-                update_config["configurable"] = {
-                    **config["configurable"],
-                    "checkpoint_ns": config["configurable"].get("checkpoint_ns", ""),
-                }
-                next_config = await graph.aupdate_state(
-                    update_config, values, as_node=as_node
-                )
+                ) as graph:
+                    update_config = config.copy()
+                    update_config["configurable"] = {
+                        **config["configurable"],
+                        "checkpoint_ns": config["configurable"].get(
+                            "checkpoint_ns", ""
+                        ),
+                    }
+                    next_config = await graph.aupdate_state(
+                        update_config, values, as_node=as_node
+                    )
 
-                # Get current state
-                state = await Threads.State.get(conn, config, subgraphs=False, ctx=ctx)
-                # Update thread values
-                for thread in conn.store["threads"]:
-                    if thread["thread_id"] == thread_id:
-                        thread["values"] = state.values
-                        break
-
-                return ThreadUpdateResponse(
-                    checkpoint=next_config["configurable"],
-                    # Including deprecated fields
-                    configurable=next_config["configurable"],
-                    checkpoint_id=next_config["configurable"]["checkpoint_id"],
-                )
+                    # Get current state
+                    state = await Threads.State.get(
+                        conn, config, subgraphs=False, ctx=ctx
+                    )
+                    # Update thread values
+                    for thread in conn.store["threads"]:
+                        if thread["thread_id"] == thread_id:
+                            thread["values"] = state.values
+                            break
+
+                    return ThreadUpdateResponse(
+                        checkpoint=next_config["configurable"],
+                        # Including deprecated fields
+                        configurable=next_config["configurable"],
+                        checkpoint_id=next_config["configurable"]["checkpoint_id"],
+                    )
             else:
                 raise HTTPException(status_code=400, detail="Thread has no graph ID.")
 
@@ -1094,25 +1098,24 @@ class Threads(Authenticated):
             thread_config = thread["config"]
             # If graph_id exists, get state history
             if graph_id := thread_metadata.get("graph_id"):
-                graph = await get_graph(
+                async with get_graph(
                     graph_id, thread_config, checkpointer=Checkpointer(conn)
-                )
-
-                # Convert before parameter if it's a string
-                before_param = (
-                    {"configurable": {"checkpoint_id": before}}
-                    if isinstance(before, str)
-                    else before
-                )
-
-                states = [
-                    state
-                    async for state in graph.aget_state_history(
-                        config, limit=limit, filter=metadata, before=before_param
+                ) as graph:
+                    # Convert before parameter if it's a string
+                    before_param = (
+                        {"configurable": {"checkpoint_id": before}}
+                        if isinstance(before, str)
+                        else before
                     )
-                ]
 
-                return states
+                    states = [
+                        state
+                        async for state in graph.aget_state_history(
+                            config, limit=limit, filter=metadata, before=before_param
+                        )
+                    ]
+
+                    return states
 
             return []
 

openapi.json

@@ -3242,7 +3242,11 @@
         "description": "The command to run.",
         "properties": {
           "update": {
-            "type": "object",
+            "type": [
+              "object",
+              "array",
+              "null"
+            ],
             "title": "Update",
             "description": "An update to the state."
           },
@@ -3268,13 +3272,22 @@
                   "$ref": "#/components/schemas/Send"
                 }
               },
-              { "type": "string" },
-              { "type": "array", "items": { "type": "string" } },
-              { "type": "null" }
+              {
+                "type": "string"
+              },
+              {
+                "type": "array",
+                "items": {
+                  "type": "string"
+                }
+              },
+              {
+                "type": "null"
+              }
             ],
             "title": "Goto",
             "description": "Name of the node(s) to navigate to next or node(s) to be executed with a provided input."
-        }
+          }
         }
       },
       "RunCreateStateful": {