langgraph-api 0.0.26__py3-none-any.whl → 0.0.28rc1__py3-none-any.whl

langgraph_api/lifespan.py

@@ -1,3 +1,4 @@
+import asyncio
 from contextlib import asynccontextmanager
 
 from starlette.applications import Starlette
@@ -8,13 +9,17 @@ from langgraph_api.cron_scheduler import cron_scheduler
 from langgraph_api.graph import collect_graphs_from_env, stop_remote_graphs
 from langgraph_api.http import start_http_client, stop_http_client
 from langgraph_api.metadata import metadata_loop
-from langgraph_api.queue import queue
 from langgraph_license.validation import get_license_status, plus_features_enabled
 from langgraph_storage.database import start_pool, stop_pool
+from langgraph_storage.queue import queue
 
 
 @asynccontextmanager
-async def lifespan(app: Starlette):
+async def lifespan(
+    app: Starlette | None = None,
+    with_cron_scheduler: bool = True,
+    taskset: set[asyncio.Task] | None = None,
+):
     if not await get_license_status():
         raise ValueError(
             "License verification failed. Please ensure proper configuration:\n"
@@ -29,10 +34,15 @@ async def lifespan(app: Starlette):
     await start_pool()
     await collect_graphs_from_env(True)
     try:
-        async with SimpleTaskGroup(cancel=True) as tg:
+        async with SimpleTaskGroup(cancel=True, taskset=taskset) as tg:
             tg.create_task(metadata_loop())
-            tg.create_task(queue(config.N_JOBS_PER_WORKER, config.BG_JOB_TIMEOUT_SECS))
-            if config.FF_CRONS_ENABLED and plus_features_enabled():
+            if config.N_JOBS_PER_WORKER > 0:
+                tg.create_task(queue())
+            if (
+                with_cron_scheduler
+                and config.FF_CRONS_ENABLED
+                and plus_features_enabled()
+            ):
                 tg.create_task(cron_scheduler())
             yield
     finally:

langgraph_api/logging.py

@@ -1,5 +1,6 @@
 import logging
 import os
+import threading
 
 import structlog
 from starlette.config import Config
@@ -22,6 +23,13 @@ logging.getLogger("psycopg").setLevel(logging.WARNING)
 # custom processors
 
 
+def add_thread_name(
+    logger: logging.Logger, method_name: str, event_dict: EventDict
+) -> EventDict:
+    event_dict["thread_name"] = threading.current_thread().name
+    return event_dict
+
+
 class AddPrefixedEnvVars:
     def __init__(self, prefix: str) -> None:
         self.kv = {
@@ -68,6 +76,7 @@ class TapForMetadata:
 # shared config, for both logging and structlog
 
 shared_processors = [
+    add_thread_name,
     structlog.stdlib.add_logger_name,
     structlog.stdlib.add_log_level,
     structlog.stdlib.PositionalArgumentsFormatter(),

langgraph_api/metadata.py

@@ -10,6 +10,8 @@ from langgraph_api.config import (
     LANGGRAPH_CLOUD_LICENSE_KEY,
     LANGSMITH_API_KEY,
     LANGSMITH_AUTH_ENDPOINT,
+    USES_CUSTOM_APP,
+    USES_INDEXING,
 )
 from langgraph_api.http import http_request
 from langgraph_license.validation import plus_features_enabled
@@ -87,6 +89,8 @@ async def metadata_loop() -> None:
                 "langgraph.platform.variant": VARIANT,
                 "langgraph.platform.host": HOST,
                 "langgraph.platform.plan": PLAN,
+                "user_app.uses_indexing": USES_INDEXING,
+                "user_app.uses_custom_app": USES_CUSTOM_APP,
             },
             "measures": {
                 "langgraph.platform.runs": runs,
@@ -106,5 +110,5 @@ async def metadata_loop() -> None:
             incr_runs(incr=runs)
             incr_nodes("", incr=nodes)
             FROM_TIMESTAMP = from_timestamp
-            logger.warning("Failed to submit metadata", exc_info=e)
+            await logger.ainfo("Metadata submission skipped.", error=str(e))
         await asyncio.sleep(INTERVAL)

langgraph_api/middleware/http_logger.py

@@ -78,7 +78,7 @@ class AccessLoggerMiddleware:
             )
 
 
-HEADERS_IGNORE = {"authorization", "cookie", "set-cookie", "x-api-key"}
+HEADERS_IGNORE = {b"authorization", b"cookie", b"set-cookie", b"x-api-key"}
 
 
 def _headers_to_dict(headers: list[tuple[bytes, bytes]] | None) -> dict[str, str]:

langgraph_api/patch.py

@@ -26,6 +26,8 @@ async def StreamingResponse_stream_response(self, send: Send) -> None:
         }
     )
     async for chunk in self.body_iterator:
