langgraph-api 0.0.24__py3-none-any.whl → 0.0.26__py3-none-any.whl

langgraph_api/api/__init__.py

@@ -1,5 +1,10 @@
 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
@@ -11,11 +16,13 @@ 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 MIGRATIONS_PATH
+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"
@@ -37,19 +44,86 @@ async def docs(request: Request):
     return HTMLResponse(DOCS_HTML)
 
 
-routes: list[BaseRoute] = [
+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"]),
-    Mount(
-        "",
-        middleware=[auth_middleware],
-        routes=[*assistants_routes, *runs_routes, *threads_routes, *store_routes],
-    ),
 ]
 
+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:
+        os.environ["__LANGGRAPH_DEFER_LOOPBACK_TRANSPORT"] = "true"
+        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
+    finally:
+        os.environ.pop("__LANGGRAPH_DEFER_LOOPBACK_TRANSPORT", None)
+    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:
 

langgraph_api/api/openapi.py

@@ -1,4 +1,6 @@
+import copy
 import logging
+import typing
 from functools import lru_cache
 
 import orjson
@@ -9,6 +11,13 @@ 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:
@@ -66,4 +75,240 @@ def get_openapi_spec() -> str:
                 "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)
+    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/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/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/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/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/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,
                 },

langgraph_api/server.py

@@ -1,5 +1,6 @@
 # MONKEY PATCH: Patch Starlette to fix an error in the library
 import langgraph_api.patch  # noqa: F401,I001
+import sys
 
 # WARNING: Keep the import above before other code runs as it
 # patches an error in the Starlette library.
@@ -7,13 +8,15 @@ import logging
 
 import jsonschema_rs
 import structlog
+from contextlib import asynccontextmanager
 from langgraph.errors import EmptyInputError, InvalidUpdateError
 from starlette.applications import Starlette
 from starlette.middleware import Middleware
 from starlette.middleware.cors import CORSMiddleware
+from langgraph_api.api.openapi import set_custom_spec
 
 import langgraph_api.config as config
