langgraph-api 0.7.91__tar.gz → 0.7.94__tar.gz

{langgraph_api-0.7.91 → langgraph_api-0.7.94}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langgraph-api
-Version: 0.7.91
+Version: 0.7.94
 Author-email: Will Fu-Hinthorn <will@langchain.dev>, Josh Rogers <josh@langchain.dev>, Parker Rule <parker@langchain.dev>
 License: Elastic-2.0
 License-File: LICENSE

langgraph_api-0.7.94/langgraph_api/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.7.94"

{langgraph_api-0.7.91 → langgraph_api-0.7.94}/langgraph_api/_checkpointer/_adapter.py

@@ -22,6 +22,7 @@ from langgraph.pregel import Pregel
 from langgraph_grpc_common.checkpointer import GrpcCheckpointer
 
 from langgraph_api import config, timing
+from langgraph_api.asyncio import as_asynccontextmanager
 from langgraph_api.grpc.client import get_shared_client
 from langgraph_api.timing import profiled_import
 from langgraph_api.utils.config import run_in_executor
@@ -375,15 +376,9 @@ async def collect_checkpointer_from_env() -> None:
 async def _yield_checkpointer(value: Any):
     if isinstance(value, BaseCheckpointSaver):
         yield value
-    # Async context manager
-    elif hasattr(value, "__aenter__") and hasattr(value, "__aexit__"):
-        async with value as ctx_value:
+    elif hasattr(value, "__aenter__") or hasattr(value, "__enter__"):
+        async with as_asynccontextmanager(value) as ctx_value:
             yield ctx_value
-    # Sync context manager
-    elif hasattr(value, "__enter__") and hasattr(value, "__exit__"):
-        with value as ctx_value:
-            yield ctx_value
-    # async factory
     elif asyncio.iscoroutine(value):
         result = await value
         if not isinstance(result, BaseCheckpointSaver):
@@ -391,7 +386,6 @@ async def _yield_checkpointer(value: Any):
                 "Custom checkpointer must resolve to a BaseCheckpointSaver instance."
             )
         yield result
-    # factory
     elif callable(value):
         async with _yield_checkpointer(value()) as ctx_value:
             yield ctx_value

{langgraph_api-0.7.91 → langgraph_api-0.7.94}/langgraph_api/asyncio.py

@@ -1,7 +1,7 @@
 import asyncio
 import concurrent.futures
 from collections.abc import AsyncIterator, Coroutine
-from contextlib import AbstractAsyncContextManager, suppress
+from contextlib import AbstractAsyncContextManager, asynccontextmanager, suppress
 from functools import partial
 from typing import Any, Generic, TypeVar
 
@@ -14,6 +14,25 @@ logger = structlog.stdlib.get_logger(__name__)
 _MAIN_LOOP: asyncio.AbstractEventLoop | None = None
 
 
+@asynccontextmanager
+async def as_asynccontextmanager(value: Any) -> AsyncIterator[Any]:
+    """Normalize an async CM, sync CM, or coroutine into a single async context manager.
+
+    Handles the three factory return styles used across graph, store, and checkpointer
+    loading without duplicating the dispatch logic.
+    """
+    if hasattr(value, "__aenter__") and hasattr(value, "__aexit__"):
+        async with value as result:
+            yield result
+    elif hasattr(value, "__enter__") and hasattr(value, "__exit__"):
+        with value as result:
+            yield result
+    elif asyncio.iscoroutine(value):
+        yield await value
+    else:
+        yield value
+
+
 def set_event_loop(loop: asyncio.AbstractEventLoop) -> None:
     global _MAIN_LOOP
     _MAIN_LOOP = loop

{langgraph_api-0.7.91 → langgraph_api-0.7.94}/langgraph_api/graph.py

@@ -34,6 +34,7 @@ from langgraph_api._factory_utils import (
     is_factory,
     is_for_execution,
 )
