langgraph-api 0.0.8__tar.gz → 0.0.9__tar.gz

{langgraph_api-0.0.8 → langgraph_api-0.0.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langgraph-api
-Version: 0.0.8
+Version: 0.0.9
 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: langsmith (>=0.1.63,<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)

langgraph_api-0.0.9/langgraph_api/api/openapi.py

@@ -0,0 +1,69 @@
+import logging
+from functools import lru_cache
+
+import orjson
+
+from langgraph_api.config import LANGGRAPH_AUTH, LANGGRAPH_AUTH_TYPE
+from langgraph_api.graph import GRAPHS
+from langgraph_api.validation import openapi
+
+logger = logging.getLogger(__name__)
+
+
+@lru_cache(maxsize=1)
+def get_openapi_spec() -> str:
+    # patch the graph_id enums
+    graph_ids = list(GRAPHS.keys())
+    for schema in (
+        "Assistant",
+        "AssistantCreate",
+        "AssistantPatch",
+        "GraphSchema",
+        "AssistantSearchRequest",
+    ):
+        openapi["components"]["schemas"][schema]["properties"]["graph_id"]["enum"] = (
+            graph_ids
+        )
+    # patch the auth schemes
+    if LANGGRAPH_AUTH_TYPE == "langsmith":
+        openapi["security"] = [
+            {"x-api-key": []},
+        ]
+        openapi["components"]["securitySchemes"] = {
+            "x-api-key": {"type": "apiKey", "in": "header", "name": "x-api-key"}
+        }
+    elif LANGGRAPH_AUTH_TYPE == "custom":
+        # Allow user to specify OpenAPI security configuration
+        if isinstance(LANGGRAPH_AUTH, dict) and "openapi" in LANGGRAPH_AUTH:
+            openapi_config = LANGGRAPH_AUTH["openapi"]
+            if isinstance(openapi_config, dict):
+                # Add security schemes
+                if "securitySchemes" in openapi_config:
+                    openapi["components"]["securitySchemes"] = openapi_config[
+                        "securitySchemes"
+                    ]
+                elif "security_schemes" in openapi_config:
+                    # For our sorry python users
+                    openapi["components"]["securitySchemes"] = openapi_config[
+                        "security_schemes"
+                    ]
+
+                # Add default security if specified
+                if "security" in openapi_config:
+                    openapi["security"] = openapi_config["security"]
+
+                if "paths" in openapi_config:
+                    for path, methods in openapi_config["paths"].items():
+                        if path in openapi["paths"]:
+                            openapi_path = openapi["paths"][path]
+                            for method, security in methods.items():
+                                method = method.lower()
+                                if method in openapi_path:
+                                    openapi_path[method]["security"] = security
+        else:
+            logger.warning(
+                "Custom authentication is enabled but no OpenAPI security configuration was provided. "
+                "API documentation will not show authentication requirements. "
+                "Add 'openapi' section to auth section of your `langgraph.json` file to specify security schemes."
+            )
+    return orjson.dumps(openapi)

{langgraph_api-0.0.8 → langgraph_api-0.0.9}/langgraph_api/api/runs.py

@@ -24,13 +24,6 @@ from langgraph_storage.ops import Crons, Runs, Threads
 from langgraph_storage.retry import retry_db
 
 
-def get_user_id(request: ApiRequest) -> str | None:
-    try:
-        return request.user.display_name
-    except AssertionError:
-        return None
-
-
 @retry_db
 async def create_run(request: ApiRequest):
     """Create a run."""
@@ -41,7 +34,6 @@ async def create_run(request: ApiRequest):
             conn,
             thread_id,
             payload,
-            get_user_id(request),
             request.headers,
         )
     return ApiResponse(run)
@@ -53,7 +45,10 @@ async def create_stateless_run(request: ApiRequest):
     payload = await request.json(RunCreateStateless)
     async with connect() as conn:
         run = await create_valid_run(
-            conn, None, payload, get_user_id(request), request.headers
+            conn,
+            None,
+            payload,
+            request.headers,
         )
     return ApiResponse(run)
 
