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

langgraph_api/logging.py

@@ -69,9 +69,12 @@ class AddApiVersion:
     def __call__(
         self, logger: logging.Logger, method_name: str, event_dict: EventDict
     ) -> EventDict:
-        from langgraph_api import __version__
+        try:
+            from langgraph_api import __version__
 
-        event_dict["langgraph_api_version"] = __version__
+            event_dict["langgraph_api_version"] = __version__
+        except ImportError:
+            pass
         return event_dict
 
 
@@ -117,6 +120,30 @@ class JSONRenderer:
         return json_dumpb(event_dict).decode()
 
 
+# same as Formatter, but always uses JSONRenderer. Used by OTLP log handler for self hosted logging
+class OTLPFormatter(structlog.stdlib.ProcessorFormatter):
+    def __init__(self, *args, **kwargs) -> None:
+        if len(args) == 3:
+            fmt, datefmt, style = args
+            kwargs["fmt"] = fmt
+            kwargs["datefmt"] = datefmt
+            kwargs["style"] = style
+        else:
+            raise RuntimeError(
+                f"OTLPFormatter expected 3 positional arguments (fmt, datefmt, style), "
+                f"but got {len(args)} arguments."
+            )
+        super().__init__(
+            processors=[
+                structlog.stdlib.ProcessorFormatter.remove_processors_meta,
+                AddLoggingContext(),
+                JSONRenderer(),
+            ],
+            foreign_pre_chain=shared_processors,
+            **kwargs,
+        )
+
+
 LEVELS = logging.getLevelNamesMapping()
 
 

langgraph_api/metadata.py

@@ -2,22 +2,28 @@ import asyncio
 import os
 import uuid
 from datetime import UTC, datetime
+from typing import Any
 
 import langgraph.version
 import orjson
 import structlog
 
+import langgraph_api.config as config
+from langgraph_api.auth.custom import get_auth_instance
 from langgraph_api.config import (
     LANGGRAPH_CLOUD_LICENSE_KEY,
-    LANGSMITH_API_KEY,
     LANGSMITH_AUTH_ENDPOINT,
+    LANGSMITH_CONTROL_PLANE_API_KEY,
+    LANGSMITH_LICENSE_REQUIRED_CLAIMS,
     USES_CUSTOM_APP,
     USES_CUSTOM_AUTH,
     USES_INDEXING,
     USES_STORE_TTL,
     USES_THREAD_TTL,
 )
+from langgraph_api.graph import GRAPHS, is_js_graph
 from langgraph_api.http import http_request
+from langgraph_api.js.base import is_js_path
 from langgraph_license.validation import plus_features_enabled
 
 logger = structlog.stdlib.get_logger(__name__)
@@ -56,7 +62,7 @@ NODE_COUNTER = 0
 FROM_TIMESTAMP = datetime.now(UTC).isoformat()
 
 # Beacon endpoint for license key submissions
-BEACON_ENDPOINT = "https://api.smith.langchain.com/v1/metadata/submit"
+BEACON_ENDPOINT = "https://beacon.langchain.com/v1/beacon/metadata/submit"
 
 # LangChain auth endpoint for API key submissions
 LANGCHAIN_METADATA_ENDPOINT = None
@@ -72,6 +78,36 @@ if LANGSMITH_AUTH_ENDPOINT:
         )
 
 