+from langgraph_api.asyncio import as_asynccontextmanager
 from langgraph_api.feature_flags import (
     IS_POSTGRES_OR_GRPC_BACKEND,
     USE_RUNTIME_CONTEXT_API,
@@ -169,9 +170,59 @@ def _log_slow_graph_generation(
         )
 
 
+_ddtracer: Any = None
+
+
+def _get_ddtracer() -> Any:
+    """Return the ddtrace tracer singleton, or None if ddtrace is not installed."""
+    global _ddtracer
+    if not hasattr(_get_ddtracer, "_checked"):
+        _get_ddtracer._checked = True
+        try:
+            from ddtrace import tracer  # type: ignore[unresolved-import]  # noqa: PLC0415, I001
+
+            _ddtracer = tracer
+        except ImportError:
+            # ddtrace is an optional dependency; tracing is silently disabled when absent.
+            pass
+    return _ddtracer
+
+
+def _start_graph_load_span(graph_id: str, access_context: str | None) -> Any:
+    """Start a ddtrace span covering graph factory __aenter__ time.
+
+    Starting before __aenter__ means HTTP calls made by the factory appear as
+    children of this span. Returns the span, or None if ddtrace is unavailable.
+    """
+    ddtracer = _get_ddtracer()
+    if ddtracer is None:
+        return None
+    try:
+        span = ddtracer.start_span("langgraph.graph_load")
+        span.set_tag("graph_id", graph_id)
+        if access_context:
+            span.set_tag("access_context", access_context)
+        return span
+    except Exception:
+        return None
+
+
+def _finish_graph_load_span(span: Any, value_type: str) -> None:
+    if span is None:
+        return
+    try:
+        span.set_tag("value_type", value_type)
+        span.finish()
+    except Exception:
+        pass  # Tracing must never interfere with application logic
+
+
 @asynccontextmanager
 async def _generate_graph(
-    value: Any, graph_id: str, run_id: str | None = None
+    value: Any,
+    graph_id: str,
+    run_id: str | None = None,
+    access_context: str | None = None,
 ) -> AsyncIterator[Any]:
     """Yield a graph object regardless of its type.
 
@@ -183,20 +234,15 @@ async def _generate_graph(
     value_type = type(value).__name__
     if isinstance(value, Pregel | BaseRemotePregel):
         yield value
-    elif hasattr(value, "__aenter__") and hasattr(value, "__aexit__"):
-        async with value as ctx_value:
-            _log_slow_graph_generation(start, value_type, graph_id, run_id=run_id)
-            yield ctx_value
-    elif hasattr(value, "__enter__") and hasattr(value, "__exit__"):
-        with value as ctx_value:
+        return
+    span = _start_graph_load_span(graph_id, access_context)
+    try:
+        async with as_asynccontextmanager(value) as ctx_value:
             _log_slow_graph_generation(start, value_type, graph_id, run_id=run_id)
+            _finish_graph_load_span(span, value_type)
             yield ctx_value
-    elif asyncio.iscoroutine(value):
-        result = await value
-        _log_slow_graph_generation(start, value_type, graph_id, run_id=run_id)
-        yield result
-    else:
-        yield value
+    finally:
+        _finish_graph_load_span(span, value_type)
 
 
 def is_js_graph(graph_id: str) -> TypeGuard[BaseRemotePregel]:
@@ -246,7 +292,9 @@ async def get_graph(
 
         value = invoke_factory(value, graph_id, config, server_runtime)
     try:
-        async with _generate_graph(value, graph_id, run_id=run_id) as graph_obj:
+        async with _generate_graph(
+            value, graph_id, run_id=run_id, access_context=access_context
+        ) as graph_obj:
             if isinstance(graph_obj, StateGraph):
                 graph_obj = graph_obj.compile()
             if not isinstance(graph_obj, Pregel | BaseRemotePregel):
@@ -480,7 +528,7 @@ async def collect_graphs_from_env(register: bool = False) -> None:
         for task in js_bg_tasks:
             task.add_done_callback(_handle_exception)
 
-        await wait_until_js_ready()
+        await wait_until_js_ready(js_bg_tasks)
 
         for spec in js_specs:
             graph = RemotePregel(graph_id=spec.id)
@@ -526,6 +574,43 @@ def _metadata_fn(spec: GraphSpec) -> dict[str, Any]:
     return {"graph_id": spec.id, "module": spec.module, "path": spec.path}
 
 
+def patch_packages_distributions() -> None:
+    """Cache importlib.metadata.packages_distributions() to avoid repeated full scans.
+
+    google-api-core >=2.28.0 calls packages_distributions() — an uncached O(N)
+    scan of every installed package's RECORD file — 13+ times at import time
+    (once per google.cloud.* sub-package).  With ddtrace's import hooks each
+    call takes ~13 s in production, totalling ~170 s.
+
+    The installed-package set never changes during a process lifetime, so a
+    single cached result is safe and reduces 13 scans to 1.
+
+    Controlled by LSD_CACHE_PACKAGES_DISTRIBUTIONS (default "false").
+    Set to "true" to enable.
+    """
+    if os.environ.get("LSD_CACHE_PACKAGES_DISTRIBUTIONS", "false").lower() != "true":
+        return
+
+    import importlib.metadata  # noqa: PLC0415
+
+    if getattr(importlib.metadata.packages_distributions, "_cached", False):
+        return
+
+    logger.info("Caching importlib.metadata.packages_distributions()")
+
+    original = importlib.metadata.packages_distributions
+    cache: dict | None = None
+
+    def _cached():
+        nonlocal cache
+        if cache is None:
+            cache = original()
+        return cache
+
+    _cached._cached = True
+    importlib.metadata.packages_distributions = _cached
+
+
 @timing.timer(
     message="Importing graph with id {graph_id}",
     metadata_fn=_metadata_fn,

{langgraph_api-0.7.91 → langgraph_api-0.7.94}/langgraph_api/js/remote.py

@@ -414,8 +414,19 @@ async def run_js_process(paths_str: str | None, watch: bool = False):
                     **os.environ,
                 },
             )
-            logger.info("Started JS graphs process [%d]", process.pid)
+            logger.info(
+                "Started JS graphs process",
+                pid=process.pid,
+                attempt=attempt,
+                args=args,
+            )
             code = await process.wait()
+            logger.error(
+                "JS graphs process exited unexpectedly",
+                pid=process.pid,
+                exit_code=code,
+                attempt=attempt,
+            )
             raise Exception(f"JS process exited with code {code}")
         except asyncio.CancelledError:
             logger.info("Terminating JS graphs process")
@@ -462,9 +473,20 @@ async def run_js_http_process(
             )
 
             pid = process.pid
-            logger.info("Started JS HTTP process [%d]", pid)
+            logger.info(
+                "Started JS HTTP process",
+                pid=pid,
+                attempt=attempt,
+                args=args,
+            )
 
             code = await process.wait()
+            logger.error(
+                "JS HTTP process exited unexpectedly",
+                pid=pid,
+                exit_code=code,
+                attempt=attempt,
+            )
             raise Exception(f"JS HTTP process exited with code {code}")
 
         except asyncio.CancelledError:
@@ -806,7 +828,9 @@ class DisableHttpxLoggingContextManager(contextlib.AbstractContextManager):
         logging.getLogger("httpx").removeFilter(self.filter)
 
 
-async def wait_until_js_ready():
+async def wait_until_js_ready(
+    bg_tasks: set[asyncio.Task] | None = None,
+):
     with DisableHttpxLoggingContextManager():
         async with (
             httpx.AsyncClient(
@@ -821,19 +845,50 @@ async def wait_until_js_ready():
             ) as checkpointer_client,
         ):
             attempt = 0
+            graph_ready = False
             while (
                 current_task := asyncio.current_task()
             ) and not current_task.cancelled():
+                if bg_tasks:
+                    for task in bg_tasks:
+                        if task.done():
+                            exc = task.exception() if not task.cancelled() else None
+                            logger.error(
+                                "JS background task finished while waiting for"
+                                " JS ready",
+                                task_name=task.get_name(),
+                                task_cancelled=task.cancelled(),
+                                task_exception=repr(exc) if exc else None,
+                            )
+                            raise RuntimeError(
+                                f"JS background task '{task.get_name()}' died"
+                                " during startup"
+                            ) from exc
                 try:
-                    res = await graph_client.get("/ok")
-                    res.raise_for_status()
+                    if not graph_ready:
+                        res = await graph_client.get("/ok")
+                        res.raise_for_status()
+                        graph_ready = True
                     res = await checkpointer_client.get("/ok")
                     res.raise_for_status()
                     return
-                except httpx.HTTPError:
+                except httpx.HTTPError as exc:
                     if attempt > 240:
+                        logger.exception(
+                            "Timed out waiting for JS process to become ready",
+                            attempts=attempt,
+                            graph_ready=graph_ready,
+                        )
                         raise
                     else:
+                        if attempt % 20 == 0 and attempt > 0:
+                            logger.warning(
+                                "Still waiting for JS process to become ready",
+                                attempts=attempt,
+                                elapsed_seconds=attempt * 0.5,
+                                graph_ready=graph_ready,
+                                last_error=repr(exc),
+                            )
                         attempt += 1
                         await asyncio.sleep(0.5)
 

{langgraph_api-0.7.91 → langgraph_api-0.7.94}/langgraph_api/metrics_datadog.py

@@ -247,6 +247,14 @@ class DatadogMetricsReporter:
                         Histogram: AggregationTemporality.DELTA,
                     },
                 )
+                # Burn after reading: remove DD keys from env so user code
+                # and child processes cannot access them.
+                for key in (
+                    "LSD_DD_API_KEY",
+                    "LSD_DD_ENDPOINT",
+                ):
+                    os.environ.pop(key, None)
+
                 reader = PeriodicExportingMetricReader(
                     _FilteringExporter(base_exporter),
                     export_interval_millis=10_000,

{langgraph_api-0.7.91 → langgraph_api-0.7.94}/langgraph_api/store.py

@@ -13,6 +13,7 @@ from langgraph.pregel import Pregel
 from langgraph.store.base import BaseStore
 
 from langgraph_api import config, timing
+from langgraph_api.asyncio import as_asynccontextmanager
 from langgraph_api.timing import profiled_import
 from langgraph_api.utils.config import run_in_executor
 
@@ -50,14 +51,13 @@ async def exit_store():
 async def _yield_store(value: Any):
     if isinstance(value, BaseStore):
         yield value
-    elif hasattr(value, "__aenter__") and hasattr(value, "__aexit__"):
-        async with value as ctx_value:
+    elif (
+        hasattr(value, "__aenter__")
+        or hasattr(value, "__enter__")
+        or asyncio.iscoroutine(value)
+    ):
+        async with as_asynccontextmanager(value) as ctx_value:
             yield ctx_value
-    elif hasattr(value, "__enter__") and hasattr(value, "__exit__"):
-        with value as ctx_value:
-            yield ctx_value
-    elif asyncio.iscoroutine(value):
-        yield await value
     elif callable(value):
         async with _yield_store(value()) as ctx_value:
             yield ctx_value

langgraph_api-0.7.91/langgraph_api/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.7.91"