langgraph-api 0.2.27__py3-none-any.whl → 0.2.28__py3-none-any.whl

langgraph_api/__init__.py

@@ -1 +1 @@
-__version__ = "0.2.27"
+__version__ = "0.2.28"

langgraph_api/api/assistants.py

@@ -9,6 +9,7 @@ from starlette.exceptions import HTTPException
 from starlette.responses import Response
 from starlette.routing import BaseRoute
 
+from langgraph_api import store as api_store
 from langgraph_api.graph import get_assistant_id, get_graph
 from langgraph_api.js.base import BaseRemotePregel
 from langgraph_api.route import ApiRequest, ApiResponse, ApiRoute
@@ -25,7 +26,6 @@ from langgraph_runtime.checkpoint import Checkpointer
 from langgraph_runtime.database import connect
 from langgraph_runtime.ops import Assistants
 from langgraph_runtime.retry import retry_db
-from langgraph_runtime.store import Store
 
 logger = structlog.stdlib.get_logger(__name__)
 
@@ -194,7 +194,7 @@ async def get_assistant_graph(
             assistant["graph_id"],
             config,
             checkpointer=Checkpointer(conn),
-            store=Store(),
+            store=(await api_store.get_store()),
         ) as graph:
             xray: bool | int = False
             xray_query = request.query_params.get("xray")
@@ -240,7 +240,7 @@ async def get_assistant_subgraphs(
             assistant["graph_id"],
             config,
             checkpointer=Checkpointer(conn),
-            store=Store(),
+            store=(await api_store.get_store()),
         ) as graph:
             namespace = request.path_params.get("namespace")
 
@@ -286,7 +286,7 @@ async def get_assistant_schemas(
             assistant["graph_id"],
             config,
             checkpointer=Checkpointer(conn),
-            store=Store(),
+            store=(await api_store.get_store()),
         ) as graph:
             if isinstance(graph, BaseRemotePregel):
                 schemas = await graph.fetch_state_schema()

langgraph_api/api/store.py

@@ -6,6 +6,7 @@ from starlette.routing import BaseRoute
 
 from langgraph_api.auth.custom import handle_event as _handle_event
 from langgraph_api.route import ApiRequest, ApiResponse, ApiRoute
+from langgraph_api.store import get_store
 from langgraph_api.utils import get_auth_ctx
 from langgraph_api.validation import (
     StoreDeleteRequest,
@@ -14,7 +15,6 @@ from langgraph_api.validation import (
     StoreSearchRequest,
 )
 from langgraph_runtime.retry import retry_db
-from langgraph_runtime.store import Store
 
 
 def _validate_namespace(namespace: tuple[str, ...]) -> Response | None:
@@ -57,7 +57,9 @@ async def put_item(request: ApiRequest):
         "value": payload["value"],
     }
     await handle_event("put", handler_payload)
-    await Store().aput(namespace, handler_payload["key"], handler_payload["value"])
+    await (await get_store()).aput(
+        namespace, handler_payload["key"], handler_payload["value"]
+    )
     return Response(status_code=204)
 
 
@@ -75,7 +77,7 @@ async def get_item(request: ApiRequest):
         "key": key,
     }
     await handle_event("get", handler_payload)
-    result = await Store().aget(namespace, key)
+    result = await (await get_store()).aget(namespace, key)
     return ApiResponse(result.dict() if result is not None else None)
 
 
@@ -91,7 +93,9 @@ async def delete_item(request: ApiRequest):
         "key": payload["key"],
     }
     await handle_event("delete", handler_payload)
-    await Store().adelete(handler_payload["namespace"], handler_payload["key"])
+    await (await get_store()).adelete(
+        handler_payload["namespace"], handler_payload["key"]
+    )
     return Response(status_code=204)
 
 
@@ -114,7 +118,7 @@ async def search_items(request: ApiRequest):
         "query": query,
     }
     await handle_event("search", handler_payload)