+def _lang_usage_metadata() -> tuple[dict[str, str], dict[str, int]]:
+    js_graph_count = sum(1 for graph_id in GRAPHS if is_js_graph(graph_id))
+    py_graph_count = len(GRAPHS) - js_graph_count
+
+    auth_instance = get_auth_instance()
+    custom_auth_enabled = auth_instance is not None
+    custom_js_auth_enabled = auth_instance == "js"
+
+    js_proxy_middleware_enabled = False
+    if (
+        config.HTTP_CONFIG
+        and (app := config.HTTP_CONFIG.get("app"))
+        and isinstance(app, str)
+    ):
+        app_path = app.split(":", 1)[0]  # type: ignore[possibly-unresolved-reference]
+        js_proxy_middleware_enabled = is_js_path(app_path)
+
+    tags = {
+        "langgraph.platform.uses_custom_auth": str(custom_auth_enabled),
+        "langgraph.platform.uses_js_custom_auth": str(custom_js_auth_enabled),
+        "langgraph.platform.uses_js_proxy_middleware": str(js_proxy_middleware_enabled),
+    }
+    measures = {
+        "langgraph.platform.py_graphs": py_graph_count,
+        "langgraph.platform.js_graphs": js_graph_count,
+    }
+
+    return tags, measures
+
+
 def incr_runs(*, incr: int = 1) -> None:
     global RUN_COUNTER
     RUN_COUNTER += incr
@@ -87,20 +123,57 @@ async def metadata_loop() -> None:
         from langgraph_api import __version__
     except ImportError:
         __version__ = None
-    if not LANGGRAPH_CLOUD_LICENSE_KEY and not LANGSMITH_API_KEY:
+    if not LANGGRAPH_CLOUD_LICENSE_KEY and not LANGSMITH_CONTROL_PLANE_API_KEY:
+        logger.info(
+            "No license key or control plane API key set, skipping metadata loop"
+        )
         return
+    lg_version = langgraph.version.__version__
 
     if (
         LANGGRAPH_CLOUD_LICENSE_KEY
         and not LANGGRAPH_CLOUD_LICENSE_KEY.startswith("lcl_")
-        and not LANGSMITH_API_KEY
+        and not LANGSMITH_CONTROL_PLANE_API_KEY
     ):
         logger.info("Running in air-gapped mode, skipping metadata loop")
         return
 
-    logger.info("Starting metadata loop")
+    # TODO: This is a temporary "hack". A user could inadvertently include
+    # 'agent_builder_enabled' in LANGSMITH_LICENSE_REQUIRED_CLAIMS for a
+    # non-Agent Builder self-hosted deployment. If the 'agent_builder_enabled'
+    # entitlement is enabled, then this would bypass the metadata loop.
+    #
+    # If the 'agent_builder_enabled' entitlement is disabled, then this is ok
+    # because the license key validation would fail and the app would not start.
+    if (
+        LANGGRAPH_CLOUD_LICENSE_KEY
+        and "agent_builder_enabled" in LANGSMITH_LICENSE_REQUIRED_CLAIMS
+    ):
+        logger.info("Skipping metadata loop for self-hosted Agent Builder")
+        return
+
+    logger.info("Starting metadata loop", endpoint=LANGCHAIN_METADATA_ENDPOINT)
 
     global RUN_COUNTER, NODE_COUNTER, FROM_TIMESTAMP
+    base_tags = _ensure_strings(
+        # Tag values must be strings.
+        {
+            "langgraph.python.version": lg_version,
+            "langgraph_api.version": __version__ or "",
+            "langgraph.platform.revision": REVISION or "",
+            "langgraph.platform.variant": VARIANT or "",
+            "langgraph.platform.host": HOST,
+            "langgraph.platform.tenant_id": TENANT_ID or "",
+            "langgraph.platform.project_id": PROJECT_ID or "",
+            "langgraph.platform.plan": PLAN,
+            # user app features
+            "user_app.uses_indexing": USES_INDEXING or "",
+            "user_app.uses_custom_app": USES_CUSTOM_APP or "",
+            "user_app.uses_custom_auth": USES_CUSTOM_AUTH or "",
+            "user_app.uses_thread_ttl": USES_THREAD_TTL or "",
+            "user_app.uses_store_ttl": USES_STORE_TTL or "",
+        }
+    )
     while True:
         # because we always read and write from coroutines in main thread
         # we don't need a lock as long as there's no awaits in this block
