langgraph-api 0.0.23__tar.gz → 0.0.25__tar.gz

{langgraph_api-0.0.23 → langgraph_api-0.0.25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langgraph-api
-Version: 0.0.23
+Version: 0.0.25
 Summary: 
 License: Elastic-2.0
 Author: Nuno Campos
@@ -15,7 +15,7 @@ Requires-Dist: httpx (>=0.27.0)
 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-checkpoint (>=2.0.15,<3.0)
 Requires-Dist: langgraph-sdk (>=0.1.51,<0.2.0)
 Requires-Dist: langsmith (>=0.1.63,<0.4.0)
 Requires-Dist: orjson (>=3.10.1)

langgraph_api-0.0.25/langgraph_api/api/__init__.py

@@ -0,0 +1,135 @@
+import asyncio
+import importlib
+import importlib.util
+import os
+
+import structlog
+from starlette.applications import Starlette
+from starlette.requests import Request
+from starlette.responses import HTMLResponse, JSONResponse, Response
+from starlette.routing import BaseRoute, Mount, Route
+
+from langgraph_api.api.assistants import assistants_routes
+from langgraph_api.api.meta import meta_info, meta_metrics
+from langgraph_api.api.openapi import get_openapi_spec
+from langgraph_api.api.runs import runs_routes
+from langgraph_api.api.store import store_routes
+from langgraph_api.api.threads import threads_routes
+from langgraph_api.auth.middleware import auth_middleware
+from langgraph_api.config import HTTP_CONFIG, MIGRATIONS_PATH
+from langgraph_api.graph import js_bg_tasks
+from langgraph_api.validation import DOCS_HTML
+from langgraph_storage.database import connect, healthcheck
+
+logger = structlog.stdlib.get_logger(__name__)
+
+
+async def ok(request: Request):
+    check_db = int(request.query_params.get("check_db", "0"))  # must be "0" or "1"
+    if check_db:
+        await healthcheck()
+    if js_bg_tasks:
+        from langgraph_api.js.remote import js_healthcheck
+
+        await js_healthcheck()
+    return JSONResponse({"ok": True})
+
+
+async def openapi(request: Request):
+    spec = await asyncio.to_thread(get_openapi_spec)
+    return Response(spec, media_type="application/json")
+
+
+async def docs(request: Request):
+    return HTMLResponse(DOCS_HTML)
+
+
+meta_routes: list[BaseRoute] = [
+    Route("/ok", ok, methods=["GET"]),
+    Route("/openapi.json", openapi, methods=["GET"]),
+    Route("/docs", docs, methods=["GET"]),
+    Route("/info", meta_info, methods=["GET"]),
+    Route("/metrics", meta_metrics, methods=["GET"]),
+]
+
+protected_routes: list[BaseRoute] = []
+
+if HTTP_CONFIG:
+    if not HTTP_CONFIG.get("disable_assistants"):
+        protected_routes.extend(assistants_routes)
+    if not HTTP_CONFIG.get("disable_runs"):
+        protected_routes.extend(runs_routes)
+    if not HTTP_CONFIG.get("disable_threads"):
+        protected_routes.extend(threads_routes)
+    if not HTTP_CONFIG.get("disable_store"):
+        protected_routes.extend(store_routes)
+else:
+    protected_routes.extend(assistants_routes)
+    protected_routes.extend(runs_routes)
+    protected_routes.extend(threads_routes)
+    protected_routes.extend(store_routes)
+
+routes: list[BaseRoute] = []
+user_router = None
+
+
+def load_custom_app(app_import: str) -> Starlette | None:
+    # Expect a string in either "path/to/file.py:my_variable" or "some.module.in:my_variable"
+    logger.info(f"Loading custom app from {app_import}")
+    path, name = app_import.rsplit(":", 1)
+    try:
+        if os.path.isfile(path) or path.endswith(".py"):
+            # Import from file path using a unique module name.
+            spec = importlib.util.spec_from_file_location("user_router_module", path)
+            if spec is None or spec.loader is None:
+                raise ImportError(f"Cannot load spec from {path}")
+            module = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(module)
+        else:
+            # Import as a normal module.
+            module = importlib.import_module(path)
+        user_router = getattr(module, name)
+        if not isinstance(user_router, Starlette):
+            raise TypeError(
+                f"Object '{name}' in module '{path}' is not a Starlette or FastAPI application. "
+                "Please initialize your app by importing and using the appropriate class: "
+                "\nfrom starlette.applications import Starlette\n\napp = Starlette(...)\n\n"
+                "or\n\nfrom fastapi import FastAPI\n\napp = FastAPI(...)\n\n"
+            )
+    except ImportError as e:
+        raise ImportError(f"Failed to import app module '{path}'") from e
+    except AttributeError as e:
+        raise AttributeError(f"App '{name}' not found in module '{path}'") from e
+    return user_router
+
+
+if HTTP_CONFIG:
+    if router_import := HTTP_CONFIG.get("app"):
+        user_router = load_custom_app(router_import)
+    if not HTTP_CONFIG.get("disable_meta"):
+        routes.extend(meta_routes)
+    if protected_routes:
+        routes.append(
+            Mount(
+                "/",
+                middleware=[auth_middleware],
+                routes=protected_routes,
+            ),
+        )
+
+else:
+    routes.extend(meta_routes)
+    routes.append(Mount("/", middleware=[auth_middleware], routes=protected_routes))
+
+
+if "inmem" in MIGRATIONS_PATH:
+
+    async def truncate(request: Request):
+        from langgraph_storage.checkpoint import Checkpointer
+
+        Checkpointer().clear()
+        async with connect() as conn:
+            conn.clear()
+        return JSONResponse({"ok": True})
+
+    routes.insert(0, Route("/internal/truncate", truncate, methods=["POST"]))

langgraph_api-0.0.25/langgraph_api/api/openapi.py

@@ -0,0 +1,314 @@
+import copy
+import logging
+import typing
+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__)
+
+CUSTOM_OPENAPI_SPEC = None
+
+
+def set_custom_spec(spec: dict):
+    global CUSTOM_OPENAPI_SPEC
+    CUSTOM_OPENAPI_SPEC = spec
+
+
+@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"}
+        }
+    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"]
+            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."
+            )
+    final = openapi
+    if CUSTOM_OPENAPI_SPEC:
+        final = merge_openapi_specs(openapi, CUSTOM_OPENAPI_SPEC)
+    return orjson.dumps(final)
+
+
+def merge_openapi_specs(spec_a: dict, spec_b: dict) -> dict:
+    """
+    Merge two OpenAPI specifications with spec_b taking precedence on conflicts.
+
+    This function handles merging of the following keys:
+      - "openapi": Uses spec_b’s version.
+      - "info": Merges dictionaries with spec_b taking precedence.
+      - "servers": Merges lists with deduplication (by URL and description).
+      - "paths": For shared paths, merges HTTP methods:
+           - If a method exists in both, spec_b’s definition wins.
+           - Otherwise, methods from both are preserved.
+         Additionally, merges path-level "parameters" by (name, in).
+      - "components": Merges per component type (schemas, responses, etc.).
+      - "security" and "tags": Merges lists with deduplication using a key function.
+      - "externalDocs" and any additional keys: spec_b wins.
+
+    Args:
+        spec_a (dict): First OpenAPI specification.
+        spec_b (dict): Second OpenAPI specification (takes precedence).
+
+    Returns:
+        dict: The merged OpenAPI specification.
+
+    Raises:
+        TypeError: If either input is not a dict.
+        ValueError: If a required field (openapi, info, paths) is missing.
+    """
+    if not isinstance(spec_a, dict) or not isinstance(spec_b, dict):
+        raise TypeError("Both specifications must be dictionaries.")
+
+    required_fields = {"openapi", "info", "paths"}
+    for spec in (spec_a, spec_b):
+        missing = required_fields - spec.keys()
+        if missing:
+            raise ValueError(f"Missing required OpenAPI fields: {missing}")
+
+    merged = copy.deepcopy(spec_a)
+
+    if "openapi" in spec_b:
+        merged["openapi"] = spec_b["openapi"]
+
+    # Merge "info": Combine dictionaries with spec_b overriding spec_a.
+    merged["info"] = {**merged.get("info", {}), **spec_b.get("info", {})}
+
+    # Merge "servers": Use deduplication based on (url, description).
+    merged["servers"] = _merge_lists(
+        merged.get("servers", []),
+        spec_b.get("servers", []),
+        key_func=lambda x: (x.get("url"), x.get("description")),
+    )
+
+    # Merge "paths": Merge individual paths and methods.
+    merged["paths"] = _merge_paths(merged.get("paths", {}), spec_b.get("paths", {}))
+
+    # Merge "components": Merge per component type.
+    merged["components"] = _merge_components(
+        merged.get("components", {}), spec_b.get("components", {})
+    )
+
+    # Merge "security": Merge lists with deduplication.
+    merged["security"] = _merge_lists(
+        merged.get("security", []),
+        spec_b.get("security", []),
+        key_func=lambda x: tuple(sorted(x.items())),
+    )
+
+    # Merge "tags": Deduplicate tags by "name".
+    merged["tags"] = _merge_lists(
+        merged.get("tags", []), spec_b.get("tags", []), key_func=lambda x: x.get("name")
+    )
+
+    # Merge "externalDocs": Use spec_b if provided.
+    if "externalDocs" in spec_b:
+        merged["externalDocs"] = spec_b["externalDocs"]
+
+    # Merge any additional keys not explicitly handled.
+    handled_keys = {
+        "openapi",
+        "info",
+        "servers",
+        "paths",
+        "components",
+        "security",
+        "tags",
+        "externalDocs",
+    }
+    for key in set(spec_a.keys()).union(spec_b.keys()) - handled_keys:
+        merged[key] = spec_b.get(key, spec_a.get(key))
+
+    return merged
+
+
+def _merge_lists(list_a: list, list_b: list, key_func) -> list:
+    """
+    Merge two lists using a key function for deduplication.
+    Items from list_b take precedence over items from list_a.
+
+    Args:
+        list_a (list): First list.
+        list_b (list): Second list.
+        key_func (callable): Function that returns a key used for deduplication.
+
+    Returns:
+        list: Merged list.
+    """
+    merged_dict = {}
+    for item in list_a:
+        key = _ensure_hashable(key_func(item))
+        if key not in merged_dict:
+            merged_dict[key] = item
+    for item in list_b:
+        key = _ensure_hashable(key_func(item))
+        merged_dict[key] = item  # spec_b wins
+    return list(merged_dict.values())
+
+
+def _merge_paths(paths_a: dict, paths_b: dict) -> dict:
+    """
+    Merge OpenAPI paths objects.
+
+    For each path:
+      - If the path exists in both specs, merge HTTP methods:
+          - If a method exists in both, use spec_b’s definition.
+          - Otherwise, preserve both.
+      - Additionally, merge path-level "parameters" if present.
+
+    Args:
+        paths_a (dict): Paths from the first spec.
+        paths_b (dict): Paths from the second spec.
+
+    Returns:
+        dict: Merged paths.
+    """
+    merged_paths = {}
+    # Start with all paths from paths_a.
+    for path, methods in paths_a.items():
+        merged_paths[path] = copy.deepcopy(methods)
+
+    # Merge or add paths from paths_b.
+    for path, methods_b in paths_b.items():
+        if path not in merged_paths:
+            merged_paths[path] = copy.deepcopy(methods_b)
+        else:
+            methods_a = merged_paths[path]
+            for method, details_b in methods_b.items():
+                key = method.lower()
+                # If the method is "parameters", merge them.
+                if key == "parameters":
+                    params_a = methods_a.get("parameters", [])
+                    params_b = details_b if isinstance(details_b, list) else []
+                    methods_a["parameters"] = _merge_lists(
+                        params_a,
+                        params_b,
+                        key_func=lambda x: (x.get("name"), x.get("in")),
+                    )
+                else:
+                    # For HTTP methods, spec_b wins if conflict.
+                    methods_a[key] = copy.deepcopy(details_b)
+            merged_paths[path] = methods_a
+    return merged_paths
+
+
+def _merge_components(components_a: dict, components_b: dict) -> dict:
+    """
+    Merge OpenAPI components objects.
+
+    For each component type (schemas, responses, parameters, examples, requestBodies,
+    headers, securitySchemes, links, callbacks), merge dictionaries with spec_b taking precedence.
+
+    Args:
+        components_a (dict): Components from the first spec.
+        components_b (dict): Components from the second spec.
+
+    Returns:
+        dict: Merged components.
+    """
+    merged_components = {}
+    # Define the common component types to merge.
+    component_types = {
+        "schemas",
+        "responses",
+        "parameters",
+        "examples",
+        "requestBodies",
+        "headers",
+        "securitySchemes",
+        "links",
+        "callbacks",
+    }
+
+    for comp_type in component_types:
+        comp_a = components_a.get(comp_type, {})
+        comp_b = components_b.get(comp_type, {})
+        merged_components[comp_type] = {**comp_a, **comp_b}
+
+    # Merge any additional keys in components.
+    extra_keys = set(components_a.keys()).union(components_b.keys()) - component_types
+    for key in extra_keys:
+        merged_components[key] = {
+            **components_a.get(key, {}),
+            **components_b.get(key, {}),
+        }
+
+    return merged_components
+
+
+def _ensure_hashable(obj, depth=0, max_depth=3):
+    """
+    Recursively convert a Python object into a hashable representation up to a maximum depth.
+    If the depth limit is reached, return str(obj).
+
+    - Lists are converted to tuples.
+    - Dictionaries are converted to tuples of sorted (key, value) pairs.
+    - Other types are returned as-is.
+
+    Args:
+        obj: The object to convert.
+        depth (int): Current recursion depth.
+        max_depth (int): Maximum recursion depth.
+    """
+    if depth >= max_depth:
+        return str(obj)
+    if isinstance(obj, typing.Sequence):
+        return tuple(_ensure_hashable(e, depth + 1, max_depth) for e in obj)
+    if isinstance(obj, typing.Mapping):
+        return tuple(
+            sorted(
+                (k, _ensure_hashable(v, depth + 1, max_depth)) for k, v in obj.items()
+            )
+        )
+    return obj