+        if chunk is None:
+            continue
         if not isinstance(chunk, (bytes, bytearray, memoryview)):  # noqa: UP038
             chunk = chunk.encode(self.charset)
         await send({"type": "http.response.body", "body": chunk, "more_body": True})

langgraph_api/queue_entrypoint.py

@@ -0,0 +1,63 @@
+import asyncio
+import http.server
+import json
+import logging.config
+import os
+import pathlib
+
+import structlog
+import uvloop
+
+from langgraph_api.lifespan import lifespan
+
+logger = structlog.stdlib.get_logger(__name__)
+
+
+async def healthcheck_server():
+    port = int(os.getenv("PORT", "8080"))
+    ok = json.dumps({"status": "ok"}).encode()
+    ok_len = str(len(ok))
+
+    class HealthHandler(http.server.SimpleHTTPRequestHandler):
+        def do_GET(self):
+            if self.path == "/ok":
+                self.send_response(200)
+                self.send_header("Content-Type", "application/json")
+                self.send_header("Content-Length", ok_len)
+                self.end_headers()
+                self.wfile.write(ok)
+            else:
+                self.send_error(http.HTTPStatus.NOT_FOUND)
+
+    with http.server.ThreadingHTTPServer(("0.0.0.0", port), HealthHandler) as httpd:
+        logger.info(f"Health server started at http://0.0.0.0:{port}")
+        try:
+            await asyncio.to_thread(httpd.serve_forever)
+        finally:
+            httpd.shutdown()
+
+
+async def entrypoint():
+    tasks: set[asyncio.Task] = set()
+    # start simple http server for health checks
+    tasks.add(asyncio.create_task(healthcheck_server()))
+    # start queue and associated tasks
+    async with lifespan(None, with_cron_scheduler=False, taskset=tasks):
+        # run forever, error if any tasks fail
+        try:
+            await asyncio.gather(*tasks)
+        except asyncio.CancelledError:
+            pass
+
+
+if __name__ == "__main__":
+    # set up logging
+    with open(pathlib.Path(__file__).parent.parent / "logging.json") as file:
+        loaded_config = json.load(file)
+        logging.config.dictConfig(loaded_config)
+
+    # set up uvloop
+    uvloop.install()
+
+    # run the entrypoint
+    asyncio.run(entrypoint())

langgraph_api/schema.py

@@ -71,6 +71,8 @@ class Assistant(TypedDict):
     """The ID of the assistant."""
     graph_id: str
     """The ID of the graph."""
+    name: str
+    """The name of the assistant."""
     config: Config
     """The assistant config."""
     created_at: datetime

langgraph_api/stream.py

