langgraph-api 0.2.72__py3-none-any.whl → 0.2.75__py3-none-any.whl

langgraph_api/__init__.py

@@ -1 +1 @@
-__version__ = "0.2.72"
+__version__ = "0.2.75"

langgraph_api/api/assistants.py

@@ -2,6 +2,8 @@ from typing import Any
 from uuid import uuid4
 
 import structlog
+
+# TODO: Remove dependency on langchain-core here.
 from langchain_core.runnables.utils import create_model
 from langgraph.pregel import Pregel
 from pydantic import TypeAdapter

langgraph_api/asyncio.py

@@ -6,7 +6,6 @@ from functools import partial
 from typing import Any, Generic, TypeVar
 
 import structlog
-from langgraph.utils.future import chain_future
 
 T = TypeVar("T")
 
@@ -130,11 +129,15 @@ def run_coroutine_threadsafe(
 
 def call_soon_in_main_loop(coro: Coroutine[Any, Any, T]) -> asyncio.Future[T]:
     """Run a coroutine in the main event loop."""
+    from langgraph_api.utils import future as lg_future
+
     if _MAIN_LOOP is None:
         raise RuntimeError("No event loop set")
     main_loop_fut = asyncio.ensure_future(coro, loop=_MAIN_LOOP)
     this_loop_fut = asyncio.get_running_loop().create_future()
-    _MAIN_LOOP.call_soon_threadsafe(chain_future, main_loop_fut, this_loop_fut)
+    _MAIN_LOOP.call_soon_threadsafe(
+        lg_future.chain_future, main_loop_fut, this_loop_fut
+    )
     return this_loop_fut
 
 

langgraph_api/cron_scheduler.py

@@ -2,10 +2,10 @@ import asyncio
 from random import random
 
 import structlog
-from langchain_core.runnables.config import run_in_executor
 
 from langgraph_api.models.run import create_valid_run
 from langgraph_api.utils import next_cron_date
+from langgraph_api.utils.config import run_in_executor
 from langgraph_api.worker import set_auth_ctx_for_run
 from langgraph_runtime.database import connect
 from langgraph_runtime.ops import Crons

langgraph_api/graph.py

@@ -14,19 +14,18 @@ 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
 from langgraph.constants import CONFIG_KEY_CHECKPOINTER, CONFIG_KEY_STORE
 from langgraph.graph import StateGraph
 from langgraph.pregel import Pregel
 from langgraph.store.base import BaseStore
-from langgraph.utils.config import ensure_config
 from starlette.exceptions import HTTPException
 
 from langgraph_api import asyncio as lg_asyncio
 from langgraph_api import config
 from langgraph_api.js.base import BaseRemotePregel, is_js_path
 from langgraph_api.schema import Config
+from langgraph_api.utils.config import run_in_executor, var_child_runnable_config
 
 if TYPE_CHECKING:
     from langchain_core.embeddings import Embeddings
@@ -123,10 +122,12 @@ async def get_graph(
     store: BaseStore | None = None,
 ) -> AsyncIterator[Pregel]:
     """Return the runnable."""
+    from langgraph_api.utils import config as lg_config
+
     assert_graph_exists(graph_id)
     value = GRAPHS[graph_id]
     if graph_id in FACTORY_ACCEPTS_CONFIG:
-        config = ensure_config(config)
+        config = lg_config.ensure_config(config)
         if store is not None and not config["configurable"].get(CONFIG_KEY_STORE):
             config["configurable"][CONFIG_KEY_STORE] = store
         if checkpointer is not None and not config["configurable"].get(

langgraph_api/logging.py

@@ -15,7 +15,6 @@ log_env = Config()
 LOG_JSON = log_env("LOG_JSON", cast=bool, default=False)
 LOG_COLOR = log_env("LOG_COLOR", cast=bool, default=True)
 LOG_LEVEL = log_env("LOG_LEVEL", cast=str, default="INFO")
-LOG_DICT_TRACEBACKS = log_env("LOG_DICT_TRACEBACKS", cast=bool, default=True)
 
 logging.getLogger().setLevel(LOG_LEVEL.upper())
 logging.getLogger("psycopg").setLevel(logging.WARNING)
@@ -104,11 +103,7 @@ shared_processors = [
     AddApiVersion(),
     structlog.processors.TimeStamper(fmt="iso", utc=True),
     structlog.processors.StackInfoRenderer(),
-    (
-        structlog.processors.dict_tracebacks
-        if LOG_JSON and LOG_DICT_TRACEBACKS
-        else structlog.processors.format_exc_info
-    ),
+    structlog.processors.format_exc_info,
     structlog.processors.UnicodeDecoder(),
     AddLoggingContext(),
 ]

langgraph_api/state.py

@@ -1,8 +1,14 @@
-from langchain_core.runnables.config import RunnableConfig
+from __future__ import annotations
+
+import typing
+
 from langgraph.types import StateSnapshot
 
 from langgraph_api.schema import Checkpoint, ThreadState
 
+if typing.TYPE_CHECKING:
+    from langchain_core.runnables.config import RunnableConfig
+
 
 def runnable_config_to_checkpoint(
     config: RunnableConfig | None,

langgraph_api/store.py

@@ -8,12 +8,12 @@ from random import choice
 from typing import Any
 
 import structlog
-from langchain_core.runnables.config import run_in_executor
 from langgraph.graph import StateGraph
 from langgraph.pregel import Pregel
 from langgraph.store.base import BaseStore
 
 from langgraph_api import config
+from langgraph_api.utils.config import run_in_executor
 
 logger = structlog.stdlib.get_logger(__name__)
 

langgraph_api/stream.py

@@ -7,12 +7,12 @@ import langgraph.version
 import langsmith
 import structlog
 from langchain_core.messages import (
+    # TODO: Remove explicit dependency
     BaseMessage,
     BaseMessageChunk,
     convert_to_messages,
     message_chunk_to_message,
 )
-from langchain_core.runnables.config import run_in_executor
 from langgraph.errors import (
     EmptyChannelError,
     EmptyInputError,
@@ -33,6 +33,7 @@ from langgraph_api.js.base import BaseRemotePregel
 from langgraph_api.metadata import HOST, PLAN, USER_API_URL, incr_nodes
 from langgraph_api.schema import Run, StreamMode
 from langgraph_api.serde import json_dumpb
+from langgraph_api.utils.config import run_in_executor
 from langgraph_runtime.checkpoint import Checkpointer
 from langgraph_runtime.ops import Runs
 
@@ -320,7 +321,6 @@ async def consume(stream: AnyStream, run_id: str, resumable: bool = False) -> No
                     resumable=resumable,
                 )
         except Exception as e:
-            g = e
             if isinstance(e, ExceptionGroup):
                 e = e.exceptions[0]
             await Runs.Stream.publish(
@@ -329,7 +329,7 @@ async def consume(stream: AnyStream, run_id: str, resumable: bool = False) -> No
                 await run_in_executor(None, json_dumpb, e),
                 resumable=resumable,
             )
-            raise e from g
+            raise e
 
 
 def get_feedback_urls(run_id: str, feedback_keys: list[str]) -> dict[str, str]:

langgraph_api/utils/__init__.py

@@ -0,0 +1,129 @@
+import contextvars
+import uuid
+from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
+from datetime import datetime
+from typing import Any, Protocol, TypeAlias, TypeVar
+
+import structlog
+from langgraph_sdk import Auth
+from starlette.authentication import AuthCredentials, BaseUser
+from starlette.exceptions import HTTPException
+from starlette.schemas import BaseSchemaGenerator
+
+from langgraph_api.auth.custom import SimpleUser
+
+logger = structlog.stdlib.get_logger(__name__)
+
+
+T = TypeVar("T")
+Row: TypeAlias = dict[str, Any]
+AuthContext = contextvars.ContextVar[Auth.types.BaseAuthContext | None](
+    "AuthContext", default=None
+)
+
+
+@asynccontextmanager
+async def with_user(
+    user: BaseUser | None = None, auth: AuthCredentials | list[str] | None = None
+):
+    current = get_auth_ctx()
+    set_auth_ctx(user, auth)
+    yield
+    if current is None:
+        return
+    set_auth_ctx(current.user, AuthCredentials(scopes=current.permissions))
+
+
+def set_auth_ctx(
+    user: BaseUser | None, auth: AuthCredentials | list[str] | None
+) -> None:
+    if user is None and auth is None:
+        AuthContext.set(None)
+    else:
+        AuthContext.set(
+            Auth.types.BaseAuthContext(
+                permissions=(
+                    auth.scopes if isinstance(auth, AuthCredentials) else (auth or [])
+                ),
+                user=user or SimpleUser(""),
+            )
+        )
+
+
+def get_auth_ctx() -> Auth.types.BaseAuthContext | None:
+    return AuthContext.get()
+
+
+class AsyncCursorProto(Protocol):
+    async def fetchone(self) -> Row: ...
+
+    async def fetchall(self) -> list[Row]: ...
+
+    async def __aiter__(self) -> AsyncIterator[Row]:
+        yield ...
+
+
+class AsyncPipelineProto(Protocol):
+    async def sync(self) -> None: ...
+
+
+class AsyncConnectionProto(Protocol):
+    @asynccontextmanager
+    async def pipeline(self) -> AsyncIterator[AsyncPipelineProto]:
+        yield ...
+
+    async def execute(self, query: str, *args, **kwargs) -> AsyncCursorProto: ...
+
+
+async def fetchone(
+    it: AsyncIterator[T],
+    *,
+    not_found_code: int = 404,
+    not_found_detail: str | None = None,
+) -> T:
+    """Fetch the first row from an async iterator."""
+    try:
+        return await anext(it)
+    except StopAsyncIteration:
+        raise HTTPException(
+            status_code=not_found_code, detail=not_found_detail
+        ) from None
+
+
+def validate_uuid(uuid_str: str, invalid_uuid_detail: str | None) -> uuid.UUID:
+    try:
+        return uuid.UUID(uuid_str)
+    except ValueError:
+        raise HTTPException(status_code=422, detail=invalid_uuid_detail) from None
+
+
+def next_cron_date(schedule: str, base_time: datetime) -> datetime:
+    import croniter
+
+    cron_iter = croniter.croniter(schedule, base_time)
+    return cron_iter.get_next(datetime)
+
+
+class SchemaGenerator(BaseSchemaGenerator):
+    def __init__(self, base_schema: dict[str, Any]) -> None:
+        self.base_schema = base_schema
+
+    def get_schema(self, routes: list) -> dict[str, Any]:
+        schema = dict(self.base_schema)
+        schema.setdefault("paths", {})
+        endpoints_info = self.get_endpoints(routes)
+
+        for endpoint in endpoints_info:
+            try:
+                parsed = self.parse_docstring(endpoint.func)
+            except AssertionError:
+                logger.warning("Could not parse docstrings for route %s", endpoint.path)
+                parsed = {}
+
+            if endpoint.path not in schema["paths"]:
+                schema["paths"][endpoint.path] = {}
+
+            schema["paths"][endpoint.path][endpoint.http_method] = parsed
+
+        return schema

langgraph_api/utils/config.py

@@ -0,0 +1,140 @@
+from __future__ import annotations
+
+import asyncio
+import functools
+import typing
+from collections import ChainMap
+from concurrent.futures import Executor
+from contextvars import copy_context
+from os import getenv
+from typing import Any, ParamSpec, TypeVar, cast
+
+from langgraph.constants import CONF
+
+if typing.TYPE_CHECKING:
+    from langchain_core.runnables import RunnableConfig
+
+try:
+    from langchain_core.runnables.config import (
+        var_child_runnable_config,
+    )
+except ImportError:
+    var_child_runnable_config = None
+
+CONFIG_KEYS = [
+    "tags",
+    "metadata",
+    "callbacks",
+    "run_name",
+    "max_concurrency",
+    "recursion_limit",
+    "configurable",
+    "run_id",
+]
+
+COPIABLE_KEYS = [
+    "tags",
+    "metadata",
+    "callbacks",
+    "configurable",
+]
+
+DEFAULT_RECURSION_LIMIT = int(getenv("LANGGRAPH_DEFAULT_RECURSION_LIMIT", "25"))
+
+T = TypeVar("T")
+P = ParamSpec("P")
+
+
+def _is_not_empty(value: Any) -> bool:
+    if isinstance(value, list | tuple | dict):
+        return len(value) > 0
+    else:
+        return value is not None
+
+
+def ensure_config(*configs: RunnableConfig | None) -> RunnableConfig:
+    """Return a config with all keys, merging any provided configs.
+
+    Args:
+        *configs: Configs to merge before ensuring defaults.
+
+    Returns:
+        RunnableConfig: The merged and ensured config.
+    """
+    empty = dict(
+        tags=[],
+        metadata=ChainMap(),
+        callbacks=None,
+        recursion_limit=DEFAULT_RECURSION_LIMIT,
+        configurable={},
+    )
+    if var_child_runnable_config is not None and (
+        var_config := var_child_runnable_config.get()
+    ):
+        empty.update(
+            {
+                k: v.copy() if k in COPIABLE_KEYS else v  # type: ignore[attr-defined]
+                for k, v in var_config.items()
+                if _is_not_empty(v)
+            },
+        )
+    for config in configs:
+        if config is None:
+            continue
+        for k, v in config.items():
+            if _is_not_empty(v) and k in CONFIG_KEYS:
+                if k == CONF:
+                    empty[k] = cast(dict, v).copy()
+                else:
+                    empty[k] = v  # type: ignore[literal-required]
+        for k, v in config.items():
+            if _is_not_empty(v) and k not in CONFIG_KEYS:
+                empty[CONF][k] = v
+    for key, value in empty[CONF].items():
+        if (
+            not key.startswith("__")
+            and isinstance(value, str | int | float | bool)
+            and key not in empty["metadata"]
+        ):
+            empty["metadata"][key] = value
+    return empty
+
+
+async def run_in_executor(
+    executor_or_config: Executor | RunnableConfig | None,
+    func: typing.Callable[P, T],
+    *args: P.args,
+    **kwargs: P.kwargs,
+) -> T:
+    """Run a function in an executor.
+
+    Args:
+        executor_or_config: The executor or config to run in.
+        func (Callable[P, Output]): The function.
+        *args (Any): The positional arguments to the function.
+        **kwargs (Any): The keyword arguments to the function.
+
+    Returns:
+        Output: The output of the function.
+
+    Raises:
+        RuntimeError: If the function raises a StopIteration.
+    """
+
+    def wrapper() -> T:
+        try:
+            return func(*args, **kwargs)
+        except StopIteration as exc:
+            # StopIteration can't be set on an asyncio.Future
+            # it raises a TypeError and leaves the Future pending forever
+            # so we need to convert it to a RuntimeError
+            raise RuntimeError from exc
+
+    if executor_or_config is None or isinstance(executor_or_config, dict):
+        # Use default executor with context copied from current context
+        return await asyncio.get_running_loop().run_in_executor(
+            None,
+            functools.partial(copy_context().run, wrapper),
+        )
+
+    return await asyncio.get_running_loop().run_in_executor(executor_or_config, wrapper)

langgraph_api/utils/future.py

@@ -0,0 +1,220 @@
+from __future__ import annotations
+
+import asyncio
+import concurrent.futures
+import contextvars
+import inspect
+import sys
+import types
+from collections.abc import Awaitable, Coroutine, Generator
+from typing import TypeVar, cast
+
+T = TypeVar("T")
+AnyFuture = asyncio.Future | concurrent.futures.Future
+
+CONTEXT_NOT_SUPPORTED = sys.version_info < (3, 11)
+EAGER_NOT_SUPPORTED = sys.version_info < (3, 12)
+
+
+def _get_loop(fut: asyncio.Future) -> asyncio.AbstractEventLoop:
+    # Tries to call Future.get_loop() if it's available.
+    # Otherwise fallbacks to using the old '_loop' property.
+    try:
+        get_loop = fut.get_loop
+    except AttributeError:
+        pass
+    else:
+        return get_loop()
+    return fut._loop
+
+
+def _convert_future_exc(exc: BaseException) -> BaseException:
+    exc_class = type(exc)
+    if exc_class is concurrent.futures.CancelledError:
+        return asyncio.CancelledError(*exc.args)
+    elif exc_class is concurrent.futures.TimeoutError:
+        return TimeoutError(*exc.args)
+    elif exc_class is concurrent.futures.InvalidStateError:
+        return asyncio.InvalidStateError(*exc.args)
+    else:
+        return exc
+
+
+def _set_concurrent_future_state(
+    concurrent: concurrent.futures.Future,
+    source: AnyFuture,
+) -> None:
+    """Copy state from a future to a concurrent.futures.Future."""
+    assert source.done()
+    if source.cancelled():
+        concurrent.cancel()
+    if not concurrent.set_running_or_notify_cancel():
+        return
+    exception = source.exception()
+    if exception is not None:
+        concurrent.set_exception(_convert_future_exc(exception))
+    else:
+        result = source.result()
+        concurrent.set_result(result)
+
+
+def _copy_future_state(source: AnyFuture, dest: asyncio.Future) -> None:
+    """Internal helper to copy state from another Future.
+
+    The other Future may be a concurrent.futures.Future.
+    """
+    if dest.done():
+        return
+    assert source.done()
+    if dest.cancelled():
+        return
+    if source.cancelled():
+        dest.cancel()
+    else:
+        exception = source.exception()
+        if exception is not None:
+            dest.set_exception(_convert_future_exc(exception))
+        else:
+            result = source.result()
+            dest.set_result(result)
+
+
+def _chain_future(source: AnyFuture, destination: AnyFuture) -> None:
+    """Chain two futures so that when one completes, so does the other.
+
+    The result (or exception) of source will be copied to destination.
+    If destination is cancelled, source gets cancelled too.
+    Compatible with both asyncio.Future and concurrent.futures.Future.
+    """
+    if not asyncio.isfuture(source) and not isinstance(
+        source, concurrent.futures.Future
+    ):
+        raise TypeError("A future is required for source argument")
+    if not asyncio.isfuture(destination) and not isinstance(
+        destination, concurrent.futures.Future
+    ):
+        raise TypeError("A future is required for destination argument")
+    source_loop = _get_loop(source) if asyncio.isfuture(source) else None
+    dest_loop = _get_loop(destination) if asyncio.isfuture(destination) else None
+
+    def _set_state(future: AnyFuture, other: AnyFuture) -> None:
+        if asyncio.isfuture(future):
+            _copy_future_state(other, future)
+        else:
+            _set_concurrent_future_state(future, other)
+
+    def _call_check_cancel(destination: AnyFuture) -> None:
+        if destination.cancelled():
+            if source_loop is None or source_loop is dest_loop:
+                source.cancel()
+            else:
+                source_loop.call_soon_threadsafe(source.cancel)
+
+    def _call_set_state(source: AnyFuture) -> None:
+        if destination.cancelled() and dest_loop is not None and dest_loop.is_closed():
+            return
+        if dest_loop is None or dest_loop is source_loop:
+            _set_state(destination, source)
+        else:
+            if dest_loop.is_closed():
+                return
+            dest_loop.call_soon_threadsafe(_set_state, destination, source)
+
+    destination.add_done_callback(_call_check_cancel)
+    source.add_done_callback(_call_set_state)
+
+
+def chain_future(source: AnyFuture, destination: AnyFuture) -> AnyFuture:
+    # adapted from asyncio.run_coroutine_threadsafe
+    try:
+        _chain_future(source, destination)
+        return destination
+    except (SystemExit, KeyboardInterrupt):
+        raise
+    except BaseException as exc:
+        if isinstance(destination, concurrent.futures.Future):
+            if destination.set_running_or_notify_cancel():
+                destination.set_exception(exc)
+        else:
+            destination.set_exception(exc)
+        raise
+
+
+def _ensure_future(
+    coro_or_future: Coroutine[None, None, T] | Awaitable[T],
+    *,
+    loop: asyncio.AbstractEventLoop,
+    name: str | None = None,
+    context: contextvars.Context | None = None,
+    lazy: bool = True,
+) -> asyncio.Task[T]:
+    called_wrap_awaitable = False
+    if not asyncio.iscoroutine(coro_or_future):
+        if inspect.isawaitable(coro_or_future):
+            coro_or_future = cast(
+                Coroutine[None, None, T], _wrap_awaitable(coro_or_future)
+            )
+            called_wrap_awaitable = True
+        else:
+            raise TypeError(
+                "An asyncio.Future, a coroutine or an awaitable is required."
+                f" Got {type(coro_or_future).__name__} instead."
+            )
+
+    try:
+        if CONTEXT_NOT_SUPPORTED:
+            return loop.create_task(coro_or_future, name=name)
+        elif EAGER_NOT_SUPPORTED or lazy:
+            return loop.create_task(coro_or_future, name=name, context=context)
+        else:
+            return asyncio.eager_task_factory(
+                loop, coro_or_future, name=name, context=context
+            )
+    except RuntimeError:
+        if not called_wrap_awaitable:
+            coro_or_future.close()
+        raise
+
+
+@types.coroutine
+def _wrap_awaitable(awaitable: Awaitable[T]) -> Generator[None, None, T]:
+    """Helper for asyncio.ensure_future().
+
+    Wraps awaitable (an object with __await__) into a coroutine
+    that will later be wrapped in a Task by ensure_future().
+    """
+    return (yield from awaitable.__await__())
+
+
+def run_coroutine_threadsafe(
+    coro: Coroutine[None, None, T],
+    loop: asyncio.AbstractEventLoop,
+    *,
+    lazy: bool,
+    name: str | None = None,
+    context: contextvars.Context | None = None,
+) -> asyncio.Future[T]:
+    """Submit a coroutine object to a given event loop.
+
+    Return an asyncio.Future to access the result.
+    """
+
+    if asyncio._get_running_loop() is loop:
+        return _ensure_future(coro, loop=loop, name=name, context=context, lazy=lazy)
+    else:
+        future: asyncio.Future[T] = asyncio.Future(loop=loop)
+
+        def callback() -> None:
+            try:
+                chain_future(
+                    _ensure_future(coro, loop=loop, name=name, context=context),
+                    future,
+                )
+            except (SystemExit, KeyboardInterrupt):
+                raise
+            except BaseException as exc:
+                future.set_exception(exc)
+                raise
+
+        loop.call_soon_threadsafe(callback, context=context)
+        return future

langgraph_api/utils.py

@@ -1,129 +0,0 @@
-import contextvars
-import uuid
-from collections.abc import AsyncIterator
-from contextlib import asynccontextmanager
-from datetime import datetime
-from typing import Any, Protocol, TypeAlias, TypeVar
-
-import structlog
-from langgraph_sdk import Auth
-from starlette.authentication import AuthCredentials, BaseUser
-from starlette.exceptions import HTTPException
-from starlette.schemas import BaseSchemaGenerator
-
-from langgraph_api.auth.custom import SimpleUser
-
-logger = structlog.stdlib.get_logger(__name__)
-
-
-T = TypeVar("T")
-Row: TypeAlias = dict[str, Any]
-AuthContext = contextvars.ContextVar[Auth.types.BaseAuthContext | None](
-    "AuthContext", default=None
-)
-
-
-@asynccontextmanager
-async def with_user(
-    user: BaseUser | None = None, auth: AuthCredentials | list[str] | None = None
-):
-    current = get_auth_ctx()
-    set_auth_ctx(user, auth)
-    yield
-    if current is None:
-        return
-    set_auth_ctx(current.user, AuthCredentials(scopes=current.permissions))
-
-
-def set_auth_ctx(
-    user: BaseUser | None, auth: AuthCredentials | list[str] | None
-) -> None:
-    if user is None and auth is None:
-        AuthContext.set(None)
-    else:
-        AuthContext.set(
-            Auth.types.BaseAuthContext(
-                permissions=(
-                    auth.scopes if isinstance(auth, AuthCredentials) else (auth or [])
-                ),
-                user=user or SimpleUser(""),
-            )
-        )
-
-
-def get_auth_ctx() -> Auth.types.BaseAuthContext | None:
-    return AuthContext.get()
-
-
-class AsyncCursorProto(Protocol):
-    async def fetchone(self) -> Row: ...
-
-    async def fetchall(self) -> list[Row]: ...
-
-    async def __aiter__(self) -> AsyncIterator[Row]:
-        yield ...
-
-
-class AsyncPipelineProto(Protocol):
-    async def sync(self) -> None: ...
-
-
-class AsyncConnectionProto(Protocol):
-    @asynccontextmanager
-    async def pipeline(self) -> AsyncIterator[AsyncPipelineProto]:
-        yield ...
-
-    async def execute(self, query: str, *args, **kwargs) -> AsyncCursorProto: ...
-
-
-async def fetchone(
-    it: AsyncIterator[T],
-    *,
-    not_found_code: int = 404,
-    not_found_detail: str | None = None,
-) -> T:
-    """Fetch the first row from an async iterator."""
-    try:
-        return await anext(it)
-    except StopAsyncIteration:
-        raise HTTPException(
-            status_code=not_found_code, detail=not_found_detail
-        ) from None
-
-
-def validate_uuid(uuid_str: str, invalid_uuid_detail: str | None) -> uuid.UUID:
-    try:
-        return uuid.UUID(uuid_str)
-    except ValueError:
-        raise HTTPException(status_code=422, detail=invalid_uuid_detail) from None
-
-
-def next_cron_date(schedule: str, base_time: datetime) -> datetime:
-    import croniter
-
-    cron_iter = croniter.croniter(schedule, base_time)
-    return cron_iter.get_next(datetime)
-
-
-class SchemaGenerator(BaseSchemaGenerator):
-    def __init__(self, base_schema: dict[str, Any]) -> None:
-        self.base_schema = base_schema
-
-    def get_schema(self, routes: list) -> dict[str, Any]:
-        schema = dict(self.base_schema)
-        schema.setdefault("paths", {})
-        endpoints_info = self.get_endpoints(routes)
-
-        for endpoint in endpoints_info:
-            try:
-                parsed = self.parse_docstring(endpoint.func)
-            except AssertionError:
-                logger.warning("Could not parse docstrings for route %s", endpoint.path)
-                parsed = {}
-
-            if endpoint.path not in schema["paths"]:
-                schema["paths"][endpoint.path] = {}
-
-            schema["paths"][endpoint.path][endpoint.http_method] = parsed
-
-        return schema

{langgraph_api-0.2.72.dist-info → langgraph_api-0.2.75.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langgraph-api
-Version: 0.2.72
+Version: 0.2.75
 Author-email: Nuno Campos <nuno@langchain.dev>, Will Fu-Hinthorn <will@langchain.dev>
 License: Elastic-2.0
 License-File: LICENSE

{langgraph_api-0.2.72.dist-info → langgraph_api-0.2.75.dist-info}/RECORD

@@ -1,14 +1,14 @@
-langgraph_api/__init__.py,sha256=c7hAogCcGJv4p-Jen7YzVrMqWqmXOzFfJmuFoOBDLYU,23
+langgraph_api/__init__.py,sha256=fGfmYDwqJaQwj-AKSkwGYRZdqQNoadp6S3aayGVqQ9E,23
 langgraph_api/asgi_transport.py,sha256=eqifhHxNnxvI7jJqrY1_8RjL4Fp9NdN4prEub2FWBt8,5091
-langgraph_api/asyncio.py,sha256=Odnc6mAJIGF3eFWT8Xcrg2Zam7FwzXkfCWEHaXfrzQQ,9371
+langgraph_api/asyncio.py,sha256=qrYEqPRrqtGq7E7KjcMC-ALyN79HkRnmp9rM2TAw9L8,9404
 langgraph_api/cli.py,sha256=13mKb-WT7fGx_yqcbWITPB9ICEHCrPzIP1ddZ5RbXbY,16015
 langgraph_api/command.py,sha256=3O9v3i0OPa96ARyJ_oJbLXkfO8rPgDhLCswgO9koTFA,768
 langgraph_api/config.py,sha256=jmtO5LXubet2Hl7S2tF2BRyB_q2yqCzFqCwN7n6za4Y,11727
-langgraph_api/cron_scheduler.py,sha256=i87j4pJrcsmsqMKeKUs69gaAjrGaSM3pM3jnXdN5JDQ,2630
+langgraph_api/cron_scheduler.py,sha256=CiwZ-U4gDOdG9zl9dlr7mH50USUgNB2Fvb8YTKVRBN4,2625
 langgraph_api/errors.py,sha256=zlnl3xXIwVG0oGNKKpXf1an9Rn_SBDHSyhe53hU6aLw,1858
-langgraph_api/graph.py,sha256=t18rq0NHHRILUI5cONhKPzKhbqLGn6_BRytiEh0gdcg,23561
+langgraph_api/graph.py,sha256=pw_3jVZNe0stO5-Y8kLUuC8EJ5tFqdLu9fLpwUz4Hc4,23574
 langgraph_api/http.py,sha256=gYbxxjY8aLnsXeJymcJ7G7Nj_yToOGpPYQqmZ1_ggfA,5240
-langgraph_api/logging.py,sha256=Do62kNJtY7Ns7q7XrP2VIxho3c85jt8_l3yfRtqM7xM,4370
+langgraph_api/logging.py,sha256=LL2LNuMYFrqDhG_KbyKy9AoAPghcdlFj2T50zMyPddk,4182
 langgraph_api/metadata.py,sha256=Gx0b6YszLRjdWLDVN8OcVgC_YYQG_nQitPfUfgQx1w8,4648
 langgraph_api/patch.py,sha256=Dgs0PXHytekX4SUL6KsjjN0hHcOtGLvv1GRGbh6PswU,1408
 langgraph_api/queue_entrypoint.py,sha256=hC8j-A4cUxibusiiPJBlK0mkmChNZxNcXn5GVwL0yic,4889
@@ -17,16 +17,16 @@ langgraph_api/schema.py,sha256=a6it0h9ku4jrTXiW9MhnGok_wignyQ4cXBra67FiryM,5678
 langgraph_api/serde.py,sha256=8fQXg7T7RVUqj_jgOoSOJrWVpQDW0qJKjAjSsEhPHo4,4803
 langgraph_api/server.py,sha256=Z_VL-kIphybTRDWBIqHMfRhgCmAFyTRqAGlgnHQF0Zg,6973
 langgraph_api/sse.py,sha256=SLdtZmTdh5D8fbWrQjuY9HYLd2dg8Rmi6ZMmFMVc2iE,4204
-langgraph_api/state.py,sha256=8jx4IoTCOjTJuwzuXJKKFwo1VseHjNnw_CCq4x1SW14,2284
-langgraph_api/store.py,sha256=_xGhdwEIMoY1_hIy_oWwxZp4Y7FH833BNJfgFIhT80E,4640
-langgraph_api/stream.py,sha256=UoJzqCzWhTVildxOlU87mX4NtZSUhtl1RGDeMFRYyNI,13660
+langgraph_api/state.py,sha256=NLl5YgLKppHJ7zfF0bXjsroXmIGCZez0IlDAKNGVy0g,2365
+langgraph_api/store.py,sha256=srRI0fQXNFo_RSUs4apucr4BEp_KrIseJksZXs32MlQ,4635
+langgraph_api/stream.py,sha256=EorM9BD7oiCvkRXlMqnOkBd9P1X3mEagS_oHp-_9aRQ,13669
 langgraph_api/thread_ttl.py,sha256=-Ox8NFHqUH3wGNdEKMIfAXUubY5WGifIgCaJ7npqLgw,1762
-langgraph_api/utils.py,sha256=92mSti9GfGdMRRWyESKQW5yV-75Z9icGHnIrBYvdypU,3619
+langgraph_api/utils.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langgraph_api/validation.py,sha256=zMuKmwUEBjBgFMwAaeLZmatwGVijKv2sOYtYg7gfRtc,4950
 langgraph_api/webhook.py,sha256=1ncwO0rIZcj-Df9sxSnFEzd1gP1bfS4okeZQS8NSRoE,1382
 langgraph_api/worker.py,sha256=fL0pNEW9FaldEREq_4L-ivkxTr2R_rEpmVMi-zRx__U,14226
 langgraph_api/api/__init__.py,sha256=YVzpbn5IQotvuuLG9fhS9QMrxXfP4s4EpEMG0n4q3Nw,5625
-langgraph_api/api/assistants.py,sha256=YdnLBMg_2k01n_OY3GT-vX41fMsWFS4sRbZd_irOYDY,16196
+langgraph_api/api/assistants.py,sha256=w7nXjEknDVHSuP228S8ZLh4bG0nRGnSwVP9pECQOK90,16247
 langgraph_api/api/mcp.py,sha256=RvRYgANqRzNQzSmgjNkq4RlKTtoEJYil04ot9lsmEtE,14352
 langgraph_api/api/meta.py,sha256=MU9Ehdo2M8oaxGVBXVQFNRP6qSTXyrsGXFcndRlnvIE,3924
 langgraph_api/api/openapi.py,sha256=362m6Ny8wOwZ6HrDK9JAVUzPkyLYWKeV1E71hPOaA0U,11278
@@ -72,6 +72,9 @@ langgraph_api/middleware/request_id.py,sha256=SDj3Yi3WvTbFQ2ewrPQBjAV8sYReOJGeIi
 langgraph_api/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langgraph_api/models/run.py,sha256=j1s9KRfFXgjKUudB9z7IVJ34Klo85PPeaVFtmWHhEdo,14514
 langgraph_api/tunneling/cloudflare.py,sha256=iKb6tj-VWPlDchHFjuQyep2Dpb-w2NGfJKt-WJG9LH0,3650
+langgraph_api/utils/__init__.py,sha256=92mSti9GfGdMRRWyESKQW5yV-75Z9icGHnIrBYvdypU,3619
+langgraph_api/utils/config.py,sha256=gONI0UsoSpuR72D9lSGAmpr-_iSMDFdD4M_tiXXjmNk,3936
+langgraph_api/utils/future.py,sha256=CGhUb_Ht4_CnTuXc2kI8evEn1gnMKYN0ce9ZyUkW5G4,7251
 langgraph_license/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langgraph_license/validation.py,sha256=ZKraAVJArAABKqrmHN-EN18ncoNUmRm500Yt1Sc7tUA,537
 langgraph_runtime/__init__.py,sha256=O4GgSmu33c-Pr8Xzxj_brcK5vkm70iNTcyxEjICFZxA,1075
@@ -86,8 +89,8 @@ langgraph_runtime/store.py,sha256=7mowndlsIroGHv3NpTSOZDJR0lCuaYMBoTnTrewjslw,11
 LICENSE,sha256=ZPwVR73Biwm3sK6vR54djCrhaRiM4cAD2zvOQZV8Xis,3859
 logging.json,sha256=3RNjSADZmDq38eHePMm1CbP6qZ71AmpBtLwCmKU9Zgo,379
 openapi.json,sha256=NVgY0hdCu6v5anNus9I-CVYKKcrDLKd1qhILy-kQpq8,142590
-langgraph_api-0.2.72.dist-info/METADATA,sha256=avTOLxcRvrv8RpORHCbAZBXMk7Le3PlSAvykaxIY33Q,3891
-langgraph_api-0.2.72.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-langgraph_api-0.2.72.dist-info/entry_points.txt,sha256=hGedv8n7cgi41PypMfinwS_HfCwA7xJIfS0jAp8htV8,78
-langgraph_api-0.2.72.dist-info/licenses/LICENSE,sha256=ZPwVR73Biwm3sK6vR54djCrhaRiM4cAD2zvOQZV8Xis,3859
-langgraph_api-0.2.72.dist-info/RECORD,,
+langgraph_api-0.2.75.dist-info/METADATA,sha256=2WD4F3joubu25ijCCW5czUAgFBv0-50WZVHhKiuYW48,3891
+langgraph_api-0.2.75.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+langgraph_api-0.2.75.dist-info/entry_points.txt,sha256=hGedv8n7cgi41PypMfinwS_HfCwA7xJIfS0jAp8htV8,78
+langgraph_api-0.2.75.dist-info/licenses/LICENSE,sha256=ZPwVR73Biwm3sK6vR54djCrhaRiM4cAD2zvOQZV8Xis,3859
+langgraph_api-0.2.75.dist-info/RECORD,,