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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langgraph-api
-Version: 0.7.91
+Version: 0.7.92
 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.92/langgraph_api/__init__.py

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

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

@@ -480,7 +480,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 +526,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.92}/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/__init__.py

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