@@ -111,30 +184,16 @@ async def metadata_loop() -> None:
         RUN_COUNTER = 0
         NODE_COUNTER = 0
         FROM_TIMESTAMP = to_timestamp
+        usage_tags, usage_measures = _lang_usage_metadata()
 
         base_payload = {
             "from_timestamp": from_timestamp,
             "to_timestamp": to_timestamp,
-            "tags": {
-                # Tag values must be strings.
-                "langgraph.python.version": langgraph.version.__version__,
-                "langgraph_api.version": __version__ or "",
-                "langgraph.platform.revision": REVISION or "",
-                "langgraph.platform.variant": VARIANT or "",
-                "langgraph.platform.host": HOST,
-                "langgraph.platform.tenant_id": TENANT_ID or "",
-                "langgraph.platform.project_id": PROJECT_ID or "",
-                "langgraph.platform.plan": PLAN,
-                # user app features
-                "user_app.uses_indexing": str(USES_INDEXING or ""),
-                "user_app.uses_custom_app": str(USES_CUSTOM_APP or ""),
-                "user_app.uses_custom_auth": str(USES_CUSTOM_AUTH),
-                "user_app.uses_thread_ttl": str(USES_THREAD_TTL),
-                "user_app.uses_store_ttl": str(USES_STORE_TTL),
-            },
+            "tags": base_tags | _ensure_strings(usage_tags),
             "measures": {
-                "langgraph.platform.runs": runs,
-                "langgraph.platform.nodes": nodes,
+                "langgraph.platform.runs": int(runs),
+                "langgraph.platform.nodes": int(nodes),
+                **usage_measures,
             },
             "logs": [],
         }
@@ -159,7 +218,11 @@ async def metadata_loop() -> None:
                     body=orjson.dumps(beacon_payload),
                     headers={"Content-Type": "application/json"},
                 )
-                await logger.ainfo("Successfully submitted metadata to beacon endpoint")
+                await logger.ainfo(
+                    "Successfully submitted metadata to beacon endpoint",
+                    n_runs=runs,
+                    n_nodes=nodes,
+                )
             except Exception as e:
                 submissions_failed.append("beacon")
                 await logger.awarning(
@@ -167,10 +230,10 @@ async def metadata_loop() -> None:
                 )
 
         # 2. Send to langchain auth endpoint if API key is set
-        if LANGSMITH_API_KEY and LANGCHAIN_METADATA_ENDPOINT:
+        if LANGSMITH_CONTROL_PLANE_API_KEY and LANGCHAIN_METADATA_ENDPOINT:
             langchain_payload = {
                 **base_payload,
-                "api_key": LANGSMITH_API_KEY,
+                "api_key": LANGSMITH_CONTROL_PLANE_API_KEY,
             }
             submissions_attempted.append("langchain")
             try:
@@ -180,7 +243,11 @@ async def metadata_loop() -> None:
                     body=orjson.dumps(langchain_payload),
                     headers={"Content-Type": "application/json"},
                 )
-                logger.info("Successfully submitted metadata to LangSmith instance")
+                logger.info(
+                    "Successfully submitted metadata to LangSmith instance",
+                    n_runs=runs,
+                    n_nodes=nodes,
+                )
             except Exception as e:
                 submissions_failed.append("langchain")
                 await logger.awarning(
@@ -201,3 +268,7 @@ async def metadata_loop() -> None:
             )
 
         await asyncio.sleep(INTERVAL)
+
+
+def _ensure_strings(payload: dict[str, Any]) -> dict[str, Any]:
+    return {k: "" if v is None else str(v) for k, v in payload.items()}

langgraph_api/middleware/http_logger.py

@@ -5,11 +5,13 @@ import structlog
 from starlette.requests import ClientDisconnect
 from starlette.types import Message, Receive, Scope, Send
 
+from langgraph_api.config import MOUNT_PREFIX
 from langgraph_api.http_metrics import HTTP_METRICS_COLLECTOR
 from langgraph_api.utils.headers import should_include_header_in_logs
 
 asgi = structlog.stdlib.get_logger("asgi")
 