@@ -111,6 +111,7 @@ async def astream_state(
     await stack.enter_async_context(conn.pipeline())
     # extract args from run
     kwargs = run["kwargs"].copy()
+    kwargs.pop("webhook", None)
     subgraphs = kwargs.get("subgraphs", False)
     temporary = kwargs.pop("temporary", False)
     config = kwargs.pop("config")

langgraph_api/webhook.py

@@ -0,0 +1,42 @@
+from datetime import UTC, datetime
+
+import structlog
+
+from langgraph_api.http import get_http_client, get_loopback_client
+from langgraph_api.worker import WorkerResult
+
+logger = structlog.stdlib.get_logger(__name__)
+
+
+async def call_webhook(result: "WorkerResult") -> None:
+    checkpoint = result["checkpoint"]
+    payload = {
+        **result["run"],
+        "status": result["status"],
+        "run_started_at": result["run_started_at"],
+        "run_ended_at": result["run_ended_at"],
+        "webhook_sent_at": datetime.now(UTC).isoformat(),
+        "values": checkpoint["values"] if checkpoint else None,
+    }
+    if exception := result["exception"]:
+        payload["error"] = str(exception)
+
+    try:
+        webhook = result["webhook"]
+        if webhook.startswith("/"):
+            # Call into this own app
+            webhook_client = get_loopback_client()
+        else:
+            webhook_client = get_http_client()
+        await webhook_client.post(webhook, json=payload, total_timeout=20)
+        await logger.ainfo(
+            "Background worker called webhook",
+            webhook=result["webhook"],
+            run_id=result["run"]["run_id"],
+        )
+    except Exception as exc:
+        logger.exception(
+            f"Background worker failed to call webhook {result['webhook']}",
+            exc_info=exc,
+            webhook=result["webhook"],
+        )

langgraph_api/{queue.py → worker.py}

@@ -6,14 +6,17 @@ from typing import TypedDict, cast
 
 import structlog
 from langgraph.pregel.debug import CheckpointPayload, TaskResultPayload
+from starlette.exceptions import HTTPException
 
 from langgraph_api.auth.custom import SimpleUser, normalize_user
-from langgraph_api.config import BG_JOB_HEARTBEAT, STATS_INTERVAL_SECS
+from langgraph_api.config import (
+    BG_JOB_MAX_RETRIES,
+    BG_JOB_TIMEOUT_SECS,
+)
 from langgraph_api.errors import (
     UserInterrupt,
     UserRollback,
 )
-from langgraph_api.http import get_http_client
 from langgraph_api.js.errors import RemoteException
 from langgraph_api.metadata import incr_runs
 from langgraph_api.schema import Run
@@ -33,135 +36,6 @@ except ImportError:
 
 logger = structlog.stdlib.get_logger(__name__)
 
-WORKERS: set[asyncio.Task] = set()
-WEBHOOKS: set[asyncio.Task] = set()
-MAX_RETRY_ATTEMPTS = 3
-SHUTDOWN_GRACE_PERIOD_SECS = 5
-
-
-def ms(after: datetime, before: datetime) -> int:
-    return int((after - before).total_seconds() * 1000)
-
-
-async def queue(concurrency: int, timeout: float):
-    loop = asyncio.get_running_loop()
-    last_stats_secs: int | None = None
-    last_sweep_secs: int | None = None
-    semaphore = asyncio.Semaphore(concurrency)
-
-    def cleanup(task: asyncio.Task):
-        WORKERS.remove(task)
-        semaphore.release()
-        try:
-            result: WorkerResult | None = task.result()
-            exc = task.exception()
-            if exc:
-                logger.exception("Background worker failed", exc_info=exc)
-            if result and result["webhook"]:
-                checkpoint = result["checkpoint"]
-                payload = {
-                    **result["run"],
-                    "status": result["status"],
-                    "run_started_at": result["run_started_at"],
-                    "run_ended_at": result["run_ended_at"],
-                    "webhook_sent_at": datetime.now(UTC).isoformat(),
-                    "values": checkpoint["values"] if checkpoint else None,
-                }
-                if exception := result["exception"]:
-                    payload["error"] = str(exception)
-
-                async def _call_webhook() -> None:
-                    try:
-                        await get_http_client().post(
-                            result["webhook"], json=payload, total_timeout=20
-                        )
-                    except Exception as exc:
-                        logger.exception(
-                            f"Background worker failed to call webhook {result['webhook']}",
-                            exc_info=exc,
-                            webhook=result["webhook"],
-                        )
-
-                hook_task = asyncio.create_task(
-                    _call_webhook(),
-                    name=f"webhook-{result['run']['run_id']}",
-                )
-                WEBHOOKS.add(hook_task)
-                hook_task.add_done_callback(WEBHOOKS.remove)
-
-        except asyncio.CancelledError:
-            pass
-        except Exception as exc:
-            logger.exception("Background worker cleanup failed", exc_info=exc)
-
-    await logger.ainfo(f"Starting {concurrency} background workers")
-    try:
-        tup: tuple[Run, int] | None = None
-        while True:
-            try:
-                # check if we need to sweep runs
-                do_sweep = (
-                    last_sweep_secs is None
-                    or loop.time() - last_sweep_secs > BG_JOB_HEARTBEAT * 2
-                )
-                # check if we need to update stats
-                if calc_stats := (
-                    last_stats_secs is None
-                    or loop.time() - last_stats_secs > STATS_INTERVAL_SECS
-                ):
-                    last_stats_secs = loop.time()
-                    active = len(WORKERS)
-                    await logger.ainfo(
-                        "Worker stats",
-                        max=concurrency,
-                        available=concurrency - active,
-                        active=active,
-                    )
-                # wait for semaphore to respect concurrency
-                await semaphore.acquire()
-                exit = AsyncExitStack()
-                # skip the wait, if 1st time, or got a run last time
-                wait = tup is None and last_stats_secs is not None
-                # try to get a run, handle it
-                if tup := await exit.enter_async_context(Runs.next(wait=wait)):
-                    run_, attempt_ = tup
-                    task = asyncio.create_task(
-                        worker(timeout, exit, run_, attempt_),
-                        name=f"run-{run_['run_id']}-attempt-{attempt_}",
-                    )
-                    task.add_done_callback(cleanup)
-                    WORKERS.add(task)
-                else:
-                    semaphore.release()
-                    await exit.aclose()
-                # run stats and sweep if needed
-                if calc_stats or do_sweep:
-                    async with connect() as conn:
-                        # update stats if needed
-                        if calc_stats:
-                            stats = await Runs.stats(conn)
-                            await logger.ainfo("Queue stats", **stats)
-                        # sweep runs if needed
-                        if do_sweep:
-                            last_sweep_secs = loop.time()
-                            run_ids = await Runs.sweep(conn)
-                            logger.info("Sweeped runs", run_ids=run_ids)
-            except Exception as exc:
-                # keep trying to run the scheduler indefinitely
-                logger.exception("Background worker scheduler failed", exc_info=exc)
-                semaphore.release()
-                await exit.aclose()
-    finally:
-        logger.info("Shutting down background workers")
-        for task in WORKERS:
-            task.cancel()
-        for task in WEBHOOKS:
-            task.cancel()
-        await asyncio.wait_for(
-            asyncio.gather(*WORKERS, *WEBHOOKS, return_exceptions=True),
-            SHUTDOWN_GRACE_PERIOD_SECS,
-        )
-
 
 class WorkerResult(TypedDict):
     checkpoint: CheckpointPayload | None
@@ -181,32 +55,21 @@ async def set_auth_ctx_for_run(
     try:
         user = run_kwargs["config"]["configurable"]["langgraph_auth_user"]
         permissions = run_kwargs["config"]["configurable"]["langgraph_auth_permissions"]
-        if user is not None:
-            user = normalize_user(user)
-            async with with_user(user, permissions):
-                yield None
-        else:
-            yield None
-
-    except KeyError:
-        if user_id is not None:
-            await logger.ainfo(
-                "Setting auth to backup user_id",
-                user_id=user_id,
-            )
-            async with with_user(SimpleUser(user_id)):
-                yield None
-        else:
-            yield None
+        user = normalize_user(user)
     except Exception:
-        pass
+        user = SimpleUser(user_id) if user_id is not None else None
+        permissions = None
+    if user is not None:
+        async with with_user(user, permissions):
+            yield None
+    else:
+        yield None
 
 
 async def worker(
-    timeout: float,
-    exit: AsyncExitStack,
     run: Run,
     attempt: int,
+    main_loop: asyncio.AbstractEventLoop,
 ) -> WorkerResult:
     run_id = run["run_id"]
     if attempt == 1:
@@ -214,15 +77,14 @@ async def worker(
     checkpoint: CheckpointPayload | None = None
     exception: Exception | None = None
     status: str | None = None
-    webhook = run["kwargs"].pop("webhook", None)
+    webhook = run["kwargs"].get("webhook", None)
     run_started_at = datetime.now(UTC)
     run_ended_at: str | None = None
 
     async with (
         connect() as conn,
         set_auth_ctx_for_run(run["kwargs"]),
-        Runs.enter(run_id) as done,
-        exit,
+        Runs.enter(run_id, main_loop) as done,
     ):
         temporary = run["kwargs"].get("temporary", False)
         run_created_at = run["created_at"].isoformat()
@@ -247,7 +109,7 @@ async def worker(
                         break
 
         try:
-            if attempt > MAX_RETRY_ATTEMPTS:
+            if attempt > BG_JOB_MAX_RETRIES:
                 raise RuntimeError(f"Run {run['run_id']} exceeded max attempts")
             if temporary:
                 stream = astream_state(
@@ -263,7 +125,7 @@ async def worker(
                     on_checkpoint=on_checkpoint,
                     on_task_result=on_task_result,
                 )
-            await asyncio.wait_for(consume(stream, run_id), timeout)
+            await asyncio.wait_for(consume(stream, run_id), BG_JOB_TIMEOUT_SECS)
             run_ended_at = datetime.now(UTC).isoformat()
             await logger.ainfo(
                 "Background run succeeded",
@@ -294,17 +156,18 @@ async def worker(
             exception = e
             status = "rollback"
             run_ended_at = datetime.now(UTC).isoformat()
-            await logger.ainfo(
-                "Background run rolled back",
-                run_id=str(run_id),
-                run_attempt=attempt,
-                run_created_at=run_created_at,
-                run_started_at=run_started_at.isoformat(),
-                run_ended_at=run_ended_at,
-                run_exec_ms=ms(datetime.now(UTC), run_started_at),
-            )
             try:
                 await Runs.delete(conn, run_id, thread_id=run["thread_id"])
+                await logger.ainfo(
+                    "Background run rolled back",
+                    run_id=str(run_id),
+                    run_attempt=attempt,
+                    run_created_at=run_created_at,
+                    run_started_at=run_started_at.isoformat(),
+                    run_ended_at=run_ended_at,
+                    run_exec_ms=ms(datetime.now(UTC), run_started_at),
+                )
+
             except InFailedSqlTransaction as e:
                 await logger.ainfo(
                     "Ignoring rollback error",
@@ -316,6 +179,17 @@ async def worker(
                 # We need to clean up the transaction early if we want to
                 # update the thread status with the same connection
                 await exit.aclose()
+            except HTTPException as e:
+                if e.status_code == 404:
+                    await logger.ainfo(
+                        "Ignoring rollback error for missing run",
+                        run_id=str(run_id),
+                        run_attempt=attempt,
+                        run_created_at=run_created_at,
+                    )
+                else:
+                    raise
+
             checkpoint = None  # reset the checkpoint
         except UserInterrupt as e:
             exception = e
@@ -367,7 +241,15 @@ async def worker(
         if temporary:
             await Threads.delete(conn, run["thread_id"])
         else:
-            await Threads.set_status(conn, run["thread_id"], checkpoint, exception)
+            try:
+                await Threads.set_status(conn, run["thread_id"], checkpoint, exception)
+            except HTTPException as e:
+                if e.status_code == 404:
+                    await logger.ainfo(
+                        "Ignoring set_status error for missing thread", exc=str(e)
+                    )
+                else:
+                    raise
         # Note we don't handle asyncio.CancelledError here, as we want to
         # let it bubble up and rollback db transaction, thus marking the run
         # as available to be picked up by another worker
@@ -380,3 +262,7 @@ async def worker(
         "exception": exception,
         "webhook": webhook,
     }
+
+
+def ms(after: datetime, before: datetime) -> int:
+    return int((after - before).total_seconds() * 1000)

{langgraph_api-0.0.26.dist-info → langgraph_api-0.0.28rc1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langgraph-api
-Version: 0.0.26
+Version: 0.0.28rc1
 Summary: 
 License: Elastic-2.0
 Author: Nuno Campos
@@ -11,26 +11,26 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: cryptography (>=43.0.3,<44.0.0)
-Requires-Dist: httpx (>=0.27.0)
-Requires-Dist: jsonschema-rs (>=0.25.0,<0.26.0)
+Requires-Dist: httpx (>=0.25.0)
+Requires-Dist: jsonschema-rs (>=0.20.0,<0.21.0)
 Requires-Dist: langchain-core (>=0.2.38,<0.4.0)
-Requires-Dist: langgraph (>=0.2.56,<0.3.0)
+Requires-Dist: langgraph (>=0.2.56,<0.4.0)
 Requires-Dist: langgraph-checkpoint (>=2.0.15,<3.0)
 Requires-Dist: langgraph-sdk (>=0.1.53,<0.2.0)
 Requires-Dist: langsmith (>=0.1.63,<0.4.0)
-Requires-Dist: orjson (>=3.10.1)
+Requires-Dist: orjson (>=3.9.7)
 Requires-Dist: pyjwt (>=2.9.0,<3.0.0)
 Requires-Dist: sse-starlette (>=2.1.0,<2.2.0)
 Requires-Dist: starlette (>=0.38.6)
-Requires-Dist: structlog (>=24.4.0,<25.0.0)
-Requires-Dist: tenacity (>=8.3.0,<10)
+Requires-Dist: structlog (>=24.1.0,<26)
+Requires-Dist: tenacity (>=8.0.0)
 Requires-Dist: uvicorn (>=0.26.0)
 Requires-Dist: watchfiles (>=0.13)
 Description-Content-Type: text/markdown
 
 # LangGraph API
 
-This package implements the LangGraph API for rapid development and testing. Build and iterate on LangGraph agents with a tight feedback loop. The sesrver is backed by a predominently in-memory data store that is persisted to local disk when the server is restarted.
+This package implements the LangGraph API for rapid development and testing. Build and iterate on LangGraph agents with a tight feedback loop. The server is backed by a predominently in-memory data store that is persisted to local disk when the server is restarted.
 
 For production use, see the various [deployment options](https://langchain-ai.github.io/langgraph/concepts/deployment_options/) for the LangGraph API, which are backed by a production-grade database.