langgraph-api 0.0.45__tar.gz → 0.0.47__tar.gz

{langgraph_api-0.0.45 → langgraph_api-0.0.47}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: langgraph-api
-Version: 0.0.45
+Version: 0.0.47
 Summary: 
 License: Elastic-2.0
 Author: Nuno Campos
@@ -13,13 +13,13 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: blockbuster (>=1.5.24,<2.0.0)
 Requires-Dist: cloudpickle (>=3.0.0,<4.0.0)
-Requires-Dist: cryptography (>=43.0.3,<44.0.0)
+Requires-Dist: cryptography (>=42.0.0,<45.0)
 Requires-Dist: httpx (>=0.25.0)
 Requires-Dist: jsonschema-rs (>=0.20.0,<0.30)
 Requires-Dist: langchain-core (>=0.2.38,<0.4.0)
 Requires-Dist: langgraph (>=0.2.56,<0.4.0)
 Requires-Dist: langgraph-checkpoint (>=2.0.23,<3.0)
-Requires-Dist: langgraph-sdk (>=0.1.59,<0.2.0)
+Requires-Dist: langgraph-sdk (>=0.1.61,<0.2.0)
 Requires-Dist: langsmith (>=0.1.63,<0.4.0)
 Requires-Dist: orjson (>=3.9.7)
 Requires-Dist: pyjwt (>=2.9.0,<3.0.0)

langgraph_api-0.0.47/langgraph_api/__init__.py

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

{langgraph_api-0.0.45 → langgraph_api-0.0.47}/langgraph_api/api/ui.py

@@ -1,34 +1,39 @@
 import json
 import os
-from functools import lru_cache
-from pathlib import Path
 from typing import TypedDict
 
+from anyio import open_file
 from orjson import loads
 from starlette.responses import Response
 from starlette.routing import BaseRoute, Mount
 from starlette.staticfiles import StaticFiles
 
+from langgraph_api.js.ui import UI_PUBLIC_DIR, UI_SCHEMAS_FILE
 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]:
+_UI_SCHEMAS_CACHE: dict[str, UiSchema] | None = None
+
+
+async def load_ui_schemas() -> dict[str, UiSchema]:
     """Load and cache UI schema mappings from JSON file."""
-    if not SCHEMAS_FILE.exists():
-        return {}
+    global _UI_SCHEMAS_CACHE
+
+    if _UI_SCHEMAS_CACHE is not None:
+        return _UI_SCHEMAS_CACHE
+
+    if not UI_SCHEMAS_FILE.exists():
+        _UI_SCHEMAS_CACHE = {}
+    else:
+        async with await open_file(UI_SCHEMAS_FILE, mode="r") as f:
+            _UI_SCHEMAS_CACHE = loads(await f.read())
 
-    with open(SCHEMAS_FILE) as f:
-        return loads(f.read())
+    return _UI_SCHEMAS_CACHE
 
 
 async def handle_ui(request: ApiRequest) -> Response:
@@ -38,7 +43,7 @@ async def handle_ui(request: ApiRequest) -> Response:
     message = await request.json(schema=None)
 
     # Load UI file paths from schema
-    schemas = load_ui_schemas()
+    schemas = await load_ui_schemas()
 
     if graph_id not in schemas:
         return Response(f"UI not found for graph '{graph_id}'", status_code=404)
@@ -64,5 +69,5 @@ async def handle_ui(request: ApiRequest) -> Response:
 
 ui_routes: list[BaseRoute] = [
     ApiRoute("/ui/{graph_id}", handle_ui, methods=["POST"]),
-    Mount("/ui", StaticFiles(directory=UI_DIR, check_dir=False)),
+    Mount("/ui", StaticFiles(directory=UI_PUBLIC_DIR, check_dir=False)),
 ]

{langgraph_api-0.0.45 → langgraph_api-0.0.47}/langgraph_api/cli.py