+
 PATHS_IGNORE = {"/ok", "/metrics"}
 
 
@@ -37,7 +39,10 @@ class AccessLoggerMiddleware:
             self.debug_enabled = False
 
     async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
-        if scope["type"] != "http" or scope.get("path") in PATHS_IGNORE:
+        if (
+            scope["type"] != "http"
+            or scope.get("path", "").replace(MOUNT_PREFIX or "", "") in PATHS_IGNORE
+        ):
             return await self.app(scope, receive, send)  # pragma: no cover
 
         loop = asyncio.get_event_loop()
@@ -92,7 +97,7 @@ class AccessLoggerMiddleware:
                 path=path,
                 status=status,
                 latency_ms=latency,
-                route=route,
+                route=str(route),
                 path_params=scope.get("path_params"),
                 query_string=qs.decode() if qs else "",
                 proto=scope.get("http_version"),

langgraph_api/middleware/private_network.py

@@ -25,19 +25,19 @@ class PrivateNetworkMiddleware(BaseHTTPMiddleware):
     A web browser determines whether a network is private based on IP address ranges
     and local networking conditions. Typically, it checks:
 
-    IP Address Range – If the website is hosted on an IP within private address
+    IP Address Range - If the website is hosted on an IP within private address
     ranges (RFC 1918):
 
-    10.0.0.0 – 10.255.255.255
-    172.16.0.0 – 172.31.255.255
-    192.168.0.0 – 192.168.255.255
+    10.0.0.0 - 10.255.255.255
+    172.16.0.0 - 172.31.255.255
+    192.168.0.0 - 192.168.255.255
     127.0.0.1 (loopback)
-    Localhost and Hostname – Domains like localhost or .local are assumed to be private.
+    Localhost and Hostname - Domains like localhost or .local are assumed to be private.
 
-    Network Context – The browser may check if the device is connected
+    Network Context - The browser may check if the device is connected
     to a local network (e.g., corporate or home Wi-Fi) rather than the public internet.
 
-    CORS and Private Network Access (PNA) – Modern browsers implement restrictions
+    CORS and Private Network Access (PNA) - Modern browsers implement restrictions
     where resources on private networks require explicit permission (via CORS headers)
     when accessed from a public site.
     """

langgraph_api/models/run.py

@@ -1,19 +1,20 @@
 import asyncio
 import contextlib
 import time
-import urllib.parse
 import uuid
 from collections.abc import Mapping, Sequence
-from typing import Any, NamedTuple, cast
+from typing import TYPE_CHECKING, Any, NamedTuple, cast
 from uuid import UUID
 
-import orjson
 import structlog
-from starlette.authentication import BaseUser
 from starlette.exceptions import HTTPException
 from typing_extensions import TypedDict
 
+from langgraph_api.encryption.middleware import encrypt_request
+from langgraph_api.feature_flags import FF_USE_CORE_API
 from langgraph_api.graph import GRAPHS, get_assistant_id
+from langgraph_api.grpc.ops import Runs as GrpcRuns
+from langgraph_api.otel_context import inject_current_trace_context
 from langgraph_api.schema import (
     All,
     Config,
@@ -26,11 +27,17 @@ from langgraph_api.schema import (
     RunCommand,
     StreamMode,
 )
-from langgraph_api.utils import AsyncConnectionProto, get_auth_ctx
-from langgraph_api.utils.headers import should_include_header
+from langgraph_api.utils import AsyncConnectionProto, get_auth_ctx, get_user_id
+from langgraph_api.utils.headers import get_configurable_headers
 from langgraph_api.utils.uuids import uuid7
+from langgraph_api.webhook import validate_webhook_url_or_raise
 from langgraph_runtime.ops import Runs
 
+CrudRuns = GrpcRuns if FF_USE_CORE_API else Runs
+
+if TYPE_CHECKING:
+    from starlette.authentication import BaseUser
+
 logger = structlog.stdlib.get_logger(__name__)
 
 
@@ -84,13 +91,13 @@ class RunCreateDict(TypedDict):
     stream_mode: list[StreamMode] | StreamMode
     """One or more of "values", "messages", "updates" or "events".
     - "values": Stream the thread state any time it changes.