{langgraph_api-0.0.23 → langgraph_api-0.0.25}/langgraph_api/auth/custom.py

@@ -375,6 +375,8 @@ def _solve_fastapi_dependencies(
 
 @functools.lru_cache(maxsize=1)
 def _depends() -> Any:
+    if "fastapi" not in sys.modules:
+        return None
     try:
         from fastapi.params import Depends
 

{langgraph_api-0.0.23 → langgraph_api-0.0.25}/langgraph_api/cli.py

@@ -4,8 +4,13 @@ import logging
 import os
 import pathlib
 import threading
+import typing
 from collections.abc import Mapping, Sequence
-from typing import Any, TypedDict
+
+from typing_extensions import TypedDict
+
+if typing.TYPE_CHECKING:
+    from langgraph_api.config import HttpConfig
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
@@ -147,7 +152,8 @@ def run_server(
     reload_excludes: Sequence[str] | None = None,
     store: StoreConfig | None = None,
     auth: AuthConfig | None = None,
-    **kwargs: Any,
+    http: typing.Optional["HttpConfig"] = None,
+    **kwargs: typing.Any,
 ):
     """Run the LangGraph API server."""
 
@@ -263,6 +269,7 @@ For production use, please use LangGraph Cloud.
         LANGSERVE_GRAPHS=json.dumps(graphs) if graphs else None,
         LANGSMITH_LANGGRAPH_API_VARIANT="local_dev",
         LANGGRAPH_AUTH=json.dumps(auth) if auth else None,
+        LANGGRAPH_HTTP=json.dumps(http) if http else None,
         # See https://developer.chrome.com/blog/private-network-access-update-2024-03
         ALLOW_PRIVATE_NETWORK="true",
         **(env_vars or {}),

{langgraph_api-0.0.23 → langgraph_api-0.0.25}/langgraph_api/config.py

@@ -1,9 +1,41 @@
 from os import environ, getenv
+from typing import TypedDict
 
 import orjson
 from starlette.config import Config, undefined
 from starlette.datastructures import CommaSeparatedStrings
 
+# types
+
+
+class CorsConfig(TypedDict, total=False):
+    allow_origins: list[str]
+    allow_methods: list[str]
+    allow_headers: list[str]
+    allow_credentials: bool
+    allow_origin_regex: str
+    expose_headers: list[str]
+    max_age: int
+
+
+class HttpConfig(TypedDict, total=False):
+    app: str
+    """Import path for a custom Starlette/FastAPI app to mount"""
+    disable_assistants: bool
+    """Disable /assistants routes"""
+    disable_threads: bool
+    """Disable /threads routes"""
+    disable_runs: bool
+    """Disable /runs routes"""
+    disable_store: bool
+    """Disable /store routes"""
+    disable_meta: bool
+    """Disable /ok, /info, /metrics, and /docs routes"""
+    cors: CorsConfig | None
+
+
+# env
+
 env = Config()
 
 
@@ -17,7 +49,6 @@ def _parse_json(json: str | None) -> dict | None:
 
 
 STATS_INTERVAL_SECS = env("STATS_INTERVAL_SECS", cast=int, default=60)
-HTTP_CONCURRENCY = env("HTTP_CONCURRENCY", cast=int, default=10)
 
 # storage
 
@@ -36,9 +67,12 @@ ALLOW_PRIVATE_NETWORK = env("ALLOW_PRIVATE_NETWORK", cast=bool, default=False)
 See https://developer.chrome.com/blog/private-network-access-update-2024-03
 """
 
+HTTP_CONFIG: HttpConfig | None = env("LANGGRAPH_HTTP", cast=_parse_json, default=None)
 CORS_ALLOW_ORIGINS = env("CORS_ALLOW_ORIGINS", cast=CommaSeparatedStrings, default="*")
-
-CORS_CONFIG = env("CORS_CONFIG", cast=_parse_json, default=None)
+if HTTP_CONFIG and HTTP_CONFIG.get("cors"):
+    CORS_CONFIG = HTTP_CONFIG["cors"]
+else:
+    CORS_CONFIG: CorsConfig | None = env("CORS_CONFIG", cast=_parse_json, default=None)
 """
 {
     "type": "object",

{langgraph_api-0.0.23 → langgraph_api-0.0.25}/langgraph_api/js/remote_new.py

@@ -336,6 +336,7 @@ async def run_js_process(paths_str: str, watch: bool = False):
                 env={
                     "LANGSERVE_GRAPHS": paths_str,
                     "LANGCHAIN_CALLBACKS_BACKGROUND": "true",
+                    "NODE_ENV": "development" if watch else "production",
                     "CHOKIDAR_USEPOLLING": "true",
                     **os.environ,
                 },

{langgraph_api-0.0.23 → langgraph_api-0.0.25}/langgraph_api/js/remote_old.py

@@ -296,6 +296,7 @@ async def run_js_process(paths_str: str, watch: bool = False):
                 env={
                     "LANGSERVE_GRAPHS": paths_str,
                     "LANGCHAIN_CALLBACKS_BACKGROUND": "true",
+                    "NODE_ENV": "development" if watch else "production",
                     "CHOKIDAR_USEPOLLING": "true",
                     **os.environ,
                 },