-from langgraph_api.api import routes
+from langgraph_api.api import routes, user_router
 from langgraph_api.errors import (
     overloaded_error_handler,
     validation_error_handler,
@@ -22,8 +25,10 @@ from langgraph_api.errors import (
 from langgraph_api.lifespan import lifespan
 from langgraph_api.middleware.http_logger import AccessLoggerMiddleware
 from langgraph_api.middleware.private_network import PrivateNetworkMiddleware
+from langgraph_api.utils import SchemaGenerator
 from langgraph_license.middleware import LicenseValidationMiddleware
 from langgraph_storage.retry import OVERLOADED_EXCEPTIONS
+from langgraph_sdk.client import configure_loopback_transports
 
 logging.captureWarnings(True)
 logger = structlog.stdlib.get_logger(__name__)
@@ -35,33 +40,103 @@ if config.ALLOW_PRIVATE_NETWORK:
 
 middleware.extend(
     [
-        Middleware(
-            CORSMiddleware,
-            allow_origins=config.CORS_ALLOW_ORIGINS,
-            allow_credentials=True,
-            allow_methods=["*"],
-            allow_headers=["*"],
-        )
-        if config.CORS_CONFIG is None
-        else Middleware(
-            CORSMiddleware,
-            **config.CORS_CONFIG,
+        (
+            Middleware(
+                CORSMiddleware,
+                allow_origins=config.CORS_ALLOW_ORIGINS,
+                allow_credentials=True,
+                allow_methods=["*"],
+                allow_headers=["*"],
+            )
+            if config.CORS_CONFIG is None
+            else Middleware(
+                CORSMiddleware,
+                **config.CORS_CONFIG,
+            )
         ),
         Middleware(LicenseValidationMiddleware),
         Middleware(AccessLoggerMiddleware, logger=logger),
     ]
 )
+exception_handlers = {
+    ValueError: value_error_handler,
+    InvalidUpdateError: value_error_handler,
+    EmptyInputError: value_error_handler,
+    jsonschema_rs.ValidationError: validation_error_handler,
+} | {exc: overloaded_error_handler for exc in OVERLOADED_EXCEPTIONS}
 
 
-app = Starlette(
-    routes=routes,
-    lifespan=lifespan,
-    middleware=middleware,
-    exception_handlers={
-        ValueError: value_error_handler,
-        InvalidUpdateError: value_error_handler,
-        EmptyInputError: value_error_handler,
-        jsonschema_rs.ValidationError: validation_error_handler,
-    }
-    | {exc: overloaded_error_handler for exc in OVERLOADED_EXCEPTIONS},
-)
+def update_openapi_spec(app):
+    spec = None
+    if "fastapi" in sys.modules:
+        # It's maybe a fastapi app
+        from fastapi import FastAPI
+
+        if isinstance(user_router, FastAPI):
+            spec = app.openapi()
+
+    if spec is None:
+        # How do we add
+        schemas = SchemaGenerator(
+            {
+                "openapi": "3.1.0",
+                "info": {"title": "LangGraph Platform", "version": "0.1.0"},
+            }
+        )
+        spec = schemas.get_schema(routes=app.routes)
+
+    if spec:
+        set_custom_spec(spec)
+
+
+if user_router:
+    # Merge routes
+    app = user_router
+    update_openapi_spec(app)
+    for route in routes:
+        if route.path in ("/docs", "/openapi.json"):
+            # Our handlers for these are inclusive of the custom routes and default API ones
+            # Don't let these be shadowed
+            app.router.routes.insert(0, route)
+        else:
+            # Everything else could be shadowed.
+            app.router.routes.append(route)
+
+    # Merge lifespans
+    original_lifespan = app.router.lifespan_context
+    if app.router.on_startup or app.router.on_shutdown:
+        raise ValueError(
+            f"Cannot merge lifespans with on_startup or on_shutdown: {app.router.on_startup} {app.router.on_shutdown}"
+        )
+
+    @asynccontextmanager
+    async def combined_lifespan(app):
+        async with lifespan(app):
+            if original_lifespan:
+                async with original_lifespan(app):
+                    yield
+            else:
+                yield
+
+    app.router.lifespan_context = combined_lifespan
+
+    # Merge middleware
+    app.user_middleware = (app.user_middleware or []) + middleware
+    # Merge exception handlers
+    for k, v in exception_handlers.items():
+        if k not in app.exception_handlers:
+            app.exception_handlers[k] = v
+        else:
+            logger.debug(f"Overriding exception handler for {k}")
+    # If the user creates a loopback client with `get_client() (no url)
+    # this will update the http transport to connect to the right app
+    configure_loopback_transports(app)
+
+else:
+    # It's a regular starlette app
+    app = Starlette(
+        routes=routes,
+        lifespan=lifespan,
+        middleware=middleware,
+        exception_handlers=exception_handlers,
+    )

langgraph_api/utils.py

@@ -5,12 +5,17 @@ from contextlib import asynccontextmanager
 from datetime import datetime
 from typing import Any, Protocol, TypeAlias, TypeVar
 
+import structlog
 from langgraph_sdk import Auth
 from starlette.authentication import AuthCredentials, BaseUser
 from starlette.exceptions import HTTPException
+from starlette.schemas import BaseSchemaGenerator
 
 from langgraph_api.auth.custom import SimpleUser
 
+logger = structlog.stdlib.get_logger(__name__)
+
+
 T = TypeVar("T")
 Row: TypeAlias = dict[str, Any]
 AuthContext = contextvars.ContextVar[Auth.types.BaseAuthContext | None](
@@ -98,3 +103,27 @@ def next_cron_date(schedule: str, base_time: datetime) -> datetime:
 
     cron_iter = croniter.croniter(schedule, base_time)
     return cron_iter.get_next(datetime)
+
+
+class SchemaGenerator(BaseSchemaGenerator):
+    def __init__(self, base_schema: dict[str, Any]) -> None:
+        self.base_schema = base_schema
+
+    def get_schema(self, routes: list) -> dict[str, Any]:
+        schema = dict(self.base_schema)
+        schema.setdefault("paths", {})
+        endpoints_info = self.get_endpoints(routes)
+
+        for endpoint in endpoints_info:
+            try:
+                parsed = self.parse_docstring(endpoint.func)
+            except AssertionError:
+                logger.warning("Could not parse docstrings for route %s", endpoint.path)
+                parsed = {}
+
+            if endpoint.path not in schema["paths"]:
+                schema["paths"][endpoint.path] = {}
+
+            schema["paths"][endpoint.path][endpoint.http_method] = parsed
+
+        return schema

{langgraph_api-0.0.24.dist-info → langgraph_api-0.0.26.dist-info}/METADATA

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

{langgraph_api-0.0.24.dist-info → langgraph_api-0.0.26.dist-info}/RECORD

@@ -1,23 +1,23 @@
 LICENSE,sha256=ZPwVR73Biwm3sK6vR54djCrhaRiM4cAD2zvOQZV8Xis,3859
 langgraph_api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-langgraph_api/api/__init__.py,sha256=zAdS_0jgjmCJK6E0VwEuNcNRkaknMXfQ2C_OES5tEI4,2066
+langgraph_api/api/__init__.py,sha256=WBw9xUm5JkvgWVbwHs8vhR5jOf3_zhMjktB96zKNI58,4962
 langgraph_api/api/assistants.py,sha256=9wngelDC9vnSs2vYGTHDSCLf5KNds-6mgP1BWnfoY2M,12865
 langgraph_api/api/meta.py,sha256=hueasWpTDQ6xYLo9Bzt2jhNH8XQRzreH8FTeFfnRoxQ,2700
-langgraph_api/api/openapi.py,sha256=AUxfnD5hlRp7s-0g2hBC5dNSNk3HTwOLeJiF489DT44,2762
+langgraph_api/api/openapi.py,sha256=f9gfmWN2AMKNUpLCpSgZuw_aeOF9jCXPdOtFT5PaTWM,10960
 langgraph_api/api/runs.py,sha256=wAzPXi_kcYB9BcLBL4FXgkBohWwCPIpe4XERnsnWnsA,16042
 langgraph_api/api/store.py,sha256=VzAJVOwO0IxosBB7km5TTf2rhlWGyPkVz_LpvbxetVY,5437
 langgraph_api/api/threads.py,sha256=taU61XPcCEhBPCYPZcMDsgVDwwWUWJs8p-PrXFXWY48,8661
 langgraph_api/asyncio.py,sha256=2fOlx-cZvuj1gQ867Kw1R_wsBsl9jdHYHcUtK2a-x-U,6264
 langgraph_api/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-langgraph_api/auth/custom.py,sha256=ZFyR5Yf_n5KJrMxBOy30hA396itQVvU4ywcyPwTE0og,21031
+langgraph_api/auth/custom.py,sha256=oyXz7UONY1YeTJ5IBGRAbFUz_K6krkptNxW8zzjb0uk,21088
 langgraph_api/auth/langsmith/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langgraph_api/auth/langsmith/backend.py,sha256=InScaL-HYCnxYEauhxU198gRZV9pJn9SzzBoR9Edn7g,2654
 langgraph_api/auth/langsmith/client.py,sha256=eKchvAom7hdkUXauD8vHNceBDDUijrFgdTV8bKd7x4Q,3998
 langgraph_api/auth/middleware.py,sha256=qc7SbaFoeWaqxS1wbjZ2PPQ4iI2p9T0shWL7c6g0ed4,1636
 langgraph_api/auth/noop.py,sha256=Bk6Nf3p8D_iMVy_OyfPlyiJp_aEwzL-sHrbxoXpCbac,586
 langgraph_api/auth/studio_user.py,sha256=FzFQRROKDlA9JjtBuwyZvk6Mbwno5M9RVYjDO6FU3F8,186
-langgraph_api/cli.py,sha256=r7NJVIdTQ9mQ6_X01tk_I0ktlgn9odH0B8J53oaySz4,12022
-langgraph_api/config.py,sha256=mkuhRHjUHA5cjzcSy0nYYS6K28FZ_3_FRl9s0sg_030,4225
+langgraph_api/cli.py,sha256=PKZDWjb1NjGXT1qRN0ogsFw2ANlyq7VvXI6QeTPaFhI,12231
+langgraph_api/config.py,sha256=Alb7vm8t13Y1oM9W6JaplApMwTLL1qVZZuXHG08FtgE,5104
 langgraph_api/cron_scheduler.py,sha256=MW41-TSGUe5OuXycFTy7Ax7ypxHVAv-0ImLonRT8h8o,2629
 langgraph_api/errors.py,sha256=Bu_i5drgNTyJcLiyrwVE_6-XrSU50BHf9TDpttki9wQ,1690
 langgraph_api/graph.py,sha256=FombjYQkqj8jrXJFEVkl3m2UyFcq5nSVNswR2HoRsQY,16385
@@ -31,8 +31,8 @@ langgraph_api/js/errors.py,sha256=Cm1TKWlUCwZReDC5AQ6SgNIVGD27Qov2xcgHyf8-GXo,36
 langgraph_api/js/global.d.ts,sha256=zR_zLYfpzyPfxpEFth5RgZoyfGulIXyZYPRf7cU0K0Y,106
 langgraph_api/js/package.json,sha256=AmpkMzr96yF9xZ7bCrSApF-j7PJH6WeALn9HpPGBnmQ,840
 langgraph_api/js/remote.py,sha256=D9cqcEgXau-fm_trpNwCHMra5BXntgUa469lgs_a9JQ,622
-langgraph_api/js/remote_new.py,sha256=T_Vr8459bax1C9xxqz_ZYmGivq5Vhspg2Iu9TL0Qc-Q,22707
-langgraph_api/js/remote_old.py,sha256=wC0wpYR4xv6Xqqq1PboIluViVeJ9ETFVTUEl53FSZyo,22578
+langgraph_api/js/remote_new.py,sha256=-9gsJeV32cHPXd-EESFVfPoBoPC7pqR7XKhkb_q9cHA,22781
+langgraph_api/js/remote_old.py,sha256=A28NMSvLGPfg044NDTHSv63pcujYZQXZujDxryGGhOw,22652
 langgraph_api/js/schema.py,sha256=7idnv7URlYUdSNMBXQcw7E4SxaPxCq_Oxwnlml8q5ik,408
 langgraph_api/js/server_sent_events.py,sha256=DLgXOHauemt7706vnfDUCG1GI3TidKycSizccdz9KgA,3702
 langgraph_api/js/src/graph.mts,sha256=J-M-vYHj1G5tyonPUym3ePNGqGYtspPCrZOgr92xKb4,3171
@@ -71,11 +71,11 @@ langgraph_api/queue.py,sha256=2sw9HB2cYVBhYUNA3F7lcJAgRjhQJXhA_HNGhFt2BW8,14508
 langgraph_api/route.py,sha256=fM4qYCGbmH0a3_cV8uKocb1sLklehxO6HhdRXqLK6OM,4421
 langgraph_api/schema.py,sha256=mgam5lpuqZnrNWMm_0nQ95683gCnCvQNRKbiuFj7z8Q,5310
 langgraph_api/serde.py,sha256=VoJ7Z1IuqrQGXFzEP1qijAITtWCrmjtVqlCRuScjXJI,3533
-langgraph_api/server.py,sha256=mKJWBuHN5HFHCQIL_FtH04wyFabR4mR6WmQcioI-_Ns,2071
+langgraph_api/server.py,sha256=CiNK327zTsEpoVGeJK1JOtZHvOBYRoz0CnBTZUmsC7c,4567
 langgraph_api/sse.py,sha256=2wNodCOP2eg7a9mpSu0S3FQ0CHk2BBV_vv0UtIgJIcc,4034
 langgraph_api/state.py,sha256=8jx4IoTCOjTJuwzuXJKKFwo1VseHjNnw_CCq4x1SW14,2284
 langgraph_api/stream.py,sha256=MUYYNgwtLs1Mhq1dm12zda7j8uFYir49umigK6CnuXU,11944
-langgraph_api/utils.py,sha256=aIHPp_yu-NFUzs0jzNRm6mcqoZmtbLMZl1ugFmwWTss,2692
+langgraph_api/utils.py,sha256=92mSti9GfGdMRRWyESKQW5yV-75Z9icGHnIrBYvdypU,3619
 langgraph_api/validation.py,sha256=McizHlz-Ez8Jhdbc79mbPSde7GIuf2Jlbjx2yv_l6dA,4475
 langgraph_license/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langgraph_license/middleware.py,sha256=_ODIYzQkymr6W9_Fp9wtf1kAQspnpsmr53xuzyF2GA0,612
@@ -90,8 +90,8 @@ langgraph_storage/store.py,sha256=D-p3cWc_umamkKp-6Cz3cAriSACpvM5nxUIvND6PuxE,27
 langgraph_storage/ttl_dict.py,sha256=FlpEY8EANeXWKo_G5nmIotPquABZGyIJyk6HD9u6vqY,1533
 logging.json,sha256=3RNjSADZmDq38eHePMm1CbP6qZ71AmpBtLwCmKU9Zgo,379
 openapi.json,sha256=DqXpD6JD4tvSOhUgDN_6f919F8YmOSAK4CsGi1NDoiI,125252
-langgraph_api-0.0.24.dist-info/LICENSE,sha256=ZPwVR73Biwm3sK6vR54djCrhaRiM4cAD2zvOQZV8Xis,3859
-langgraph_api-0.0.24.dist-info/METADATA,sha256=o2E2pKvMgkmvWDiUbkLHlrG4_UFTRjr_1zE8gDgCFys,4038
-langgraph_api-0.0.24.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-langgraph_api-0.0.24.dist-info/entry_points.txt,sha256=3EYLgj89DfzqJHHYGxPH4A_fEtClvlRbWRUHaXO7hj4,77
-langgraph_api-0.0.24.dist-info/RECORD,,
+langgraph_api-0.0.26.dist-info/LICENSE,sha256=ZPwVR73Biwm3sK6vR54djCrhaRiM4cAD2zvOQZV8Xis,3859
+langgraph_api-0.0.26.dist-info/METADATA,sha256=VFGg6OyMT4eyXHQgQiRPD9aWiHWlAjIKqTqQCX34CSc,4039
+langgraph_api-0.0.26.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+langgraph_api-0.0.26.dist-info/entry_points.txt,sha256=3EYLgj89DfzqJHHYGxPH4A_fEtClvlRbWRUHaXO7hj4,77
+langgraph_api-0.0.26.dist-info/RECORD,,