-    items = await Store().asearch(
+    items = await (await get_store()).asearch(
         handler_payload["namespace"],
         filter=handler_payload["filter"],
         limit=handler_payload["limit"],
@@ -145,7 +149,7 @@ async def list_namespaces(request: ApiRequest):
         "offset": offset,
     }
     await handle_event("list_namespaces", handler_payload)
-    result = await Store().alist_namespaces(
+    result = await (await get_store()).alist_namespaces(
         prefix=handler_payload["namespace"],
         suffix=handler_payload["suffix"],
         max_depth=handler_payload["max_depth"],

langgraph_api/config.py

@@ -109,6 +109,7 @@ class TTLConfig(TypedDict, total=False):
 
 
 class StoreConfig(TypedDict, total=False):
+    path: str
     index: IndexConfig
     ttl: TTLConfig
 

langgraph_api/graph.py

@@ -3,7 +3,6 @@ import functools
 import glob
 import importlib.util
 import inspect
-import json
 import os
 import sys
 import warnings
@@ -14,6 +13,7 @@ from random import choice
 from typing import TYPE_CHECKING, Any, NamedTuple
 from uuid import UUID, uuid5
 
+import orjson
 import structlog
 from langchain_core.runnables.config import run_in_executor, var_child_runnable_config
 from langgraph.checkpoint.base import BaseCheckpointSaver
@@ -60,6 +60,12 @@ async def register_graph(
     if callable(graph):
         FACTORY_ACCEPTS_CONFIG[graph_id] = len(inspect.signature(graph).parameters) > 0
     async with connect() as conn:
+        graph_name = getattr(graph, "name", None) if isinstance(graph, Pregel) else None
+        assistant_name = (
+            graph_name
+            if graph_name is not None and graph_name != "LangGraph"
+            else graph_id
+        )
         await Assistants.put(
             conn,
             str(uuid5(NAMESPACE_GRAPH, graph_id)),
@@ -67,7 +73,7 @@ async def register_graph(
             metadata={"created_by": "system"},
             config=config or {},
             if_exists="do_nothing",
-            name=graph_id,
+            name=assistant_name,
             description=description,
         )
 
@@ -200,10 +206,19 @@ def _load_graph_config_from_env() -> dict | None:
     config_str = os.getenv("LANGGRAPH_CONFIG")
     if not config_str:
         return None
+    try:
+        config_per_id = orjson.loads(config_str)
+    except orjson.JSONDecodeError as e:
+        raise ValueError(
+            "Provided environment variable LANGGRAPH_CONFIG must be a valid JSON object"
+            f"\nFound: {config_str}"
+        ) from e
 
-    config_per_id = json.loads(config_str)
     if not isinstance(config_per_id, dict):
-        raise ValueError("LANGGRAPH_CONFIG must be a JSON object")
+        raise ValueError(
+            "Provided environment variable LANGGRAPH_CONFIG must be a JSON object"
+            f"\nFound: {config_str}"
+        )
 
     return config_per_id
 
@@ -218,7 +233,15 @@ async def collect_graphs_from_env(register: bool = False) -> None:
         specs = []
         # 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)
+        try:
+            graphs_config = orjson.loads(paths_str)
+        except orjson.JSONDecodeError as e:
+            raise ValueError(
+                "LANGSERVE_GRAPHS must be a valid JSON object."
+                f"\nFound: {paths_str}"
+                "\n The LANGSERVE_GRAPHS environment variable is typically set"
+                'from the "graphs" field in your configuration (langgraph.json) file.'
+            ) from e
 
         for key, value in graphs_config.items():
             if isinstance(value, dict) and "path" in value:

langgraph_api/js/remote.py

@@ -39,6 +39,7 @@ from starlette.exceptions import HTTPException
 from starlette.requests import HTTPConnection, Request
 from starlette.routing import Route
 
+from langgraph_api import store as api_store
 from langgraph_api.auth.custom import DotDict, ProxyUser
 from langgraph_api.config import LANGGRAPH_AUTH_TYPE
 from langgraph_api.js.base import BaseRemotePregel
@@ -70,6 +71,12 @@ _client = httpx.AsyncClient(
 )
 
 
+def _snapshot_defaults():
+    if not hasattr(StateSnapshot, "interrupts"):
+        return {}
+    return {"interrupts": tuple()}
+
+
 def default_command(obj):
     if isinstance(obj, Send):
         return {"node": obj.node, "args": obj.arg}
@@ -251,7 +258,7 @@ class RemotePregel(BaseRemotePregel):
             item.get("parentConfig"),
             _convert_tasks(item.get("tasks", [])),
             # TODO: add handling of interrupts when multiple resumes land in JS
-            tuple(),
+            **_snapshot_defaults(),
         )
 
     async def aget_state(
@@ -473,10 +480,8 @@ def _get_passthrough_checkpointer(conn: AsyncConnectionProto):
     return checkpointer
 
 
-def _get_passthrough_store():
-    from langgraph_runtime.store import Store
-
-    return Store()
+async def _get_passthrough_store():
+    return await api_store.get_store()
 
 
 # Setup a HTTP server on top of CHECKPOINTER_SOCKET unix socket
@@ -574,7 +579,7 @@ async def run_remote_checkpointer():
             else:
                 raise ValueError(f"Unknown operation type: {op}")
 
-        store = _get_passthrough_store()
+        store = await _get_passthrough_store()
         results = await store.abatch(processed_operations)
 
         # Handle potentially undefined or non-dict results
@@ -613,7 +618,7 @@ async def run_remote_checkpointer():
 
         namespaces = namespaces_str.split(".")
 
-        store = _get_passthrough_store()
+        store = await _get_passthrough_store()
         result = await store.aget(namespaces, key)
 
         return result
@@ -626,7 +631,7 @@ async def run_remote_checkpointer():
         value = payload["value"]
         index = payload.get("index")
 
-        store = _get_passthrough_store()
+        store = await _get_passthrough_store()
         await store.aput(namespace, key, value, index=index)
 
         return {"success": True}
@@ -639,7 +644,7 @@ async def run_remote_checkpointer():
         offset = payload.get("offset", 0)
         query = payload.get("query")
 
-        store = _get_passthrough_store()
+        store = await _get_passthrough_store()
         result = await store.asearch(
             namespace_prefix, filter=filter, limit=limit, offset=offset, query=query
         )
@@ -652,7 +657,7 @@ async def run_remote_checkpointer():
         namespace = tuple(payload["namespace"])
         key = payload["key"]
 
-        store = _get_passthrough_store()
+        store = await _get_passthrough_store()
         await store.adelete(namespace, key)
 
         return {"success": True}
@@ -665,7 +670,7 @@ async def run_remote_checkpointer():
         limit = payload.get("limit", 100)
         offset = payload.get("offset", 0)
 
-        store = _get_passthrough_store()
+        store = await _get_passthrough_store()
         result = await store.alist_namespaces(
             prefix=prefix,
             suffix=suffix,

langgraph_api/metadata.py

@@ -1,5 +1,6 @@
 import asyncio
 import os
+from collections import defaultdict
 from datetime import UTC, datetime
 
 import langgraph.version
@@ -36,8 +37,8 @@ PLAN = "enterprise" if plus_features_enabled() else "developer"
 USER_API_URL = os.getenv("LANGGRAPH_API_URL", None)
 
 LOGS: list[dict] = []
-RUN_COUNTER = 0
-NODE_COUNTER = 0
+RUN_COUNTER = defaultdict(int)
+NODE_COUNTER = defaultdict(int)
 FROM_TIMESTAMP = datetime.now(UTC).isoformat()
 
 if (
@@ -49,14 +50,12 @@ else:
     METADATA_ENDPOINT = "https://api.smith.langchain.com/v1/metadata/submit"
 
 
-def incr_runs(*, incr: int = 1) -> None:
-    global RUN_COUNTER
-    RUN_COUNTER += incr
+def incr_runs(*, graph_id: str | None = None, incr: int = 1) -> None:
+    RUN_COUNTER[graph_id] += incr
 
 
-def incr_nodes(_, *, incr: int = 1) -> None:
-    global NODE_COUNTER
-    NODE_COUNTER += incr
+def incr_nodes(*_, graph_id: str | None = None, incr: int = 1) -> None:
+    NODE_COUNTER[graph_id] += incr
 
 
 def append_log(log: dict) -> None:
@@ -89,13 +88,23 @@ async def metadata_loop() -> None:
         # we don't need a lock as long as there's no awaits in this block
         from_timestamp = FROM_TIMESTAMP
         to_timestamp = datetime.now(UTC).isoformat()
-        nodes = NODE_COUNTER
-        runs = RUN_COUNTER
+        nodes = NODE_COUNTER.copy()
+        runs = RUN_COUNTER.copy()
         logs = LOGS.copy()
         LOGS.clear()
-        RUN_COUNTER = 0
-        NODE_COUNTER = 0
+        RUN_COUNTER.clear()
+        NODE_COUNTER.clear()
         FROM_TIMESTAMP = to_timestamp
+        graph_measures = {
+            f"langgraph.platform.graph_runs.{graph_id}": runs.get(graph_id, 0)
+            for graph_id in runs
+        }
+        graph_measures.update(
+            {
+                f"langgraph.platform.graph_nodes.{graph_id}": nodes.get(graph_id, 0)
+                for graph_id in nodes
+            }
+        )
 
         payload = {
             "license_key": LANGGRAPH_CLOUD_LICENSE_KEY,
@@ -120,8 +129,9 @@ async def metadata_loop() -> None:
                 "user_app.uses_store_ttl": str(USES_STORE_TTL),
             },
             "measures": {
-                "langgraph.platform.runs": runs,
-                "langgraph.platform.nodes": nodes,
+                "langgraph.platform.runs": sum(runs.values()),
+                "langgraph.platform.nodes": sum(nodes.values()),
+                **graph_measures,
             },
             "logs": logs,
         }
@@ -134,8 +144,10 @@ async def metadata_loop() -> None:
             )
         except Exception as e:
             # retry on next iteration
-            incr_runs(incr=runs)
-            incr_nodes("", incr=nodes)
+            for graph_id, incr in runs.items():
+                incr_runs(graph_id=graph_id, incr=incr)
+            for graph_id, incr in nodes.items():
+                incr_nodes(graph_id=graph_id, incr=incr)
             FROM_TIMESTAMP = from_timestamp
             await logger.ainfo("Metadata submission skipped.", error=str(e))
         await asyncio.sleep(INTERVAL)

langgraph_api/store.py

@@ -0,0 +1,127 @@
+import asyncio
+import importlib.util
+import sys
+import threading
+from collections.abc import Callable
+from contextlib import AsyncExitStack, asynccontextmanager
+from random import choice
+from typing import Any
+
+import structlog
+from langchain_core.runnables.config import run_in_executor
+from langgraph.graph import Graph
+from langgraph.pregel import Pregel
+from langgraph.store.base import BaseStore
+
+from langgraph_api import config
+
+logger = structlog.stdlib.get_logger(__name__)
+
+CUSTOM_STORE: BaseStore | Callable[[], BaseStore] | None = None
+STORE_STACK = threading.local()
+
+
+async def get_store() -> BaseStore:
+    if CUSTOM_STORE:
+        if not hasattr(STORE_STACK, "stack"):
+            stack = AsyncExitStack()
+            STORE_STACK.stack = stack
+            store = await stack.enter_async_context(_yield_store(CUSTOM_STORE))
+            STORE_STACK.store = store
+            await logger.ainfo(f"Using custom store: {store}", kind=str(type(store)))
+            return store
+        return STORE_STACK.store
+    else:
+        from langgraph_runtime.store import Store
+
+        return Store()
+
+
+async def exit_store():
+    if not CUSTOM_STORE:
+        return
+    if not hasattr(STORE_STACK, "stack"):
+        return
+    await STORE_STACK.stack.aclose()
+
+
+@asynccontextmanager
+async def _yield_store(value: Any):
+    if isinstance(value, BaseStore):
+        yield value
+    elif hasattr(value, "__aenter__") and hasattr(value, "__aexit__"):
+        async with value as ctx_value:
+            yield ctx_value
+    elif hasattr(value, "__enter__") and hasattr(value, "__exit__"):
+        with value as ctx_value:
+            yield ctx_value
+    elif asyncio.iscoroutine(value):
+        yield await value
+    elif callable(value):
+        async with _yield_store(value()) as ctx_value:
+            yield ctx_value
+    else:
+        raise ValueError(
+            f"Unsupported store type: {type(value)}. Expected an instance of BaseStore "
+            "or a function or async generator that returns one."
+        )
+
+
+async def collect_store_from_env() -> None:
+    global CUSTOM_STORE
+    if not config.STORE_CONFIG or not (store_path := config.STORE_CONFIG.get("path")):
+        return
+    await logger.ainfo(
+        f"Heads up! You are configuring a custom long-term memory store at {store_path}\n\n"
+        "This store will be used IN STEAD OF the default postgres + pgvector store."
+        "Some functionality, such as TTLs and vector search, may not be available."
+        "Search performance & other capabilities will depend on the quality of your implementation."
+    )
+    # Try to load. The loaded object can either be a BaseStore instance, a function that generates it, etc.
+    value = await run_in_executor(None, _load_store, store_path)
+    CUSTOM_STORE = value
+
+
+def _load_store(store_path: str) -> Any:
+    if "/" in store_path or ".py:" in store_path:
+        modname = "".join(choice("abcdefghijklmnopqrstuvwxyz") for _ in range(24))
+        path_name, function = store_path.rsplit(":", 1)
+        module_name = path_name.rstrip(":")
+        # Load from file path
+        modspec = importlib.util.spec_from_file_location(modname, module_name)
+        if modspec is None:
+            raise ValueError(f"Could not find store file: {path_name}")
+        module = importlib.util.module_from_spec(modspec)
+        sys.modules[module_name] = module
+        modspec.loader.exec_module(module)
+
+    else:
+        path_name, function = store_path.rsplit(".", 1)
+        module = importlib.import_module(path_name)
+
+    try:
+        store: BaseStore | Callable[[config.StoreConfig], BaseStore] = module.__dict__[
+            function
+        ]
+    except KeyError as e:
+        available = [k for k in module.__dict__ if not k.startswith("__")]
+        suggestion = ""
+        if available:
+            likely = [
+                k for k in available if isinstance(module.__dict__[k], Graph | Pregel)
+            ]
+            if likely:
+                likely_ = "\n".join(
+                    [f"\t- {path_name}:{k}" if path_name else k for k in likely]
+                )
+                suggestion = f"\nDid you mean to use one of the following?\n{likely_}"
+            elif available:
+                suggestion = f"\nFound the following exports: {', '.join(available)}"
+
+        raise ValueError(
+            f"Could not find store '{store_path}'. "
+            f"Please check that:\n"
+            f"1. The file exports a variable named '{store_path}'\n"
+            f"2. The variable name in your config matches the export name{suggestion}"
+        ) from e
+    return store

langgraph_api/stream.py

@@ -1,6 +1,6 @@
+import functools
 from collections.abc import AsyncIterator, Callable
 from contextlib import AsyncExitStack, aclosing
-from functools import lru_cache
 from typing import Any, cast
 
 import langgraph.version
@@ -23,6 +23,7 @@ from langgraph.pregel.debug import CheckpointPayload, TaskResultPayload
 from pydantic import ValidationError
 from pydantic.v1 import ValidationError as ValidationErrorLegacy
 
+from langgraph_api import store as api_store
 from langgraph_api.asyncio import ValueEvent, wait_if_not_done
 from langgraph_api.command import map_cmd
 from langgraph_api.graph import get_graph
@@ -33,7 +34,6 @@ from langgraph_api.serde import json_dumpb
 from langgraph_api.utils import AsyncConnectionProto
 from langgraph_runtime.checkpoint import Checkpointer
 from langgraph_runtime.ops import Runs
-from langgraph_runtime.store import Store
 
 logger = structlog.stdlib.get_logger(__name__)
 
@@ -94,7 +94,7 @@ async def astream_state(
         get_graph(
             config["configurable"]["graph_id"],
             config,
-            store=Store(),
+            store=(await api_store.get_store()),
             checkpointer=None if temporary else Checkpointer(conn),
         )
     )
@@ -119,7 +119,9 @@ async def astream_state(
     # attach node counter
     is_remote_pregel = isinstance(graph, BaseRemotePregel)
     if not is_remote_pregel:
-        config["configurable"]["__pregel_node_finished"] = incr_nodes
+        config["configurable"]["__pregel_node_finished"] = functools.partial(
+            incr_nodes, graph_id=_get_graph_id(run)
+        )
 
     # attach run_id to config
     # for attempts beyond the first, use a fresh, unique run_id
@@ -263,10 +265,10 @@ async def astream_state(
                         yield mode, chunk
                 # --- end shared logic with astream_events ---
     if is_remote_pregel:
-        # increament the remote runs
+        # increment the remote runs
         try:
             nodes_executed = await graph.fetch_nodes_executed()
-            incr_nodes(None, incr=nodes_executed)
+            incr_nodes(graph_id=graph.graph_id, incr=nodes_executed)
         except Exception as e:
             logger.warning(f"Failed to fetch nodes executed for {graph.graph_id}: {e}")
 
@@ -301,7 +303,7 @@ def get_feedback_urls(run_id: str, feedback_keys: list[str]) -> dict[str, str]:
     return {key: token.url for key, token in zip(feedback_keys, tokens, strict=False)}
 
 
-@lru_cache(maxsize=1)
+@functools.lru_cache(maxsize=1)
 def get_langsmith_client() -> langsmith.Client:
     return langsmith.Client()
 
@@ -315,3 +317,11 @@ EXPECTED_ERRORS = (
     ValidationError,
     ValidationErrorLegacy,
 )
+
+
+def _get_graph_id(run: Run) -> str | None:
+    try:
+        return run["kwargs"]["config"]["configurable"]["graph_id"]
+    except Exception:
+        logger.info(f"Failed to get graph_id from run {run['run_id']}")
+        return "Unknown"

langgraph_api/worker.py

@@ -69,7 +69,7 @@ async def worker(
 ) -> WorkerResult:
     run_id = run["run_id"]
     if attempt == 1:
-        incr_runs()
+        incr_runs(graph_id=_get_graph_id(run))
     checkpoint: CheckpointPayload | None = None
     exception: Exception | None = None
     status: str | None = None

{langgraph_api-0.2.27.dist-info → langgraph_api-0.2.28.dist-info}/METADATA

@@ -1,35 +1,29 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: langgraph-api
-Version: 0.2.27
-Summary: 
+Version: 0.2.28
+Author-email: Nuno Campos <nuno@langchain.dev>, Will Fu-Hinthorn <will@langchain.dev>
 License: Elastic-2.0
-Author: Nuno Campos
-Author-email: nuno@langchain.dev
+License-File: LICENSE
 Requires-Python: >=3.11
-Classifier: License :: Other/Proprietary License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Requires-Dist: cloudpickle (>=3.0.0,<4.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) ; python_version < "4.0"
-Requires-Dist: langgraph (>=0.3.27) ; python_version < "4.0"
-Requires-Dist: langgraph-checkpoint (>=2.0.23) ; python_version < "4.0"
-Requires-Dist: langgraph-runtime-inmem (>=0.0.9,<0.1)
-Requires-Dist: langgraph-sdk (>=0.1.66,<0.2.0) ; python_version < "4.0"
-Requires-Dist: langsmith (>=0.1.63)
-Requires-Dist: orjson (>=3.9.7)
-Requires-Dist: pyjwt (>=2.9.0,<3.0.0)
-Requires-Dist: sse-starlette (>=2.1.0,<2.2.0)
-Requires-Dist: starlette (>=0.38.6)
-Requires-Dist: structlog (>=24.1.0,<26)
-Requires-Dist: tenacity (>=8.0.0)
-Requires-Dist: truststore (>=0.1)
-Requires-Dist: uvicorn (>=0.26.0)
-Requires-Dist: watchfiles (>=0.13)
+Requires-Dist: cloudpickle>=3.0.0
+Requires-Dist: cryptography<45.0,>=42.0.0
+Requires-Dist: httpx>=0.25.0
+Requires-Dist: jsonschema-rs<0.30,>=0.20.0
+Requires-Dist: langchain-core>=0.2.38
+Requires-Dist: langgraph-checkpoint>=2.0.23
+Requires-Dist: langgraph-runtime-inmem<0.2,>=0.1.0
+Requires-Dist: langgraph-sdk>=0.1.66
+Requires-Dist: langgraph>=0.3.27
+Requires-Dist: langsmith>=0.1.112
+Requires-Dist: orjson>=3.9.7
+Requires-Dist: pyjwt>=2.9.0
+Requires-Dist: sse-starlette<2.2.0,>=2.1.0
+Requires-Dist: starlette>=0.38.6
+Requires-Dist: structlog<26,>=24.1.0
+Requires-Dist: tenacity>=8.0.0
+Requires-Dist: truststore>=0.1
+Requires-Dist: uvicorn>=0.26.0
+Requires-Dist: watchfiles>=0.13
 Description-Content-Type: text/markdown
 
 # LangGraph API
@@ -132,4 +126,4 @@ Options:
 
 ## License
 
-This project is licensed under the Elastic License 2.0 - see the [LICENSE](./LICENSE) file for details.
+This project is licensed under the Elastic License 2.0 - see the [LICENSE](./LICENSE) file for details.