@@ -66,12 +61,15 @@ async def create_stateless_run_batch(request: ApiRequest):
         barrier = asyncio.Barrier(len(batch_payload))
         coros = [
             create_valid_run(
-                conn, None, payload, get_user_id(request), request.headers, barrier
+                conn,
+                None,
+                payload,
+                request.headers,
+                barrier,
             )
             for payload in batch_payload
         ]
         runs = await asyncio.gather(*coros)
-
     return ApiResponse(runs)
 
 
@@ -91,7 +89,6 @@ async def stream_run(
                 conn,
                 thread_id,
                 payload,
-                get_user_id(request),
                 request.headers,
                 run_id=run_id,
             )
@@ -127,7 +124,6 @@ async def stream_run_stateless(
                 conn,
                 None,
                 payload,
-                get_user_id(request),
                 request.headers,
                 run_id=run_id,
             )
@@ -165,7 +161,6 @@ async def wait_run(request: ApiRequest):
                 conn,
                 thread_id,
                 payload,
-                get_user_id(request),
                 request.headers,
                 run_id=run_id,
             )
@@ -226,7 +221,6 @@ async def wait_run_stateless(request: ApiRequest):
                 conn,
                 None,
                 payload,
-                get_user_id(request),
                 request.headers,
                 run_id=run_id,
             )
