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

langgraph_api/api/openapi.py

@@ -5,12 +5,7 @@ from functools import lru_cache
 
 import orjson
 
-from langgraph_api.config import (
-    HTTP_CONFIG,
-    LANGGRAPH_AUTH,
-    LANGGRAPH_AUTH_TYPE,
-    MOUNT_PREFIX,
-)
+from langgraph_api import config
 from langgraph_api.graph import GRAPHS
 from langgraph_api.validation import openapi
 
@@ -39,17 +34,20 @@ def get_openapi_spec() -> bytes:
             graph_ids
         )
     # patch the auth schemes
-    if LANGGRAPH_AUTH_TYPE == "langsmith":
+    if config.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:
+    if config.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(config.LANGGRAPH_AUTH, dict)
+            and "openapi" in config.LANGGRAPH_AUTH
+        ):
+            openapi_config = config.LANGGRAPH_AUTH["openapi"]
             if isinstance(openapi_config, dict):
                 # Add security schemes
                 if "securitySchemes" in openapi_config:
@@ -82,8 +80,13 @@ def get_openapi_spec() -> bytes:
             )
 
     # Remove webhook parameters if webhooks are disabled
-    if HTTP_CONFIG and HTTP_CONFIG.get("disable_webhooks"):
-        webhook_schemas = ["CronCreate", "RunCreateStateful", "RunCreateStateless"]
+    if config.WEBHOOKS_ENABLED:
+        webhook_schemas = [
+            "CronCreate",
+            "ThreadCronCreate",
+            "RunCreateStateful",
+            "RunCreateStateless",
+        ]
         for schema_name in webhook_schemas:
             if schema_name in openapi["components"]["schemas"]:
                 schema = openapi["components"]["schemas"][schema_name]
@@ -96,14 +99,21 @@ def get_openapi_spec() -> bytes:
     final = openapi
     if CUSTOM_OPENAPI_SPEC:
         final = merge_openapi_specs(openapi, CUSTOM_OPENAPI_SPEC)
-    if MOUNT_PREFIX:
-        final["servers"] = [{"url": MOUNT_PREFIX}]
-
-    MCP_ENABLED = HTTP_CONFIG is None or not HTTP_CONFIG.get("disable_mcp")
+    if config.MOUNT_PREFIX:
+        final["servers"] = [{"url": config.MOUNT_PREFIX}]
 
-    if not MCP_ENABLED:
+    if not config.MCP_ENABLED:
         # Remove the MCP paths from the OpenAPI spec
         final["paths"].pop("/mcp/", None)
+        # Remove the MCP tag definition
+        final["tags"] = [t for t in final.get("tags", []) if t.get("name") != "MCP"]
+
+    if not config.A2A_ENABLED:
+        # Remove the A2A paths from the OpenAPI spec
+        final["paths"].pop("/a2a/{assistant_id}", None)
+        final["paths"].pop("/.well-known/agent-card.json", None)
+        # Remove the A2A tag definition
+        final["tags"] = [t for t in final.get("tags", []) if t.get("name") != "A2A"]
 
     return orjson.dumps(final)
 

langgraph_api/api/profile.py

@@ -0,0 +1,108 @@
+import asyncio
+import contextlib
+import os
+import shutil
+import subprocess
+import tempfile
+import time
+from typing import Literal
+
+import structlog
+from starlette.responses import JSONResponse, Response
+from starlette.routing import BaseRoute
+
+from langgraph_api import config
+from langgraph_api.route import ApiRequest, ApiRoute
+
+logger = structlog.stdlib.get_logger(__name__)
+
+
+def _clamp_duration(seconds: int) -> int:
+    seconds = max(1, seconds)
+    return min(seconds, max(1, config.FF_PYSPY_PROFILING_MAX_DURATION_SECS))
+
+
+async def _profile_with_pyspy(seconds: int, fmt: Literal["svg"]) -> Response:
+    """Run py-spy against the current process for N seconds and return SVG."""
+    pyspy = shutil.which("py-spy")
+    if not pyspy:
+        return JSONResponse({"error": "py-spy not found on PATH"}, status_code=501)
+
+    # py-spy writes to a file; use a temp file then return its contents.
+    fd, path = tempfile.mkstemp(suffix=".svg")
+    os.close(fd)
+    try:
+        pid = os.getpid()
+        # Example:
+        # py-spy record -p <pid> -d <seconds> --format flamegraph -o out.svg
+        cmd = [
+            pyspy,
+            "record",
+            "-p",
+            str(pid),
+            "-d",
+            str(seconds),
+            "--format",
+            "flamegraph",
+            "-o",
+            path,
+        ]
+        proc = await asyncio.create_subprocess_exec(
+            *cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE
+        )
+        try:
+            _, stderr = await asyncio.wait_for(proc.communicate(), timeout=seconds + 15)
+        except TimeoutError:
+            with contextlib.suppress(ProcessLookupError):
+                proc.kill()
+            return JSONResponse(
+                {
+                    "error": "py-spy timed out",
+                    "hint": "Check ptrace permissions or reduce duration",
+                },
+                status_code=504,
+            )
+        if proc.returncode != 0:
+            # Common failures: missing ptrace capability in containers.
+            msg = stderr.decode("utf-8", errors="ignore") if stderr else "py-spy failed"
+            await logger.awarning("py-spy failed", returncode=proc.returncode, msg=msg)
+            return JSONResponse(
+                {
+                    "error": "py-spy failed",
+                    "detail": msg,
+                    "hint": "Ensure the container has CAP_SYS_PTRACE / seccomp=unconfined",
+                },
+                status_code=500,
+            )
+
+        with open(path, "rb") as f:
+            content = f.read()
+        ts = int(time.time())
+        return Response(
+            content,
+            media_type="image/svg+xml",
+            headers={
+                "Content-Disposition": f"inline; filename=pyspy-{ts}.svg",
+                "Cache-Control": "no-store",
+            },
+        )
+    finally:
+        with contextlib.suppress(FileNotFoundError):
+            os.remove(path)
+
+
+async def profile(request: ApiRequest):
+    if not config.FF_PYSPY_PROFILING_ENABLED:
+        return JSONResponse({"error": "Profiling disabled"}, status_code=403)
+
+    params = request.query_params
+    try:
+        seconds = _clamp_duration(int(params.get("seconds", "15")))
+    except ValueError:
+        return JSONResponse({"error": "Invalid seconds"}, status_code=400)
+    return await _profile_with_pyspy(seconds, "svg")
+
+
+profile_routes: list[BaseRoute] = [
+    ApiRoute("/profile", profile, methods=["GET"]),
+]