langgraph-api 0.0.27__tar.gz → 0.0.28rc1__tar.gz

{langgraph_api-0.0.27 → langgraph_api-0.0.28rc1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langgraph-api
-Version: 0.0.27
+Version: 0.0.28rc1
 Summary: 
 License: Elastic-2.0
 Author: Nuno Campos
@@ -22,7 +22,7 @@ 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 (>=23.1.0,<24.0.0)
+Requires-Dist: structlog (>=24.1.0,<26)
 Requires-Dist: tenacity (>=8.0.0)
 Requires-Dist: uvicorn (>=0.26.0)
 Requires-Dist: watchfiles (>=0.13)

{langgraph_api-0.0.27 → langgraph_api-0.0.28rc1}/langgraph_api/api/__init__.py

@@ -15,6 +15,7 @@ from langgraph_api.api.openapi import get_openapi_spec
 from langgraph_api.api.runs import runs_routes
 from langgraph_api.api.store import store_routes
 from langgraph_api.api.threads import threads_routes
+from langgraph_api.api.ui import ui_routes
 from langgraph_api.auth.middleware import auth_middleware
 from langgraph_api.config import HTTP_CONFIG, MIGRATIONS_PATH
 from langgraph_api.graph import js_bg_tasks
@@ -68,6 +69,7 @@ else:
     protected_routes.extend(runs_routes)
     protected_routes.extend(threads_routes)
     protected_routes.extend(store_routes)
+    protected_routes.extend(ui_routes)
 
 routes: list[BaseRoute] = []
 user_router = None

{langgraph_api-0.0.27 → langgraph_api-0.0.28rc1}/langgraph_api/api/assistants.py

@@ -4,6 +4,7 @@ from uuid import uuid4
 import structlog
 from langchain_core.runnables.utils import create_model
 from langgraph.pregel import Pregel
+from pydantic import TypeAdapter
 from starlette.exceptions import HTTPException
 from starlette.responses import Response
 from starlette.routing import BaseRoute
@@ -27,6 +28,38 @@ from langgraph_storage.retry import retry_db
 logger = structlog.stdlib.get_logger(__name__)
 
 
+def _get_configurable_jsonschema(graph: Pregel) -> dict:
+    """Get the JSON schema for the configurable part of the graph.
+
+    Important: we only return the `configurable` part of the schema.
+
+    The default get_config_schema method returns the entire schema (RunnableConfig),
+    which includes other root keys like "max_concurrency", which we
+    do not want to expose.
+
+    Args:
+        graph: The graph to get the schema for.
+
+    Returns:
+       The JSON schema for the configurable part of the graph.
+    """
+    # Otherwise, use the config_schema method.
+    config_schema = graph.config_schema()
+
+    if "configurable" in config_schema.__fields__:
+        configurable = TypeAdapter(config_schema.__fields__["configurable"].annotation)
+        json_schema = configurable.json_schema()
+        # The type name of the configurable type is not preserved.
+        # We'll add it back to the schema if we can.
+        if hasattr(graph, "config_type") and graph.config_type is not None:
+            if hasattr(graph.config_type, "__name__"):
+                json_schema["title"] = graph.config_type.__name__
+            return json_schema
+
+    # If the schema does not have a configurable field, return an empty schema.
+    return {}
+
+
 def _state_jsonschema(graph: Pregel) -> dict | None:
     fields: dict = {}
     for k in graph.stream_channels_list:
@@ -56,11 +89,7 @@ def _graph_schemas(graph: Pregel) -> dict:
         output_schema = None
     state_schema = _state_jsonschema(graph)
     try:
-        config_schema = (
-            graph.config_schema().__fields__["configurable"].annotation.schema()
-            if "configurable" in graph.config_schema().__fields__
-            else {}
-        )
+        config_schema = _get_configurable_jsonschema(graph)
     except Exception as e:
         logger.warning(
             f"Failed to get config schema for graph {graph.name} with error: `{str(e)}`"
@@ -227,14 +256,14 @@ async def get_assistant_schemas(
             )
 
         try:
-            input_schema = graph.get_input_schema().schema()
+            input_schema = graph.get_input_jsonschema()
         except Exception as e:
             logger.warning(
                 f"Failed to get input schema for graph {graph.name} with error: `{str(e)}`"
             )
             input_schema = None
         try:
-            output_schema = graph.get_output_schema().schema()
+            output_schema = graph.get_output_jsonschema()
         except Exception as e:
             logger.warning(
                 f"Failed to get output schema for graph {graph.name} with error: `{str(e)}`"
@@ -243,11 +272,7 @@ async def get_assistant_schemas(
 
         state_schema = _state_jsonschema(graph)
         try:
-            config_schema = (
-                graph.config_schema().__fields__["configurable"].annotation.schema()
-                if "configurable" in graph.config_schema().__fields__
-                else {}
-            )
+            config_schema = _get_configurable_jsonschema(graph)
         except Exception as e:
             config_schema = None
             logger.warning(
@@ -309,7 +334,12 @@ async def get_assistant_versions(request: ApiRequest) -> ApiResponse:
             limit=payload.get("limit") or 10,
             offset=payload.get("offset") or 0,
         )
-    return ApiResponse([assistant async for assistant in assistants_iter])
+    assistants = [assistant async for assistant in assistants_iter]
+    if not assistants:
+        raise HTTPException(
+            status_code=404, detail=f"Assistant {assistant_id} not found"
+        )
+    return ApiResponse(assistants)
 
 
 @retry_db

{langgraph_api-0.0.27 → langgraph_api-0.0.28rc1}/langgraph_api/api/meta.py

@@ -3,11 +3,11 @@ import os
 from starlette.responses import JSONResponse, PlainTextResponse
 
 from langgraph_api import config
-from langgraph_api.queue import WORKERS
 from langgraph_api.route import ApiRequest
 from langgraph_license.validation import plus_features_enabled
 from langgraph_storage.database import connect, pool_stats
 from langgraph_storage.ops import Runs
+from langgraph_storage.queue import WORKERS
 
 METRICS_FORMATS = {"prometheus", "json"}
 

{langgraph_api-0.0.27 → langgraph_api-0.0.28rc1}/langgraph_api/api/runs.py

@@ -184,7 +184,16 @@ async def wait_run(request: ApiRequest):
                     vchunk = chunk
                 elif mode == b"error":
                     vchunk = orjson.dumps({"__error__": orjson.Fragment(chunk)})
+        if vchunk is not None:
             last_chunk.set(vchunk)
+        else:
+            async with connect() as conn:
+                thread_iter = await Threads.get(conn, thread_id)
+                try:
+                    thread = await anext(thread_iter)
+                    last_chunk.set(thread["values"])
+                except StopAsyncIteration:
+                    last_chunk.set(b"{}")
 
     # keep the connection open by sending whitespace every 5 seconds
     # leading whitespace will be ignored by json parsers
@@ -244,7 +253,11 @@ async def wait_run_stateless(request: ApiRequest):
                     vchunk = chunk
                 elif mode == b"error":
                     vchunk = orjson.dumps({"__error__": orjson.Fragment(chunk)})
+        if vchunk is not None:
             last_chunk.set(vchunk)
+        else:
+            # we can't fetch the thread (it was deleted), so just return empty values
+            last_chunk.set(b"{}")
 
     # keep the connection open by sending whitespace every 5 seconds
     # leading whitespace will be ignored by json parsers
@@ -359,7 +372,7 @@ async def cancel_run(
     run_id = request.path_params["run_id"]
     validate_uuid(thread_id, "Invalid thread ID: must be a UUID")
     validate_uuid(run_id, "Invalid run ID: must be a UUID")
-    wait_str = request.query_params.get("wait", False)
+    wait_str = request.query_params.get("wait", "false")
     wait = wait_str.lower() in {"true", "yes", "1"}
     action_str = request.query_params.get("action", "interrupt")
     action = action_str if action_str in {"interrupt", "rollback"} else "interrupt"

langgraph_api-0.0.28rc1/langgraph_api/api/ui.py

@@ -0,0 +1,68 @@
+import json
+import os
+from functools import lru_cache
+from pathlib import Path
+from typing import TypedDict
+
+from orjson import loads
+from starlette.responses import Response
+from starlette.routing import BaseRoute, Mount
+from starlette.staticfiles import StaticFiles
+
+from langgraph_api.route import ApiRequest, ApiRoute
+
+# Get path to built UI assets
+UI_DIR = Path(os.path.dirname(__file__)).parent / "js" / "ui"
+SCHEMAS_FILE = Path(os.path.dirname(__file__)).parent / "js" / "client.ui.schemas.json"
+
+
+class UiSchema(TypedDict):
+    name: str
+    assets: list[str]
+
+
+@lru_cache(maxsize=1)
+def load_ui_schemas() -> dict[str, UiSchema]:
+    """Load and cache UI schema mappings from JSON file."""
+    if not SCHEMAS_FILE.exists():
+        return {}
+
+    with open(SCHEMAS_FILE) as f:
+        return loads(f.read())
+
+
+async def handle_ui(request: ApiRequest) -> Response:
+    """Serve UI HTML with appropriate script/style tags."""
+    graph_id = request.path_params["graph_id"]
+    host = request.headers.get("host")
+    message = await request.json(schema=None)
+
+    # Load UI file paths from schema
+    schemas = load_ui_schemas()
+
+    if graph_id not in schemas:
+        return Response(f"UI not found for graph '{graph_id}'", status_code=404)
+
+    result = []
+    for filepath in schemas[graph_id]["assets"]:
+        basename = os.path.basename(filepath)
+        ext = os.path.splitext(basename)[1]
+
+        if ext == ".css":
+            result.append(
+                f'<link rel="stylesheet" href="//{host}/ui/{graph_id}/{basename}" />'
+            )
+        elif ext == ".js":
+            result.append(
+                f'<script src="//{host}/ui/{graph_id}/{basename}" '
+                f'onload=\'__LGUI_{graph_id}.render({json.dumps(message["name"])}, "{{{{shadowRootId}}}}")\'>'
+                '</script>'
+            )
+
+    return Response(content="\n".join(result), headers={"Content-Type": "text/html"})
+
+
+ui_routes: list[BaseRoute] = [
+    ApiRoute("/ui/{graph_id}", handle_ui, methods=["POST"]),
+    Mount("/ui", StaticFiles(directory=UI_DIR, check_dir=False)),
+]

{langgraph_api-0.0.27 → langgraph_api-0.0.28rc1}/langgraph_api/asyncio.py

@@ -82,7 +82,7 @@ def _create_task_done_callback(
     try:
         if exc := task.exception():
             if not isinstance(exc, ignore_exceptions):
-                logger.exception("Background task failed", exc_info=exc)
+                logger.exception("asyncio.task failed", exc_info=exc)
     except asyncio.CancelledError:
         pass
 
@@ -107,11 +107,18 @@ class SimpleTaskGroup(AbstractAsyncContextManager["SimpleTaskGroup"]):
     tasks: set[asyncio.Task]
 
     def __init__(
-        self, *coros: Coroutine[Any, Any, T], cancel: bool = False, wait: bool = True
+        self,
+        *coros: Coroutine[Any, Any, T],
+        cancel: bool = False,
+        wait: bool = True,
+        taskset: set[asyncio.Task] | None = None,
     ) -> None:
-        self.tasks = set()
+        self.tasks = taskset if taskset is not None else set()
         self.cancel = cancel
         self.wait = wait
+        if taskset:
+            for task in tuple(taskset):
+                task.add_done_callback(partial(self._create_task_done_callback, ()))
         for coro in coros:
             self.create_task(coro)
 
@@ -125,7 +132,7 @@ class SimpleTaskGroup(AbstractAsyncContextManager["SimpleTaskGroup"]):
         try:
             if exc := task.exception():
                 if not isinstance(exc, ignore_exceptions):
-                    logger.exception("Background task failed", exc_info=exc)
+                    logger.exception("asyncio.task failed in task group", exc_info=exc)
         except asyncio.CancelledError:
             pass
 
@@ -204,3 +211,35 @@ async def aclosing_aiter(aiter: AsyncIterator[T]) -> AsyncIterator[T]:
         async with aclosing(aiter):
             async for item in aiter:
                 yield item
+
+
+class AsyncQueue(Generic[T], asyncio.Queue[T]):
+    """Async unbounded FIFO queue with a wait() method.
+
+    Subclassed from asyncio.Queue, adding a wait() method."""
+
+    async def wait(self) -> None:
+        """If queue is empty, wait until an item is available.
+
+        Copied from Queue.get(), removing the call to .get_nowait(),
+        ie. this doesn't consume the item, just waits for it.
+        """
+        while self.empty():
+            getter = self._get_loop().create_future()
+            self._getters.append(getter)
+            try:
+                await getter
+            except:
+                getter.cancel()  # Just in case getter is not done yet.
+                try:
+                    # Clean self._getters from canceled getters.
+                    self._getters.remove(getter)
+                except ValueError:
+                    # The getter could be removed from self._getters by a
+                    # previous put_nowait call.
+                    pass
+                if not self.empty() and not getter.cancelled():
+                    # We were woken up by put_nowait(), but can't take
+                    # the call.  Wake up the next in line.
+                    self._wakeup_next(self._getters)
+                raise

{langgraph_api-0.0.27 → langgraph_api-0.0.28rc1}/langgraph_api/auth/middleware.py

@@ -14,12 +14,12 @@ logger = structlog.stdlib.get_logger(__name__)
 
 
 def get_auth_backend():
-    logger.info(f"Using auth of type={LANGGRAPH_AUTH_TYPE}")
     if LANGGRAPH_AUTH:
         from langgraph_api.auth.custom import get_custom_auth_middleware
 
+        logger.info("Using auth of type=custom")
         return get_custom_auth_middleware()
-
+    logger.info(f"Using auth of type={LANGGRAPH_AUTH_TYPE}")
     if LANGGRAPH_AUTH_TYPE == "langsmith":
         from langgraph_api.auth.langsmith.backend import LangsmithAuthBackend
 

{langgraph_api-0.0.27 → langgraph_api-0.0.28rc1}/langgraph_api/config.py

@@ -59,6 +59,7 @@ MIGRATIONS_PATH = env("MIGRATIONS_PATH", cast=str, default="/storage/migrations"
 REDIS_URI = env("REDIS_URI", cast=str)
 REDIS_CLUSTER = env("REDIS_CLUSTER", cast=bool, default=False)
 REDIS_MAX_CONNECTIONS = env("REDIS_MAX_CONNECTIONS", cast=int, default=500)
+REDIS_CONNECT_TIMEOUT = env("REDIS_CONNECT_TIMEOUT", cast=float, default=10.0)
 
 # server
 ALLOW_PRIVATE_NETWORK = env("ALLOW_PRIVATE_NETWORK", cast=bool, default=False)
@@ -68,6 +69,7 @@ See https://developer.chrome.com/blog/private-network-access-update-2024-03
 """
 
 HTTP_CONFIG: HttpConfig | None = env("LANGGRAPH_HTTP", cast=_parse_json, default=None)
+STORE_CONFIG: dict | None = env("LANGGRAPH_STORE", cast=_parse_json, default=None)
 CORS_ALLOW_ORIGINS = env("CORS_ALLOW_ORIGINS", cast=CommaSeparatedStrings, default="*")
 if HTTP_CONFIG and HTTP_CONFIG.get("cors"):
     CORS_CONFIG = HTTP_CONFIG["cors"]
@@ -119,11 +121,13 @@ if CORS_CONFIG is not None and CORS_ALLOW_ORIGINS != "*":
 
 BG_JOB_HEARTBEAT = 120  # seconds
 BG_JOB_INTERVAL = 30  # seconds
+BG_JOB_MAX_RETRIES = 3
+BG_JOB_ISOLATED_LOOPS = env("BG_JOB_ISOLATED_LOOPS", cast=bool, default=False)
+
 
 N_JOBS_PER_WORKER = env("N_JOBS_PER_WORKER", cast=int, default=10)
 BG_JOB_TIMEOUT_SECS = env("BG_JOB_TIMEOUT_SECS", cast=float, default=3600)
 FF_CRONS_ENABLED = env("FF_CRONS_ENABLED", cast=bool, default=True)
-FF_JS_ZEROMQ_ENABLED = env("FF_JS_ZEROMQ_ENABLED", cast=bool, default=False)
 
 # auth
 
@@ -182,3 +186,12 @@ TRACING = (
 
 if getenv("LANGSMITH_LANGGRAPH_API_VARIANT") == "licensed" and LANGSMITH_API_KEY:
     environ["LANGSMITH_LANGGRAPH_API_VARIANT"] = "local"
+
+
+# Metrics.
+USES_INDEXING = (
+    STORE_CONFIG
+    and STORE_CONFIG.get("index")
+    and STORE_CONFIG.get("index").get("embed")
+)
+USES_CUSTOM_APP = HTTP_CONFIG and HTTP_CONFIG.get("app")

{langgraph_api-0.0.27 → langgraph_api-0.0.28rc1}/langgraph_api/cron_scheduler.py

@@ -5,8 +5,8 @@ import structlog
 from langchain_core.runnables.config import run_in_executor
 
 from langgraph_api.models.run import create_valid_run
-from langgraph_api.queue import set_auth_ctx_for_run
 from langgraph_api.utils import next_cron_date
+from langgraph_api.worker import set_auth_ctx_for_run
 from langgraph_storage.database import connect
 from langgraph_storage.ops import Crons
 from langgraph_storage.retry import retry_db

{langgraph_api-0.0.27 → langgraph_api-0.0.28rc1}/langgraph_api/graph.py

@@ -77,6 +77,11 @@ async def _generate_graph(value: Any) -> AsyncIterator[Any]:
         yield value
 
 
+def is_js_graph(graph_id: str) -> bool:
+    """Return whether a graph is a JS graph."""
+    return graph_id in GRAPHS and isinstance(GRAPHS[graph_id], BaseRemotePregel)
+
+
 @asynccontextmanager
 async def get_graph(
     graph_id: str,

{langgraph_api-0.0.27 → langgraph_api-0.0.28rc1}/langgraph_api/http.py

@@ -45,13 +45,15 @@ class JsonHttpClient:
                     path,
                     content=json_dumpb(json) if json else content,
                     headers=request_headers,
-                    timeout=httpx.Timeout(
-                        request_timeout or connect_timeout,
-                        connect=connect_timeout,
-                        read=request_timeout,
-                    )
-                    if connect_timeout or request_timeout
-                    else None,
+                    timeout=(
+                        httpx.Timeout(
+                            request_timeout or connect_timeout,
+                            connect=connect_timeout,
+                            read=request_timeout,
+                        )
+                        if connect_timeout or request_timeout
+                        else None
+                    ),
                     params=params,
                 ),
                 # httpx timeout controls are additive for each operation
@@ -70,6 +72,7 @@ class JsonHttpClient:
 
 
 _http_client: JsonHttpClient
+_loopback_client: JsonHttpClient = None
 
 
 async def start_http_client() -> None:
@@ -96,6 +99,20 @@ def get_http_client() -> JsonHttpClient:
     return _http_client
 
 
+def get_loopback_client() -> JsonHttpClient:
+    global _loopback_client
+    if _loopback_client is None:
+        from langgraph_api.server import app  # type: ignore
+
+        _loopback_client = JsonHttpClient(
+            client=httpx.AsyncClient(
+                base_url="http://api",
+                transport=httpx.ASGITransport(app, root_path="/noauth"),
+            ),
+        )
+    return _loopback_client
+
+
 def is_retriable_error(exception: Exception) -> bool:
     if isinstance(exception, httpx.HTTPError):
         return (

{langgraph_api-0.0.27 → langgraph_api-0.0.28rc1}/langgraph_api/js/.gitignore

@@ -1,2 +1,4 @@
 node_modules
 client.schemas.json
+client.ui.schemas.json
+ui

langgraph_api-0.0.28rc1/langgraph_api/js/build.mts

@@ -0,0 +1,98 @@
+/// <reference types="./global.d.ts" />
+
+import { z } from "zod";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import {
+  filterValidGraphSpecs,
+  GraphSchema,
+  resolveGraph,
+  runGraphSchemaWorker,
+} from "./src/graph.mts";
+import { build } from "@langchain/langgraph-api/ui/bundler";
+
+const __dirname = new URL(".", import.meta.url).pathname;
+
+async function main() {
+  const specs = filterValidGraphSpecs(
+    z.record(z.string()).parse(JSON.parse(process.env.LANGSERVE_GRAPHS))
+  );
+
+  const GRAPH_SCHEMAS: Record<string, Record<string, GraphSchema> | false> = {};
+
+  try {
+    await Promise.all(
+      specs.map(async ([graphId, rawSpec]) => {
+        console.info(`[${graphId}]: Checking for source file existence`);
+        const { resolved, ...spec } = await resolveGraph(rawSpec, {
+          onlyFilePresence: true,
+        });
+
+        try {
+          console.info(`[${graphId}]: Extracting schema`);
+          GRAPH_SCHEMAS[graphId] = await runGraphSchemaWorker(spec, {
+            timeoutMs: 120_000,
+          });
+        } catch (error) {
+          console.error(`[${graphId}]: Error extracting schema: ${error}`);
+          GRAPH_SCHEMAS[graphId] = false;
+        }
+      })
+    );
+
+    await fs.writeFile(
+      path.resolve(__dirname, "client.schemas.json"),
+      JSON.stringify(GRAPH_SCHEMAS),
+      { encoding: "utf-8" }
+    );
+  } catch (error) {
+    console.error(`Error resolving graphs: ${error}`);
+    process.exit(1);
+  }
+
+  const uiSpecs = z
+    .record(z.string())
+    .parse(JSON.parse(process.env.LANGGRAPH_UI || "{}"));
+
+  if (Object.keys(uiSpecs).length > 0) {
+    try {
+      const schemas: Record<string, { assets: string[]; name: string }> = {};
+      await Promise.all(
+        Object.entries(uiSpecs).map(async ([graphId, uiUserPath]) => {
+          console.info(`[${graphId}]: Building UI`);
+          const userPath = path.resolve(process.cwd(), uiUserPath);
+          const files = await build(graphId, userPath);
+          await Promise.all([
+            ...files.map(async (item) => {
+              const folder = path.resolve(__dirname, "ui", graphId);
+              const source = path.resolve(folder, item.basename);
+
+              await fs.mkdir(path.dirname(source), { recursive: true });
+              await fs.writeFile(source, item.contents);
+
+              schemas[graphId] ??= { assets: [], name: graphId };
+
+              const relative = path.relative(
+                path.resolve(__dirname, "ui", graphId),
+                source
+              );
+
+              schemas[graphId].assets.push(relative);
+            }),
+          ]);
+        })
+      );
+
+      await fs.writeFile(
+        path.resolve(__dirname, "client.ui.schemas.json"),
+        JSON.stringify(schemas),
+        { encoding: "utf-8" }
+      );
+    } catch (error) {
+      console.error(`Error building UI: ${error}`);
+      process.exit(1);
+    }
+  }
+}
+
+main();