langgraph-api 0.4.40__py3-none-any.whl → 0.5.6__py3-none-any.whl

langgraph_api/__init__.py

@@ -1 +1 @@
-__version__ = "0.4.40"
+__version__ = "0.5.6"

langgraph_api/api/assistants.py

@@ -1,3 +1,4 @@
+from functools import partial
 from typing import Any
 from uuid import uuid4
 
@@ -15,7 +16,7 @@ from starlette.routing import BaseRoute
 from langgraph_api import store as api_store
 from langgraph_api.feature_flags import FF_USE_CORE_API, USE_RUNTIME_CONTEXT_API
 from langgraph_api.graph import get_assistant_id, get_graph
-from langgraph_api.grpc_ops.ops import Assistants as GrpcAssistants
+from langgraph_api.grpc.ops import Assistants as GrpcAssistants
 from langgraph_api.js.base import BaseRemotePregel
 from langgraph_api.route import ApiRequest, ApiResponse, ApiRoute
 from langgraph_api.schema import ASSISTANT_FIELDS
@@ -37,7 +38,7 @@ from langgraph_api.validation import (
     ConfigValidator,
 )
 from langgraph_runtime.checkpoint import Checkpointer
-from langgraph_runtime.database import connect
+from langgraph_runtime.database import connect as base_connect
 from langgraph_runtime.ops import Assistants
 from langgraph_runtime.retry import retry_db
 
@@ -45,6 +46,8 @@ logger = structlog.stdlib.get_logger(__name__)
 
 CrudAssistants = GrpcAssistants if FF_USE_CORE_API else Assistants
 
