langgraph-api 0.2.45__py3-none-any.whl → 0.2.48__py3-none-any.whl

langgraph_api/__init__.py

@@ -1 +1 @@
-__version__ = "0.2.45"
+__version__ = "0.2.48"

langgraph_api/api/assistants.py

@@ -189,40 +189,40 @@ async def get_assistant_graph(
     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,
-            checkpointer=Checkpointer(conn),
-            store=(await api_store.get_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())
+    config = await ajson_loads(assistant["config"])
+    async with get_graph(
+        assistant["graph_id"],
+        config,
+        checkpointer=Checkpointer(),
+        store=(await api_store.get_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
+        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
@@ -239,7 +239,7 @@ async def get_assistant_subgraphs(
         async with get_graph(
             assistant["graph_id"],
             config,
-            checkpointer=Checkpointer(conn),
+            checkpointer=Checkpointer(),
             store=(await api_store.get_store()),
         ) as graph:
             namespace = request.path_params.get("namespace")
@@ -285,7 +285,7 @@ async def get_assistant_schemas(
         async with get_graph(
             assistant["graph_id"],
             config,
-            checkpointer=Checkpointer(conn),
+            checkpointer=Checkpointer(),
             store=(await api_store.get_store()),
         ) as graph:
             if isinstance(graph, BaseRemotePregel):

langgraph_api/api/meta.py

@@ -2,7 +2,7 @@ import os
 
 from starlette.responses import JSONResponse, PlainTextResponse
 
-from langgraph_api import config, metadata
+from langgraph_api import __version__, config, metadata
 from langgraph_api.route import ApiRequest
 from langgraph_license.validation import plus_features_enabled
 from langgraph_runtime.database import connect, pool_stats
@@ -16,10 +16,12 @@ async def meta_info(request: ApiRequest):
     plus = plus_features_enabled()
     return JSONResponse(
         {
+            "version": __version__,
             "flags": {
                 "assistants": True,
                 "crons": plus and config.FF_CRONS_ENABLED,
                 "langsmith": bool(config.LANGSMITH_API_KEY) and bool(config.TRACING),
+                "langsmith_tracing_replicas": True,
             },
             "host": {
                 "kind": metadata.HOST,

langgraph_api/api/runs.py

@@ -222,6 +222,9 @@ async def wait_run(request: ApiRequest):
         stream = asyncio.create_task(consume())
         while True:
             try:
+                if stream.done():
+                    # raise stream exception if any
+                    stream.result()
                 yield await asyncio.wait_for(last_chunk.wait(), timeout=5)
                 break
             except TimeoutError:
@@ -270,7 +273,10 @@ async def wait_run_stateless(request: ApiRequest):
         vchunk: bytes | None = None
         async with aclosing(
             Runs.Stream.join(
-                run["run_id"], thread_id=run["thread_id"], stream_mode=await sub
+                run["run_id"],
+                thread_id=run["thread_id"],
+                stream_mode=await sub,
+                ignore_404=True,
             )
         ) as stream:
             async for mode, chunk, _ in stream:
@@ -290,6 +296,9 @@ async def wait_run_stateless(request: ApiRequest):
         stream = asyncio.create_task(consume())
         while True:
             try:
+                if stream.done():
+                    # raise stream exception if any
+                    stream.result()
                 yield await asyncio.wait_for(last_chunk.wait(), timeout=5)
                 break
             except TimeoutError:

langgraph_api/js/remote.py

@@ -48,7 +48,6 @@ from langgraph_api.js.sse import SSEDecoder, aiter_lines_raw
 from langgraph_api.route import ApiResponse
 from langgraph_api.schema import Config
 from langgraph_api.serde import json_dumpb
-from langgraph_api.utils import AsyncConnectionProto
 
 logger = structlog.stdlib.get_logger(__name__)
 
@@ -469,10 +468,10 @@ class PassthroughSerialiser(SerializerProtocol):
         return orjson.loads(payload)
 
 
-def _get_passthrough_checkpointer(conn: AsyncConnectionProto):
+def _get_passthrough_checkpointer():
     from langgraph_runtime.checkpoint import Checkpointer
 
-    checkpointer = Checkpointer(conn)
+    checkpointer = Checkpointer()
     # This checkpointer does not attempt to revive LC-objects.
     # Instead, it will pass through the JSON values as-is.
     checkpointer.serde = PassthroughSerialiser()
@@ -487,53 +486,46 @@ async def _get_passthrough_store():
 # Setup a HTTP server on top of CHECKPOINTER_SOCKET unix socket
 # used by `client.mts` to communicate with the Python checkpointer
 async def run_remote_checkpointer():
-    from langgraph_runtime.database import connect
-
     async def checkpointer_list(payload: dict):
         """Search checkpoints"""
 
         result = []
-        async with connect() as conn:
-            checkpointer = _get_passthrough_checkpointer(conn)
-            async for item in checkpointer.alist(
-                config=payload.get("config"),
-                limit=int(payload.get("limit") or 10),
-                before=payload.get("before"),
-                filter=payload.get("filter"),
-            ):
-                result.append(item)
+        checkpointer = _get_passthrough_checkpointer()
+        async for item in checkpointer.alist(
+            config=payload.get("config"),
+            limit=int(payload.get("limit") or 10),
+            before=payload.get("before"),
+            filter=payload.get("filter"),
+        ):
+            result.append(item)
 
         return result
 
     async def checkpointer_put(payload: dict):
         """Put the new checkpoint metadata"""
 
-        async with connect() as conn:
-            checkpointer = _get_passthrough_checkpointer(conn)
-            return await checkpointer.aput(
-                payload["config"],
-                payload["checkpoint"],
-                payload["metadata"],
-                payload.get("new_versions", {}),
-            )
+        checkpointer = _get_passthrough_checkpointer()
+        return await checkpointer.aput(
+            payload["config"],
+            payload["checkpoint"],
+            payload["metadata"],
+            payload.get("new_versions", {}),
+        )
 
     async def checkpointer_get_tuple(payload: dict):
         """Get actual checkpoint values (reads)"""
-
-        async with connect() as conn:
-            checkpointer = _get_passthrough_checkpointer(conn)
-            return await checkpointer.aget_tuple(config=payload["config"])
+        checkpointer = _get_passthrough_checkpointer()
+        return await checkpointer.aget_tuple(config=payload["config"])
 
     async def checkpointer_put_writes(payload: dict):
         """Put actual checkpoint values (writes)"""
 
-        async with connect() as conn:
-            checkpointer = _get_passthrough_checkpointer(conn)
-            return await checkpointer.aput_writes(
-                payload["config"],
-                payload["writes"],
-                payload["taskId"],
-            )
+        checkpointer = _get_passthrough_checkpointer()
+        return await checkpointer.aput_writes(
+            payload["config"],
+            payload["writes"],
+            payload["taskId"],
+        )
 
     async def store_batch(payload: dict):
         """Batch operations on the store"""

langgraph_api/stream.py

@@ -32,7 +32,6 @@ from langgraph_api.js.base import BaseRemotePregel
 from langgraph_api.metadata import HOST, PLAN, USER_API_URL, incr_nodes
 from langgraph_api.schema import Run, StreamMode
 from langgraph_api.serde import json_dumpb
-from langgraph_api.utils import AsyncConnectionProto
 from langgraph_runtime.checkpoint import Checkpointer
 from langgraph_runtime.ops import Runs
 
@@ -79,8 +78,6 @@ async def async_tracing_context(*args, **kwargs):
 
 
 async def astream_state(
-    stack: AsyncExitStack,
-    conn: AsyncConnectionProto,
     run: Run,
     attempt: int,
     done: ValueEvent,
@@ -90,7 +87,6 @@ async def astream_state(
 ) -> AnyStream:
     """Stream messages from the runnable."""
     run_id = str(run["run_id"])
-    await stack.enter_async_context(conn.pipeline())
     # extract args from run
     kwargs = run["kwargs"].copy()
     kwargs.pop("webhook", None)
@@ -98,12 +94,13 @@ async def astream_state(
     subgraphs = kwargs.get("subgraphs", False)
     temporary = kwargs.pop("temporary", False)
     config = kwargs.pop("config")
+    stack = AsyncExitStack()
     graph = await stack.enter_async_context(
         get_graph(
             config["configurable"]["graph_id"],
             config,
             store=(await api_store.get_store()),
-            checkpointer=None if temporary else Checkpointer(conn),
+            checkpointer=None if temporary else Checkpointer(),
         )
     )
     input = kwargs.pop("input")