langgraph-api 0.2.20__tar.gz → 0.2.21__tar.gz

{langgraph_api-0.2.20 → langgraph_api-0.2.21}/PKG-INFO

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

langgraph_api-0.2.21/langgraph_api/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.2.21"

{langgraph_api-0.2.20 → langgraph_api-0.2.21}/langgraph_api/api/assistants.py

@@ -3,6 +3,13 @@ from uuid import uuid4
 
 import structlog
 from langchain_core.runnables.utils import create_model
+from langgraph.constants import (
+    CONFIG_KEY_CHECKPOINT_ID,
+    CONFIG_KEY_CHECKPOINT_NS,
+    CONFIG_KEY_CHECKPOINTER,
+    CONFIG_KEY_STORE,
+    CONFIG_KEY_THREAD_ID,
+)
 from langgraph.pregel import Pregel
 from pydantic import TypeAdapter
 from starlette.exceptions import HTTPException
@@ -21,13 +28,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 = (
+    CONFIG_KEY_CHECKPOINTER,
+    CONFIG_KEY_STORE,
+    CONFIG_KEY_CHECKPOINT_ID,
+    CONFIG_KEY_CHECKPOINT_NS,
+    CONFIG_KEY_THREAD_ID,
+)
+
+
 def _get_configurable_jsonschema(graph: Pregel) -> dict:
     """Get the JSON schema for the configurable part of the graph.
 
@@ -52,6 +70,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 +195,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 +241,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 +286,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-0.2.20 → langgraph_api-0.2.21}/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-0.2.20 → langgraph_api-0.2.21}/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 → langgraph_api-0.2.21}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "langgraph-api"
-version = "0.2.20"
+version = "0.2.21"
 description = ""
 authors = [
     "Nuno Campos <nuno@langchain.dev>",

langgraph_api-0.2.20/langgraph_api/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.2.20"