+connect = partial(base_connect, supports_core_api=FF_USE_CORE_API)
+
 EXCLUDED_CONFIG_SCHEMA = (
     "__pregel_checkpointer",
     "__pregel_store",
@@ -255,7 +258,7 @@ async def get_assistant_graph(
     assistant_id = get_assistant_id(str(request.path_params["assistant_id"]))
     validate_uuid(assistant_id, "Invalid assistant ID: must be a UUID")
     async with connect() as conn:
-        assistant_ = await Assistants.get(conn, assistant_id)
+        assistant_ = await CrudAssistants.get(conn, assistant_id)
         assistant = await fetchone(assistant_)
     config = json_loads(assistant["config"])
     configurable = config.setdefault("configurable", {})
@@ -312,43 +315,44 @@ async def get_assistant_subgraphs(
     assistant_id = request.path_params["assistant_id"]
     validate_uuid(assistant_id, "Invalid assistant ID: must be a UUID")
     async with connect() as conn:
-        assistant_ = await Assistants.get(conn, assistant_id)
+        assistant_ = await CrudAssistants.get(conn, assistant_id)
         assistant = await fetchone(assistant_)
-        config = json_loads(assistant["config"])
-        configurable = config.setdefault("configurable", {})
-        configurable.update(get_configurable_headers(request.headers))
-        async with get_graph(
-            assistant["graph_id"],
-            config,
-            checkpointer=Checkpointer(),
-            store=(await api_store.get_store()),
-        ) as graph:
-            namespace = request.path_params.get("namespace")
-
-            if isinstance(graph, BaseRemotePregel):
-                return ApiResponse(
-                    await graph.fetch_subgraphs(
+
+    config = json_loads(assistant["config"])
+    configurable = config.setdefault("configurable", {})
+    configurable.update(get_configurable_headers(request.headers))
+    async with get_graph(
+        assistant["graph_id"],
+        config,
+        checkpointer=Checkpointer(),
+        store=(await api_store.get_store()),
+    ) as graph:
+        namespace = request.path_params.get("namespace")
+
+        if isinstance(graph, BaseRemotePregel):
+            return ApiResponse(
+                await graph.fetch_subgraphs(
+                    namespace=namespace,
+                    recurse=request.query_params.get("recurse", "False")
+                    in ("true", "True"),
+                )
+            )
+
+        try:
+            return ApiResponse(
+                {
+                    ns: _graph_schemas(subgraph)
+                    async for ns, subgraph in graph.aget_subgraphs(
                         namespace=namespace,
                         recurse=request.query_params.get("recurse", "False")
                         in ("true", "True"),
                     )
-                )
-
-            try:
-                return ApiResponse(
-                    {
-                        ns: _graph_schemas(subgraph)
-                        async for ns, subgraph in graph.aget_subgraphs(
-                            namespace=namespace,
-                            recurse=request.query_params.get("recurse", "False")
-                            in ("true", "True"),
-                        )
-                    }
-                )
-            except NotImplementedError:
-                raise HTTPException(
-                    422, detail="The graph does not support visualization"
-                ) from None
+                }
+            )
+        except NotImplementedError:
+            raise HTTPException(
+                422, detail="The graph does not support visualization"
+            ) from None
 
 
 @retry_db
@@ -359,40 +363,40 @@ async def get_assistant_schemas(
     assistant_id = request.path_params["assistant_id"]
     validate_uuid(assistant_id, "Invalid assistant ID: must be a UUID")
     async with connect() as conn:
-        assistant_ = await Assistants.get(conn, assistant_id)
-        # TODO Implementa  cache so we can de-dent and release this connection.
+        assistant_ = await CrudAssistants.get(conn, assistant_id)
         assistant = await fetchone(assistant_)
-        config = json_loads(assistant["config"])
-        configurable = config.setdefault("configurable", {})
-        configurable.update(get_configurable_headers(request.headers))
-        async with get_graph(
-            assistant["graph_id"],
-            config,
-            checkpointer=Checkpointer(),
-            store=(await api_store.get_store()),
-        ) as graph:
-            if isinstance(graph, BaseRemotePregel):
-                schemas = await graph.fetch_state_schema()
-                return ApiResponse(
-                    {
-                        "graph_id": assistant["graph_id"],
-                        "input_schema": schemas.get("input"),
-                        "output_schema": schemas.get("output"),
-                        "state_schema": schemas.get("state"),
-                        "config_schema": schemas.get("config"),
-                        "context_schema": schemas.get("context"),
-                    }
-                )
-
-            schemas = _graph_schemas(graph)
 
+    config = json_loads(assistant["config"])
+    configurable = config.setdefault("configurable", {})
+    configurable.update(get_configurable_headers(request.headers))
+    async with get_graph(
+        assistant["graph_id"],
+        config,
+        checkpointer=Checkpointer(),
+        store=(await api_store.get_store()),
+    ) as graph:
+        if isinstance(graph, BaseRemotePregel):
+            schemas = await graph.fetch_state_schema()
             return ApiResponse(
                 {
                     "graph_id": assistant["graph_id"],
-                    **schemas,
+                    "input_schema": schemas.get("input"),
+                    "output_schema": schemas.get("output"),
+                    "state_schema": schemas.get("state"),
+                    "config_schema": schemas.get("config"),
+                    "context_schema": schemas.get("context"),
                 }
             )
 
+        schemas = _graph_schemas(graph)
+
+        return ApiResponse(
+            {
+                "graph_id": assistant["graph_id"],
+                **schemas,
+            }
+        )
+
 
 @retry_db
 async def patch_assistant(

langgraph_api/api/meta.py

@@ -86,6 +86,12 @@ async def meta_metrics(request: ApiRequest):
                         "# HELP lg_api_num_running_runs The number of runs currently running.",
                         "# TYPE lg_api_num_running_runs gauge",
                         f'lg_api_num_running_runs{{project_id="{metadata.PROJECT_ID}", revision_id="{metadata.HOST_REVISION_ID}"}} {queue_stats["n_running"]}',
+                        "# HELP lg_api_pending_runs_wait_time_max The maximum time a run has been pending, in seconds.",
+                        "# TYPE lg_api_pending_runs_wait_time_max gauge",
+                        f'lg_api_pending_runs_wait_time_max{{project_id="{metadata.PROJECT_ID}", revision_id="{metadata.HOST_REVISION_ID}"}} {queue_stats.get("pending_runs_wait_time_max_secs") or 0}',
+                        "# HELP lg_api_pending_runs_wait_time_med The median pending wait time across runs, in seconds.",
+                        "# TYPE lg_api_pending_runs_wait_time_med gauge",
+                        f'lg_api_pending_runs_wait_time_med{{project_id="{metadata.PROJECT_ID}", revision_id="{metadata.HOST_REVISION_ID}"}} {queue_stats.get("pending_runs_wait_time_med_secs") or 0}',
                     ]
                 )
         except Exception as e:

langgraph_api/api/threads.py

@@ -5,6 +5,8 @@ from starlette.exceptions import HTTPException
 from starlette.responses import Response
 from starlette.routing import BaseRoute
 
+from langgraph_api.feature_flags import FF_USE_CORE_API
+from langgraph_api.grpc.ops import Threads as GrpcThreads
 from langgraph_api.route import ApiRequest, ApiResponse, ApiRoute
 from langgraph_api.schema import THREAD_FIELDS, ThreadStreamMode
 from langgraph_api.sse import EventSourceResponse
@@ -30,6 +32,8 @@ from langgraph_runtime.database import connect
 from langgraph_runtime.ops import Threads
 from langgraph_runtime.retry import retry_db
 
+CrudThreads = GrpcThreads if FF_USE_CORE_API else Threads
+
 
 @retry_db
 async def create_thread(
@@ -41,7 +45,7 @@ async def create_thread(
         validate_uuid(thread_id, "Invalid thread ID: must be a UUID")
     async with connect() as conn:
         thread_id = thread_id or str(uuid4())
-        iter = await Threads.put(
+        iter = await CrudThreads.put(
             conn,
             thread_id,
             metadata=payload.get("metadata"),
@@ -78,7 +82,7 @@ async def search_threads(
     limit = int(payload.get("limit") or 10)
     offset = int(payload.get("offset") or 0)
     async with connect() as conn:
-        threads_iter, next_offset = await Threads.search(
+        threads_iter, next_offset = await CrudThreads.search(
             conn,
             status=payload.get("status"),
             values=payload.get("values"),
@@ -103,7 +107,7 @@ async def count_threads(
     """Count threads."""
     payload = await request.json(ThreadCountRequest)
     async with connect() as conn:
-        count = await Threads.count(
+        count = await CrudThreads.count(
             conn,
             status=payload.get("status"),
             values=payload.get("values"),
@@ -277,7 +281,7 @@ async def get_thread(
     thread_id = request.path_params["thread_id"]
     validate_uuid(thread_id, "Invalid thread ID: must be a UUID")
     async with connect() as conn:
-        thread = await Threads.get(conn, thread_id)
+        thread = await CrudThreads.get(conn, thread_id)
     return ApiResponse(await fetchone(thread))
 
 
@@ -290,7 +294,7 @@ async def patch_thread(
     validate_uuid(thread_id, "Invalid thread ID: must be a UUID")
     payload = await request.json(ThreadPatch)
     async with connect() as conn:
-        thread = await Threads.patch(
+        thread = await CrudThreads.patch(
             conn,
             thread_id,
             metadata=payload.get("metadata", {}),
@@ -305,7 +309,7 @@ async def delete_thread(request: ApiRequest):
     thread_id = request.path_params["thread_id"]
     validate_uuid(thread_id, "Invalid thread ID: must be a UUID")
     async with connect() as conn:
-        tid = await Threads.delete(conn, thread_id)
+        tid = await CrudThreads.delete(conn, thread_id)
     await fetchone(tid)
     return Response(status_code=204)
 
@@ -314,7 +318,7 @@ async def delete_thread(request: ApiRequest):
 async def copy_thread(request: ApiRequest):
     thread_id = request.path_params["thread_id"]
     async with connect() as conn:
-        iter = await Threads.copy(conn, thread_id)
+        iter = await CrudThreads.copy(conn, thread_id)
     return ApiResponse(await fetchone(iter, not_found_code=409))
 
 

langgraph_api/auth/custom.py

@@ -355,34 +355,39 @@ def _solve_fastapi_dependencies(
     }
 
     async def decorator(scope: dict, request: Request):
-        async with AsyncExitStack() as stack:
-            all_solved = await asyncio.gather(
-                *(
-                    solve_dependencies(
-                        request=request,
-                        dependant=dependent,
-                        async_exit_stack=stack,
-                        embed_body_fields=False,
+        async with AsyncExitStack() as request_stack:
+            scope["fastapi_inner_astack"] = request_stack
+            async with AsyncExitStack() as stack:
+                scope["fastapi_function_astack"] = stack
+                all_solved = await asyncio.gather(
+                    *(
+                        solve_dependencies(
+                            request=request,
+                            dependant=dependent,
+                            async_exit_stack=stack,
+                            embed_body_fields=False,
+                        )
+                        for dependent in dependents.values()
                     )
-                    for dependent in dependents.values()
                 )
-            )
-            all_injected = await asyncio.gather(
-                *(
-                    _run_async(dependent.call, solved.values, is_async)
-                    for dependent, solved in zip(
-                        dependents.values(), all_solved, strict=False
+                all_injected = await asyncio.gather(
+                    *(
+                        _run_async(dependent.call, solved.values, is_async)
+                        for dependent, solved in zip(
+                            dependents.values(), all_solved, strict=False
+                        )
                     )
                 )
-            )
-            kwargs = {
-                name: value
-                for name, value in zip(dependents.keys(), all_injected, strict=False)
-            }
-            other_params = _extract_arguments_from_scope(
-                scope, _param_names, request=request
-            )
-            return await fn(**(kwargs | other_params))
+                kwargs = {
+                    name: value
+                    for name, value in zip(
+                        dependents.keys(), all_injected, strict=False
+                    )
+                }
+                other_params = _extract_arguments_from_scope(
+                    scope, _param_names, request=request
+                )
+                return await fn(**(kwargs | other_params))
 
     return decorator
 

langgraph_api/cli.py

@@ -8,12 +8,10 @@ import typing
 from collections.abc import Mapping, Sequence
 from typing import Literal
 
-from typing_extensions import TypedDict
-
 if typing.TYPE_CHECKING:
     from packaging.version import Version
 
-    from langgraph_api.config import HttpConfig, StoreConfig
+    from langgraph_api.config import AuthConfig, HttpConfig, StoreConfig
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
@@ -81,51 +79,6 @@ def patch_environment(**kwargs):
                 os.environ[key] = value
 
 
-class SecurityConfig(TypedDict, total=False):
-    securitySchemes: dict
-    security: list
-    # path => {method => security}
-    paths: dict[str, dict[str, list]]
-
-
-class CacheConfig(TypedDict, total=False):
-    cache_keys: list[str]
-    ttl_seconds: int
-    max_size: int
-
-
-class AuthConfig(TypedDict, total=False):
-    path: str
-    """Path to the authentication function in a Python file."""
-    disable_studio_auth: bool
-    """Whether to disable auth when connecting from the LangSmith Studio."""
-    openapi: SecurityConfig
-    """The schema to use for updating the openapi spec.
-
-    Example:
-        {
-            "securitySchemes": {
-                "OAuth2": {
-                    "type": "oauth2",
-                    "flows": {
-                        "password": {
-                            "tokenUrl": "/token",
-                            "scopes": {
-                                "me": "Read information about the current user",
-                                "items": "Access to create and manage items"
-                            }
-                        }
-                    }
-                }
-            },
-            "security": [
-                {"OAuth2": ["me"]}  # Default security requirement for all endpoints
-            ]
-        }
-    """
-    cache: CacheConfig | None
-
-
 def run_server(
     host: str = "127.0.0.1",
     port: int = 2024,
@@ -141,7 +94,7 @@ def run_server(
     reload_includes: Sequence[str] | None = None,
     reload_excludes: Sequence[str] | None = None,
     store: typing.Optional["StoreConfig"] = None,
-    auth: AuthConfig | None = None,
+    auth: typing.Optional["AuthConfig"] = None,
     http: typing.Optional["HttpConfig"] = None,
     ui: dict | None = None,
     ui_config: dict | None = None,

langgraph_api/config.py

@@ -1,8 +1,10 @@
 import os
+from collections.abc import Callable
 from os import environ, getenv
-from typing import Literal
+from typing import Literal, TypeVar, cast
 
 import orjson
+from pydantic import TypeAdapter
 from starlette.config import Config, undefined
 from starlette.datastructures import CommaSeparatedStrings
 from typing_extensions import TypedDict
@@ -22,11 +24,14 @@ class CorsConfig(TypedDict, total=False):
     max_age: int
 
 
-class ConfigurableHeaders(TypedDict):
+class ConfigurableHeaders(TypedDict, total=False):
     includes: list[str] | None
     excludes: list[str] | None
 
 
+MiddlewareOrders = Literal["auth_first", "middleware_first"]
+
+
 class HttpConfig(TypedDict, total=False):
     app: str
     """Import path for a custom Starlette/FastAPI app to mount"""
@@ -52,6 +57,8 @@ class HttpConfig(TypedDict, total=False):
     """Prefix for mounted routes. E.g., "/my-deployment/api"."""
     configurable_headers: ConfigurableHeaders | None
     logging_headers: ConfigurableHeaders | None
+    enable_custom_route_auth: bool
+    middleware_order: MiddlewareOrders | None
 
 
 class ThreadTTLConfig(TypedDict, total=False):
@@ -121,6 +128,45 @@ class StoreConfig(TypedDict, total=False):
     ttl: TTLConfig
 
 
+class SerdeConfig(TypedDict, total=False):
+    """Configuration for the built-in serde, which handles checkpointing of state.
+
+    If omitted, no serde is set up (the object store will still be present, however)."""
+
+    allowed_json_modules: list[list[str]] | Literal[True] | None
+    """Optional. List of allowed python modules to de-serialize custom objects from.
+    
+    If provided, only the specified modules will be allowed to be deserialized.
+    If omitted, no modules are allowed, and the object returned will simply be a json object OR
+    a deserialized langchain object.
+    
+    Example:
+    {...
+        "serde": {
+            "allowed_json_modules": [
+                ["my_agent", "my_file", "SomeType"],
+            ]
+        }
+    }
+
+    If you set this to True, any module will be allowed to be deserialized.
+
+    Example:
+    {...
+        "serde": {
+            "allowed_json_modules": true
+        }
+    }
+    
+    """
+    pickle_fallback: bool
+    """Optional. Whether to allow pickling as a fallback for deserialization.
+    
+    If True, pickling will be allowed as a fallback for deserialization.
+    If False, pickling will not be allowed as a fallback for deserialization.
+    Defaults to True if not configured."""
+
+
 class CheckpointerConfig(TypedDict, total=False):
     """Configuration for the built-in checkpointer, which handles checkpointing of state.
 
@@ -133,6 +179,53 @@ class CheckpointerConfig(TypedDict, total=False):
     If provided, the checkpointer will apply TTL settings according to the configuration.
     If omitted, no TTL behavior is configured.
     """
+    serde: SerdeConfig | None
+    """Optional. Defines the configuration for how checkpoints are serialized."""
+
+
+class SecurityConfig(TypedDict, total=False):
+    securitySchemes: dict
+    security: list
+    # path => {method => security}
+    paths: dict[str, dict[str, list]]
+
+
+class CacheConfig(TypedDict, total=False):
+    cache_keys: list[str]
+    ttl_seconds: int
+    max_size: int
+
+
+class AuthConfig(TypedDict, total=False):
+    path: str
+    """Path to the authentication function in a Python file."""
+    disable_studio_auth: bool
+    """Whether to disable auth when connecting from the LangSmith Studio."""
+    openapi: SecurityConfig
+    """The schema to use for updating the openapi spec.
+
+    Example:
+        {
+            "securitySchemes": {
+                "OAuth2": {
+                    "type": "oauth2",
+                    "flows": {
+                        "password": {
+                            "tokenUrl": "/token",
+                            "scopes": {
+                                "me": "Read information about the current user",
+                                "items": "Access to create and manage items"
+                            }
+                        }
+                    }
+                }
+            },
+            "security": [
+                {"OAuth2": ["me"]}  # Default security requirement for all endpoints
+            ]
+        }
+    """
+    cache: CacheConfig | None
 
 
 # env
@@ -140,13 +233,22 @@ class CheckpointerConfig(TypedDict, total=False):
 env = Config()
 
 
-def _parse_json(json: str | None) -> dict | None:
+TD = TypeVar("TD")
+
+
+def _parse_json(json: str | None, schema: TypeAdapter | None = None) -> dict | None:
     if not json:
         return None
-    parsed = orjson.loads(json)
-    if not parsed:
-        return None
-    return parsed
+    parsed = schema.validate_json(json) if schema else orjson.loads(json)
+    return parsed or None
+
+
+def _parse_schema(schema: type[TD]) -> Callable[[str | None], TD | None]:
+    def composed(json: str | None) -> TD | None:
+        return cast(TD | None, _parse_json(json, schema=TypeAdapter(schema)))
+
+    composed.__name__ = schema.__name__  # This just gives a nicer error message if the user provides an incompatible value
+    return composed
 
 
 STATS_INTERVAL_SECS = env("STATS_INTERVAL_SECS", cast=int, default=60)
@@ -179,6 +281,9 @@ 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=2000)
 REDIS_CONNECT_TIMEOUT = env("REDIS_CONNECT_TIMEOUT", cast=float, default=10.0)
+REDIS_HEALTH_CHECK_INTERVAL = env(
+    "REDIS_HEALTH_CHECK_INTERVAL", cast=float, default=10.0
+)
 REDIS_KEY_PREFIX = env("REDIS_KEY_PREFIX", cast=str, default="")
 RUN_STATS_CACHE_SECONDS = env("RUN_STATS_CACHE_SECONDS", cast=int, default=60)
 
@@ -189,17 +294,22 @@ ALLOW_PRIVATE_NETWORK = env("ALLOW_PRIVATE_NETWORK", cast=bool, default=False)
 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: StoreConfig | None = env(
-    "LANGGRAPH_STORE", cast=_parse_json, default=None
-)
+# gRPC client pool size for persistence server.
+GRPC_CLIENT_POOL_SIZE = env("GRPC_CLIENT_POOL_SIZE", cast=int, default=5)
+
+# Minimum payload size to use the dedicated thread pool for JSON parsing.
+# (Otherwise, the payload is parsed directly in the event loop.)
+JSON_THREAD_POOL_MINIMUM_SIZE_BYTES = 100 * 1024  # 100 KB
+
+HTTP_CONFIG = env("LANGGRAPH_HTTP", cast=_parse_schema(HttpConfig), default=None)
+STORE_CONFIG = env("LANGGRAPH_STORE", cast=_parse_schema(StoreConfig), default=None)
 
 MOUNT_PREFIX: str | None = env("MOUNT_PREFIX", cast=str, default=None) or (
     HTTP_CONFIG.get("mount_prefix") if HTTP_CONFIG else None
 )
 
 CORS_ALLOW_ORIGINS = env("CORS_ALLOW_ORIGINS", cast=CommaSeparatedStrings, default="*")
-CORS_CONFIG: CorsConfig | None = env("CORS_CONFIG", cast=_parse_json, default=None) or (
+CORS_CONFIG = env("CORS_CONFIG", cast=_parse_schema(CorsConfig), default=None) or (
     HTTP_CONFIG.get("cors") if HTTP_CONFIG else None
 )
 """
@@ -277,8 +387,13 @@ def _parse_thread_ttl(value: str | None) -> ThreadTTLConfig | None:
     }
 
 
-CHECKPOINTER_CONFIG: CheckpointerConfig | None = env(
-    "LANGGRAPH_CHECKPOINTER", cast=_parse_json, default=None
+CHECKPOINTER_CONFIG = env(
+    "LANGGRAPH_CHECKPOINTER", cast=_parse_schema(CheckpointerConfig), default=None
+)
+SERDE: SerdeConfig | None = (
+    CHECKPOINTER_CONFIG["serde"]
+    if CHECKPOINTER_CONFIG and "serde" in CHECKPOINTER_CONFIG
+    else None
 )
 THREAD_TTL: ThreadTTLConfig | None = env(
     "LANGGRAPH_THREAD_TTL", cast=_parse_thread_ttl, default=None
@@ -290,8 +405,8 @@ 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_RICH_THREADS = env("FF_RICH_THREADS", cast=bool, default=True)
 FF_LOG_DROPPED_EVENTS = env("FF_LOG_DROPPED_EVENTS", cast=bool, default=False)
+FF_LOG_QUERY_AND_PARAMS = env("FF_LOG_QUERY_AND_PARAMS", cast=bool, default=False)
 
 # auth
 
@@ -303,7 +418,7 @@ if LANGGRAPH_POSTGRES_EXTENSIONS not in ("standard", "lite"):
     raise ValueError(
         f"Unknown LANGGRAPH_POSTGRES_EXTENSIONS value: {LANGGRAPH_POSTGRES_EXTENSIONS}"
     )
-LANGGRAPH_AUTH = env("LANGGRAPH_AUTH", cast=_parse_json, default=None)
+LANGGRAPH_AUTH = env("LANGGRAPH_AUTH", cast=_parse_schema(AuthConfig), default=None)
 LANGSMITH_TENANT_ID = env("LANGSMITH_TENANT_ID", cast=str, default=None)
 LANGSMITH_AUTH_VERIFY_TENANT_ID = env(
     "LANGSMITH_AUTH_VERIFY_TENANT_ID",

langgraph_api/graph.py

@@ -51,7 +51,7 @@ async def register_graph(
     description: str | None = None,
 ) -> None:
     """Register a graph."""
-    from langgraph_api.grpc_ops.ops import Assistants as AssistantsGrpc
+    from langgraph_api.grpc.ops import Assistants as AssistantsGrpc
     from langgraph_runtime.database import connect
     from langgraph_runtime.ops import Assistants as AssistantsRuntime