langgraph-api 0.2.20__py3-none-any.whl → 0.2.23__py3-none-any.whl

langgraph_api/__init__.py

@@ -1 +1 @@
-__version__ = "0.2.20"
+__version__ = "0.2.23"

langgraph_api/api/assistants.py

@@ -21,13 +21,24 @@ from langgraph_api.validation import (
     AssistantVersionChange,
     AssistantVersionsSearchRequest,
 )
+from langgraph_runtime.checkpoint import Checkpointer
 from langgraph_runtime.database import connect
 from langgraph_runtime.ops import Assistants
 from langgraph_runtime.retry import retry_db
+from langgraph_runtime.store import Store
 
 logger = structlog.stdlib.get_logger(__name__)
 
 
+EXCLUDED_CONFIG_SCHEMA = (
+    "__pregel_checkpointer",
+    "__pregel_store",
+    "checkpoint_id",
+    "checkpoint_ns",
+    "thread_id",
+)
+
+
 def _get_configurable_jsonschema(graph: Pregel) -> dict:
     """Get the JSON schema for the configurable part of the graph.
 
@@ -52,6 +63,9 @@ def _get_configurable_jsonschema(graph: Pregel) -> dict:
     if model_fields is not None and "configurable" in model_fields:
         configurable = TypeAdapter(model_fields["configurable"].annotation)
         json_schema = configurable.json_schema()
+        if json_schema:
+            for key in EXCLUDED_CONFIG_SCHEMA:
+                json_schema["properties"].pop(key, None)
         # The type name of the configurable type is not preserved.
         # We'll add it back to the schema if we can.
         if hasattr(graph, "config_type") and graph.config_type is not None:
@@ -174,36 +188,41 @@ async def get_assistant_graph(
     validate_uuid(assistant_id, "Invalid assistant ID: must be a UUID")
     async with connect() as conn:
         assistant_ = await Assistants.get(conn, assistant_id)
-    assistant = await fetchone(assistant_)
-    config = await ajson_loads(assistant["config"])
-    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, BaseRemotePregel):
-            drawable_graph = await graph.fetch_graph(xray=xray)
-            return ApiResponse(drawable_graph.to_json())
-
-        try:
-            drawable_graph = await graph.aget_graph(xray=xray)
-            return ApiResponse(drawable_graph.to_json())
-        except NotImplementedError:
-            raise HTTPException(
-                422, detail="The graph does not support visualization"
-            ) from None
+        assistant = await fetchone(assistant_)
+        config = await ajson_loads(assistant["config"])
+        async with get_graph(
+            assistant["graph_id"],
+            config,
+            checkpointer=Checkpointer(conn),
+            store=Store(),
+        ) 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, BaseRemotePregel):
+                drawable_graph = await graph.fetch_graph(xray=xray)
+                return ApiResponse(drawable_graph.to_json())
+
+            try:
+                drawable_graph = await graph.aget_graph(xray=xray)
+                return ApiResponse(drawable_graph.to_json())
+            except NotImplementedError:
+                raise HTTPException(
+                    422, detail="The graph does not support visualization"
+                ) from None
 
 
 @retry_db
@@ -215,35 +234,40 @@ async def get_assistant_subgraphs(
     validate_uuid(assistant_id, "Invalid assistant ID: must be a UUID")
     async with connect() as conn:
         assistant_ = await Assistants.get(conn, assistant_id)
-    assistant = await fetchone(assistant_)
-    config = await ajson_loads(assistant["config"])
-    async with get_graph(assistant["graph_id"], config) as graph:
-        namespace = request.path_params.get("namespace")
-
-        if isinstance(graph, BaseRemotePregel):
-            return ApiResponse(
-                await graph.fetch_subgraphs(
-                    namespace=namespace,
-                    recurse=request.query_params.get("recurse", "False")
-                    in ("true", "True"),
-                )
-            )
-
-        try:
-            return ApiResponse(
-                {
-                    ns: _graph_schemas(subgraph)
-                    async for ns, subgraph in graph.aget_subgraphs(
+        assistant = await fetchone(assistant_)
+        config = await ajson_loads(assistant["config"])
+        async with get_graph(
+            assistant["graph_id"],
+            config,
+            checkpointer=Checkpointer(conn),
+            store=Store(),
+        ) as graph:
+            namespace = request.path_params.get("namespace")
+
+            if isinstance(graph, BaseRemotePregel):
+                return ApiResponse(
+                    await graph.fetch_subgraphs(
                         namespace=namespace,
                         recurse=request.query_params.get("recurse", "False")
                         in ("true", "True"),
                     )
-                }
-            )
-        except NotImplementedError:
-            raise HTTPException(
-                422, detail="The graph does not support visualization"
-            ) from None
+                )
+
+            try:
+                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"),
+                        )
+                    }
+                )
+            except NotImplementedError:
+                raise HTTPException(
+                    422, detail="The graph does not support visualization"
+                ) from None
 
 
 @retry_db
@@ -255,54 +279,60 @@ async def get_assistant_schemas(
     validate_uuid(assistant_id, "Invalid assistant ID: must be a UUID")
     async with connect() as conn:
         assistant_ = await Assistants.get(conn, assistant_id)
-    assistant = await fetchone(assistant_)
-    config = await ajson_loads(assistant["config"])
-    async with get_graph(assistant["graph_id"], config) as graph:
-        if isinstance(graph, BaseRemotePregel):
-            schemas = await graph.fetch_state_schema()
+        # TODO Implementa  cache so we can de-dent and release this connection.
+        assistant = await fetchone(assistant_)
+        config = await ajson_loads(assistant["config"])
+        async with get_graph(
+            assistant["graph_id"],
+            config,
+            checkpointer=Checkpointer(conn),
+            store=Store(),
+        ) as graph:
+            if isinstance(graph, BaseRemotePregel):
+                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_jsonschema()
+            except Exception as e:
+                logger.warning(
+                    f"Failed to get input schema for graph {graph.name} with error: `{str(e)}`"
+                )
+                input_schema = None
+            try:
+                output_schema = graph.get_output_jsonschema()
+            except Exception as e:
+                logger.warning(
+                    f"Failed to get output schema for graph {graph.name} with error: `{str(e)}`"
+                )
+                output_schema = None
+
+            state_schema = _state_jsonschema(graph)
+            try:
+                config_schema = _get_configurable_jsonschema(graph)
+            except Exception as e:
+                config_schema = None
+                logger.warning(
+                    f"Failed to get config schema for graph {graph.name} with error: `{str(e)}`"
+                )
             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_jsonschema()
-        except Exception as e:
-            logger.warning(
-                f"Failed to get input schema for graph {graph.name} with error: `{str(e)}`"
-            )
-            input_schema = None
-        try:
-            output_schema = graph.get_output_jsonschema()
-        except Exception as e:
-            logger.warning(
-                f"Failed to get output schema for graph {graph.name} with error: `{str(e)}`"
-            )
-            output_schema = None
-
-        state_schema = _state_jsonschema(graph)
-        try:
-            config_schema = _get_configurable_jsonschema(graph)
-        except Exception as e:
-            config_schema = None
-            logger.warning(
-                f"Failed to get config schema for graph {graph.name} with error: `{str(e)}`"
-            )
-        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/graph.py

@@ -15,11 +15,13 @@ from typing import TYPE_CHECKING, Any, NamedTuple
 from uuid import UUID, uuid5
 
 import structlog
-from langchain_core.runnables.config import run_in_executor
+from langchain_core.runnables.config import run_in_executor, var_child_runnable_config
 from langgraph.checkpoint.base import BaseCheckpointSaver
+from langgraph.constants import CONFIG_KEY_CHECKPOINTER, CONFIG_KEY_STORE
 from langgraph.graph import Graph
 from langgraph.pregel import Pregel
 from langgraph.store.base import BaseStore
+from langgraph.utils.config import ensure_config
 from starlette.exceptions import HTTPException
 
 from langgraph_api import asyncio as lg_asyncio
@@ -109,26 +111,38 @@ async def get_graph(
     """Return the runnable."""
     assert_graph_exists(graph_id)
     value = GRAPHS[graph_id]
+    token = None
     if graph_id in FACTORY_ACCEPTS_CONFIG:
+        config = ensure_config(config)
+        if store is not None and not config["configurable"].get(CONFIG_KEY_STORE):
+            config["configurable"][CONFIG_KEY_STORE] = store
+        if checkpointer is not None and not config["configurable"].get(
+            CONFIG_KEY_CHECKPOINTER
+        ):
+            config["configurable"][CONFIG_KEY_CHECKPOINTER] = checkpointer
+        token = var_child_runnable_config.set(config)
         value = value(config) if FACTORY_ACCEPTS_CONFIG[graph_id] else value()
-
-    async with _generate_graph(value) as graph_obj:
-        if isinstance(graph_obj, Graph):
-            graph_obj = graph_obj.compile()
-        if not isinstance(graph_obj, Pregel | BaseRemotePregel):
-            raise HTTPException(
-                status_code=424,
-                detail=f"Graph '{graph_id}' is not valid. Review graph registration.",
-            )
-        update = {
-            "checkpointer": checkpointer,
-            "store": store,
-        }
-        if graph_obj.name == "LangGraph":
-            update["name"] = graph_id
-        if isinstance(graph_obj, BaseRemotePregel):
-            update["config"] = config
-        yield graph_obj.copy(update=update)
+    try:
+        async with _generate_graph(value) as graph_obj:
+            if isinstance(graph_obj, Graph):
+                graph_obj = graph_obj.compile()
+            if not isinstance(graph_obj, Pregel | BaseRemotePregel):
+                raise HTTPException(
+                    status_code=424,
+                    detail=f"Graph '{graph_id}' is not valid. Review graph registration.",
+                )
+            update = {
+                "checkpointer": checkpointer,
+                "store": store,
+            }
+            if graph_obj.name == "LangGraph":
+                update["name"] = graph_id
+            if isinstance(graph_obj, BaseRemotePregel):
+                update["config"] = config
+            yield graph_obj.copy(update=update)
+    finally:
+        if token is not None:
+            var_child_runnable_config.reset(token)
 
 
 def graph_exists(graph_id: str) -> bool:

langgraph_api/stream.py

@@ -119,7 +119,7 @@ async def astream_state(
     is_remote_pregel = isinstance(graph, BaseRemotePregel)
     if not is_remote_pregel:
         config["configurable"]["__pregel_node_finished"] = incr_nodes
-        # TODO add node tracking for JS graphs
+
     # attach run_id to config
     # for attempts beyond the first, use a fresh, unique run_id
     config = {**config, "run_id": run["run_id"]} if attempt == 1 else config

{langgraph_api-0.2.20.dist-info → langgraph_api-0.2.23.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: langgraph-api
-Version: 0.2.20
+Version: 0.2.23
 Summary: 
 License: Elastic-2.0
 Author: Nuno Campos

{langgraph_api-0.2.20.dist-info → langgraph_api-0.2.23.dist-info}/RECORD

@@ -1,7 +1,7 @@
 LICENSE,sha256=ZPwVR73Biwm3sK6vR54djCrhaRiM4cAD2zvOQZV8Xis,3859
-langgraph_api/__init__.py,sha256=PP1XN3LVw4efHZSwpFDbQRezvRqPg1JqZ--H2vUombw,23
+langgraph_api/__init__.py,sha256=drfF0qMRjoB2RacyqP-NkNmDOIBrys6RWHvqSTpZLuc,23
 langgraph_api/api/__init__.py,sha256=YVzpbn5IQotvuuLG9fhS9QMrxXfP4s4EpEMG0n4q3Nw,5625
-langgraph_api/api/assistants.py,sha256=mcKaVeNG8hQAV4IQDhaukS7FgVqTIVQNTyti3GfK2KI,14649
+langgraph_api/api/assistants.py,sha256=4_tZCXlOmFg-YwgtsCZPc1wr-3fexqJ6A3_2a5giF90,15811
 langgraph_api/api/mcp.py,sha256=RvRYgANqRzNQzSmgjNkq4RlKTtoEJYil04ot9lsmEtE,14352
 langgraph_api/api/meta.py,sha256=sTgkhE-DaFWpERG6F7KelZfDsmJAiVc4j5dg50tDkSo,2950
 langgraph_api/api/openapi.py,sha256=362m6Ny8wOwZ6HrDK9JAVUzPkyLYWKeV1E71hPOaA0U,11278
@@ -23,7 +23,7 @@ langgraph_api/command.py,sha256=3O9v3i0OPa96ARyJ_oJbLXkfO8rPgDhLCswgO9koTFA,768
 langgraph_api/config.py,sha256=AsEyWCZXl_x-NvFhbhM7wagspA7DRyoL-IY6f2dBpUo,10968
 langgraph_api/cron_scheduler.py,sha256=i87j4pJrcsmsqMKeKUs69gaAjrGaSM3pM3jnXdN5JDQ,2630
 langgraph_api/errors.py,sha256=Bu_i5drgNTyJcLiyrwVE_6-XrSU50BHf9TDpttki9wQ,1690
-langgraph_api/graph.py,sha256=YyWCPtoI9VDV0knjCMUFoH4r9OFVsAiv5K8FzbziMqs,21488
+langgraph_api/graph.py,sha256=sn3rH_D51CZ9Ghd6pIb8LO0nc0oIc8H9RXGRWbiamQU,22256
 langgraph_api/http.py,sha256=gYbxxjY8aLnsXeJymcJ7G7Nj_yToOGpPYQqmZ1_ggfA,5240
 langgraph_api/js/.gitignore,sha256=l5yI6G_V6F1600I1IjiUKn87f4uYIrBAYU1MOyBBhg4,59
 langgraph_api/js/.prettierrc,sha256=0es3ovvyNIqIw81rPQsdt1zCQcOdBqyR_DMbFE4Ifms,19
@@ -85,7 +85,7 @@ langgraph_api/serde.py,sha256=TVsx2QQtepf8Wsgsabcku1NV4Vbugu4Oujmdnq4qMS0,3964
 langgraph_api/server.py,sha256=4P7GpXbE9m-sAV7rBQ4Gd3oFk6htNbL-tRQfICAFc2k,6837
 langgraph_api/sse.py,sha256=3jG_FZj8FI9r7xGWTqaAyDkmqf6P1NOu0EzGrcSOGYc,4033
 langgraph_api/state.py,sha256=8jx4IoTCOjTJuwzuXJKKFwo1VseHjNnw_CCq4x1SW14,2284
-langgraph_api/stream.py,sha256=BEDhdpoXIL6CpSOEUSYG5ZZC8b4DnyThHX5rHB3xGa4,12088
+langgraph_api/stream.py,sha256=4wKeoLuxqy7m7iamONmP9Lw4vcHEMWPeQFV_PrJC5AY,12042
 langgraph_api/thread_ttl.py,sha256=-Ox8NFHqUH3wGNdEKMIfAXUubY5WGifIgCaJ7npqLgw,1762
 langgraph_api/tunneling/cloudflare.py,sha256=iKb6tj-VWPlDchHFjuQyep2Dpb-w2NGfJKt-WJG9LH0,3650
 langgraph_api/utils.py,sha256=92mSti9GfGdMRRWyESKQW5yV-75Z9icGHnIrBYvdypU,3619
@@ -97,8 +97,8 @@ langgraph_license/validation.py,sha256=ZKraAVJArAABKqrmHN-EN18ncoNUmRm500Yt1Sc7t
 langgraph_runtime/__init__.py,sha256=O4GgSmu33c-Pr8Xzxj_brcK5vkm70iNTcyxEjICFZxA,1075
 logging.json,sha256=3RNjSADZmDq38eHePMm1CbP6qZ71AmpBtLwCmKU9Zgo,379
 openapi.json,sha256=h2zgGTQD9houdruwRdNwZuAFo-w3eP_f6huQ6jRFp84,133801
-langgraph_api-0.2.20.dist-info/LICENSE,sha256=ZPwVR73Biwm3sK6vR54djCrhaRiM4cAD2zvOQZV8Xis,3859
-langgraph_api-0.2.20.dist-info/METADATA,sha256=QmTOcC7iTvhr_aoJ84OkNjaUd6CkKE5R35cVzQidB8I,4275
-langgraph_api-0.2.20.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
-langgraph_api-0.2.20.dist-info/entry_points.txt,sha256=3EYLgj89DfzqJHHYGxPH4A_fEtClvlRbWRUHaXO7hj4,77
-langgraph_api-0.2.20.dist-info/RECORD,,
+langgraph_api-0.2.23.dist-info/LICENSE,sha256=ZPwVR73Biwm3sK6vR54djCrhaRiM4cAD2zvOQZV8Xis,3859
+langgraph_api-0.2.23.dist-info/METADATA,sha256=17XvJmMLdBhzcwrl06VdUWmqIFUgDbCb5_rUjfDrPwY,4275
+langgraph_api-0.2.23.dist-info/WHEEL,sha256=fGIA9gx4Qxk2KDKeNJCbOEwSrmLtjWCwzBz351GyrPQ,88
+langgraph_api-0.2.23.dist-info/entry_points.txt,sha256=3EYLgj89DfzqJHHYGxPH4A_fEtClvlRbWRUHaXO7hj4,77
+langgraph_api-0.2.23.dist-info/RECORD,,