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

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/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/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"}
 
@@ -19,6 +19,7 @@ async def meta_info(request: ApiRequest):
             "flags": {
                 "assistants": True,
                 "crons": plus and config.FF_CRONS_ENABLED,
+                "langsmith": bool(config.LANGSMITH_API_KEY) and bool(config.TRACING),
             }
         }
     )

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/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/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/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/cli.py

@@ -16,6 +16,16 @@ logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
 
+def _get_ls_origin() -> str | None:
+    from langsmith.client import Client
+    from langsmith.utils import tracing_is_enabled
+
+    if not tracing_is_enabled():
+        return
+    client = Client()
+    return client._host_url
+
+
 def _get_org_id() -> str | None:
     from langsmith.client import Client
     from langsmith.utils import tracing_is_enabled
@@ -201,49 +211,67 @@ def run_server(
             logger.info("Debugger attached. Starting server...")
 
     local_url = f"http://{host}:{port}"
-    studio_url = f"https://smith.langchain.com/studio/?baseUrl={local_url}"
-
-    def _open_browser():
-        nonlocal studio_url
-        import time
-        import urllib.request
-        import webbrowser
-        from concurrent.futures import ThreadPoolExecutor
-
-        thread_logger = logging.getLogger("browser_opener")
-        if not thread_logger.handlers:
-            handler = logging.StreamHandler()
-            handler.setFormatter(logging.Formatter("%(message)s"))
-            thread_logger.addHandler(handler)
-
-        with ThreadPoolExecutor(max_workers=1) as executor:
-            org_id_future = executor.submit(_get_org_id)
-
-            while True:
-                try:
-                    with urllib.request.urlopen(f"{local_url}/ok") as response:
-                        if response.status == 200:
-                            try:
-                                org_id = org_id_future.result(timeout=3.0)
-                                if org_id:
-                                    studio_url = f"https://smith.langchain.com/studio/?baseUrl={local_url}&organizationId={org_id}"
-                            except TimeoutError as e:
-                                thread_logger.debug(
-                                    f"Failed to get organization ID: {str(e)}"
+
+    with patch_environment(
+        MIGRATIONS_PATH="__inmem",
+        DATABASE_URI=":memory:",
+        REDIS_URI="fake",
+        N_JOBS_PER_WORKER=str(n_jobs_per_worker if n_jobs_per_worker else 1),
+        LANGGRAPH_STORE=json.dumps(store) if store else None,
+        LANGSERVE_GRAPHS=json.dumps(graphs) if graphs else None,
+        LANGSMITH_LANGGRAPH_API_VARIANT="local_dev",
+        LANGGRAPH_AUTH=json.dumps(auth) if auth else None,
+        LANGGRAPH_HTTP=json.dumps(http) if http else None,
+        # See https://developer.chrome.com/blog/private-network-access-update-2024-03
+        ALLOW_PRIVATE_NETWORK="true",
+        **(env_vars or {}),
+    ):
+        studio_origin = _get_ls_origin() or "https://smith.langchain.com"
+        studio_url = f"{studio_origin}/studio/?baseUrl={local_url}"
+
+        def _open_browser():
+            nonlocal studio_origin, studio_url
+            import time
+            import urllib.request
+            import webbrowser
+            from concurrent.futures import ThreadPoolExecutor
+
+            thread_logger = logging.getLogger("browser_opener")
+            if not thread_logger.handlers:
+                handler = logging.StreamHandler()
+                handler.setFormatter(logging.Formatter("%(message)s"))
+                thread_logger.addHandler(handler)
+
+            with ThreadPoolExecutor(max_workers=1) as executor:
+                org_id_future = executor.submit(_get_org_id)
+
+                while True:
+                    try:
+                        with urllib.request.urlopen(f"{local_url}/ok") as response:
+                            if response.status == 200:
+                                try:
+                                    org_id = org_id_future.result(timeout=3.0)
+                                    if org_id:
+                                        studio_url = f"{studio_origin}/studio/?baseUrl={local_url}&organizationId={org_id}"
+                                except TimeoutError as e:
+                                    thread_logger.debug(
+                                        f"Failed to get organization ID: {str(e)}"
+                                    )
+                                    pass
+                                thread_logger.info(
+                                    f"Server started in {time.time() - start_time:.2f}s"
                                 )
-                                pass
-                            thread_logger.info(
-                                f"Server started in {time.time() - start_time:.2f}s"
-                            )
-                            thread_logger.info("🎨 Opening Studio in your browser...")
-                            thread_logger.info("URL: " + studio_url)
-                            webbrowser.open(studio_url)
-                            return
-                except urllib.error.URLError:
-                    pass
-                time.sleep(0.1)
-
-    welcome = f"""
+                                thread_logger.info(
+                                    "🎨 Opening Studio in your browser..."
+                                )
+                                thread_logger.info("URL: " + studio_url)
+                                webbrowser.open(studio_url)
+                                return
+                    except urllib.error.URLError:
+                        pass
+                    time.sleep(0.1)
+
+        welcome = f"""
 
         Welcome to
 
@@ -259,21 +287,8 @@ This in-memory server is designed for development and testing.
 For production use, please use LangGraph Cloud.
 
 """
-    logger.info(welcome)
-    with patch_environment(
-        MIGRATIONS_PATH="__inmem",
-        DATABASE_URI=":memory:",
-        REDIS_URI="fake",
-        N_JOBS_PER_WORKER=str(n_jobs_per_worker if n_jobs_per_worker else 1),
-        LANGGRAPH_STORE=json.dumps(store) if store else None,
-        LANGSERVE_GRAPHS=json.dumps(graphs) if graphs else None,
-        LANGSMITH_LANGGRAPH_API_VARIANT="local_dev",
-        LANGGRAPH_AUTH=json.dumps(auth) if auth else None,
-        LANGGRAPH_HTTP=json.dumps(http) if http else None,
-        # See https://developer.chrome.com/blog/private-network-access-update-2024-03
-        ALLOW_PRIVATE_NETWORK="true",
-        **(env_vars or {}),
-    ):
+        logger.info(welcome)
+
         if open_browser:
             threading.Thread(target=_open_browser, daemon=True).start()
         supported_kwargs = {

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
 
@@ -166,10 +170,28 @@ if (
     LANGSMITH_API_KEY
     and not getenv("LANGCHAIN_TRACING_V2")
     and not getenv("LANGCHAIN_TRACING")
+    and not getenv("LANGSMITH_TRACING_V2")
+    and not getenv("LANGSMITH_TRACING")
 ):
     environ["LANGCHAIN_TRACING_V2"] = "true"
 
+TRACING = (
+    env("LANGCHAIN_TRACING_V2", cast=bool, default=None)
+    or env("LANGCHAIN_TRACING", cast=bool, default=None)
+    or env("LANGSMITH_TRACING_V2", cast=bool, default=None)
+    or env("LANGSMITH_TRACING", cast=bool, default=None)
+)
+
 # if variant is "licensed", update to "local" if using LANGSMITH_API_KEY instead
 
 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/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/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/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/js/.gitignore

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