langgraph-api 0.5.4__py3-none-any.whl → 0.7.3__py3-none-any.whl

langgraph_api/api/store.py

@@ -5,7 +5,13 @@ from starlette.responses import Response
 from starlette.routing import BaseRoute
 
 from langgraph_api.auth.custom import handle_event as _handle_event
+from langgraph_api.encryption.middleware import (
+    decrypt_response,
+    decrypt_responses,
+    encrypt_request,
+)
 from langgraph_api.route import ApiRequest, ApiResponse, ApiRoute
+from langgraph_api.schema import STORE_ENCRYPTION_FIELDS
 from langgraph_api.store import get_store
 from langgraph_api.utils import get_auth_ctx
 from langgraph_api.validation import (
@@ -48,6 +54,7 @@ async def handle_event(
 async def put_item(request: ApiRequest):
     """Store or update an item."""
     payload = await request.json(StorePutRequest)
+    payload = await encrypt_request(payload, "store", STORE_ENCRYPTION_FIELDS)
     namespace = tuple(payload["namespace"]) if payload.get("namespace") else ()
     if err := _validate_namespace(namespace):
         return err
@@ -78,7 +85,11 @@ async def get_item(request: ApiRequest):
     }
     await handle_event("get", handler_payload)
     result = await (await get_store()).aget(namespace, key)
-    return ApiResponse(result.dict() if result is not None else None)
+    if result is None:
+        return ApiResponse(None)
+    return ApiResponse(
+        await decrypt_response(result.dict(), "store", STORE_ENCRYPTION_FIELDS)
+    )
 
 
 @retry_db
@@ -125,7 +136,13 @@ async def search_items(request: ApiRequest):
         offset=handler_payload["offset"],
         query=handler_payload["query"],
     )
-    return ApiResponse({"items": [item.dict() for item in items]})
+    return ApiResponse(
+        {
+            "items": await decrypt_responses(
+                [item.dict() for item in items], "store", STORE_ENCRYPTION_FIELDS
+            )
+        }
+    )
 
 
 @retry_db

langgraph_api/api/threads.py

@@ -5,10 +5,19 @@ from starlette.exceptions import HTTPException
 from starlette.responses import Response
 from starlette.routing import BaseRoute
 
+from langgraph_api.encryption.middleware import (
+    decrypt_response,
+    decrypt_responses,
+    encrypt_request,
+)
 from langgraph_api.feature_flags import FF_USE_CORE_API
