langgraph-api 0.4.1__py3-none-any.whl → 0.7.3__py3-none-any.whl

langgraph_api/cli.py

@@ -1,3 +1,4 @@
+import asyncio
 import contextlib
 import json
 import logging
@@ -8,15 +9,18 @@ import typing
 from collections.abc import Mapping, Sequence
 from typing import Literal
 
-from typing_extensions import TypedDict
-
 if typing.TYPE_CHECKING:
-    from langgraph_api.config import HttpConfig, StoreConfig
+    from packaging.version import Version
+
+    from langgraph_api.config import AuthConfig, HttpConfig, StoreConfig
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
 
+SUPPORT_STATUS = Literal["active", "critical", "eol"]
+
+
 def _get_ls_origin() -> str | None:
     from langsmith.client import Client
     from langsmith.utils import tracing_is_enabled
@@ -76,91 +80,6 @@ def patch_environment(**kwargs):
                 os.environ[key] = value
 
 
-class SecurityConfig(TypedDict, total=False):
-    securitySchemes: dict
-    security: list
-    # path => {method => security}
-    paths: dict[str, dict[str, list]]
-
-
-class CacheConfig(TypedDict, total=False):
-    cache_keys: list[str]
-    ttl_seconds: int
-    max_size: int
-
-
-class AuthConfig(TypedDict, total=False):
-    path: str
-    """Path to the authentication function in a Python file."""
-    disable_studio_auth: bool
-    """Whether to disable auth when connecting from the LangSmith Studio."""
-    openapi: SecurityConfig
-    """The schema to use for updating the openapi spec.
-
-    Example:
-        {
-            "securitySchemes": {
-                "OAuth2": {
-                    "type": "oauth2",
-                    "flows": {
-                        "password": {
-                            "tokenUrl": "/token",
-                            "scopes": {
-                                "me": "Read information about the current user",
-                                "items": "Access to create and manage items"
-                            }
-                        }
-                    }
-                }
-            },
-            "security": [
-                {"OAuth2": ["me"]}  # Default security requirement for all endpoints
-            ]
-        }
-    """
-    cache: CacheConfig | None
-
-
-def _check_newer_version(pkg: str, timeout: float = 0.2) -> None:
-    """Log a notice if PyPI reports a newer version."""
-    import importlib.metadata as md
-    import json
-    import urllib.request
-
-    from packaging.version import Version
-
-    thread_logger = logging.getLogger("check_version")
-    if not thread_logger.handlers:
-        handler = logging.StreamHandler()
-        handler.setFormatter(logging.Formatter("%(message)s"))
-        thread_logger.addHandler(handler)
-
-    try:
-        current = Version(md.version(pkg))
-        with urllib.request.urlopen(
-            f"https://pypi.org/pypi/{pkg}/json", timeout=timeout
-        ) as resp:
-            latest_str = json.load(resp)["info"]["version"]
-        latest = Version(latest_str)
-        if latest > current:
-            thread_logger.info(
-                "🔔  A newer version of %s is available: %s → %s (pip install -U %s)",
-                pkg,
-                current,
-                latest,
-                pkg,
-            )
-
-    except Exception:
-        pass
-
-    except RuntimeError:
-        thread_logger.info(
-            f"Failed to check for newer version of {pkg}."
-            " To disable version checks, set LANGGRAPH_NO_VERSION_CHECK=true"
-        )
-
-
 def run_server(
     host: str = "127.0.0.1",
     port: int = 2024,
@@ -176,15 +95,20 @@ def run_server(
     reload_includes: Sequence[str] | None = None,
     reload_excludes: Sequence[str] | None = None,
     store: typing.Optional["StoreConfig"] = None,
-    auth: AuthConfig | None = None,
+    auth: typing.Optional["AuthConfig"] = None,
     http: typing.Optional["HttpConfig"] = None,
     ui: dict | None = None,
+    webhooks: dict | None = None,
     ui_config: dict | None = None,
     studio_url: str | None = None,
     disable_persistence: bool = False,
     allow_blocking: bool = False,
     runtime_edition: Literal["inmem", "community", "postgres"] = "inmem",
     server_level: str = "WARNING",
+    __redis_uri__: str | None = "fake",
+    __database_uri__: str | None = ":memory:",
+    __migrations_path__: str | None = "__inmem",
+    __entrypoint__: Literal["server", "python-executor"] = "server",
     **kwargs: typing.Any,
 ):
     """Run the LangGraph API server."""
@@ -200,6 +124,8 @@ def run_server(
     mount_prefix = None
     if http is not None and http.get("mount_prefix") is not None:
         mount_prefix = http.get("mount_prefix")
+    if os.environ.get("MOUNT_PREFIX"):
+        mount_prefix = os.environ.get("MOUNT_PREFIX")
     if os.environ.get("LANGGRAPH_MOUNT_PREFIX"):
         mount_prefix = os.environ.get("LANGGRAPH_MOUNT_PREFIX")
     if isinstance(env, str | pathlib.Path):
@@ -265,16 +191,19 @@ def run_server(
     else:
         local_url = upstream_url
     to_patch = dict(
-        MIGRATIONS_PATH="__inmem",
-        DATABASE_URI=":memory:",
-        REDIS_URI="fake",
-        N_JOBS_PER_WORKER=str(n_jobs_per_worker if n_jobs_per_worker else 1),
+        MIGRATIONS_PATH=__migrations_path__,
+        DATABASE_URI=__database_uri__,
+        REDIS_URI=__redis_uri__,
+        N_JOBS_PER_WORKER=str(
+            n_jobs_per_worker if n_jobs_per_worker is not None else 1
+        ),
         LANGGRAPH_STORE=json.dumps(store) if store else None,
         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,
         LANGGRAPH_UI=json.dumps(ui) if ui else None,
+        LANGGRAPH_WEBHOOKS=json.dumps(webhooks) if webhooks else None,
         LANGGRAPH_UI_CONFIG=json.dumps(ui_config) if ui_config else None,
         LANGGRAPH_UI_BUNDLER="true",
         LANGGRAPH_API_URL=local_url,
@@ -291,7 +220,7 @@ def run_server(
             if k in to_patch:
                 logger.debug(f"Skipping loaded env var {k}={v}")
                 continue
-            to_patch[k] = v
+            to_patch[k] = v  # type: ignore[invalid-assignment]
     with patch_environment(
         **to_patch,
     ):
@@ -325,7 +254,7 @@ def run_server(
                                         full_studio_url = f"{studio_origin}/studio/?baseUrl={local_url}&organizationId={org_id}"
                                 except TimeoutError as e:
                                     thread_logger.debug(
-                                        f"Failed to get organization ID: {str(e)}"
+                                        f"Failed to get organization ID: {e!s}"
                                     )
                                     pass
                                 thread_logger.info(
@@ -354,7 +283,7 @@ def run_server(
 - 📚 API Docs: \033[36m{local_url}/docs\033[0m
 
 This in-memory server is designed for development and testing.
-For production use, please use LangGraph Platform.
+For production use, please use LangSmith Deployment.
 
 """
         logger.info(welcome)
@@ -362,8 +291,12 @@ For production use, please use LangGraph Platform.
             threading.Thread(target=_open_browser, daemon=True).start()
         nvc = os.getenv("LANGGRAPH_NO_VERSION_CHECK")
         if nvc is None or nvc.lower() not in ("true", "1"):
+            from langgraph_api import __version__
+
             threading.Thread(
-                target=_check_newer_version, args=("langgraph-api",), daemon=True
+                target=_check_newer_version,
+                args=("langgraph-api", __version__),
+                daemon=True,
             ).start()
         supported_kwargs = {
             k: v
@@ -371,40 +304,53 @@ For production use, please use LangGraph Platform.
             if k in inspect.signature(uvicorn.run).parameters
         }
         server_level = server_level.upper()
-        uvicorn.run(
-            "langgraph_api.server:app",
-            host=host,
-            port=port,
-            reload=reload,
-            env_file=env_file,
-            access_log=False,
-            reload_includes=list(reload_includes) if reload_includes else None,
-            reload_excludes=list(reload_excludes) if reload_excludes else None,
-            log_config={
-                "version": 1,
-                "incremental": False,
-                "disable_existing_loggers": False,
-                "formatters": {
-                    "simple": {
-                        "class": "langgraph_api.logging.Formatter",
-                    }
-                },
-                "handlers": {
-                    "console": {
-                        "class": "logging.StreamHandler",
-                        "formatter": "simple",
-                        "stream": "ext://sys.stdout",
-                    }
-                },
-                "loggers": {
-                    "uvicorn": {"level": server_level},
-                    "uvicorn.error": {"level": server_level},
-                    "langgraph_api.server": {"level": server_level},
+        if __entrypoint__ == "server":
+            uvicorn.run(
+                "langgraph_api.server:app",
+                host=host,
+                port=port,
+                reload=reload,
+                env_file=env_file,
+                access_log=False,
+                reload_includes=list(reload_includes) if reload_includes else None,
+                reload_excludes=list(reload_excludes) if reload_excludes else None,
+                log_config={
+                    "version": 1,
+                    "incremental": False,
+                    "disable_existing_loggers": False,
+                    "formatters": {
+                        "simple": {
+                            "class": "langgraph_api.logging.Formatter",
+                        }
+                    },
+                    "handlers": {
+                        "console": {
+                            "class": "logging.StreamHandler",
+                            "formatter": "simple",
+                            "stream": "ext://sys.stdout",
+                        }
+                    },
+                    "loggers": {
+                        "uvicorn": {"level": server_level},
+                        "uvicorn.error": {"level": server_level},
+                        "langgraph_api.server": {"level": server_level},
+                    },
+                    "root": {"handlers": ["console"]},
                 },
-                "root": {"handlers": ["console"]},
-            },
-            **supported_kwargs,
-        )
+                **supported_kwargs,
+            )
+        elif __entrypoint__ == "python-executor":
+            from langgraph_api.executor_entrypoint import (
+                main as executor_entrypoint_main,
+            )
+
+            asyncio.run(
+                executor_entrypoint_main(
+                    grpc_port=8188,
+                )
+            )
+        else:
+            raise ValueError(f"Unknown entrypoint: {__entrypoint__}")
 
 
 def main():
@@ -429,7 +375,7 @@ def main():
         help="Number of jobs per worker. Default is None (meaning 10)",
     )
     parser.add_argument(
-        "--no-browser", action="store_true", help="Disable automatic browser opening"
+        "--open-browser", action="store_true", help="Open browser automatically"
     )
     parser.add_argument(
         "--debug-port", type=int, help="Port for debugger to listen on (default: none)"
@@ -444,7 +390,19 @@ def main():
         action="store_true",
         help="Expose the server via Cloudflare Tunnel",
     )
-
+    parser.add_argument(
+        "--runtime-edition",
+        type=str,
+        default="inmem",
+        help="Runtime edition to use",
+    )
+    parser.add_argument(
+        "--entrypoint",
+        type=str,
+        default="server",
+        choices=["server", "python-executor"],
+        help="Entry point to use",
+    )
     args = parser.parse_args()
 
     with open(args.config, encoding="utf-8") as f:
@@ -453,23 +411,162 @@ def main():
     graphs = config_data.get("graphs", {})
     auth = config_data.get("auth")
     ui = config_data.get("ui")
+    webhooks = config_data.get("webhooks")
     ui_config = config_data.get("ui_config")
+    kwargs = {}
+    if args.runtime_edition == "postgres":
+        kwargs["__redis_uri__"] = os.getenv("REDIS_URI")
+        kwargs["__database_uri__"] = os.getenv("DATABASE_URI")
+        kwargs["__migrations_path__"] = os.getenv("MIGRATIONS_PATH")
+    if args.entrypoint == "python-executor":
+        kwargs["__entrypoint__"] = "python-executor"
     run_server(
         args.host,
         args.port,
         not args.no_reload,
         graphs,
         n_jobs_per_worker=args.n_jobs_per_worker,
-        open_browser=not args.no_browser,
+        open_browser=args.open_browser,
         tunnel=args.tunnel,
         debug_port=args.debug_port,
         wait_for_client=args.wait_for_client,
         env=config_data.get("env", None),
         auth=auth,
         ui=ui,
+        webhooks=webhooks,
         ui_config=ui_config,
+        runtime_edition=args.runtime_edition,
+        **kwargs,
+    )
+
+
+def _check_newer_version(pkg: str, current_version: str, timeout: float = 0.5) -> None:
+    """Check PyPI for newer versions and log support status.
+
+    Critical = one minor behind on same major, OR latest minor of previous major while latest is X.0.*
+    EOL = two+ minors behind on same major, OR any previous major after X.1.*
+    """
+    import json
+    import urllib.request
+
+    from packaging.version import InvalidVersion, Version
+
+    log = logging.getLogger("version_check")
+    if not log.handlers:
+        h = logging.StreamHandler()
+        h.setFormatter(logging.Formatter("%(message)s"))
+        log.addHandler(h)
+
+    if os.getenv("LANGGRAPH_NO_VERSION_CHECK", "").lower() in ("true", "1"):
+        return
+
+    def _parse(v: str) -> Version | None:
+        try:
+            return Version(v)
+        except InvalidVersion:
+            return None
+
+    try:
+        current = Version(current_version)
+    except InvalidVersion:
+        log.info(
+            f"[version] Could not parse installed version {current_version!r}. Skipping support check."
+        )
+        return
+
+    try:
+        with urllib.request.urlopen(
+            f"https://pypi.org/pypi/{pkg}/json", timeout=timeout
+        ) as resp:
+            payload = json.load(resp)
+        latest_str = payload["info"]["version"]
+        latest = Version(latest_str)
+        releases: dict[str, list[dict]] = payload.get("releases", {})
+    except Exception:
+        log.debug("Failed to retrieve latest version info for %s", pkg)
+        return
+    prev_major_latest_minor: Version | None = None
+    if latest.major > 0:
+        pm = latest.major - 1
+        prev_major_versions = [
+            v
+            for s in releases
+            if (v := _parse(s)) is not None and not v.is_prerelease and v.major == pm
+        ]
+        if prev_major_versions:
+            prev_major_latest_minor = max(
+                prev_major_versions, key=lambda v: (v.major, v.minor, v.micro)
+            )
+
+    if latest > current and not current.is_prerelease:
+        log.info(
+            "[version] A newer version of %s is available: %s → %s  (pip install -U %s)",
+            pkg,
+            current,
+            latest,
+            pkg,
+        )
+
+    level = _support_level(current, latest, prev_major_latest_minor)
+    changelog = (
+        "https://docs.langchain.com/langgraph-platform/langgraph-server-changelog"
     )
 
+    if level == "critical":
+        # Distinguish same-major vs cross-major grace in the wording
+        if current.major == latest.major and current.minor == latest.minor - 1:
+            tail = "You are one minor version behind the latest (%d.%d.x).\n"
+        else:
+            tail = "You are on the latest minor of the previous major while a new major (%d.%d.x) just released.\n"
+        log.info(
+            "⚠️ [support] %s %s is in Critical support.\n"
+            "Only critical security and installation fixes are provided.\n"
+            + tail
+            + "Please plan an upgrade soon. See changelog: %s",
+            pkg,
+            current,
+            latest.major,
+            latest.minor,
+            changelog,
+        )
+    elif level == "eol":
+        log.info(
+            "⚠️ [support] %s %s is End of Life.\n"
+            "No bug fixes or security updates will be provided.\n"
+            "You are two or more minor versions behind the latest (%d.%d.x).\n"
+            "You should upgrade immediately. See changelog: %s",
+            pkg,
+            current,
+            latest.major,
+            latest.minor,
+            changelog,
+        )
+
+
+def _support_level(
+    cur: "Version", lat: "Version", prev_major_latest_minor: "Version | None"
+) -> SUPPORT_STATUS:
+    if cur.major > lat.major:
+        return "active"
+    if cur.major == lat.major:
+        if cur.minor == lat.minor:
+            return "active"
+        if cur.minor == lat.minor - 1:
+            return "critical"
+        if cur.minor <= lat.minor - 2:
+            return "eol"
+        return "active"
+
+    if cur.major == lat.major - 1 and lat.minor == 0:
+        if (
+            prev_major_latest_minor is not None
+            and cur.minor == prev_major_latest_minor.minor
+        ):
+            return "critical"
+        return "eol"
+
+    return "eol"
+
 
 if __name__ == "__main__":
     main()

langgraph_api/command.py

@@ -1,3 +1,5 @@
+from typing import cast
+
 from langgraph.types import Command, Send
 
 from langgraph_api.schema import RunCommand
@@ -11,15 +13,15 @@ def map_cmd(cmd: RunCommand) -> Command:
     update = cmd.get("update")
     if isinstance(update, tuple | list) and all(
         isinstance(t, tuple | list) and len(t) == 2 and isinstance(t[0], str)
-        for t in update
+        for t in cast("list", update)
     ):
-        update = [tuple(t) for t in update]
+        update = [tuple(t) for t in cast("list", update)]
 
     return Command(
         update=update,
         goto=(
             [
-                it if isinstance(it, str) else Send(it["node"], it["input"])
+                it if isinstance(it, str) else Send(it["node"], it["input"])  # type: ignore[non-subscriptable]
                 for it in goto
             ]
             if goto