-    - "messages": Stream chat messages from thread state and calls to chat models, 
+    - "messages": Stream chat messages from thread state and calls to chat models,
       token-by-token where possible.
     - "updates": Stream the state updates returned by each node.
     - "events": Stream all events produced by sub-runs (eg. nodes, LLMs, etc.).
     - "custom": Stream custom events produced by your nodes.
-    
-    Note: __interrupt__ events are always included in the updates stream, even when "updates" 
+
+    Note: __interrupt__ events are always included in the updates stream, even when "updates"
     is not explicitly requested, to ensure interrupt events are always visible.
     """
     stream_subgraphs: bool | None
@@ -106,6 +113,8 @@ class RunCreateDict(TypedDict):
     """Create the thread if it doesn't exist. If False, reply with 404."""
     langsmith_tracer: LangSmithTracer | None
     """Configuration for additional tracing with LangSmith."""
+    durability: str | None
+    """Durability level for the run. Must be one of 'sync', 'async', or 'exit'."""
 
 
 def ensure_ids(
@@ -147,7 +156,7 @@ def ensure_ids(
             ) from None
     else:
         results.append(None)
-    return tuple(results)
+    return tuple(results)  # type: ignore[invalid-return-type]
 
 
 def assign_defaults(
@@ -166,81 +175,6 @@ def assign_defaults(
     return stream_mode, multitask_strategy, prevent_insert_if_inflight
 
 
-def get_user_id(user: BaseUser | None) -> str | None:
-    if user is None:
-        return None
-    try:
-        return user.identity
-    except NotImplementedError:
-        try:
-            return user.display_name
-        except NotImplementedError:
-            pass
-
-
-LANGSMITH_METADATA = "langsmith-metadata"
-LANGSMITH_TAGS = "langsmith-tags"
-LANGSMITH_PROJECT = "langsmith-project"
-
-
-# Default headers to exclude from run configuration for security
-DEFAULT_RUN_HEADERS_EXCLUDE = {"x-api-key", "x-tenant-id", "x-service-key"}
-
-
-def get_configurable_headers(headers: Mapping[str, str]) -> dict[str, str]:
-    """Extract headers that should be added to run configuration.
-
-    This function handles special cases like langsmith-trace and baggage headers,
-    while respecting the configurable header patterns.
-    """
-    configurable = {}
-
-    for key, value in headers.items():
-        # First handle tracing stuff - always included regardless of patterns
-        if key == "langsmith-trace":
-            configurable[key] = value
-            if baggage := headers.get("baggage"):
-                for item in baggage.split(","):
-                    baggage_key, baggage_value = item.split("=")
-                    if (
-                        baggage_key == LANGSMITH_METADATA
-                        and baggage_key not in configurable
-                    ):
-                        configurable[baggage_key] = orjson.loads(
-                            urllib.parse.unquote(baggage_value)
-                        )
-                    elif baggage_key == LANGSMITH_TAGS:
-                        configurable[baggage_key] = urllib.parse.unquote(
-                            baggage_value
-                        ).split(",")
-                    elif baggage_key == LANGSMITH_PROJECT:
-                        configurable[baggage_key] = urllib.parse.unquote(baggage_value)
-            continue
-
-        # Check if header should be included based on patterns
-        # For run configuration, we have specific default behavior for x-* headers
-        if key.startswith("x-"):
-            # Check against default excludes for x-* headers
-            if key in DEFAULT_RUN_HEADERS_EXCLUDE:
-                # Check if explicitly included via patterns
-                if should_include_header(key):
-                    configurable[key] = value
-                continue
-            # Other x-* headers are included by default unless patterns exclude them
-            if should_include_header(key):
-                configurable[key] = value
-        elif key == "user-agent":
-            # user-agent is included by default unless excluded by patterns
-            if should_include_header(key):
-                configurable[key] = value
-        else:
-            # All other headers only included if patterns allow
-            if should_include_header(key):
-                configurable[key] = value
-
-    return configurable
-
-
 async def create_valid_run(
     conn: AsyncConnectionProto,
     thread_id: str | None,
@@ -301,10 +235,12 @@ async def create_valid_run(
     if checkpoint := payload.get("checkpoint"):
         configurable.update(checkpoint)
     configurable.update(get_configurable_headers(headers))
+    inject_current_trace_context(configurable)
     ctx = get_auth_ctx()
     if ctx:
-        user = cast(BaseUser | None, ctx.user)
+        user = cast("BaseUser | None", ctx.user)
         user_id = get_user_id(user)
+        # Store user as-is; encryption middleware will serialize if needed
         configurable["langgraph_auth_user"] = user
         configurable["langgraph_auth_user_id"] = user_id
         configurable["langgraph_auth_permissions"] = ctx.permissions
@@ -317,19 +253,43 @@ async def create_valid_run(
         configurable["__langsmith_example_id__"] = ls_tracing.get("example_id")
     if request_start_time:
         configurable["__request_start_time_ms__"] = request_start_time
-    after_seconds = payload.get("after_seconds", 0)
+    after_seconds = cast("int", payload.get("after_seconds", 0))
     configurable["__after_seconds__"] = after_seconds
+    # Note: encryption context is injected by encrypt_request → encrypt_json_if_needed
+    # as the __encryption_context__ marker. Worker reads it before decryption.
     put_time_start = time.time()
     if_not_exists = payload.get("if_not_exists", "reject")
 
-    run_coro = Runs.put(
-        conn,
-        assistant_id,
+    durability = payload.get("durability")
+    if durability is None:
+        checkpoint_during = payload.get("checkpoint_during")
+        durability = "async" if checkpoint_during in (None, True) else "exit"
+
+    if webhook := payload.get("webhook"):
+        await validate_webhook_url_or_raise(str(webhook))
+
+    # We can't pass payload directly because config and context have
+    # been modified above (with auth context, checkpoint info, etc.)
+    encrypted = await encrypt_request(
         {
+            "metadata": payload.get("metadata"),
             "input": payload.get("input"),
-            "command": payload.get("command"),
             "config": config,
             "context": context,
+            "command": payload.get("command"),
+        },
+        "run",
+        ["metadata", "input", "config", "context", "command"],
+    )
+
+    run_coro = CrudRuns.put(
+        conn,
+        assistant_id,
+        {
+            "input": encrypted.get("input"),
+            "command": encrypted.get("command"),
+            "config": encrypted.get("config"),
+            "context": encrypted.get("context"),
             "stream_mode": stream_mode,
             "interrupt_before": payload.get("interrupt_before"),
             "interrupt_after": payload.get("interrupt_after"),
@@ -339,8 +299,9 @@ async def create_valid_run(
             "subgraphs": payload.get("stream_subgraphs", False),
             "resumable": stream_resumable,
             "checkpoint_during": payload.get("checkpoint_during", True),
+            "durability": durability,
         },
-        metadata=payload.get("metadata"),
+        metadata=encrypted.get("metadata"),
         status="pending",
         user_id=user_id,
         thread_id=thread_id_,
@@ -389,7 +350,7 @@ async def create_valid_run(
         if multitask_strategy in ("interrupt", "rollback") and inflight_runs:
             with contextlib.suppress(HTTPException):
                 # if we can't find the inflight runs again, we can proceeed
-                await Runs.cancel(
+                await CrudRuns.cancel(
                     conn,
                     [run["run_id"] for run in inflight_runs],
                     thread_id=thread_id_,