@@ -284,6 +278,7 @@ async def list_runs_http(
     limit = int(request.query_params.get("limit", 10))
     offset = int(request.query_params.get("offset", 0))
     status = request.query_params.get("status")
+
     async with connect() as conn, conn.pipeline():
         thread, runs = await asyncio.gather(
             Threads.get(conn, thread_id),
@@ -307,10 +302,15 @@ async def get_run_http(request: ApiRequest):
     run_id = request.path_params["run_id"]
     validate_uuid(thread_id, "Invalid thread ID: must be a UUID")
     validate_uuid(run_id, "Invalid run ID: must be a UUID")
+
     async with connect() as conn, conn.pipeline():
         thread, run = await asyncio.gather(
             Threads.get(conn, thread_id),
-            Runs.get(conn, run_id, thread_id=thread_id),
+            Runs.get(
+                conn,
+                run_id,
+                thread_id=thread_id,
+            ),
         )
     await fetchone(thread)
     return ApiResponse(await fetchone(run))
@@ -323,7 +323,13 @@ async def join_run(request: ApiRequest):
     run_id = request.path_params["run_id"]
     validate_uuid(thread_id, "Invalid thread ID: must be a UUID")
     validate_uuid(run_id, "Invalid run ID: must be a UUID")
-    return ApiResponse(await Runs.join(run_id, thread_id=thread_id))
+
+    return ApiResponse(
+        await Runs.join(
+            run_id,
+            thread_id=thread_id,
+        )
+    )
 
 
 @retry_db
@@ -337,7 +343,9 @@ async def join_run_stream_endpoint(request: ApiRequest):
     validate_uuid(run_id, "Invalid run ID: must be a UUID")
     return EventSourceResponse(
         Runs.Stream.join(
-            run_id, thread_id=thread_id, cancel_on_disconnect=cancel_on_disconnect
+            run_id,
+            thread_id=thread_id,
+            cancel_on_disconnect=cancel_on_disconnect,
         )
     )
 
@@ -355,10 +363,19 @@ async def cancel_run(
     wait = wait_str.lower() in {"true", "yes", "1"}
     action_str = request.query_params.get("action", "interrupt")
     action = action_str if action_str in {"interrupt", "rollback"} else "interrupt"
+
     async with connect() as conn:
-        await Runs.cancel(conn, [run_id], action=action, thread_id=thread_id)
+        await Runs.cancel(
+            conn,
+            [run_id],
+            action=action,
+            thread_id=thread_id,
+        )
     if wait:
-        await Runs.join(run_id, thread_id=thread_id)
+        await Runs.join(
+            run_id,
+            thread_id=thread_id,
+        )
     return Response(status_code=204 if wait else 202)
 
 
@@ -369,8 +386,13 @@ async def delete_run(request: ApiRequest):
     run_id = request.path_params["run_id"]
     validate_uuid(thread_id, "Invalid thread ID: must be a UUID")
     validate_uuid(run_id, "Invalid run ID: must be a UUID")
+
     async with connect() as conn:
-        rid = await Runs.delete(conn, run_id, thread_id=thread_id)
+        rid = await Runs.delete(
+            conn,
+            run_id,
+            thread_id=thread_id,
+        )
     await fetchone(rid)
     return Response(status_code=204)
 
@@ -383,7 +405,6 @@ async def create_cron(request: ApiRequest):
     async with connect() as conn:
         cron = await Crons.put(
             conn,
-            user_id=get_user_id(request),
             thread_id=None,
             end_time=payload.get("end_time"),
             schedule=payload.get("schedule"),
@@ -402,7 +423,6 @@ async def create_thread_cron(request: ApiRequest):
     async with connect() as conn:
         cron = await Crons.put(
             conn,
-            user_id=get_user_id(request),
             thread_id=thread_id,
             end_time=payload.get("end_time"),
             schedule=payload.get("schedule"),
@@ -418,7 +438,10 @@ async def delete_cron(request: ApiRequest):
     validate_uuid(cron_id, "Invalid cron ID: must be a UUID")
 
     async with connect() as conn:
-        cid = await Crons.delete(conn, cron_id)
+        cid = await Crons.delete(
+            conn,
+            cron_id=cron_id,
+        )
     await fetchone(cid)
     return Response(status_code=204)
 
@@ -431,6 +454,7 @@ async def search_crons(request: ApiRequest):
         validate_uuid(assistant_id, "Invalid assistant ID: must be a UUID")
     if thread_id := payload.get("thread_id"):
         validate_uuid(thread_id, "Invalid thread ID: must be a UUID")
+
     async with connect() as conn:
         crons_iter = await Crons.search(
             conn,
@@ -447,12 +471,16 @@ runs_routes = [
     ApiRoute("/runs/wait", wait_run_stateless, methods=["POST"]),
     ApiRoute("/runs", create_stateless_run, methods=["POST"]),
     ApiRoute("/runs/batch", create_stateless_run_batch, methods=["POST"]),
-    ApiRoute("/runs/crons", create_cron, methods=["POST"])
-    if config.FF_CRONS_ENABLED and plus_features_enabled()
-    else None,
-    ApiRoute("/runs/crons/search", search_crons, methods=["POST"])
-    if config.FF_CRONS_ENABLED and plus_features_enabled()
-    else None,
+    (
+        ApiRoute("/runs/crons", create_cron, methods=["POST"])
+        if config.FF_CRONS_ENABLED and plus_features_enabled()
+        else None
+    ),
+    (
+        ApiRoute("/runs/crons/search", search_crons, methods=["POST"])
+        if config.FF_CRONS_ENABLED and plus_features_enabled()
+        else None
+    ),
     ApiRoute("/threads/{thread_id}/runs/{run_id}/join", join_run, methods=["GET"]),
     ApiRoute(
         "/threads/{thread_id}/runs/{run_id}/stream",
@@ -465,13 +493,19 @@ runs_routes = [
     ApiRoute("/threads/{thread_id}/runs/stream", stream_run, methods=["POST"]),
     ApiRoute("/threads/{thread_id}/runs/wait", wait_run, methods=["POST"]),
     ApiRoute("/threads/{thread_id}/runs", create_run, methods=["POST"]),
-    ApiRoute("/threads/{thread_id}/runs/crons", create_thread_cron, methods=["POST"])
-    if config.FF_CRONS_ENABLED and plus_features_enabled()
-    else None,
+    (
+        ApiRoute(
+            "/threads/{thread_id}/runs/crons", create_thread_cron, methods=["POST"]
+        )
+        if config.FF_CRONS_ENABLED and plus_features_enabled()
+        else None
+    ),
     ApiRoute("/threads/{thread_id}/runs", list_runs_http, methods=["GET"]),
-    ApiRoute("/runs/crons/{cron_id}", delete_cron, methods=["DELETE"])
-    if config.FF_CRONS_ENABLED and plus_features_enabled()
-    else None,
+    (
+        ApiRoute("/runs/crons/{cron_id}", delete_cron, methods=["DELETE"])
+        if config.FF_CRONS_ENABLED and plus_features_enabled()
+        else None
+    ),
 ]
 
 runs_routes = [route for route in runs_routes if route is not None]