-from langgraph_api.grpc_ops.ops import Threads as GrpcThreads
+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.schema import (
+    THREAD_ENCRYPTION_FIELDS,
+    THREAD_FIELDS,
+    ThreadStreamMode,
+)
 from langgraph_api.sse import EventSourceResponse
 from langgraph_api.state import state_snapshot_to_thread_state
 from langgraph_api.utils import (
@@ -23,6 +32,7 @@ from langgraph_api.validation import (
     ThreadCountRequest,
     ThreadCreate,
     ThreadPatch,
+    ThreadPruneRequest,
     ThreadSearchRequest,
     ThreadStateCheckpointRequest,
     ThreadStateSearch,
@@ -43,12 +53,28 @@ async def create_thread(
     payload = await request.json(ThreadCreate)
     if thread_id := payload.get("thread_id"):
         validate_uuid(thread_id, "Invalid thread ID: must be a UUID")
+
+    # Validate keep_latest TTL requires core API
+    ttl = payload.get("ttl")
+    if ttl and ttl.get("strategy") == "keep_latest" and not FF_USE_CORE_API:
+        raise HTTPException(
+            status_code=422,
+            detail="keep_latest TTL strategy requires FF_USE_CORE_API=true",
+        )
+
+    # Encrypt metadata before storing
+    encrypted_payload = await encrypt_request(
+        payload,
+        "thread",
+        ["metadata"],
+    )
+
     async with connect() as conn:
         thread_id = thread_id or str(uuid4())
         iter = await CrudThreads.put(
             conn,
             thread_id,
-            metadata=payload.get("metadata"),
+            metadata=encrypted_payload.get("metadata") or {},
             if_exists=payload.get("if_exists") or "raise",
             ttl=payload.get("ttl"),
         )
@@ -69,7 +95,14 @@ async def create_thread(
                 detail = f"Thread {thread_id} was created, but there were problems updating the state: {e.detail}"
                 raise HTTPException(status_code=201, detail=detail) from e
 
-    return ApiResponse(await fetchone(iter, not_found_code=409))
+    # Decrypt thread fields in response
+    thread = await fetchone(iter, not_found_code=409)
+    thread = await decrypt_response(
+        thread,
+        "thread",
+        THREAD_ENCRYPTION_FIELDS,
+    )
+    return ApiResponse(thread)
 
 
 @retry_db
@@ -81,6 +114,7 @@ async def search_threads(
     select = validate_select_columns(payload.get("select") or None, THREAD_FIELDS)
     limit = int(payload.get("limit") or 10)
     offset = int(payload.get("offset") or 0)
+
     async with connect() as conn:
         threads_iter, next_offset = await CrudThreads.search(
             conn,
@@ -97,7 +131,15 @@ async def search_threads(
     threads, response_headers = await get_pagination_headers(
         threads_iter, next_offset, offset
     )
-    return ApiResponse(threads, headers=response_headers)
+
+    # Decrypt metadata, values, interrupts, and error in all returned threads
+    decrypted_threads = await decrypt_responses(
+        threads,
+        "thread",
+        THREAD_ENCRYPTION_FIELDS,
+    )
+
+    return ApiResponse(decrypted_threads, headers=response_headers)
 
 
 @retry_db
@@ -280,9 +322,23 @@ async def get_thread(
     """Get a thread by ID."""
     thread_id = request.path_params["thread_id"]
     validate_uuid(thread_id, "Invalid thread ID: must be a UUID")
+
+    # Parse include parameter for optional fields (e.g., ttl)
+    include_param = request.query_params.get("include", "")
+    include_fields = [f.strip() for f in include_param.split(",") if f.strip()]
+    include_ttl = "ttl" in include_fields
+
     async with connect() as conn:
-        thread = await CrudThreads.get(conn, thread_id)
-    return ApiResponse(await fetchone(thread))
+        thread = await CrudThreads.get(conn, thread_id, include_ttl=include_ttl)
+
+    # Decrypt metadata, values, interrupts, and error in response
+    thread_data = await fetchone(thread)
+    thread_data = await decrypt_response(
+        thread_data,
+        "thread",
+        THREAD_ENCRYPTION_FIELDS,
+    )
+    return ApiResponse(thread_data)
 
 
 @retry_db
@@ -293,14 +349,37 @@ async def patch_thread(
     thread_id = request.path_params["thread_id"]
     validate_uuid(thread_id, "Invalid thread ID: must be a UUID")
     payload = await request.json(ThreadPatch)
+
+    # Validate keep_latest TTL requires core API
+    ttl = payload.get("ttl")
+    if ttl and ttl.get("strategy") == "keep_latest" and not FF_USE_CORE_API:
+        raise HTTPException(
+            status_code=422,
+            detail="keep_latest TTL strategy requires FF_USE_CORE_API=true",
+        )
+
+    # Encrypt metadata before storing
+    encrypted_payload = await encrypt_request(
+        payload,
+        "thread",
+        ["metadata"],
+    )
+
     async with connect() as conn:
         thread = await CrudThreads.patch(
             conn,
             thread_id,
-            metadata=payload.get("metadata", {}),
+            metadata=encrypted_payload.get("metadata") or {},
             ttl=payload.get("ttl"),
         )
-    return ApiResponse(await fetchone(thread))
+    thread_data = await fetchone(thread)
+    # Decrypt metadata, values, interrupts, and error in response
+    thread_data = await decrypt_response(
+        thread_data,
+        "thread",
+        THREAD_ENCRYPTION_FIELDS,
+    )
+    return ApiResponse(thread_data)
 
 
 @retry_db
@@ -314,12 +393,55 @@ async def delete_thread(request: ApiRequest):
     return Response(status_code=204)
 
 
+@retry_db
+async def prune_threads(request: ApiRequest):
+    """Prune threads by ID."""
+    payload = await request.json(ThreadPruneRequest)
+    thread_ids = payload.get("thread_ids", [])
+    strategy = payload.get("strategy", "delete")
+
+    # Validate each thread_id is a valid UUID
+    for tid in thread_ids:
+        validate_uuid(tid, "Invalid thread ID: must be a UUID")
+
+    # Validate strategy
+    if strategy not in ("delete", "keep_latest"):
+        raise HTTPException(
+            status_code=422,
+            detail=f"Invalid strategy: {strategy}. Expected 'delete' or 'keep_latest'.",
+        )
+
+    # Empty list is a no-op, return early
+    if not thread_ids:
+        return ApiResponse({"pruned_count": 0})
+
+    if not FF_USE_CORE_API:
+        raise HTTPException(
+            status_code=422,
+            detail="Thread prune requires FF_USE_CORE_API=true",
+        )
+
+    pruned_count = await CrudThreads.prune(
+        thread_ids=thread_ids,
+        strategy=strategy,
+    )
+
+    return ApiResponse({"pruned_count": pruned_count})
+
+
 @retry_db
 async def copy_thread(request: ApiRequest):
     thread_id = request.path_params["thread_id"]
     async with connect() as conn:
         iter = await CrudThreads.copy(conn, thread_id)
-    return ApiResponse(await fetchone(iter, not_found_code=409))
+    thread_data = await fetchone(iter, not_found_code=409)
+    # Decrypt metadata, values, interrupts, and error in response
+    thread_data = await decrypt_response(
+        thread_data,
+        "thread",
+        THREAD_ENCRYPTION_FIELDS,
+    )
+    return ApiResponse(thread_data)
 
 
 @retry_db
@@ -364,6 +486,7 @@ threads_routes: list[BaseRoute] = [
     ApiRoute("/threads", endpoint=create_thread, methods=["POST"]),
     ApiRoute("/threads/search", endpoint=search_threads, methods=["POST"]),
     ApiRoute("/threads/count", endpoint=count_threads, methods=["POST"]),
+    ApiRoute("/threads/prune", endpoint=prune_threads, methods=["POST"]),
     ApiRoute("/threads/{thread_id}", endpoint=get_thread, methods=["GET"]),
     ApiRoute("/threads/{thread_id}", endpoint=patch_thread, methods=["PATCH"]),
     ApiRoute("/threads/{thread_id}", endpoint=delete_thread, methods=["DELETE"]),

langgraph_api/asgi_transport.py

@@ -25,7 +25,7 @@ def is_running_trio() -> bool:
         # sniffio is a dependency of trio.
 
         # See https://github.com/python-trio/trio/issues/2802
-        import sniffio
+        import sniffio  # type: ignore[unresolved-import]
 
         if sniffio.current_async_library() == "trio":
             return True
@@ -84,7 +84,8 @@ class ASGITransport(ASGITransportBase):
     ) -> Response:
         from langgraph_api.asyncio import call_soon_in_main_loop
 
-        assert isinstance(request.stream, AsyncByteStream)
+        if not isinstance(request.stream, AsyncByteStream):
+            raise ValueError("Request stream must be an AsyncByteStream")
 
         # ASGI scope.
         scope = {
@@ -133,14 +134,15 @@ class ASGITransport(ASGITransportBase):
             nonlocal status_code, response_headers, response_started
 
             if message["type"] == "http.response.start":
-                assert not response_started
-
+                if response_started:
+                    raise RuntimeError("Response already started")
                 status_code = message["status"]
                 response_headers = message.get("headers", [])
                 response_started = True
 
             elif message["type"] == "http.response.body":
-                assert not response_complete.is_set()
+                if response_complete.is_set():
+                    raise RuntimeError("Response already complete")
                 body = message.get("body", b"")
                 more_body = message.get("more_body", False)
 
@@ -152,7 +154,7 @@ class ASGITransport(ASGITransportBase):
 
         try:
             await call_soon_in_main_loop(self.app(scope, receive, send))
-        except Exception:  # noqa: PIE-786
+        except Exception:
             if self.raise_app_exceptions:
                 raise
 
@@ -162,9 +164,12 @@ class ASGITransport(ASGITransportBase):
             if response_headers is None:
                 response_headers = {}
 
-        assert response_complete.is_set()
-        assert status_code is not None
-        assert response_headers is not None
+        if not response_complete.is_set():
+            raise RuntimeError("Response not complete")
+        if status_code is None:
+            raise RuntimeError("Status code not set")
+        if response_headers is None:
+            raise RuntimeError("Response headers not set")
 
         stream = ASGIResponseStream(body_parts)
 

langgraph_api/auth/custom.py

@@ -23,10 +23,12 @@ from starlette.exceptions import HTTPException
 from starlette.requests import HTTPConnection, Request
 from starlette.responses import Response
 
+from langgraph_api import timing
 from langgraph_api.auth.langsmith.backend import LangsmithAuthBackend
 from langgraph_api.auth.studio_user import StudioUser
 from langgraph_api.config import LANGGRAPH_AUTH, LANGGRAPH_AUTH_TYPE
 from langgraph_api.js.base import is_js_path
+from langgraph_api.timing import profiled_import
 
 logger = structlog.stdlib.get_logger(__name__)
 
@@ -233,7 +235,7 @@ def _get_custom_auth_middleware(
         auth_instance._authenticate_handler,
         disable_studio_auth,
     )
-    logger.info(f"Loaded custom auth middleware: {str(result)}")
+    logger.info(f"Loaded custom auth middleware: {result!s}")
     return result
 
 
@@ -585,6 +587,13 @@ def normalize_user(user: Any) -> BaseUser:
     )
 
 
+@timing.timer(
+    message="Loading custom auth {auth_path}",
+    metadata_fn=lambda auth_path: {"auth_path": auth_path},
+    warn_threshold_secs=5,
+    warn_message="Loading custom auth '{auth_path}' took longer than expected",
+    error_threshold_secs=10,
+)
 def _load_auth_obj(path: str) -> Auth | Literal["js"]:
     """Load an object from a path string."""
     if ":" not in path:
@@ -600,18 +609,19 @@ def _load_auth_obj(path: str) -> Auth | Literal["js"]:
         return "js"
 
     try:
-        if "/" in module_name or ".py" in module_name:
-            # Load from file path
-            modname = f"dynamic_module_{hash(module_name)}"
-            modspec = importlib.util.spec_from_file_location(modname, module_name)
-            if modspec is None or modspec.loader is None:
-                raise ValueError(f"Could not load file: {module_name}")
-            module = importlib.util.module_from_spec(modspec)
-            sys.modules[modname] = module
-            modspec.loader.exec_module(module)  # type: ignore[possibly-unbound-attribute]
-        else:
-            # Load from Python module
-            module = importlib.import_module(module_name)
+        with profiled_import(path):
+            if "/" in module_name or ".py" in module_name:
+                # Load from file path
+                modname = f"dynamic_module_{hash(module_name)}"
+                modspec = importlib.util.spec_from_file_location(modname, module_name)
+                if modspec is None or modspec.loader is None:
+                    raise ValueError(f"Could not load file: {module_name}")
+                module = importlib.util.module_from_spec(modspec)
+                sys.modules[modname] = module
+                modspec.loader.exec_module(module)  # type: ignore[possibly-unbound-attribute]
+            else:
+                # Load from Python module
+                module = importlib.import_module(module_name)
 
         loaded_auth = getattr(module, callable_name, None)
         if loaded_auth is None:

langgraph_api/cli.py

@@ -1,3 +1,4 @@
+import asyncio
 import contextlib
 import json
 import logging
@@ -97,12 +98,17 @@ def run_server(
     auth: typing.Optional["AuthConfig"] = None,
     http: typing.Optional["HttpConfig"] = None,
     ui: dict | None = None,
+    webhooks: dict | None = None,
     ui_config: dict | None = None,
     studio_url: str | None = None,
     disable_persistence: bool = False,
     allow_blocking: bool = False,
     runtime_edition: Literal["inmem", "community", "postgres"] = "inmem",
     server_level: str = "WARNING",
+    __redis_uri__: str | None = "fake",
+    __database_uri__: str | None = ":memory:",
+    __migrations_path__: str | None = "__inmem",
+    __entrypoint__: Literal["server", "python-executor"] = "server",
     **kwargs: typing.Any,
 ):
     """Run the LangGraph API server."""
@@ -185,16 +191,19 @@ def run_server(
     else:
         local_url = upstream_url
     to_patch = dict(
-        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),
+        MIGRATIONS_PATH=__migrations_path__,
+        DATABASE_URI=__database_uri__,
+        REDIS_URI=__redis_uri__,
+        N_JOBS_PER_WORKER=str(
+            n_jobs_per_worker if n_jobs_per_worker is not None 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,
         LANGGRAPH_UI=json.dumps(ui) if ui else None,
+        LANGGRAPH_WEBHOOKS=json.dumps(webhooks) if webhooks else None,
         LANGGRAPH_UI_CONFIG=json.dumps(ui_config) if ui_config else None,
         LANGGRAPH_UI_BUNDLER="true",
         LANGGRAPH_API_URL=local_url,
@@ -245,7 +254,7 @@ def run_server(
                                         full_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)}"
+                                        f"Failed to get organization ID: {e!s}"
                                     )
                                     pass
                                 thread_logger.info(
@@ -295,40 +304,53 @@ For production use, please use LangSmith Deployment.
             if k in inspect.signature(uvicorn.run).parameters
         }
         server_level = server_level.upper()
-        uvicorn.run(
-            "langgraph_api.server:app",
-            host=host,
-            port=port,
-            reload=reload,
-            env_file=env_file,
-            access_log=False,
-            reload_includes=list(reload_includes) if reload_includes else None,
-            reload_excludes=list(reload_excludes) if reload_excludes else None,
-            log_config={
-                "version": 1,
-                "incremental": False,
-                "disable_existing_loggers": False,
-                "formatters": {
-                    "simple": {
-                        "class": "langgraph_api.logging.Formatter",
-                    }
+        if __entrypoint__ == "server":
+            uvicorn.run(
+                "langgraph_api.server:app",
+                host=host,
+                port=port,
+                reload=reload,
+                env_file=env_file,
+                access_log=False,
+                reload_includes=list(reload_includes) if reload_includes else None,
+                reload_excludes=list(reload_excludes) if reload_excludes else None,
+                log_config={
+                    "version": 1,
+                    "incremental": False,
+                    "disable_existing_loggers": False,
+                    "formatters": {
+                        "simple": {
+                            "class": "langgraph_api.logging.Formatter",
+                        }
+                    },
+                    "handlers": {
+                        "console": {
+                            "class": "logging.StreamHandler",
+                            "formatter": "simple",
+                            "stream": "ext://sys.stdout",
+                        }
+                    },
+                    "loggers": {
+                        "uvicorn": {"level": server_level},
+                        "uvicorn.error": {"level": server_level},
+                        "langgraph_api.server": {"level": server_level},
+                    },
+                    "root": {"handlers": ["console"]},
                 },
-                "handlers": {
-                    "console": {
-                        "class": "logging.StreamHandler",
-                        "formatter": "simple",
-                        "stream": "ext://sys.stdout",
-                    }
-                },
-                "loggers": {
-                    "uvicorn": {"level": server_level},
-                    "uvicorn.error": {"level": server_level},
-                    "langgraph_api.server": {"level": server_level},
-                },
-                "root": {"handlers": ["console"]},
-            },
-            **supported_kwargs,
-        )
+                **supported_kwargs,
+            )
+        elif __entrypoint__ == "python-executor":
+            from langgraph_api.executor_entrypoint import (
+                main as executor_entrypoint_main,
+            )
+
+            asyncio.run(
+                executor_entrypoint_main(
+                    grpc_port=8188,
+                )
+            )
+        else:
+            raise ValueError(f"Unknown entrypoint: {__entrypoint__}")
 
 
 def main():
@@ -353,7 +375,7 @@ def main():
         help="Number of jobs per worker. Default is None (meaning 10)",
     )
     parser.add_argument(
-        "--no-browser", action="store_true", help="Disable automatic browser opening"
+        "--open-browser", action="store_true", help="Open browser automatically"
     )
     parser.add_argument(
         "--debug-port", type=int, help="Port for debugger to listen on (default: none)"
@@ -368,7 +390,19 @@ def main():
         action="store_true",
         help="Expose the server via Cloudflare Tunnel",
     )
-
+    parser.add_argument(
+        "--runtime-edition",
+        type=str,
+        default="inmem",
+        help="Runtime edition to use",
+    )
+    parser.add_argument(
+        "--entrypoint",
+        type=str,
+        default="server",
+        choices=["server", "python-executor"],
+        help="Entry point to use",
+    )
     args = parser.parse_args()
 
     with open(args.config, encoding="utf-8") as f:
@@ -377,21 +411,32 @@ def main():
     graphs = config_data.get("graphs", {})
     auth = config_data.get("auth")
     ui = config_data.get("ui")
+    webhooks = config_data.get("webhooks")
     ui_config = config_data.get("ui_config")
+    kwargs = {}
+    if args.runtime_edition == "postgres":
+        kwargs["__redis_uri__"] = os.getenv("REDIS_URI")
+        kwargs["__database_uri__"] = os.getenv("DATABASE_URI")
+        kwargs["__migrations_path__"] = os.getenv("MIGRATIONS_PATH")
+    if args.entrypoint == "python-executor":
+        kwargs["__entrypoint__"] = "python-executor"
     run_server(
         args.host,
         args.port,
         not args.no_reload,
         graphs,
         n_jobs_per_worker=args.n_jobs_per_worker,
-        open_browser=not args.no_browser,
+        open_browser=args.open_browser,
         tunnel=args.tunnel,
         debug_port=args.debug_port,
         wait_for_client=args.wait_for_client,
         env=config_data.get("env", None),
         auth=auth,
         ui=ui,
+        webhooks=webhooks,
         ui_config=ui_config,
+        runtime_edition=args.runtime_edition,
+        **kwargs,
     )
 
 

langgraph_api/command.py

@@ -13,9 +13,9 @@ def map_cmd(cmd: RunCommand) -> Command:
     update = cmd.get("update")
     if isinstance(update, tuple | list) and all(
         isinstance(t, tuple | list) and len(t) == 2 and isinstance(t[0], str)
-        for t in cast(list, update)
+        for t in cast("list", update)
     ):
-        update = [tuple(t) for t in cast(list, update)]
+        update = [tuple(t) for t in cast("list", update)]
 
     return Command(
         update=update,