langgraph-api 0.4.45__py3-none-any.whl → 0.4.47__py3-none-any.whl

langgraph_api/__init__.py

@@ -1 +1 @@
-__version__ = "0.4.45"
+__version__ = "0.4.47"

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.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/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):
@@ -135,18 +142,72 @@ class CheckpointerConfig(TypedDict, total=False):
     """
 
 
+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
 
 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)
@@ -189,17 +250,15 @@ 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
-)
+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 +336,8 @@ 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
 )
 THREAD_TTL: ThreadTTLConfig | None = env(
     "LANGGRAPH_THREAD_TTL", cast=_parse_thread_ttl, default=None
@@ -292,6 +351,7 @@ 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 +363,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/grpc_ops/client.py

@@ -5,7 +5,7 @@ import os
 import structlog
 from grpc import aio  # type: ignore[import]
 
-from .generated.core_api_pb2_grpc import AdminStub, AssistantsStub
+from .generated.core_api_pb2_grpc import AdminStub, AssistantsStub, ThreadsStub
 
 logger = structlog.stdlib.get_logger(__name__)
 
@@ -27,6 +27,7 @@ class GrpcClient:
         )
         self._channel: aio.Channel | None = None
         self._assistants_stub: AssistantsStub | None = None
+        self._threads_stub: ThreadsStub | None = None
         self._admin_stub: AdminStub | None = None
 
     async def __aenter__(self):
@@ -46,6 +47,7 @@ class GrpcClient:
         self._channel = aio.insecure_channel(self.server_address)
 
         self._assistants_stub = AssistantsStub(self._channel)
+        self._threads_stub = ThreadsStub(self._channel)
         self._admin_stub = AdminStub(self._channel)
 
         await logger.adebug(
@@ -58,6 +60,7 @@ class GrpcClient:
             await self._channel.close()
             self._channel = None
             self._assistants_stub = None
+            self._threads_stub = None
             self._admin_stub = None
             await logger.adebug("Closed gRPC connection")
 
@@ -70,6 +73,15 @@ class GrpcClient:
             )
         return self._assistants_stub
 
+    @property
+    def threads(self) -> ThreadsStub:
+        """Get the threads service stub."""
+        if self._threads_stub is None:
+            raise RuntimeError(
+                "Client not connected. Use async context manager or call connect() first."
+            )
+        return self._threads_stub
+
     @property
     def admin(self) -> AdminStub:
         """Get the admin service stub."""