@@ -129,6 +129,8 @@ def run_server(
     store: typing.Optional["StoreConfig"] = None,
     auth: AuthConfig | None = None,
     http: typing.Optional["HttpConfig"] = None,
+    ui: dict | None = None,
+    ui_config: dict | None = None,
     studio_url: str | None = None,
     disable_persistence: bool = False,
     allow_blocking: bool = False,
@@ -190,6 +192,9 @@ def run_server(
         LANGSMITH_LANGGRAPH_API_VARIANT="local_dev",
         LANGGRAPH_AUTH=json.dumps(auth) if auth else None,
         LANGGRAPH_HTTP=json.dumps(http) if http else None,
+        LANGGRAPH_UI=json.dumps(ui) if ui else None,
+        LANGGRAPH_UI_CONFIG=json.dumps(ui_config) if ui_config else None,
+        LANGGRAPH_UI_BUNDLER="true",
         LANGGRAPH_API_URL=local_url,
         LANGGRAPH_DISABLE_FILE_PERSISTENCE=str(disable_persistence).lower(),
         # If true, we will not raise on blocking IO calls (via blockbuster)
@@ -349,6 +354,8 @@ def main():
 
     graphs = config_data.get("graphs", {})
     auth = config_data.get("auth")
+    ui = config_data.get("ui")
+    ui_config = config_data.get("ui_config")
     run_server(
         args.host,
         args.port,
@@ -360,6 +367,8 @@ def main():
         wait_for_client=args.wait_for_client,
         env=config_data.get("env", None),
         auth=auth,
+        ui=ui,
+        ui_config=ui_config,
     )
 
 

{langgraph_api-0.0.45 → langgraph_api-0.0.47}/langgraph_api/config.py

@@ -325,3 +325,6 @@ USES_INDEXING = (
 USES_CUSTOM_APP = HTTP_CONFIG and HTTP_CONFIG.get("app")
 
 API_VARIANT = env("LANGSMITH_LANGGRAPH_API_VARIANT", cast=str, default="")
+
+# UI
+UI_USE_BUNDLER = env("LANGGRAPH_UI_BUNDLER", cast=bool, default=False)

{langgraph_api-0.0.45 → langgraph_api-0.0.47}/langgraph_api/graph.py

@@ -42,7 +42,13 @@ NAMESPACE_GRAPH = UUID("6ba7b821-9dad-11d1-80b4-00c04fd430c8")
 FACTORY_ACCEPTS_CONFIG: dict[str, bool] = {}
 
 
-async def register_graph(graph_id: str, graph: GraphValue, config: dict | None) -> None:
+async def register_graph(
+    graph_id: str,
+    graph: GraphValue,
+    config: dict | None,
+    *,
+    description: str | None = None,
+) -> None:
     """Register a graph."""
     from langgraph_storage.database import connect
     from langgraph_storage.ops import Assistants
@@ -60,6 +66,7 @@ async def register_graph(graph_id: str, graph: GraphValue, config: dict | None)
             config=config or {},
             if_exists="do_nothing",
             name=graph_id,
+            description=description,
         )
 
 
@@ -149,13 +156,26 @@ def get_assistant_id(assistant_id: str) -> str:
 
 
 class GraphSpec(NamedTuple):
-    """A graph specification."""
+    """A graph specification.
+
+    This is a definition of the graph that can be used to load the graph
+    from a file or module.
+    """
 
     id: str
+    """The ID of the graph."""
     path: str | None = None
     module: str | None = None
     variable: str | None = None
     config: dict | None = None
+    """The configuration for the graph.
+    
+    Contains information such as: tags, recursion_limit and configurable.
+    
+    Configurable is a dict containing user defined values for the graph.
+    """
+    description: str | None = None
+    """A description of the graph"""
 
 
 js_bg_tasks: set[asyncio.Task] = set()
@@ -193,9 +213,33 @@ async def collect_graphs_from_env(register: bool = False) -> None:
 
     if paths_str:
         specs = []
-        for key, value in json.loads(paths_str).items():
+        # graphs-config can be either a mapping from graph id to path where the graph
+        # is defined or graph id to a dictionary containing information about the graph.
+        graphs_config = json.loads(paths_str)
+
+        for key, value in graphs_config.items():
+            if isinstance(value, dict) and "path" in value:
+                source = value["path"]
+            elif isinstance(value, str):
+                source = value
+            else:
+                msg = (
+                    f"Invalid value '{value}' for graph '{key}'. "
+                    "Expected a string or a dictionary. "
+                    "If a string, it should be the path to the graph definition. "
+                    "For example: '/path/to/graph.py:graph_variable' "
+                    "or 'my.module:graph_variable'. "
+                    "If a dictionary, then it needs to contains a `path` key with the "
+                    "path to the graph definition."
+                    "It can also contains additional configuration for the graph; "
+                    "e.g., `description`."
+                    "For example: {'path': '/path/to/graph.py:graph_variable', "
+                    "'description': 'My graph'}"
+                )
+                raise TypeError(msg)
+
             try:
-                path_or_module, variable = value.rsplit(":", maxsplit=1)
+                path_or_module, variable = source.rsplit(":", maxsplit=1)
             except ValueError as e:
                 raise ValueError(
                     f"Invalid path '{value}' for graph '{key}'."
@@ -203,22 +247,30 @@ async def collect_graphs_from_env(register: bool = False) -> None:
                     " Expected one of the following formats:"
                     " 'my.module:variable_name' or '/path/to/file.py:variable_name'"
                 ) from e
+
+            graph_config = config_per_graph.get(key, {})
+            description = (
+                value.get("description", None) if isinstance(value, dict) else None
+            )
+
+            # Module syntax uses `.` instead of `/` to separate directories
+            if "/" in path_or_module:
+                path = path_or_module
+                module_ = None
+            else:
+                path = None
+                module_ = path_or_module
+
             specs.append(
                 GraphSpec(
                     key,
-                    module=path_or_module,
-                    variable=variable,
-                    config=config_per_graph.get(key),
-                )
-                if "/" not in value
-                else GraphSpec(
-                    key,
-                    path=path_or_module,
+                    module=module_,
+                    path=path,
                     variable=variable,
-                    config=config_per_graph.get(key),
+                    config=graph_config,
+                    description=description,
                 )
             )
-
     else:
         specs = [
             GraphSpec(
@@ -270,12 +322,16 @@ async def collect_graphs_from_env(register: bool = False) -> None:
         for spec in js_specs:
             graph = RemotePregel(graph_id=spec.id)
             if register:
-                await register_graph(spec.id, graph, spec.config)
+                await register_graph(
+                    spec.id, graph, spec.config, description=spec.description
+                )
 
     for spec in py_specs:
         graph = await run_in_executor(None, _graph_from_spec, spec)
         if register:
-            await register_graph(spec.id, graph, spec.config)
+            await register_graph(
+                spec.id, graph, spec.config, description=spec.description
+            )
 
 
 def _handle_exception(task: asyncio.Task) -> None:
@@ -289,7 +345,7 @@ def _handle_exception(task: asyncio.Task) -> None:
 
 
 async def stop_remote_graphs() -> None:
-    logger.info("Cancelling remote graphs")
+    logger.info("Shutting down remote graphs")
     for task in js_bg_tasks:
         task.cancel("Stopping remote graphs.")
 
@@ -375,14 +431,16 @@ def _graph_from_spec(spec: GraphSpec) -> GraphValue:
             # We don't want to fail real deployments, but this will help folks catch unnecessary custom components
             # before they deploy
             if config.API_VARIANT == "local_dev":
-                has_checkpointer = graph.checkpointer is not None
-                has_store = graph.store is not None
+                has_checkpointer = isinstance(graph.checkpointer, BaseCheckpointSaver)
+                has_store = isinstance(graph.store, BaseStore)
                 if has_checkpointer or has_store:
                     components = []
                     if has_checkpointer:
-                        components.append("checkpointer")
+                        components.append(
+                            f"checkpointer (type {type(graph.checkpointer)})"
+                        )
                     if has_store:
-                        components.append("store")
+                        components.append(f"store (type {type(graph.store)})")
                     component_list = " and ".join(components)
 
                     raise ValueError(
@@ -391,7 +449,7 @@ def _graph_from_spec(spec: GraphSpec) -> GraphValue:
                         f"so providing a custom {component_list} here isn't necessary and will be ignored when deployed.\n\n"
                         f"To simplify your setup and use the built-in persistence, please remove the custom {component_list} "
                         f"from your graph definition. If you are looking to customize which postgres database to connect to,"
-                        " please set the `POSTGRES_URI_CUSTOM` environment variable."
+                        " please set the `POSTGRES_URI` environment variable."
                         " See https://langchain-ai.github.io/langgraph/cloud/reference/env_var/#postgres_uri_custom for more details."
                     )
 

langgraph_api-0.0.47/langgraph_api/js/build.mts

@@ -0,0 +1,68 @@
+/// <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-ui";
+
+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> = {};
+  let failed = 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}`);
+    failed = true;
+  }
+
+  // Build Gen UI assets
+  try {
+    console.info("Checking for UI assets");
+    await fs.mkdir(path.resolve(__dirname, "ui"), { recursive: true });
+
+    await build({ output: path.resolve(__dirname, "ui") });
+  } catch (error) {
+    console.error(`Error building UI: ${error}`);
+    failed = true;
+  }
+
+  if (failed) process.exit(1);
+}
+
+main();

{langgraph_api-0.0.45 → langgraph_api-0.0.47}/langgraph_api/js/client.mts

@@ -13,6 +13,7 @@ import {
   Item,
   Operation,
   Command,
+  Send,
   OperationResults,
   type Checkpoint,
   type CheckpointMetadata,
@@ -539,7 +540,19 @@ const StreamEventsPayload = z.object({
   graph_name: z.string().nullish(),
   graph_config: RunnableConfigSchema.nullish(),
   input: z.unknown(),
-  command: z.object({ resume: z.unknown() }).nullish(),
+  command: z
+    .object({
+      resume: z.unknown().nullish(),
+      goto: z.custom<Send | string | (Send | string)[]>().nullish(),
+      graph: z.string().nullish(),
+      update: z
+        .union([
+          z.record(z.unknown()),
+          z.array(z.tuple([z.string(), z.unknown()])),
+        ])
+        .nullish(),
+    })
+    .nullish(),
   stream_mode: z
     .union([ExtraStreamModeSchema, z.array(ExtraStreamModeSchema)])
     .optional(),
@@ -549,14 +562,33 @@ const StreamEventsPayload = z.object({
   subgraphs: z.boolean().optional(),
 });
 
+function reviveCommand(
+  command: z.infer<typeof StreamEventsPayload>["command"]
+): Command | undefined {
+  if (command == null) return undefined;
+  let { goto, update, resume, graph } = command;
+
+  goto ??= undefined;
+  update ??= undefined;
+  resume ??= undefined;
+  graph ??= undefined;
+
+  if (goto != null && !Array.isArray(goto)) goto = [goto];
+  goto = goto?.map((item) => {
+    if (typeof item === "string") return item;
+    return new Send(item.node, item.args);
+  });
+
+  return new Command({ goto, update, resume, graph });
+}
+
 async function* streamEventsRequest(
   rawPayload: z.infer<typeof StreamEventsPayload>
 ) {
   const { graph_id: graphId, ...payload } = rawPayload;
   const config = getRunnableConfig(payload.config);
   const graph = await getGraph(graphId, config, payload.graph_name);
-
-  const input = payload.command ? new Command(payload.command) : payload.input;
+  const input = reviveCommand(payload.command) ?? payload.input;
 
   const userStreamMode =
     payload.stream_mode == null

{langgraph_api-0.0.45 → langgraph_api-0.0.47}/langgraph_api/js/package.json

@@ -24,7 +24,8 @@
     "undici": "^6.21.1",
     "uuid": "^10.0.0",
     "winston": "^3.17.0",
-    "@langchain/langgraph-api": "~0.0.19",
+    "@langchain/langgraph-api": "~0.0.20",
+    "@langchain/langgraph-ui": "~0.0.20",
     "zod": "^3.23.8"
   },
   "resolutions": {

{langgraph_api-0.0.45 → langgraph_api-0.0.47}/langgraph_api/js/remote.py

@@ -23,7 +23,7 @@ from langchain_core.runnables.schema import (
 from langgraph.checkpoint.serde.base import SerializerProtocol
 from langgraph.pregel.types import PregelTask, StateSnapshot
 from langgraph.store.base import GetOp, Item, ListNamespacesOp, PutOp, SearchOp
-from langgraph.types import Command, Interrupt
+from langgraph.types import Command, Interrupt, Send
 from pydantic import BaseModel
 from starlette.applications import Starlette
 from starlette.exceptions import HTTPException
@@ -58,6 +58,12 @@ _client = httpx.AsyncClient(
 )
 
 
+def default_command(obj):
+    if isinstance(obj, Send):
+        return {"node": obj.node, "args": obj.arg}
+    raise TypeError
+
+
 async def _client_stream(method: str, data: dict[str, Any]):
     graph_id = data.get("graph_id")
     async with _client.stream(
@@ -68,7 +74,7 @@ async def _client_stream(method: str, data: dict[str, Any]):
             "Cache-Control": "no-store",
             "Content-Type": "application/json",
         },
-        data=orjson.dumps(data),
+        data=orjson.dumps(data, default=default_command),
     ) as response:
         decoder = SSEDecoder()
         async for line in aiter_lines_raw(response):
@@ -84,7 +90,7 @@ async def _client_invoke(method: str, data: dict[str, Any]):
     res = await _client.post(
         f"/{graph_id}/{method}",
         headers={"Content-Type": "application/json"},
-        data=orjson.dumps(data),
+        data=orjson.dumps(data, default=default_command),
     )
     return res.json()