Add files using upload-large-folder tool

python/user_packages/Python313/site-packages/langgraph_sdk-0.3.14.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 LangChain, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

python/user_packages/Python313/site-packages/langgraph_sdk/_async/__init__.py

@@ -0,0 +1,20 @@
+"""Async client exports."""
+
+from langgraph_sdk._async.assistants import AssistantsClient
+from langgraph_sdk._async.client import LangGraphClient, get_client
+from langgraph_sdk._async.cron import CronClient
+from langgraph_sdk._async.http import HttpClient
+from langgraph_sdk._async.runs import RunsClient
+from langgraph_sdk._async.store import StoreClient
+from langgraph_sdk._async.threads import ThreadsClient
+
+__all__ = [
+    "AssistantsClient",
+    "CronClient",
+    "HttpClient",
+    "LangGraphClient",
+    "RunsClient",
+    "StoreClient",
+    "ThreadsClient",
+    "get_client",
+]

python/user_packages/Python313/site-packages/langgraph_sdk/_async/assistants.py

@@ -0,0 +1,733 @@
+"""Async client for managing assistants in LangGraph."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, Literal, cast, overload
+
+import httpx
+
+from langgraph_sdk._async.http import HttpClient
+from langgraph_sdk.schema import (
+    Assistant,
+    AssistantSelectField,
+    AssistantSortBy,
+    AssistantsSearchResponse,
+    AssistantVersion,
+    Config,
+    Context,
+    GraphSchema,
+    Json,
+    OnConflictBehavior,
+    QueryParamTypes,
+    SortOrder,
+    Subgraphs,
+)
+
+
+class AssistantsClient:
+    """Client for managing assistants in LangGraph.
+
+    This class provides methods to interact with assistants,
+    which are versioned configurations of your graph.
+
+    ???+ example "Example"
+
+        ```python
+        client = get_client(url="http://localhost:2024")
+        assistant = await client.assistants.get("assistant_id_123")
+        ```
+    """
+
+    def __init__(self, http: HttpClient) -> None:
+        self.http = http
+
+    async def get(
+        self,
+        assistant_id: str,
+        *,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> Assistant:
+        """Get an assistant by ID.
+
+        Args:
+            assistant_id: The ID of the assistant to get.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            Assistant: Assistant Object.
+
+        ???+ example "Example Usage"
+
+            ```python
+            assistant = await client.assistants.get(
+                assistant_id="my_assistant_id"
+            )
+            print(assistant)
+            ```
+
+            ```shell
+            ----------------------------------------------------
+
+            {
+                'assistant_id': 'my_assistant_id',
+                'graph_id': 'agent',
+                'created_at': '2024-06-25T17:10:33.109781+00:00',
+                'updated_at': '2024-06-25T17:10:33.109781+00:00',
+                'config': {},
+                'metadata': {'created_by': 'system'},
+                'version': 1,
+                'name': 'my_assistant'
+            }
+            ```
+        """
+        return await self.http.get(
+            f"/assistants/{assistant_id}", headers=headers, params=params
+        )
+
+    async def get_graph(
+        self,
+        assistant_id: str,
+        *,
+        xray: int | bool = False,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> dict[str, list[dict[str, Any]]]:
+        """Get the graph of an assistant by ID.
+
+        Args:
+            assistant_id: The ID of the assistant to get the graph of.
+            xray: Include graph representation of subgraphs. If an integer value is provided, only subgraphs with a depth less than or equal to the value will be included.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            Graph: The graph information for the assistant in JSON format.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost:2024")
+            graph_info = await client.assistants.get_graph(
+                assistant_id="my_assistant_id"
+            )
+            print(graph_info)
+            ```
+
+            ```shell
+
+            --------------------------------------------------------------------------------------------------------------------------
+
+            {
+                'nodes':
+                    [
+                        {'id': '__start__', 'type': 'schema', 'data': '__start__'},
+                        {'id': '__end__', 'type': 'schema', 'data': '__end__'},
+                        {'id': 'agent','type': 'runnable','data': {'id': ['langgraph', 'utils', 'RunnableCallable'],'name': 'agent'}},
+                    ],
+                'edges':
+                    [
+                        {'source': '__start__', 'target': 'agent'},
+                        {'source': 'agent','target': '__end__'}
+                    ]
+            }
+            ```
+
+
+        """
+        query_params = {"xray": xray}
+        if params:
+            query_params.update(params)
+
+        return await self.http.get(
+            f"/assistants/{assistant_id}/graph", params=query_params, headers=headers
+        )
+
+    async def get_schemas(
+        self,
+        assistant_id: str,
+        *,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> GraphSchema:
+        """Get the schemas of an assistant by ID.
+
+        Args:
+            assistant_id: The ID of the assistant to get the schema of.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            GraphSchema: The graph schema for the assistant.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost:2024")
+            schema = await client.assistants.get_schemas(
+                assistant_id="my_assistant_id"
+            )
+            print(schema)
+            ```
+
+            ```shell
+
+            ----------------------------------------------------------------------------------------------------------------------------
+
+            {
+                'graph_id': 'agent',
+                'state_schema':
+                    {
+                        'title': 'LangGraphInput',
+                        '$ref': '#/definitions/AgentState',
+                        'definitions':
+                            {
+                                'BaseMessage':
+                                    {
+                                        'title': 'BaseMessage',
+                                        'description': 'Base abstract Message class. Messages are the inputs and outputs of ChatModels.',
+                                        'type': 'object',
+                                        'properties':
+                                            {
+                                             'content':
+                                                {
+                                                    'title': 'Content',
+                                                    'anyOf': [
+                                                        {'type': 'string'},
+                                                        {'type': 'array','items': {'anyOf': [{'type': 'string'}, {'type': 'object'}]}}
+                                                    ]
+                                                },
+                                            'additional_kwargs':
+                                                {
+                                                    'title': 'Additional Kwargs',
+                                                    'type': 'object'
+                                                },
+                                            'response_metadata':
+                                                {
+                                                    'title': 'Response Metadata',
+                                                    'type': 'object'
+                                                },
+                                            'type':
+                                                {
+                                                    'title': 'Type',
+                                                    'type': 'string'
+                                                },
+                                            'name':
+                                                {
+                                                    'title': 'Name',
+                                                    'type': 'string'
+                                                },
+                                            'id':
+                                                {
+                                                    'title': 'Id',
+                                                    'type': 'string'
+                                                }
+                                            },
+                                        'required': ['content', 'type']
+                                    },
+                                'AgentState':
+                                    {
+                                        'title': 'AgentState',
+                                        'type': 'object',
+                                        'properties':
+                                            {
+                                                'messages':
+                                                    {
+                                                        'title': 'Messages',
+                                                        'type': 'array',
+                                                        'items': {'$ref': '#/definitions/BaseMessage'}
+                                                    }
+                                            },
+                                        'required': ['messages']
+                                    }
+                            }
+                    },
+                'context_schema':
+                    {
+                        'title': 'Context',
+                        'type': 'object',
+                        'properties':
+                            {
+                                'model_name':
+                                    {
+                                        'title': 'Model Name',
+                                        'enum': ['anthropic', 'openai'],
+                                        'type': 'string'
+                                    }
+                            }
+                    }
+            }
+            ```
+
+        """
+        return await self.http.get(
+            f"/assistants/{assistant_id}/schemas", headers=headers, params=params
+        )
+
+    async def get_subgraphs(
+        self,
+        assistant_id: str,
+        namespace: str | None = None,
+        recurse: bool = False,
+        *,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> Subgraphs:
+        """Get the schemas of an assistant by ID.
+
+        Args:
+            assistant_id: The ID of the assistant to get the schema of.
+            namespace: Optional namespace to filter by.
+            recurse: Whether to recursively get subgraphs.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            Subgraphs: The graph schema for the assistant.
+
+        """
+        get_params = {"recurse": recurse}
+        if params:
+            get_params = {**get_params, **dict(params)}
+        if namespace is not None:
+            return await self.http.get(
+                f"/assistants/{assistant_id}/subgraphs/{namespace}",
+                params=get_params,
+                headers=headers,
+            )
+        else:
+            return await self.http.get(
+                f"/assistants/{assistant_id}/subgraphs",
+                params=get_params,
+                headers=headers,
+            )
+
+    async def create(
+        self,
+        graph_id: str | None,
+        config: Config | None = None,
+        *,
+        context: Context | None = None,
+        metadata: Json = None,
+        assistant_id: str | None = None,
+        if_exists: OnConflictBehavior | None = None,
+        name: str | None = None,
+        headers: Mapping[str, str] | None = None,
+        description: str | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> Assistant:
+        """Create a new assistant.
+
+        Useful when graph is configurable and you want to create different assistants based on different configurations.
+
+        Args:
+            graph_id: The ID of the graph the assistant should use. The graph ID is normally set in your langgraph.json configuration.
+            config: Configuration to use for the graph.
+            metadata: Metadata to add to assistant.
+            context: Static context to add to the assistant.
+                !!! version-added "Added in version 0.6.0"
+            assistant_id: Assistant ID to use, will default to a random UUID if not provided.
+            if_exists: How to handle duplicate creation. Defaults to 'raise' under the hood.
+                Must be either 'raise' (raise error if duplicate), or 'do_nothing' (return existing assistant).
+            name: The name of the assistant. Defaults to 'Untitled' under the hood.
+            headers: Optional custom headers to include with the request.
+            description: Optional description of the assistant.
+                The description field is available for langgraph-api server version>=0.0.45
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            Assistant: The created assistant.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost:2024")
+            assistant = await client.assistants.create(
+                graph_id="agent",
+                context={"model_name": "openai"},
+                metadata={"number":1},
+                assistant_id="my-assistant-id",
+                if_exists="do_nothing",
+                name="my_name"
+            )
+            ```
+        """
+        payload: dict[str, Any] = {
+            "graph_id": graph_id,
+        }
+        if config:
+            payload["config"] = config
+        if context:
+            payload["context"] = context
+        if metadata:
+            payload["metadata"] = metadata
+        if assistant_id:
+            payload["assistant_id"] = assistant_id
+        if if_exists:
+            payload["if_exists"] = if_exists
+        if name:
+            payload["name"] = name
+        if description:
+            payload["description"] = description
+        return await self.http.post(
+            "/assistants", json=payload, headers=headers, params=params
+        )
+
+    async def update(
+        self,
+        assistant_id: str,
+        *,
+        graph_id: str | None = None,
+        config: Config | None = None,
+        context: Context | None = None,
+        metadata: Json = None,
+        name: str | None = None,
+        headers: Mapping[str, str] | None = None,
+        description: str | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> Assistant:
+        """Update an assistant.
+
+        Use this to point to a different graph, update the configuration, or change the metadata of an assistant.
+
+        Args:
+            assistant_id: Assistant to update.
+            graph_id: The ID of the graph the assistant should use.
+                The graph ID is normally set in your langgraph.json configuration. If `None`, assistant will keep pointing to same graph.
+            config: Configuration to use for the graph.
+            context: Static context to add to the assistant.
+                !!! version-added "Added in version 0.6.0"
+            metadata: Metadata to merge with existing assistant metadata.
+            name: The new name for the assistant.
+            headers: Optional custom headers to include with the request.
+            description: Optional description of the assistant.
+                The description field is available for langgraph-api server version>=0.0.45
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            The updated assistant.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost:2024")
+            assistant = await client.assistants.update(
+                assistant_id='e280dad7-8618-443f-87f1-8e41841c180f',
+                graph_id="other-graph",
+                context={"model_name": "anthropic"},
+                metadata={"number":2}
+            )
+            ```
+
+        """
+        payload: dict[str, Any] = {}
+        if graph_id:
+            payload["graph_id"] = graph_id
+        if config is not None:
+            payload["config"] = config
+        if context is not None:
+            payload["context"] = context
+        if metadata:
+            payload["metadata"] = metadata
+        if name:
+            payload["name"] = name
+        if description:
+            payload["description"] = description
+        return await self.http.patch(
+            f"/assistants/{assistant_id}",
+            json=payload,
+            headers=headers,
+            params=params,
+        )
+
+    async def delete(
+        self,
+        assistant_id: str,
+        *,
+        delete_threads: bool = False,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> None:
+        """Delete an assistant.
+
+        Args:
+            assistant_id: The assistant ID to delete.
+            delete_threads: If true, delete all threads with `metadata.assistant_id`
+                matching this assistant, along with runs and checkpoints belonging to
+                those threads.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            `None`
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost:2024")
+            await client.assistants.delete(
+                assistant_id="my_assistant_id"
+            )
+            ```
+
+        """
+        query_params: dict[str, Any] = {}
+        if delete_threads:
+            query_params["delete_threads"] = True
+        if params:
+            query_params.update(params)
+        await self.http.delete(
+            f"/assistants/{assistant_id}",
+            headers=headers,
+            params=query_params or None,
+        )
+
+    @overload
+    async def search(
+        self,
+        *,
+        metadata: Json = None,
+        graph_id: str | None = None,
+        name: str | None = None,
+        limit: int = 10,
+        offset: int = 0,
+        sort_by: AssistantSortBy | None = None,
+        sort_order: SortOrder | None = None,
+        select: list[AssistantSelectField] | None = None,
+        response_format: Literal["object"],
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> AssistantsSearchResponse: ...
+
+    @overload
+    async def search(
+        self,
+        *,
+        metadata: Json = None,
+        graph_id: str | None = None,
+        name: str | None = None,
+        limit: int = 10,
+        offset: int = 0,
+        sort_by: AssistantSortBy | None = None,
+        sort_order: SortOrder | None = None,
+        select: list[AssistantSelectField] | None = None,
+        response_format: Literal["array"] = "array",
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> list[Assistant]: ...
+
+    async def search(
+        self,
+        *,
+        metadata: Json = None,
+        graph_id: str | None = None,
+        name: str | None = None,
+        limit: int = 10,
+        offset: int = 0,
+        sort_by: AssistantSortBy | None = None,
+        sort_order: SortOrder | None = None,
+        select: list[AssistantSelectField] | None = None,
+        response_format: Literal["array", "object"] = "array",
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> AssistantsSearchResponse | list[Assistant]:
+        """Search for assistants.
+
+        Args:
+            metadata: Metadata to filter by. Exact match filter for each KV pair.
+            graph_id: The ID of the graph to filter by.
+                The graph ID is normally set in your langgraph.json configuration.
+            name: The name of the assistant to filter by.
+                The filtering logic will match assistants where 'name' is a substring (case insensitive) of the assistant name.
+            limit: The maximum number of results to return.
+            offset: The number of results to skip.
+            sort_by: The field to sort by.
+            sort_order: The order to sort by.
+            select: Specific assistant fields to include in the response.
+            response_format: Controls the response shape. Use `"array"` (default)
+                to return a bare list of assistants, or `"object"` to return
+                a mapping containing assistants plus pagination metadata.
+                Defaults to "array", though this default will be changed to "object" in a future release.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            A list of assistants (when `response_format="array"`) or a mapping
+            with the assistants and the next pagination cursor (when
+            `response_format="object"`).
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost:2024")
+            response = await client.assistants.search(
+                metadata = {"name":"my_name"},
+                graph_id="my_graph_id",
+                limit=5,
+                offset=5,
+                response_format="object"
+            )
+            next_cursor = response["next"]
+            assistants = response["assistants"]
+            ```
+        """
+        if response_format not in ("array", "object"):
+            raise ValueError(
+                f"response_format must be 'array' or 'object', got {response_format!r}"
+            )
+        payload: dict[str, Any] = {
+            "limit": limit,
+            "offset": offset,
+        }
+        if metadata:
+            payload["metadata"] = metadata
+        if graph_id:
+            payload["graph_id"] = graph_id
+        if name:
+            payload["name"] = name
+        if sort_by:
+            payload["sort_by"] = sort_by
+        if sort_order:
+            payload["sort_order"] = sort_order
+        if select:
+            payload["select"] = select
+        next_cursor: str | None = None
+
+        def capture_pagination(response: httpx.Response) -> None:
+            nonlocal next_cursor
+            next_cursor = response.headers.get("X-Pagination-Next")
+
+        assistants = cast(
+            list[Assistant],
+            await self.http.post(
+                "/assistants/search",
+                json=payload,
+                headers=headers,
+                params=params,
+                on_response=capture_pagination if response_format == "object" else None,
+            ),
+        )
+        if response_format == "object":
+            return {"assistants": assistants, "next": next_cursor}
+        return assistants
+
+    async def count(
+        self,
+        *,
+        metadata: Json = None,
+        graph_id: str | None = None,
+        name: str | None = None,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> int:
+        """Count assistants matching filters.
+
+        Args:
+            metadata: Metadata to filter by. Exact match for each key/value.
+            graph_id: Optional graph id to filter by.
+            name: Optional name to filter by.
+                The filtering logic will match assistants where 'name' is a substring (case insensitive) of the assistant name.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            int: Number of assistants matching the criteria.
+        """
+        payload: dict[str, Any] = {}
+        if metadata:
+            payload["metadata"] = metadata
+        if graph_id:
+            payload["graph_id"] = graph_id
+        if name:
+            payload["name"] = name
+        return await self.http.post(
+            "/assistants/count", json=payload, headers=headers, params=params
+        )
+
+    async def get_versions(
+        self,
+        assistant_id: str,
+        metadata: Json = None,
+        limit: int = 10,
+        offset: int = 0,
+        *,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> list[AssistantVersion]:
+        """List all versions of an assistant.
+
+        Args:
+            assistant_id: The assistant ID to get versions for.
+            metadata: Metadata to filter versions by. Exact match filter for each KV pair.
+            limit: The maximum number of versions to return.
+            offset: The number of versions to skip.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            A list of assistant versions.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost:2024")
+            assistant_versions = await client.assistants.get_versions(
+                assistant_id="my_assistant_id"
+            )
+            ```
+        """
+
+        payload: dict[str, Any] = {
+            "limit": limit,
+            "offset": offset,
+        }
+        if metadata:
+            payload["metadata"] = metadata
+        return await self.http.post(
+            f"/assistants/{assistant_id}/versions",
+            json=payload,
+            headers=headers,
+            params=params,
+        )
+
+    async def set_latest(
+        self,
+        assistant_id: str,
+        version: int,
+        *,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> Assistant:
+        """Change the version of an assistant.
+
+        Args:
+            assistant_id: The assistant ID to delete.
+            version: The version to change to.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            Assistant Object.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost:2024")
+            new_version_assistant = await client.assistants.set_latest(
+                assistant_id="my_assistant_id",
+                version=3
+            )
+            ```
+
+        """
+
+        payload: dict[str, Any] = {"version": version}
+
+        return await self.http.post(
+            f"/assistants/{assistant_id}/latest",
+            json=payload,
+            headers=headers,
+            params=params,
+        )

python/user_packages/Python313/site-packages/langgraph_sdk/_async/client.py

@@ -0,0 +1,178 @@
+"""Async LangGraph client."""
+
+from __future__ import annotations
+
+import logging
+import os
+from collections.abc import Mapping
+from types import TracebackType
+
+import httpx
+
+from langgraph_sdk._async.assistants import AssistantsClient
+from langgraph_sdk._async.cron import CronClient
+from langgraph_sdk._async.http import HttpClient
+from langgraph_sdk._async.runs import RunsClient
+from langgraph_sdk._async.store import StoreClient
+from langgraph_sdk._async.threads import ThreadsClient
+from langgraph_sdk._shared.types import TimeoutTypes
+from langgraph_sdk._shared.utilities import (
+    NOT_PROVIDED,
+    _get_headers,
+    _registered_transports,
+    get_asgi_transport,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def get_client(
+    *,
+    url: str | None = None,
+    api_key: str | None = NOT_PROVIDED,
+    headers: Mapping[str, str] | None = None,
+    timeout: TimeoutTypes | None = None,
+) -> LangGraphClient:
+    """Create and configure a LangGraphClient.
+
+    The client provides programmatic access to LangSmith Deployment. It supports
+    both remote servers and local in-process connections (when running inside a LangGraph server).
+
+    Args:
+        url:
+            Base URL of the LangGraph API.
+            - If `None`, the client first attempts an in-process connection via ASGI transport.
+              If that fails, it defers registration until after app initialization. This
+              only works if the client is used from within the Agent server.
+        api_key:
+            API key for authentication. Can be:
+              - A string: use this exact API key
+              - `None`: explicitly skip loading from environment variables
+              - Not provided (default): auto-load from environment in this order:
+                1. `LANGGRAPH_API_KEY`
+                2. `LANGSMITH_API_KEY`
+                3. `LANGCHAIN_API_KEY`
+        headers:
+            Additional HTTP headers to include in requests. Merged with authentication headers.
+        timeout:
+            HTTP timeout configuration. May be:
+              - `httpx.Timeout` instance
+              - float (total seconds)
+              - tuple `(connect, read, write, pool)` in seconds
+            Defaults: connect=5, read=300, write=300, pool=5.
+
+    Returns:
+        LangGraphClient:
+            A top-level client exposing sub-clients for assistants, threads,
+            runs, and cron operations.
+
+    ???+ example "Connect to a remote server:"
+
+        ```python
+        from langgraph_sdk import get_client
+
+        # get top-level LangGraphClient
+        client = get_client(url="http://localhost:8123")
+
+        # example usage: client.<model>.<method_name>()
+        assistants = await client.assistants.get(assistant_id="some_uuid")
+        ```
+
+    ???+ example "Connect in-process to a running LangGraph server:"
+
+        ```python
+        from langgraph_sdk import get_client
+
+        client = get_client(url=None)
+
+        async def my_node(...):
+            subagent_result = await client.runs.wait(
+                thread_id=None,
+                assistant_id="agent",
+                input={"messages": [{"role": "user", "content": "Foo"}]},
+            )
+        ```
+
+    ???+ example "Skip auto-loading API key from environment:"
+
+        ```python
+        from langgraph_sdk import get_client
+
+        # Don't load API key from environment variables
+        client = get_client(
+            url="http://localhost:8123",
+            api_key=None
+        )
+        ```
+    """
+
+    transport: httpx.AsyncBaseTransport | None = None
+    if url is None:
+        url = "http://api"
+        if os.environ.get("__LANGGRAPH_DEFER_LOOPBACK_TRANSPORT") == "true":
+            transport = get_asgi_transport()(app=None, root_path="/noauth")  # type: ignore[invalid-argument-type]
+            _registered_transports.append(transport)
+        else:
+            try:
+                from langgraph_api.server import app  # type: ignore
+
+                transport = get_asgi_transport()(app, root_path="/noauth")
+            except Exception:
+                logger.debug(
+                    "Failed to connect to in-process LangGraph server. Deferring configuration.",
+                    exc_info=True,
+                )
+                transport = get_asgi_transport()(app=None, root_path="/noauth")  # type: ignore[invalid-argument-type]
+                _registered_transports.append(transport)
+
+    if transport is None:
+        transport = httpx.AsyncHTTPTransport(retries=5)
+    client = httpx.AsyncClient(
+        base_url=url,
+        transport=transport,
+        timeout=(
+            httpx.Timeout(timeout)  # type: ignore[arg-type]
+            if timeout is not None
+            else httpx.Timeout(connect=5, read=300, write=300, pool=5)
+        ),
+        headers=_get_headers(api_key, headers),
+    )
+    return LangGraphClient(client)
+
+
+class LangGraphClient:
+    """Top-level client for LangGraph API.
+
+    Attributes:
+        assistants: Manages versioned configuration for your graphs.
+        threads: Handles (potentially) multi-turn interactions, such as conversational threads.
+        runs: Controls individual invocations of the graph.
+        crons: Manages scheduled operations.
+        store: Interfaces with persistent, shared data storage.
+    """
+
+    def __init__(self, client: httpx.AsyncClient) -> None:
+        self.http = HttpClient(client)
+        self.assistants = AssistantsClient(self.http)
+        self.threads = ThreadsClient(self.http)
+        self.runs = RunsClient(self.http)
+        self.crons = CronClient(self.http)
+        self.store = StoreClient(self.http)
+
+    async def __aenter__(self) -> LangGraphClient:
+        """Enter the async context manager."""
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        """Exit the async context manager."""
+        await self.aclose()
+
+    async def aclose(self) -> None:
+        """Close the underlying HTTP client."""
+        if hasattr(self, "http"):
+            await self.http.client.aclose()

python/user_packages/Python313/site-packages/langgraph_sdk/_async/cron.py

@@ -0,0 +1,521 @@
+"""Async client for managing recurrent runs (cron jobs) in LangGraph."""
+
+from __future__ import annotations
+
+import warnings
+from collections.abc import Mapping, Sequence
+from datetime import datetime, tzinfo
+from typing import Any
+
+from langgraph_sdk._async.http import HttpClient
+from langgraph_sdk._shared.utilities import _resolve_timezone
+from langgraph_sdk.schema import (
+    All,
+    Config,
+    Context,
+    Cron,
+    CronSelectField,
+    CronSortBy,
+    Durability,
+    Input,
+    OnCompletionBehavior,
+    QueryParamTypes,
+    Run,
+    SortOrder,
+    StreamMode,
+)
+
+
+class CronClient:
+    """Client for managing recurrent runs (cron jobs) in LangGraph.
+
+    A run is a single invocation of an assistant with optional input, config, and context.
+    This client allows scheduling recurring runs to occur automatically.
+
+    ???+ example "Example Usage"
+
+        ```python
+        client = get_client(url="http://localhost:2024"))
+        cron_job = await client.crons.create_for_thread(
+            thread_id="thread_123",
+            assistant_id="asst_456",
+            schedule="0 9 * * *",
+            input={"message": "Daily update"}
+        )
+        ```
+
+    !!! note "Feature Availability"
+
+        The crons client functionality is not supported on all licenses.
+        Please check the relevant license documentation for the most up-to-date
+        details on feature availability.
+    """
+
+    def __init__(self, http_client: HttpClient) -> None:
+        self.http = http_client
+
+    async def create_for_thread(
+        self,
+        thread_id: str,
+        assistant_id: str,
+        *,
+        schedule: str,
+        input: Input | None = None,
+        metadata: Mapping[str, Any] | None = None,
+        config: Config | None = None,
+        context: Context | None = None,
+        checkpoint_during: bool | None = None,  # deprecated
+        interrupt_before: All | list[str] | None = None,
+        interrupt_after: All | list[str] | None = None,
+        webhook: str | None = None,
+        multitask_strategy: str | None = None,
+        end_time: datetime | None = None,
+        enabled: bool | None = None,
+        timezone: str | tzinfo | None = None,
+        stream_mode: StreamMode | Sequence[StreamMode] | None = None,
+        stream_subgraphs: bool | None = None,
+        stream_resumable: bool | None = None,
+        durability: Durability | None = None,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> Run:
+        """Create a cron job for a thread.
+
+        Args:
+            thread_id: the thread ID to run the cron job on.
+            assistant_id: The assistant ID or graph name to use for the cron job.
+                If using graph name, will default to first assistant created from that graph.
+            schedule: The cron schedule to execute this job on.
+                Schedules are interpreted in UTC unless a timezone is specified.
+            input: The input to the graph.
+            metadata: Metadata to assign to the cron job runs.
+            config: The configuration for the assistant.
+            context: Static context to add to the assistant.
+                !!! version-added "Added in version 0.6.0"
+            checkpoint_during: (deprecated) Whether to checkpoint during the run (or only at the end/interruption).
+            interrupt_before: Nodes to interrupt immediately before they get executed.
+
+            interrupt_after: Nodes to Nodes to interrupt immediately after they get executed.
+
+            webhook: Webhook to call after LangGraph API call is done.
+            multitask_strategy: Multitask strategy to use.
+                Must be one of 'reject', 'interrupt', 'rollback', or 'enqueue'.
+            end_time: The time to stop running the cron job. If not provided, the cron job will run indefinitely.
+            enabled: Whether the cron job is enabled or not.
+            timezone: IANA timezone for the cron schedule. Accepts a string (e.g. 'America/New_York') or a ``datetime.tzinfo`` instance (e.g. ``ZoneInfo("America/New_York")``).
+            stream_mode: The stream mode(s) to use.
+            stream_subgraphs: Whether to stream output from subgraphs.
+            stream_resumable: Whether to persist the stream chunks in order to resume the stream later.
+            durability: Durability level for the run. Must be one of 'sync', 'async', or 'exit'.
+                "async" means checkpoints are persisted async while next graph step executes, replaces checkpoint_during=True
+                "sync" means checkpoints are persisted sync after graph step executes, replaces checkpoint_during=False
+                "exit" means checkpoints are only persisted when the run exits, does not save intermediate steps
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            The cron run.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost:2024")
+            cron_run = await client.crons.create_for_thread(
+                thread_id="my-thread-id",
+                assistant_id="agent",
+                schedule="27 15 * * *",
+                input={"messages": [{"role": "user", "content": "hello!"}]},
+                metadata={"name":"my_run"},
+                context={"model_name": "openai"},
+                interrupt_before=["node_to_stop_before_1","node_to_stop_before_2"],
+                interrupt_after=["node_to_stop_after_1","node_to_stop_after_2"],
+                webhook="https://my.fake.webhook.com",
+                multitask_strategy="interrupt",
+                enabled=True,
+            )
+            ```
+        """
+        if checkpoint_during is not None:
+            warnings.warn(
+                "`checkpoint_during` is deprecated and will be removed in a future version. Use `durability` instead.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+
+        payload = {
+            "schedule": schedule,
+            "input": input,
+            "config": config,
+            "metadata": metadata,
+            "context": context,
+            "assistant_id": assistant_id,
+            "checkpoint_during": checkpoint_during,
+            "interrupt_before": interrupt_before,
+            "interrupt_after": interrupt_after,
+            "webhook": webhook,
+            "end_time": end_time.isoformat() if end_time else None,
+            "enabled": enabled,
+            "timezone": _resolve_timezone(timezone),
+            "stream_mode": stream_mode,
+            "stream_subgraphs": stream_subgraphs,
+            "stream_resumable": stream_resumable,
+            "durability": durability,
+        }
+        if multitask_strategy:
+            payload["multitask_strategy"] = multitask_strategy
+        payload = {k: v for k, v in payload.items() if v is not None}
+        return await self.http.post(
+            f"/threads/{thread_id}/runs/crons",
+            json=payload,
+            headers=headers,
+            params=params,
+        )
+
+    async def create(
+        self,
+        assistant_id: str,
+        *,
+        schedule: str,
+        input: Input | None = None,
+        metadata: Mapping[str, Any] | None = None,
+        config: Config | None = None,
+        context: Context | None = None,
+        checkpoint_during: bool | None = None,  # deprecated
+        interrupt_before: All | list[str] | None = None,
+        interrupt_after: All | list[str] | None = None,
+        webhook: str | None = None,
+        on_run_completed: OnCompletionBehavior | None = None,
+        multitask_strategy: str | None = None,
+        end_time: datetime | None = None,
+        enabled: bool | None = None,
+        timezone: str | tzinfo | None = None,
+        stream_mode: StreamMode | Sequence[StreamMode] | None = None,
+        stream_subgraphs: bool | None = None,
+        stream_resumable: bool | None = None,
+        durability: Durability | None = None,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> Run:
+        """Create a cron run.
+
+        Args:
+            assistant_id: The assistant ID or graph name to use for the cron job.
+                If using graph name, will default to first assistant created from that graph.
+            schedule: The cron schedule to execute this job on.
+                Schedules are interpreted in UTC unless a timezone is specified.
+            input: The input to the graph.
+            metadata: Metadata to assign to the cron job runs.
+            config: The configuration for the assistant.
+            context: Static context to add to the assistant.
+                !!! version-added "Added in version 0.6.0"
+            checkpoint_during: (deprecated) Whether to checkpoint during the run (or only at the end/interruption).
+            interrupt_before: Nodes to interrupt immediately before they get executed.
+            interrupt_after: Nodes to Nodes to interrupt immediately after they get executed.
+            webhook: Webhook to call after LangGraph API call is done.
+            on_run_completed: What to do with the thread after the run completes.
+                Must be one of 'delete' (default) or 'keep'. 'delete' removes the thread
+                after execution. 'keep' creates a new thread for each execution but does not
+                clean them up. Clients are responsible for cleaning up kept threads.
+            multitask_strategy: Multitask strategy to use.
+                Must be one of 'reject', 'interrupt', 'rollback', or 'enqueue'.
+            end_time: The time to stop running the cron job. If not provided, the cron job will run indefinitely.
+            enabled: Whether the cron job is enabled or not.
+            timezone: IANA timezone for the cron schedule. Accepts a string (e.g. 'America/New_York') or a ``datetime.tzinfo`` instance (e.g. ``ZoneInfo("America/New_York")``).
+            stream_mode: The stream mode(s) to use.
+            stream_subgraphs: Whether to stream output from subgraphs.
+            stream_resumable: Whether to persist the stream chunks in order to resume the stream later.
+            durability: Durability level for the run. Must be one of 'sync', 'async', or 'exit'.
+                "async" means checkpoints are persisted async while next graph step executes, replaces checkpoint_during=True
+                "sync" means checkpoints are persisted sync after graph step executes, replaces checkpoint_during=False
+                "exit" means checkpoints are only persisted when the run exits, does not save intermediate steps
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            The cron run.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost:2024")
+            cron_run = client.crons.create(
+                assistant_id="agent",
+                schedule="27 15 * * *",
+                input={"messages": [{"role": "user", "content": "hello!"}]},
+                metadata={"name":"my_run"},
+                context={"model_name": "openai"},
+                interrupt_before=["node_to_stop_before_1","node_to_stop_before_2"],
+                interrupt_after=["node_to_stop_after_1","node_to_stop_after_2"],
+                webhook="https://my.fake.webhook.com",
+                multitask_strategy="interrupt",
+                enabled=True,
+            )
+            ```
+
+        """
+        if checkpoint_during is not None:
+            warnings.warn(
+                "`checkpoint_during` is deprecated and will be removed in a future version. Use `durability` instead.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+
+        payload = {
+            "schedule": schedule,
+            "input": input,
+            "config": config,
+            "metadata": metadata,
+            "context": context,
+            "assistant_id": assistant_id,
+            "checkpoint_during": checkpoint_during,
+            "interrupt_before": interrupt_before,
+            "interrupt_after": interrupt_after,
+            "webhook": webhook,
+            "on_run_completed": on_run_completed,
+            "end_time": end_time.isoformat() if end_time else None,
+            "enabled": enabled,
+            "timezone": _resolve_timezone(timezone),
+            "stream_mode": stream_mode,
+            "stream_subgraphs": stream_subgraphs,
+            "stream_resumable": stream_resumable,
+            "durability": durability,
+        }
+        if multitask_strategy:
+            payload["multitask_strategy"] = multitask_strategy
+        payload = {k: v for k, v in payload.items() if v is not None}
+        return await self.http.post(
+            "/runs/crons", json=payload, headers=headers, params=params
+        )
+
+    async def delete(
+        self,
+        cron_id: str,
+        *,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> None:
+        """Delete a cron.
+
+        Args:
+            cron_id: The cron ID to delete.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            `None`
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost:2024")
+            await client.crons.delete(
+                cron_id="cron_to_delete"
+            )
+            ```
+
+        """
+        await self.http.delete(f"/runs/crons/{cron_id}", headers=headers, params=params)
+
+    async def update(
+        self,
+        cron_id: str,
+        *,
+        schedule: str | None = None,
+        end_time: datetime | None = None,
+        input: Input | None = None,
+        metadata: Mapping[str, Any] | None = None,
+        config: Config | None = None,
+        context: Context | None = None,
+        webhook: str | None = None,
+        interrupt_before: All | list[str] | None = None,
+        interrupt_after: All | list[str] | None = None,
+        on_run_completed: OnCompletionBehavior | None = None,
+        enabled: bool | None = None,
+        timezone: str | tzinfo | None = None,
+        stream_mode: StreamMode | Sequence[StreamMode] | None = None,
+        stream_subgraphs: bool | None = None,
+        stream_resumable: bool | None = None,
+        durability: Durability | None = None,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> Cron:
+        """Update a cron job by ID.
+
+        Args:
+            cron_id: The cron ID to update.
+            schedule: The cron schedule to execute this job on.
+                Schedules are interpreted in UTC unless a timezone is specified.
+            end_time: The end date to stop running the cron.
+            input: The input to the graph.
+            metadata: Metadata to assign to the cron job runs.
+            config: The configuration for the assistant.
+            context: Static context added to the assistant.
+            webhook: Webhook to call after LangGraph API call is done.
+            interrupt_before: Nodes to interrupt immediately before they get executed.
+            interrupt_after: Nodes to interrupt immediately after they get executed.
+            on_run_completed: What to do with the thread after the run completes.
+                Must be one of 'delete' or 'keep'. 'delete' removes the thread
+                after execution. 'keep' creates a new thread for each execution but does not
+                clean them up.
+            enabled: Enable or disable the cron job.
+            timezone: IANA timezone for the cron schedule. Accepts a string (e.g. 'America/New_York') or a ``datetime.tzinfo`` instance (e.g. ``ZoneInfo("America/New_York")``).
+            stream_mode: The stream mode(s) to use.
+            stream_subgraphs: Whether to stream output from subgraphs.
+            stream_resumable: Whether to persist the stream chunks in order to resume the stream later.
+            durability: Durability level for the run. Must be one of 'sync', 'async', or 'exit'.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            The updated cron job.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost:2024")
+            updated_cron = await client.crons.update(
+                cron_id="1ef3cefa-4c09-6926-96d0-3dc97fd5e39b",
+                schedule="0 10 * * *",
+                enabled=False,
+            )
+            ```
+
+        """
+        payload = {
+            "schedule": schedule,
+            "end_time": end_time.isoformat() if end_time else None,
+            "input": input,
+            "metadata": metadata,
+            "config": config,
+            "context": context,
+            "webhook": webhook,
+            "interrupt_before": interrupt_before,
+            "interrupt_after": interrupt_after,
+            "on_run_completed": on_run_completed,
+            "enabled": enabled,
+            "timezone": _resolve_timezone(timezone),
+            "stream_mode": stream_mode,
+            "stream_subgraphs": stream_subgraphs,
+            "stream_resumable": stream_resumable,
+            "durability": durability,
+        }
+        payload = {k: v for k, v in payload.items() if v is not None}
+        return await self.http.patch(
+            f"/runs/crons/{cron_id}",
+            json=payload,
+            headers=headers,
+            params=params,
+        )
+
+    async def search(
+        self,
+        *,
+        assistant_id: str | None = None,
+        thread_id: str | None = None,
+        enabled: bool | None = None,
+        limit: int = 10,
+        offset: int = 0,
+        sort_by: CronSortBy | None = None,
+        sort_order: SortOrder | None = None,
+        select: list[CronSelectField] | None = None,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> list[Cron]:
+        """Get a list of cron jobs.
+
+        Args:
+            assistant_id: The assistant ID or graph name to search for.
+            thread_id: the thread ID to search for.
+            enabled: The enabled status to search for.
+            limit: The maximum number of results to return.
+            offset: The number of results to skip.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            The list of cron jobs returned by the search,
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost:2024")
+            cron_jobs = await client.crons.search(
+                assistant_id="my_assistant_id",
+                thread_id="my_thread_id",
+                enabled=True,
+                limit=5,
+                offset=5,
+            )
+            print(cron_jobs)
+            ```
+            ```shell
+
+            ----------------------------------------------------------
+
+            [
+                {
+                    'cron_id': '1ef3cefa-4c09-6926-96d0-3dc97fd5e39b',
+                    'assistant_id': 'my_assistant_id',
+                    'thread_id': 'my_thread_id',
+                    'user_id': None,
+                    'payload':
+                        {
+                            'input': {'start_time': ''},
+                            'schedule': '4 * * * *',
+                            'assistant_id': 'my_assistant_id'
+                        },
+                    'schedule': '4 * * * *',
+                    'next_run_date': '2024-07-25T17:04:00+00:00',
+                    'end_time': None,
+                    'created_at': '2024-07-08T06:02:23.073257+00:00',
+                    'updated_at': '2024-07-08T06:02:23.073257+00:00'
+                }
+            ]
+            ```
+
+        """
+        payload: dict[str, Any] = {
+            "assistant_id": assistant_id,
+            "thread_id": thread_id,
+            "enabled": enabled,
+            "limit": limit,
+            "offset": offset,
+        }
+        if sort_by:
+            payload["sort_by"] = sort_by
+        if sort_order:
+            payload["sort_order"] = sort_order
+        if select:
+            payload["select"] = select
+        payload = {k: v for k, v in payload.items() if v is not None}
+        return await self.http.post(
+            "/runs/crons/search", json=payload, headers=headers, params=params
+        )
+
+    async def count(
+        self,
+        *,
+        assistant_id: str | None = None,
+        thread_id: str | None = None,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> int:
+        """Count cron jobs matching filters.
+
+        Args:
+            assistant_id: Assistant ID to filter by.
+            thread_id: Thread ID to filter by.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            int: Number of crons matching the criteria.
+        """
+        payload: dict[str, Any] = {}
+        if assistant_id:
+            payload["assistant_id"] = assistant_id
+        if thread_id:
+            payload["thread_id"] = thread_id
+        return await self.http.post(
+            "/runs/crons/count", json=payload, headers=headers, params=params
+        )

python/user_packages/Python313/site-packages/langgraph_sdk/_async/http.py

@@ -0,0 +1,312 @@
+"""HTTP client for async operations."""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import sys
+import warnings
+from collections.abc import AsyncIterator, Callable, Mapping
+from typing import Any, cast
+
+import httpx
+import orjson
+
+from langgraph_sdk._shared.utilities import (
+    _orjson_default,
+    _validate_reconnect_location,
+)
+from langgraph_sdk.errors import _araise_for_status_typed
+from langgraph_sdk.schema import QueryParamTypes, StreamPart
+from langgraph_sdk.sse import SSEDecoder, aiter_lines_raw
+
+logger = logging.getLogger(__name__)
+
+
+class HttpClient:
+    """Handle async requests to the LangGraph API.
+
+    Adds additional error messaging & content handling above the
+    provided httpx client.
+
+    Attributes:
+        client (httpx.AsyncClient): Underlying HTTPX async client.
+    """
+
+    def __init__(self, client: httpx.AsyncClient) -> None:
+        self.client = client
+
+    async def get(
+        self,
+        path: str,
+        *,
+        params: QueryParamTypes | None = None,
+        headers: Mapping[str, str] | None = None,
+        on_response: Callable[[httpx.Response], None] | None = None,
+    ) -> Any:
+        """Send a `GET` request."""
+        r = await self.client.get(path, params=params, headers=headers)
+        if on_response:
+            on_response(r)
+        await _araise_for_status_typed(r)
+        return await _adecode_json(r)
+
+    async def post(
+        self,
+        path: str,
+        *,
+        json: dict[str, Any] | list | None,
+        params: QueryParamTypes | None = None,
+        headers: Mapping[str, str] | None = None,
+        on_response: Callable[[httpx.Response], None] | None = None,
+    ) -> Any:
+        """Send a `POST` request."""
+        if json is not None:
+            request_headers, content = await _aencode_json(json)
+        else:
+            request_headers, content = {}, b""
+        # Merge headers, with runtime headers taking precedence
+        if headers:
+            request_headers.update(headers)
+        r = await self.client.post(
+            path, headers=request_headers, content=content, params=params
+        )
+        if on_response:
+            on_response(r)
+        await _araise_for_status_typed(r)
+        return await _adecode_json(r)
+
+    async def put(
+        self,
+        path: str,
+        *,
+        json: dict,
+        params: QueryParamTypes | None = None,
+        headers: Mapping[str, str] | None = None,
+        on_response: Callable[[httpx.Response], None] | None = None,
+    ) -> Any:
+        """Send a `PUT` request."""
+        request_headers, content = await _aencode_json(json)
+        if headers:
+            request_headers.update(headers)
+        r = await self.client.put(
+            path, headers=request_headers, content=content, params=params
+        )
+        if on_response:
+            on_response(r)
+        await _araise_for_status_typed(r)
+        return await _adecode_json(r)
+
+    async def patch(
+        self,
+        path: str,
+        *,
+        json: dict,
+        params: QueryParamTypes | None = None,
+        headers: Mapping[str, str] | None = None,
+        on_response: Callable[[httpx.Response], None] | None = None,
+    ) -> Any:
+        """Send a `PATCH` request."""
+        request_headers, content = await _aencode_json(json)
+        if headers:
+            request_headers.update(headers)
+        r = await self.client.patch(
+            path, headers=request_headers, content=content, params=params
+        )
+        if on_response:
+            on_response(r)
+        await _araise_for_status_typed(r)
+        return await _adecode_json(r)
+
+    async def delete(
+        self,
+        path: str,
+        *,
+        json: Any | None = None,
+        params: QueryParamTypes | None = None,
+        headers: Mapping[str, str] | None = None,
+        on_response: Callable[[httpx.Response], None] | None = None,
+    ) -> None:
+        """Send a `DELETE` request."""
+        r = await self.client.request(
+            "DELETE", path, json=json, params=params, headers=headers
+        )
+        if on_response:
+            on_response(r)
+        await _araise_for_status_typed(r)
+
+    async def request_reconnect(
+        self,
+        path: str,
+        method: str,
+        *,
+        json: dict[str, Any] | None = None,
+        params: QueryParamTypes | None = None,
+        headers: Mapping[str, str] | None = None,
+        on_response: Callable[[httpx.Response], None] | None = None,
+        reconnect_limit: int = 5,
+    ) -> Any:
+        """Send a request that automatically reconnects to Location header."""
+        request_headers, content = await _aencode_json(json)
+        if headers:
+            request_headers.update(headers)
+        async with self.client.stream(
+            method, path, headers=request_headers, content=content, params=params
+        ) as r:
+            if on_response:
+                on_response(r)
+            try:
+                r.raise_for_status()
+            except httpx.HTTPStatusError as e:
+                body = (await r.aread()).decode()
+                if sys.version_info >= (3, 11):
+                    e.add_note(body)
+                else:
+                    logger.error(f"Error from langgraph-api: {body}", exc_info=e)
+                raise e
+            loc = r.headers.get("location")
+            if reconnect_limit <= 0 or not loc:
+                return await _adecode_json(r)
+            _validate_reconnect_location(self.client.base_url, loc)
+            try:
+                return await _adecode_json(r)
+            except httpx.HTTPError:
+                warnings.warn(
+                    f"Request failed, attempting reconnect to Location: {loc}",
+                    stacklevel=2,
+                )
+                await r.aclose()
+                return await self.request_reconnect(
+                    loc,
+                    "GET",
+                    headers=request_headers,
+                    # don't pass on_response so it's only called once
+                    reconnect_limit=reconnect_limit - 1,
+                )
+
+    async def stream(
+        self,
+        path: str,
+        method: str,
+        *,
+        json: dict[str, Any] | None = None,
+        params: QueryParamTypes | None = None,
+        headers: Mapping[str, str] | None = None,
+        on_response: Callable[[httpx.Response], None] | None = None,
+    ) -> AsyncIterator[StreamPart]:
+        """Stream results using SSE."""
+        request_headers, content = await _aencode_json(json)
+        request_headers["Accept"] = "text/event-stream"
+        request_headers["Cache-Control"] = "no-store"
+        # Add runtime headers with precedence
+        if headers:
+            request_headers.update(headers)
+
+        reconnect_headers = {
+            key: value
+            for key, value in request_headers.items()
+            if key.lower() not in {"content-length", "content-type"}
+        }
+
+        last_event_id: str | None = None
+        reconnect_path: str | None = None
+        reconnect_attempts = 0
+        max_reconnect_attempts = 5
+
+        while True:
+            current_headers = dict(
+                request_headers if reconnect_path is None else reconnect_headers
+            )
+            if last_event_id is not None:
+                current_headers["Last-Event-ID"] = last_event_id
+
+            current_method = method if reconnect_path is None else "GET"
+            current_content = content if reconnect_path is None else None
+            current_params = params if reconnect_path is None else None
+
+            retry = False
+            async with self.client.stream(
+                current_method,
+                reconnect_path or path,
+                headers=current_headers,
+                content=current_content,
+                params=current_params,
+            ) as res:
+                if reconnect_path is None and on_response:
+                    on_response(res)
+                # check status
+                await _araise_for_status_typed(res)
+                # check content type
+                content_type = res.headers.get("content-type", "").partition(";")[0]
+                if "text/event-stream" not in content_type:
+                    raise httpx.TransportError(
+                        "Expected response header Content-Type to contain 'text/event-stream', "
+                        f"got {content_type!r}"
+                    )
+
+                reconnect_location = res.headers.get("location")
+                if reconnect_location:
+                    _validate_reconnect_location(
+                        self.client.base_url, reconnect_location
+                    )
+                    reconnect_path = reconnect_location
+
+                # parse SSE
+                decoder = SSEDecoder()
+                try:
+                    async for line in aiter_lines_raw(res):
+                        sse = decoder.decode(line=cast("bytes", line).rstrip(b"\n"))
+                        if sse is not None:
+                            if decoder.last_event_id is not None:
+                                last_event_id = decoder.last_event_id
+                            if sse.event or sse.data is not None:
+                                yield sse
+                except httpx.HTTPError:
+                    # httpx.TransportError inherits from HTTPError, so transient
+                    # disconnects during streaming land here.
+                    if reconnect_path is None:
+                        raise
+                    retry = True
+                else:
+                    if sse := decoder.decode(b""):
+                        if decoder.last_event_id is not None:
+                            last_event_id = decoder.last_event_id
+                        if sse.event or sse.data is not None:
+                            # decoder.decode(b"") flushes the in-flight event and may
+                            # return an empty placeholder when there is no pending
+                            # message. Skip these no-op events so the stream doesn't
+                            # emit a trailing blank item after reconnects.
+                            yield sse
+            if retry:
+                reconnect_attempts += 1
+                if reconnect_attempts > max_reconnect_attempts:
+                    raise httpx.TransportError(
+                        "Exceeded maximum SSE reconnection attempts"
+                    )
+                continue
+            break
+
+
+async def _aencode_json(json: Any) -> tuple[dict[str, str], bytes | None]:
+    if json is None:
+        return {}, None
+    body = await asyncio.get_running_loop().run_in_executor(
+        None,
+        orjson.dumps,
+        json,
+        _orjson_default,
+        orjson.OPT_SERIALIZE_NUMPY | orjson.OPT_NON_STR_KEYS,
+    )
+    content_length = str(len(body))
+    content_type = "application/json"
+    headers = {"Content-Length": content_length, "Content-Type": content_type}
+    return headers, body
+
+
+async def _adecode_json(r: httpx.Response) -> Any:
+    body = await r.aread()
+    return (
+        await asyncio.get_running_loop().run_in_executor(None, orjson.loads, body)
+        if body
+        else None
+    )

python/user_packages/Python313/site-packages/langgraph_sdk/_async/runs.py

@@ -0,0 +1,1181 @@
+"""Async client for managing runs in LangGraph."""
+
+from __future__ import annotations
+
+import builtins
+import warnings
+from collections.abc import AsyncIterator, Callable, Mapping, Sequence
+from typing import Any, Literal, overload
+
+import httpx
+
+from langgraph_sdk._async.http import HttpClient
+from langgraph_sdk._shared.utilities import (
+    _get_run_metadata_from_response,
+    _sse_to_v2_dict,
+)
+from langgraph_sdk.schema import (
+    All,
+    BulkCancelRunsStatus,
+    CancelAction,
+    Checkpoint,
+    Command,
+    Config,
+    Context,
+    DisconnectMode,
+    Durability,
+    IfNotExists,
+    Input,
+    LangSmithTracing,
+    MultitaskStrategy,
+    OnCompletionBehavior,
+    QueryParamTypes,
+    Run,
+    RunCreate,
+    RunCreateMetadata,
+    RunSelectField,
+    RunStatus,
+    StreamMode,
+    StreamPart,
+    StreamPartV2,
+    StreamVersion,
+)
+
+
+async def _wrap_stream_v2(
+    raw: AsyncIterator[StreamPart],
+) -> AsyncIterator[StreamPartV2]:
+    """Wrap a raw SSE stream, converting each event to a v2 dict."""
+    async for part in raw:
+        v2 = _sse_to_v2_dict(part.event, part.data)
+        if v2 is not None:
+            yield v2
+
+
+class RunsClient:
+    """Client for managing runs in LangGraph.
+
+    A run is a single assistant invocation with optional input, config, context, and metadata.
+    This client manages runs, which can be stateful (on threads) or stateless.
+
+    ???+ example "Example"
+
+        ```python
+        client = get_client(url="http://localhost:2024")
+        run = await client.runs.create(assistant_id="asst_123", thread_id="thread_456", input={"query": "Hello"})
+        ```
+    """
+
+    def __init__(self, http: HttpClient) -> None:
+        self.http = http
+
+    @overload
+    def stream(
+        self,
+        thread_id: str,
+        assistant_id: str,
+        *,
+        input: Input | None = None,
+        command: Command | None = None,
+        stream_mode: StreamMode | Sequence[StreamMode] = "values",
+        stream_subgraphs: bool = False,
+        stream_resumable: bool = False,
+        metadata: Mapping[str, Any] | None = None,
+        config: Config | None = None,
+        context: Context | None = None,
+        checkpoint: Checkpoint | None = None,
+        checkpoint_id: str | None = None,
+        checkpoint_during: bool | None = None,
+        interrupt_before: All | Sequence[str] | None = None,
+        interrupt_after: All | Sequence[str] | None = None,
+        feedback_keys: Sequence[str] | None = None,
+        on_disconnect: DisconnectMode | None = None,
+        webhook: str | None = None,
+        multitask_strategy: MultitaskStrategy | None = None,
+        if_not_exists: IfNotExists | None = None,
+        after_seconds: int | None = None,
+        langsmith_tracing: LangSmithTracing | None = None,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+        on_run_created: Callable[[RunCreateMetadata], None] | None = None,
+        version: Literal["v1"] = "v1",
+    ) -> AsyncIterator[StreamPart]: ...
+
+    @overload
+    def stream(
+        self,
+        thread_id: str,
+        assistant_id: str,
+        *,
+        input: Input | None = None,
+        command: Command | None = None,
+        stream_mode: StreamMode | Sequence[StreamMode] = "values",
+        stream_subgraphs: bool = False,
+        stream_resumable: bool = False,
+        metadata: Mapping[str, Any] | None = None,
+        config: Config | None = None,
+        context: Context | None = None,
+        checkpoint: Checkpoint | None = None,
+        checkpoint_id: str | None = None,
+        checkpoint_during: bool | None = None,
+        interrupt_before: All | Sequence[str] | None = None,
+        interrupt_after: All | Sequence[str] | None = None,
+        feedback_keys: Sequence[str] | None = None,
+        on_disconnect: DisconnectMode | None = None,
+        webhook: str | None = None,
+        multitask_strategy: MultitaskStrategy | None = None,
+        if_not_exists: IfNotExists | None = None,
+        after_seconds: int | None = None,
+        langsmith_tracing: LangSmithTracing | None = None,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+        on_run_created: Callable[[RunCreateMetadata], None] | None = None,
+        version: Literal["v2"],
+    ) -> AsyncIterator[StreamPartV2]: ...
+
+    @overload
+    def stream(
+        self,
+        thread_id: None,
+        assistant_id: str,
+        *,
+        input: Input | None = None,
+        command: Command | None = None,
+        stream_mode: StreamMode | Sequence[StreamMode] = "values",
+        stream_subgraphs: bool = False,
+        stream_resumable: bool = False,
+        metadata: Mapping[str, Any] | None = None,
+        config: Config | None = None,
+        checkpoint_during: bool | None = None,
+        interrupt_before: All | Sequence[str] | None = None,
+        interrupt_after: All | Sequence[str] | None = None,
+        feedback_keys: Sequence[str] | None = None,
+        on_disconnect: DisconnectMode | None = None,
+        on_completion: OnCompletionBehavior | None = None,
+        if_not_exists: IfNotExists | None = None,
+        webhook: str | None = None,
+        after_seconds: int | None = None,
+        langsmith_tracing: LangSmithTracing | None = None,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+        on_run_created: Callable[[RunCreateMetadata], None] | None = None,
+        version: Literal["v1"] = "v1",
+    ) -> AsyncIterator[StreamPart]: ...
+
+    @overload
+    def stream(
+        self,
+        thread_id: None,
+        assistant_id: str,
+        *,
+        input: Input | None = None,
+        command: Command | None = None,
+        stream_mode: StreamMode | Sequence[StreamMode] = "values",
+        stream_subgraphs: bool = False,
+        stream_resumable: bool = False,
+        metadata: Mapping[str, Any] | None = None,
+        config: Config | None = None,
+        checkpoint_during: bool | None = None,
+        interrupt_before: All | Sequence[str] | None = None,
+        interrupt_after: All | Sequence[str] | None = None,
+        feedback_keys: Sequence[str] | None = None,
+        on_disconnect: DisconnectMode | None = None,
+        on_completion: OnCompletionBehavior | None = None,
+        if_not_exists: IfNotExists | None = None,
+        webhook: str | None = None,
+        after_seconds: int | None = None,
+        langsmith_tracing: LangSmithTracing | None = None,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+        on_run_created: Callable[[RunCreateMetadata], None] | None = None,
+        version: Literal["v2"],
+    ) -> AsyncIterator[StreamPartV2]: ...
+
+    def stream(
+        self,
+        thread_id: str | None,
+        assistant_id: str,
+        *,
+        input: Input | None = None,
+        command: Command | None = None,
+        stream_mode: StreamMode | Sequence[StreamMode] = "values",
+        stream_subgraphs: bool = False,
+        stream_resumable: bool = False,
+        metadata: Mapping[str, Any] | None = None,
+        config: Config | None = None,
+        context: Context | None = None,
+        checkpoint: Checkpoint | None = None,
+        checkpoint_id: str | None = None,
+        checkpoint_during: bool | None = None,  # deprecated
+        interrupt_before: All | Sequence[str] | None = None,
+        interrupt_after: All | Sequence[str] | None = None,
+        feedback_keys: Sequence[str] | None = None,
+        on_disconnect: DisconnectMode | None = None,
+        on_completion: OnCompletionBehavior | None = None,
+        webhook: str | None = None,
+        multitask_strategy: MultitaskStrategy | None = None,
+        if_not_exists: IfNotExists | None = None,
+        after_seconds: int | None = None,
+        langsmith_tracing: LangSmithTracing | None = None,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+        on_run_created: Callable[[RunCreateMetadata], None] | None = None,
+        durability: Durability | None = None,
+        version: StreamVersion = "v1",
+    ) -> AsyncIterator[StreamPart | StreamPartV2]:
+        """Create a run and stream the results.
+
+        Args:
+            thread_id: the thread ID to assign to the thread.
+                If `None` will create a stateless run.
+            assistant_id: The assistant ID or graph name to stream from.
+                If using graph name, will default to first assistant created from that graph.
+            input: The input to the graph.
+            command: A command to execute. Cannot be combined with input.
+            stream_mode: The stream mode(s) to use.
+            stream_subgraphs: Whether to stream output from subgraphs.
+            stream_resumable: Whether the stream is considered resumable.
+                If true, the stream can be resumed and replayed in its entirety even after disconnection.
+            metadata: Metadata to assign to the run.
+            config: The configuration for the assistant.
+            context: Static context to add to the assistant.
+                !!! version-added "Added in version 0.6.0"
+            checkpoint: The checkpoint to resume from.
+            checkpoint_during: (deprecated) Whether to checkpoint during the run (or only at the end/interruption).
+            interrupt_before: Nodes to interrupt immediately before they get executed.
+            interrupt_after: Nodes to Nodes to interrupt immediately after they get executed.
+            feedback_keys: Feedback keys to assign to run.
+            on_disconnect: The disconnect mode to use.
+                Must be one of 'cancel' or 'continue'.
+            on_completion: Whether to delete or keep the thread created for a stateless run.
+                Must be one of 'delete' or 'keep'.
+            webhook: Webhook to call after LangGraph API call is done.
+            multitask_strategy: Multitask strategy to use.
+                Must be one of 'reject', 'interrupt', 'rollback', or 'enqueue'.
+            if_not_exists: How to handle missing thread. Defaults to 'reject'.
+                Must be either 'reject' (raise error if missing), or 'create' (create new thread).
+            after_seconds: The number of seconds to wait before starting the run.
+                Use to schedule future runs.
+            langsmith_tracing: LangSmith tracing configuration. Allows routing traces
+                to a specific project or associating with a dataset example.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+            on_run_created: Callback when a run is created.
+            durability: The durability to use for the run. Values are "sync", "async", or "exit".
+                "async" means checkpoints are persisted async while next graph step executes, replaces checkpoint_during=True
+                "sync" means checkpoints are persisted sync after graph step executes, replaces checkpoint_during=False
+                "exit" means checkpoints are only persisted when the run exits, does not save intermediate steps
+            version: Stream format version. "v1" (default) returns raw SSE StreamPart
+                NamedTuples. "v2" returns typed dicts with `type`, `ns`, and `data` keys.
+
+        Returns:
+            Asynchronous iterator of stream results.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost:2024)
+            async for chunk in client.runs.stream(
+                thread_id=None,
+                assistant_id="agent",
+                input={"messages": [{"role": "user", "content": "how are you?"}]},
+                stream_mode=["values","debug"],
+                metadata={"name":"my_run"},
+                context={"model_name": "anthropic"},
+                interrupt_before=["node_to_stop_before_1","node_to_stop_before_2"],
+                interrupt_after=["node_to_stop_after_1","node_to_stop_after_2"],
+                feedback_keys=["my_feedback_key_1","my_feedback_key_2"],
+                webhook="https://my.fake.webhook.com",
+                multitask_strategy="interrupt"
+            ):
+                print(chunk)
+            ```
+
+            ```shell
+
+            ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+            StreamPart(event='metadata', data={'run_id': '1ef4a9b8-d7da-679a-a45a-872054341df2'})
+            StreamPart(event='values', data={'messages': [{'content': 'how are you?', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': 'fe0a5778-cfe9-42ee-b807-0adaa1873c10', 'example': False}]})
+            StreamPart(event='values', data={'messages': [{'content': 'how are you?', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': 'fe0a5778-cfe9-42ee-b807-0adaa1873c10', 'example': False}, {'content': "I'm doing well, thanks for asking! I'm an AI assistant created by Anthropic to be helpful, honest, and harmless.", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-159b782c-b679-4830-83c6-cef87798fe8b', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}]})
+            StreamPart(event='end', data=None)
+            ```
+
+        """
+        if checkpoint_during is not None:
+            warnings.warn(
+                "`checkpoint_during` is deprecated and will be removed in a future version. Use `durability` instead.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+
+        payload: dict[str, Any] = {
+            "input": input,
+            "command": (
+                {k: v for k, v in command.items() if v is not None} if command else None
+            ),
+            "config": config,
+            "context": context,
+            "metadata": metadata,
+            "stream_mode": stream_mode,
+            "stream_subgraphs": stream_subgraphs,
+            "stream_resumable": stream_resumable,
+            "assistant_id": assistant_id,
+            "interrupt_before": interrupt_before,
+            "interrupt_after": interrupt_after,
+            "feedback_keys": feedback_keys,
+            "webhook": webhook,
+            "checkpoint": checkpoint,
+            "checkpoint_id": checkpoint_id,
+            "checkpoint_during": checkpoint_during,
+            "multitask_strategy": multitask_strategy,
+            "if_not_exists": if_not_exists,
+            "on_disconnect": on_disconnect,
+            "on_completion": on_completion,
+            "after_seconds": after_seconds,
+            "durability": durability,
+            "langsmith_tracer": langsmith_tracing,
+        }
+        endpoint = (
+            f"/threads/{thread_id}/runs/stream"
+            if thread_id is not None
+            else "/runs/stream"
+        )
+
+        def on_response(res: httpx.Response):
+            """Callback function to handle the response."""
+            if on_run_created and (metadata := _get_run_metadata_from_response(res)):
+                on_run_created(metadata)
+
+        raw = self.http.stream(
+            endpoint,
+            "POST",
+            json={k: v for k, v in payload.items() if v is not None},
+            params=params,
+            headers=headers,
+            on_response=on_response if on_run_created else None,
+        )
+        if version == "v2":
+            return _wrap_stream_v2(raw)
+        return raw
+
+    @overload
+    async def create(
+        self,
+        thread_id: None,
+        assistant_id: str,
+        *,
+        input: Input | None = None,
+        command: Command | None = None,
+        stream_mode: StreamMode | Sequence[StreamMode] = "values",
+        stream_subgraphs: bool = False,
+        stream_resumable: bool = False,
+        metadata: Mapping[str, Any] | None = None,
+        checkpoint_during: bool | None = None,
+        config: Config | None = None,
+        context: Context | None = None,
+        interrupt_before: All | Sequence[str] | None = None,
+        interrupt_after: All | Sequence[str] | None = None,
+        webhook: str | None = None,
+        on_completion: OnCompletionBehavior | None = None,
+        if_not_exists: IfNotExists | None = None,
+        after_seconds: int | None = None,
+        langsmith_tracing: LangSmithTracing | None = None,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+        on_run_created: Callable[[RunCreateMetadata], None] | None = None,
+    ) -> Run: ...
+
+    @overload
+    async def create(
+        self,
+        thread_id: str,
+        assistant_id: str,
+        *,
+        input: Input | None = None,
+        command: Command | None = None,
+        stream_mode: StreamMode | Sequence[StreamMode] = "values",
+        stream_subgraphs: bool = False,
+        stream_resumable: bool = False,
+        metadata: Mapping[str, Any] | None = None,
+        config: Config | None = None,
+        context: Context | None = None,
+        checkpoint: Checkpoint | None = None,
+        checkpoint_id: str | None = None,
+        checkpoint_during: bool | None = None,
+        interrupt_before: All | Sequence[str] | None = None,
+        interrupt_after: All | Sequence[str] | None = None,
+        webhook: str | None = None,
+        multitask_strategy: MultitaskStrategy | None = None,
+        if_not_exists: IfNotExists | None = None,
+        after_seconds: int | None = None,
+        langsmith_tracing: LangSmithTracing | None = None,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+        on_run_created: Callable[[RunCreateMetadata], None] | None = None,
+    ) -> Run: ...
+
+    async def create(
+        self,
+        thread_id: str | None,
+        assistant_id: str,
+        *,
+        input: Input | None = None,
+        command: Command | None = None,
+        stream_mode: StreamMode | Sequence[StreamMode] = "values",
+        stream_subgraphs: bool = False,
+        stream_resumable: bool = False,
+        metadata: Mapping[str, Any] | None = None,
+        config: Config | None = None,
+        context: Context | None = None,
+        checkpoint: Checkpoint | None = None,
+        checkpoint_id: str | None = None,
+        checkpoint_during: bool | None = None,  # deprecated
+        interrupt_before: All | Sequence[str] | None = None,
+        interrupt_after: All | Sequence[str] | None = None,
+        webhook: str | None = None,
+        multitask_strategy: MultitaskStrategy | None = None,
+        if_not_exists: IfNotExists | None = None,
+        on_completion: OnCompletionBehavior | None = None,
+        after_seconds: int | None = None,
+        langsmith_tracing: LangSmithTracing | None = None,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+        on_run_created: Callable[[RunCreateMetadata], None] | None = None,
+        durability: Durability | None = None,
+    ) -> Run:
+        """Create a background run.
+
+        Args:
+            thread_id: the thread ID to assign to the thread.
+                If `None` will create a stateless run.
+            assistant_id: The assistant ID or graph name to stream from.
+                If using graph name, will default to first assistant created from that graph.
+            input: The input to the graph.
+            command: A command to execute. Cannot be combined with input.
+            stream_mode: The stream mode(s) to use.
+            stream_subgraphs: Whether to stream output from subgraphs.
+            stream_resumable: Whether the stream is considered resumable.
+                If true, the stream can be resumed and replayed in its entirety even after disconnection.
+            metadata: Metadata to assign to the run.
+            config: The configuration for the assistant.
+            context: Static context to add to the assistant.
+                !!! version-added "Added in version 0.6.0"
+            checkpoint: The checkpoint to resume from.
+            checkpoint_during: (deprecated) Whether to checkpoint during the run (or only at the end/interruption).
+            interrupt_before: Nodes to interrupt immediately before they get executed.
+            interrupt_after: Nodes to Nodes to interrupt immediately after they get executed.
+            webhook: Webhook to call after LangGraph API call is done.
+            multitask_strategy: Multitask strategy to use.
+                Must be one of 'reject', 'interrupt', 'rollback', or 'enqueue'.
+            on_completion: Whether to delete or keep the thread created for a stateless run.
+                Must be one of 'delete' or 'keep'.
+            if_not_exists: How to handle missing thread. Defaults to 'reject'.
+                Must be either 'reject' (raise error if missing), or 'create' (create new thread).
+            after_seconds: The number of seconds to wait before starting the run.
+                Use to schedule future runs.
+            langsmith_tracing: LangSmith tracing configuration. Allows routing traces
+                to a specific project or associating with a dataset example.
+            headers: Optional custom headers to include with the request.
+            on_run_created: Optional callback to call when a run is created.
+            durability: The durability to use for the run. Values are "sync", "async", or "exit".
+                "async" means checkpoints are persisted async while next graph step executes, replaces checkpoint_during=True
+                "sync" means checkpoints are persisted sync after graph step executes, replaces checkpoint_during=False
+                "exit" means checkpoints are only persisted when the run exits, does not save intermediate steps
+
+        Returns:
+            The created background run.
+
+        ???+ example "Example Usage"
+
+            ```python
+
+            background_run = await client.runs.create(
+                thread_id="my_thread_id",
+                assistant_id="my_assistant_id",
+                input={"messages": [{"role": "user", "content": "hello!"}]},
+                metadata={"name":"my_run"},
+                context={"model_name": "openai"},
+                interrupt_before=["node_to_stop_before_1","node_to_stop_before_2"],
+                interrupt_after=["node_to_stop_after_1","node_to_stop_after_2"],
+                webhook="https://my.fake.webhook.com",
+                multitask_strategy="interrupt"
+            )
+            print(background_run)
+            ```
+
+            ```shell
+            --------------------------------------------------------------------------------
+
+            {
+                'run_id': 'my_run_id',
+                'thread_id': 'my_thread_id',
+                'assistant_id': 'my_assistant_id',
+                'created_at': '2024-07-25T15:35:42.598503+00:00',
+                'updated_at': '2024-07-25T15:35:42.598503+00:00',
+                'metadata': {},
+                'status': 'pending',
+                'kwargs':
+                    {
+                        'input':
+                            {
+                                'messages': [
+                                    {
+                                        'role': 'user',
+                                        'content': 'how are you?'
+                                    }
+                                ]
+                            },
+                        'config':
+                            {
+                                'metadata':
+                                    {
+                                        'created_by': 'system'
+                                    },
+                                'configurable':
+                                    {
+                                        'run_id': 'my_run_id',
+                                        'user_id': None,
+                                        'graph_id': 'agent',
+                                        'thread_id': 'my_thread_id',
+                                        'checkpoint_id': None,
+                                        'assistant_id': 'my_assistant_id'
+                                    },
+                            },
+                        'context':
+                            {
+                                'model_name': 'openai'
+                            }
+                        'webhook': "https://my.fake.webhook.com",
+                        'temporary': False,
+                        'stream_mode': ['values'],
+                        'feedback_keys': None,
+                        'interrupt_after': ["node_to_stop_after_1","node_to_stop_after_2"],
+                        'interrupt_before': ["node_to_stop_before_1","node_to_stop_before_2"]
+                    },
+                'multitask_strategy': 'interrupt'
+            }
+            ```
+        """
+        if checkpoint_during is not None:
+            warnings.warn(
+                "`checkpoint_during` is deprecated and will be removed in a future version. Use `durability` instead.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+        payload = {
+            "input": input,
+            "command": (
+                {k: v for k, v in command.items() if v is not None} if command else None
+            ),
+            "stream_mode": stream_mode,
+            "stream_subgraphs": stream_subgraphs,
+            "stream_resumable": stream_resumable,
+            "config": config,
+            "context": context,
+            "metadata": metadata,
+            "assistant_id": assistant_id,
+            "interrupt_before": interrupt_before,
+            "interrupt_after": interrupt_after,
+            "webhook": webhook,
+            "checkpoint": checkpoint,
+            "checkpoint_id": checkpoint_id,
+            "checkpoint_during": checkpoint_during,
+            "multitask_strategy": multitask_strategy,
+            "if_not_exists": if_not_exists,
+            "on_completion": on_completion,
+            "after_seconds": after_seconds,
+            "durability": durability,
+            "langsmith_tracer": langsmith_tracing,
+        }
+        payload = {k: v for k, v in payload.items() if v is not None}
+
+        def on_response(res: httpx.Response):
+            """Callback function to handle the response."""
+            if on_run_created and (metadata := _get_run_metadata_from_response(res)):
+                on_run_created(metadata)
+
+        return await self.http.post(
+            f"/threads/{thread_id}/runs" if thread_id else "/runs",
+            json=payload,
+            params=params,
+            headers=headers,
+            on_response=on_response if on_run_created else None,
+        )
+
+    async def create_batch(
+        self,
+        payloads: builtins.list[RunCreate],
+        *,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> builtins.list[Run]:
+        """Create a batch of stateless background runs."""
+
+        def filter_payload(payload: RunCreate):
+            return {k: v for k, v in payload.items() if v is not None}
+
+        filtered = [filter_payload(payload) for payload in payloads]
+        return await self.http.post(
+            "/runs/batch", json=filtered, headers=headers, params=params
+        )
+
+    @overload
+    async def wait(
+        self,
+        thread_id: str,
+        assistant_id: str,
+        *,
+        input: Input | None = None,
+        command: Command | None = None,
+        metadata: Mapping[str, Any] | None = None,
+        config: Config | None = None,
+        context: Context | None = None,
+        checkpoint: Checkpoint | None = None,
+        checkpoint_id: str | None = None,
+        checkpoint_during: bool | None = None,
+        interrupt_before: All | Sequence[str] | None = None,
+        interrupt_after: All | Sequence[str] | None = None,
+        webhook: str | None = None,
+        on_disconnect: DisconnectMode | None = None,
+        multitask_strategy: MultitaskStrategy | None = None,
+        if_not_exists: IfNotExists | None = None,
+        after_seconds: int | None = None,
+        langsmith_tracing: LangSmithTracing | None = None,
+        raise_error: bool = True,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+        on_run_created: Callable[[RunCreateMetadata], None] | None = None,
+    ) -> builtins.list[dict] | dict[str, Any]: ...
+
+    @overload
+    async def wait(
+        self,
+        thread_id: None,
+        assistant_id: str,
+        *,
+        input: Input | None = None,
+        command: Command | None = None,
+        metadata: Mapping[str, Any] | None = None,
+        config: Config | None = None,
+        context: Context | None = None,
+        checkpoint_during: bool | None = None,
+        interrupt_before: All | Sequence[str] | None = None,
+        interrupt_after: All | Sequence[str] | None = None,
+        webhook: str | None = None,
+        on_disconnect: DisconnectMode | None = None,
+        on_completion: OnCompletionBehavior | None = None,
+        if_not_exists: IfNotExists | None = None,
+        after_seconds: int | None = None,
+        langsmith_tracing: LangSmithTracing | None = None,
+        raise_error: bool = True,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+        on_run_created: Callable[[RunCreateMetadata], None] | None = None,
+    ) -> builtins.list[dict] | dict[str, Any]: ...
+
+    async def wait(
+        self,
+        thread_id: str | None,
+        assistant_id: str,
+        *,
+        input: Input | None = None,
+        command: Command | None = None,
+        metadata: Mapping[str, Any] | None = None,
+        config: Config | None = None,
+        context: Context | None = None,
+        checkpoint: Checkpoint | None = None,
+        checkpoint_id: str | None = None,
+        checkpoint_during: bool | None = None,  # deprecated
+        interrupt_before: All | Sequence[str] | None = None,
+        interrupt_after: All | Sequence[str] | None = None,
+        webhook: str | None = None,
+        on_disconnect: DisconnectMode | None = None,
+        on_completion: OnCompletionBehavior | None = None,
+        multitask_strategy: MultitaskStrategy | None = None,
+        if_not_exists: IfNotExists | None = None,
+        after_seconds: int | None = None,
+        langsmith_tracing: LangSmithTracing | None = None,
+        raise_error: bool = True,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+        on_run_created: Callable[[RunCreateMetadata], None] | None = None,
+        durability: Durability | None = None,
+    ) -> builtins.list[dict] | dict[str, Any]:
+        """Create a run, wait until it finishes and return the final state.
+
+        Args:
+            thread_id: the thread ID to create the run on.
+                If `None` will create a stateless run.
+            assistant_id: The assistant ID or graph name to run.
+                If using graph name, will default to first assistant created from that graph.
+            input: The input to the graph.
+            command: A command to execute. Cannot be combined with input.
+            metadata: Metadata to assign to the run.
+            config: The configuration for the assistant.
+            context: Static context to add to the assistant.
+                !!! version-added "Added in version 0.6.0"
+            checkpoint: The checkpoint to resume from.
+            checkpoint_during: (deprecated) Whether to checkpoint during the run (or only at the end/interruption).
+            interrupt_before: Nodes to interrupt immediately before they get executed.
+            interrupt_after: Nodes to Nodes to interrupt immediately after they get executed.
+            webhook: Webhook to call after LangGraph API call is done.
+            on_disconnect: The disconnect mode to use.
+                Must be one of 'cancel' or 'continue'.
+            on_completion: Whether to delete or keep the thread created for a stateless run.
+                Must be one of 'delete' or 'keep'.
+            multitask_strategy: Multitask strategy to use.
+                Must be one of 'reject', 'interrupt', 'rollback', or 'enqueue'.
+            if_not_exists: How to handle missing thread. Defaults to 'reject'.
+                Must be either 'reject' (raise error if missing), or 'create' (create new thread).
+            after_seconds: The number of seconds to wait before starting the run.
+                Use to schedule future runs.
+            langsmith_tracing: LangSmith tracing configuration. Allows routing traces
+                to a specific project or associating with a dataset example.
+            headers: Optional custom headers to include with the request.
+            on_run_created: Optional callback to call when a run is created.
+            durability: The durability to use for the run. Values are "sync", "async", or "exit".
+                "async" means checkpoints are persisted async while next graph step executes, replaces checkpoint_during=True
+                "sync" means checkpoints are persisted sync after graph step executes, replaces checkpoint_during=False
+                "exit" means checkpoints are only persisted when the run exits, does not save intermediate steps
+
+        Returns:
+            The output of the run.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost:2024")
+            final_state_of_run = await client.runs.wait(
+                thread_id=None,
+                assistant_id="agent",
+                input={"messages": [{"role": "user", "content": "how are you?"}]},
+                metadata={"name":"my_run"},
+                context={"model_name": "anthropic"},
+                interrupt_before=["node_to_stop_before_1","node_to_stop_before_2"],
+                interrupt_after=["node_to_stop_after_1","node_to_stop_after_2"],
+                webhook="https://my.fake.webhook.com",
+                multitask_strategy="interrupt"
+            )
+            print(final_state_of_run)
+            ```
+
+            ```shell
+            -------------------------------------------------------------------------------------------------------------------------------------------
+
+            {
+                'messages': [
+                    {
+                        'content': 'how are you?',
+                        'additional_kwargs': {},
+                        'response_metadata': {},
+                        'type': 'human',
+                        'name': None,
+                        'id': 'f51a862c-62fe-4866-863b-b0863e8ad78a',
+                        'example': False
+                    },
+                    {
+                        'content': "I'm doing well, thanks for asking! I'm an AI assistant created by Anthropic to be helpful, honest, and harmless.",
+                        'additional_kwargs': {},
+                        'response_metadata': {},
+                        'type': 'ai',
+                        'name': None,
+                        'id': 'run-bf1cd3c6-768f-4c16-b62d-ba6f17ad8b36',
+                        'example': False,
+                        'tool_calls': [],
+                        'invalid_tool_calls': [],
+                        'usage_metadata': None
+                    }
+                ]
+            }
+            ```
+
+        """
+        if checkpoint_during is not None:
+            warnings.warn(
+                "`checkpoint_during` is deprecated and will be removed in a future version. Use `durability` instead.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+        payload = {
+            "input": input,
+            "command": (
+                {k: v for k, v in command.items() if v is not None} if command else None
+            ),
+            "config": config,
+            "context": context,
+            "metadata": metadata,
+            "assistant_id": assistant_id,
+            "interrupt_before": interrupt_before,
+            "interrupt_after": interrupt_after,
+            "webhook": webhook,
+            "checkpoint": checkpoint,
+            "checkpoint_id": checkpoint_id,
+            "multitask_strategy": multitask_strategy,
+            "checkpoint_during": checkpoint_during,
+            "if_not_exists": if_not_exists,
+            "on_disconnect": on_disconnect,
+            "on_completion": on_completion,
+            "after_seconds": after_seconds,
+            "durability": durability,
+            "langsmith_tracer": langsmith_tracing,
+        }
+        endpoint = (
+            f"/threads/{thread_id}/runs/wait" if thread_id is not None else "/runs/wait"
+        )
+
+        def on_response(res: httpx.Response):
+            """Callback function to handle the response."""
+            if on_run_created and (metadata := _get_run_metadata_from_response(res)):
+                on_run_created(metadata)
+
+        response = await self.http.request_reconnect(
+            endpoint,
+            "POST",
+            json={k: v for k, v in payload.items() if v is not None},
+            params=params,
+            headers=headers,
+            on_response=on_response if on_run_created else None,
+        )
+        if (
+            raise_error
+            and isinstance(response, dict)
+            and "__error__" in response
+            and isinstance(response["__error__"], dict)
+        ):
+            raise Exception(
+                f"{response['__error__'].get('error')}: {response['__error__'].get('message')}"
+            )
+        return response
+
+    async def list(
+        self,
+        thread_id: str,
+        *,
+        limit: int = 10,
+        offset: int = 0,
+        status: RunStatus | None = None,
+        select: builtins.list[RunSelectField] | None = None,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> builtins.list[Run]:
+        """List runs.
+
+        Args:
+            thread_id: The thread ID to list runs for.
+            limit: The maximum number of results to return.
+            offset: The number of results to skip.
+            status: The status of the run to filter by.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            The runs for the thread.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost:2024")
+            await client.runs.list(
+                thread_id="thread_id",
+                limit=5,
+                offset=5,
+            )
+            ```
+
+        """
+        query_params: dict[str, Any] = {
+            "limit": limit,
+            "offset": offset,
+        }
+        if status is not None:
+            query_params["status"] = status
+        if select:
+            query_params["select"] = select
+        if params:
+            query_params.update(params)
+        return await self.http.get(
+            f"/threads/{thread_id}/runs", params=query_params, headers=headers
+        )
+
+    async def get(
+        self,
+        thread_id: str,
+        run_id: str,
+        *,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> Run:
+        """Get a run.
+
+        Args:
+            thread_id: The thread ID to get.
+            run_id: The run ID to get.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            `Run` object.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost:2024")
+            run = await client.runs.get(
+                thread_id="thread_id_to_delete",
+                run_id="run_id_to_delete",
+            )
+            ```
+
+        """
+
+        return await self.http.get(
+            f"/threads/{thread_id}/runs/{run_id}", headers=headers, params=params
+        )
+
+    async def cancel(
+        self,
+        thread_id: str,
+        run_id: str,
+        *,
+        wait: bool = False,
+        action: CancelAction = "interrupt",
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> None:
+        """Get a run.
+
+        Args:
+            thread_id: The thread ID to cancel.
+            run_id: The run ID to cancel.
+            wait: Whether to wait until run has completed.
+            action: Action to take when cancelling the run. Possible values
+                are `interrupt` or `rollback`. Default is `interrupt`.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            `None`
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost:2024")
+            await client.runs.cancel(
+                thread_id="thread_id_to_cancel",
+                run_id="run_id_to_cancel",
+                wait=True,
+                action="interrupt"
+            )
+            ```
+
+        """
+        query_params = {
+            "wait": 1 if wait else 0,
+            "action": action,
+        }
+        if params:
+            query_params.update(params)
+        if wait:
+            return await self.http.request_reconnect(
+                f"/threads/{thread_id}/runs/{run_id}/cancel",
+                "POST",
+                params=query_params,
+                headers=headers,
+            )
+        else:
+            return await self.http.post(
+                f"/threads/{thread_id}/runs/{run_id}/cancel",
+                json=None,
+                params=query_params,
+                headers=headers,
+            )
+
+    async def cancel_many(
+        self,
+        *,
+        thread_id: str | None = None,
+        run_ids: Sequence[str] | None = None,
+        status: BulkCancelRunsStatus | None = None,
+        action: CancelAction = "interrupt",
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> None:
+        """Cancel one or more runs.
+
+        Can cancel runs by thread ID and run IDs, or by status filter.
+
+        Args:
+            thread_id: The ID of the thread containing runs to cancel.
+            run_ids: List of run IDs to cancel.
+            status: Filter runs by status to cancel. Must be one of
+                `"pending"`, `"running"`, or `"all"`.
+            action: Action to take when cancelling the run. Possible values
+                are `"interrupt"` or `"rollback"`. Default is `"interrupt"`.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            `None`
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost:2024")
+            # Cancel all pending runs
+            await client.runs.cancel_many(status="pending")
+            # Cancel specific runs on a thread
+            await client.runs.cancel_many(
+                thread_id="my_thread_id",
+                run_ids=["run_1", "run_2"],
+                action="rollback",
+            )
+            ```
+
+        """
+        payload: dict[str, Any] = {}
+        if thread_id:
+            payload["thread_id"] = thread_id
+        if run_ids:
+            payload["run_ids"] = run_ids
+        if status:
+            payload["status"] = status
+        query_params: dict[str, Any] = {"action": action}
+        if params:
+            query_params.update(params)
+        await self.http.post(
+            "/runs/cancel",
+            json=payload,
+            headers=headers,
+            params=query_params,
+        )
+
+    async def join(
+        self,
+        thread_id: str,
+        run_id: str,
+        *,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> dict:
+        """Block until a run is done. Returns the final state of the thread.
+
+        Args:
+            thread_id: The thread ID to join.
+            run_id: The run ID to join.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            `None`
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost:2024")
+            result =await client.runs.join(
+                thread_id="thread_id_to_join",
+                run_id="run_id_to_join"
+            )
+            ```
+
+        """
+        return await self.http.request_reconnect(
+            f"/threads/{thread_id}/runs/{run_id}/join",
+            "GET",
+            headers=headers,
+            params=params,
+        )
+
+    def join_stream(
+        self,
+        thread_id: str,
+        run_id: str,
+        *,
+        cancel_on_disconnect: bool = False,
+        stream_mode: StreamMode | Sequence[StreamMode] | None = None,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+        last_event_id: str | None = None,
+    ) -> AsyncIterator[StreamPart]:
+        """Stream output from a run in real-time, until the run is done.
+        Output is not buffered, so any output produced before this call will
+        not be received here.
+
+        Args:
+            thread_id: The thread ID to join.
+            run_id: The run ID to join.
+            cancel_on_disconnect: Whether to cancel the run when the stream is disconnected.
+            stream_mode: The stream mode(s) to use. Must be a subset of the stream modes passed
+                when creating the run. Background runs default to having the union of all
+                stream modes.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+            last_event_id: The last event ID to use for the stream.
+
+        Returns:
+            The stream of parts.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost:2024")
+            async for part in client.runs.join_stream(
+                thread_id="thread_id_to_join",
+                run_id="run_id_to_join",
+                stream_mode=["values", "debug"]
+            ):
+                print(part)
+            ```
+
+        """
+        query_params = {
+            "cancel_on_disconnect": cancel_on_disconnect,
+            "stream_mode": stream_mode,
+        }
+        if params:
+            query_params.update(params)
+        return self.http.stream(
+            f"/threads/{thread_id}/runs/{run_id}/stream",
+            "GET",
+            params=query_params,
+            headers={
+                **({"Last-Event-ID": last_event_id} if last_event_id else {}),
+                **(headers or {}),
+            }
+            or None,
+        )
+
+    async def delete(
+        self,
+        thread_id: str,
+        run_id: str,
+        *,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> None:
+        """Delete a run.
+
+        Args:
+            thread_id: The thread ID to delete.
+            run_id: The run ID to delete.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            `None`
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost:2024")
+            await client.runs.delete(
+                thread_id="thread_id_to_delete",
+                run_id="run_id_to_delete"
+            )
+            ```
+
+        """
+        await self.http.delete(
+            f"/threads/{thread_id}/runs/{run_id}", headers=headers, params=params
+        )

python/user_packages/Python313/site-packages/langgraph_sdk/_async/store.py

@@ -0,0 +1,313 @@
+"""Async Store client for LangGraph SDK."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
+from typing import Any, Literal
+
+from langgraph_sdk._async.http import HttpClient
+from langgraph_sdk._shared.utilities import _provided_vals
+from langgraph_sdk.schema import (
+    Item,
+    ListNamespaceResponse,
+    QueryParamTypes,
+    SearchItemsResponse,
+)
+
+
+class StoreClient:
+    """Client for interacting with the graph's shared storage.
+
+    The Store provides a key-value storage system for persisting data across graph executions,
+    allowing for stateful operations and data sharing across threads.
+
+    ???+ example "Example"
+
+        ```python
+        client = get_client(url="http://localhost:2024")
+        await client.store.put_item(["users", "user123"], "mem-123451342", {"name": "Alice", "score": 100})
+        ```
+    """
+
+    def __init__(self, http: HttpClient) -> None:
+        self.http = http
+
+    async def put_item(
+        self,
+        namespace: Sequence[str],
+        /,
+        key: str,
+        value: Mapping[str, Any],
+        index: Literal[False] | list[str] | None = None,
+        ttl: int | None = None,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> None:
+        """Store or update an item.
+
+        Args:
+            namespace: A list of strings representing the namespace path.
+            key: The unique identifier for the item within the namespace.
+            value: A dictionary containing the item's data.
+            index: Controls search indexing - None (use defaults), False (disable), or list of field paths to index.
+            ttl: Optional time-to-live in minutes for the item, or None for no expiration.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            `None`
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost:2024")
+            await client.store.put_item(
+                ["documents", "user123"],
+                key="item456",
+                value={"title": "My Document", "content": "Hello World"}
+            )
+            ```
+        """
+        for label in namespace:
+            if "." in label:
+                raise ValueError(
+                    f"Invalid namespace label '{label}'. Namespace labels cannot contain periods ('.')."
+                )
+        payload = {
+            "namespace": namespace,
+            "key": key,
+            "value": value,
+            "index": index,
+            "ttl": ttl,
+        }
+        await self.http.put(
+            "/store/items", json=_provided_vals(payload), headers=headers, params=params
+        )
+
+    async def get_item(
+        self,
+        namespace: Sequence[str],
+        /,
+        key: str,
+        *,
+        refresh_ttl: bool | None = None,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> Item:
+        """Retrieve a single item.
+
+        Args:
+            key: The unique identifier for the item.
+            namespace: Optional list of strings representing the namespace path.
+            refresh_ttl: Whether to refresh the TTL on this read operation. If `None`, uses the store's default behavior.
+
+        Returns:
+            Item: The retrieved item.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost:2024")
+            item = await client.store.get_item(
+                ["documents", "user123"],
+                key="item456",
+            )
+            print(item)
+            ```
+            ```shell
+
+            ----------------------------------------------------------------
+
+            {
+                'namespace': ['documents', 'user123'],
+                'key': 'item456',
+                'value': {'title': 'My Document', 'content': 'Hello World'},
+                'created_at': '2024-07-30T12:00:00Z',
+                'updated_at': '2024-07-30T12:00:00Z'
+            }
+            ```
+        """
+        for label in namespace:
+            if "." in label:
+                raise ValueError(
+                    f"Invalid namespace label '{label}'. Namespace labels cannot contain periods ('.')."
+                )
+        get_params: dict[str, Any] = {"namespace": ".".join(namespace), "key": key}
+        if refresh_ttl is not None:
+            get_params["refresh_ttl"] = refresh_ttl
+        if params:
+            get_params = {**get_params, **dict(params)}
+        return await self.http.get("/store/items", params=get_params, headers=headers)
+
+    async def delete_item(
+        self,
+        namespace: Sequence[str],
+        /,
+        key: str,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> None:
+        """Delete an item.
+
+        Args:
+            key: The unique identifier for the item.
+            namespace: Optional list of strings representing the namespace path.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            `None`
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost:2024")
+            await client.store.delete_item(
+                ["documents", "user123"],
+                key="item456",
+            )
+            ```
+        """
+        await self.http.delete(
+            "/store/items",
+            json={"namespace": namespace, "key": key},
+            headers=headers,
+            params=params,
+        )
+
+    async def search_items(
+        self,
+        namespace_prefix: Sequence[str],
+        /,
+        filter: Mapping[str, Any] | None = None,
+        limit: int = 10,
+        offset: int = 0,
+        query: str | None = None,
+        refresh_ttl: bool | None = None,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> SearchItemsResponse:
+        """Search for items within a namespace prefix.
+
+        Args:
+            namespace_prefix: List of strings representing the namespace prefix.
+            filter: Optional dictionary of key-value pairs to filter results.
+            limit: Maximum number of items to return (default is 10).
+            offset: Number of items to skip before returning results (default is 0).
+            query: Optional query for natural language search.
+            refresh_ttl: Whether to refresh the TTL on items returned by this search. If `None`, uses the store's default behavior.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            A list of items matching the search criteria.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost:2024")
+            items = await client.store.search_items(
+                ["documents"],
+                filter={"author": "John Doe"},
+                limit=5,
+                offset=0
+            )
+            print(items)
+            ```
+            ```shell
+
+            ----------------------------------------------------------------
+
+            {
+                "items": [
+                    {
+                        "namespace": ["documents", "user123"],
+                        "key": "item789",
+                        "value": {
+                            "title": "Another Document",
+                            "author": "John Doe"
+                        },
+                        "created_at": "2024-07-30T12:00:00Z",
+                        "updated_at": "2024-07-30T12:00:00Z"
+                    },
+                    # ... additional items ...
+                ]
+            }
+            ```
+        """
+        payload = {
+            "namespace_prefix": namespace_prefix,
+            "filter": filter,
+            "limit": limit,
+            "offset": offset,
+            "query": query,
+            "refresh_ttl": refresh_ttl,
+        }
+
+        return await self.http.post(
+            "/store/items/search",
+            json=_provided_vals(payload),
+            headers=headers,
+            params=params,
+        )
+
+    async def list_namespaces(
+        self,
+        prefix: list[str] | None = None,
+        suffix: list[str] | None = None,
+        max_depth: int | None = None,
+        limit: int = 100,
+        offset: int = 0,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> ListNamespaceResponse:
+        """List namespaces with optional match conditions.
+
+        Args:
+            prefix: Optional list of strings representing the prefix to filter namespaces.
+            suffix: Optional list of strings representing the suffix to filter namespaces.
+            max_depth: Optional integer specifying the maximum depth of namespaces to return.
+            limit: Maximum number of namespaces to return (default is 100).
+            offset: Number of namespaces to skip before returning results (default is 0).
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            A list of namespaces matching the criteria.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost:2024")
+            namespaces = await client.store.list_namespaces(
+                prefix=["documents"],
+                max_depth=3,
+                limit=10,
+                offset=0
+            )
+            print(namespaces)
+
+            ----------------------------------------------------------------
+
+            [
+                ["documents", "user123", "reports"],
+                ["documents", "user456", "invoices"],
+                ...
+            ]
+            ```
+        """
+        payload = {
+            "prefix": prefix,
+            "suffix": suffix,
+            "max_depth": max_depth,
+            "limit": limit,
+            "offset": offset,
+        }
+        return await self.http.post(
+            "/store/namespaces",
+            json=_provided_vals(payload),
+            headers=headers,
+            params=params,
+        )

python/user_packages/Python313/site-packages/langgraph_sdk/_async/threads.py

@@ -0,0 +1,773 @@
+"""Async client for managing threads in LangGraph."""
+
+from __future__ import annotations
+
+from collections.abc import AsyncIterator, Mapping, Sequence
+from typing import Any, Literal, overload
+
+from langgraph_sdk._async.http import HttpClient
+from langgraph_sdk.schema import (
+    Checkpoint,
+    Json,
+    OnConflictBehavior,
+    PruneStrategy,
+    QueryParamTypes,
+    SortOrder,
+    StreamPart,
+    Thread,
+    ThreadSelectField,
+    ThreadSortBy,
+    ThreadState,
+    ThreadStatus,
+    ThreadStreamMode,
+    ThreadUpdateStateResponse,
+)
+
+
+class ThreadsClient:
+    """Client for managing threads in LangGraph.
+
+    A thread maintains the state of a graph across multiple interactions/invocations (aka runs).
+    It accumulates and persists the graph's state, allowing for continuity between separate
+    invocations of the graph.
+
+    ???+ example "Example"
+
+        ```python
+        client = get_client(url="http://localhost:2024"))
+        new_thread = await client.threads.create(metadata={"user_id": "123"})
+        ```
+    """
+
+    def __init__(self, http: HttpClient) -> None:
+        self.http = http
+
+    async def get(
+        self,
+        thread_id: str,
+        *,
+        include: Sequence[str] | None = None,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> Thread:
+        """Get a thread by ID.
+
+        Args:
+            thread_id: The ID of the thread to get.
+            include: Additional fields to include in the response.
+                Supported values: `"ttl"`.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            Thread object.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost:2024")
+            thread = await client.threads.get(
+                thread_id="my_thread_id"
+            )
+            print(thread)
+            ```
+
+            ```shell
+            -----------------------------------------------------
+
+            {
+                'thread_id': 'my_thread_id',
+                'created_at': '2024-07-18T18:35:15.540834+00:00',
+                'updated_at': '2024-07-18T18:35:15.540834+00:00',
+                'metadata': {'graph_id': 'agent'}
+            }
+            ```
+
+        """
+        query_params: dict[str, Any] = {}
+        if include:
+            query_params["include"] = ",".join(include)
+        if params:
+            query_params.update(params)
+        return await self.http.get(
+            f"/threads/{thread_id}",
+            headers=headers,
+            params=query_params or None,
+        )
+
+    async def create(
+        self,
+        *,
+        metadata: Json = None,
+        thread_id: str | None = None,
+        if_exists: OnConflictBehavior | None = None,
+        supersteps: Sequence[dict[str, Sequence[dict[str, Any]]]] | None = None,
+        graph_id: str | None = None,
+        ttl: int | Mapping[str, Any] | None = None,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> Thread:
+        """Create a new thread.
+
+        Args:
+            metadata: Metadata to add to thread.
+            thread_id: ID of thread.
+                If `None`, ID will be a randomly generated UUID.
+            if_exists: How to handle duplicate creation. Defaults to 'raise' under the hood.
+                Must be either 'raise' (raise error if duplicate), or 'do_nothing' (return existing thread).
+            supersteps: Apply a list of supersteps when creating a thread, each containing a sequence of updates.
+                Each update has `values` or `command` and `as_node`. Used for copying a thread between deployments.
+            graph_id: Optional graph ID to associate with the thread.
+            ttl: Optional time-to-live in minutes for the thread. You can pass an
+                integer (minutes) or a mapping with keys `ttl` and optional
+                `strategy` (defaults to "delete").
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            The created thread.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost:2024")
+            thread = await client.threads.create(
+                metadata={"number":1},
+                thread_id="my-thread-id",
+                if_exists="raise"
+            )
+            ```
+        """
+        payload: dict[str, Any] = {}
+        if thread_id:
+            payload["thread_id"] = thread_id
+        if metadata or graph_id:
+            payload["metadata"] = {
+                **(metadata or {}),
+                **({"graph_id": graph_id} if graph_id else {}),
+            }
+        if if_exists:
+            payload["if_exists"] = if_exists
+        if supersteps:
+            payload["supersteps"] = [
+                {
+                    "updates": [
+                        {
+                            "values": u["values"],
+                            "command": u.get("command"),
+                            "as_node": u["as_node"],
+                        }
+                        for u in s["updates"]
+                    ]
+                }
+                for s in supersteps
+            ]
+        if ttl is not None:
+            if isinstance(ttl, (int, float)):
+                payload["ttl"] = {"ttl": ttl, "strategy": "delete"}
+            else:
+                payload["ttl"] = ttl
+
+        return await self.http.post(
+            "/threads", json=payload, headers=headers, params=params
+        )
+
+    @overload
+    async def update(
+        self,
+        thread_id: str,
+        *,
+        metadata: Mapping[str, Any],
+        ttl: int | Mapping[str, Any] | None = None,
+        return_minimal: Literal[False] = False,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> Thread: ...
+
+    @overload
+    async def update(
+        self,
+        thread_id: str,
+        *,
+        metadata: Mapping[str, Any],
+        ttl: int | Mapping[str, Any] | None = None,
+        return_minimal: Literal[True],
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> None: ...
+
+    @overload
+    async def update(
+        self,
+        thread_id: str,
+        *,
+        metadata: Mapping[str, Any],
+        ttl: int | Mapping[str, Any] | None = None,
+        return_minimal: bool,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> Thread | None: ...
+
+    async def update(
+        self,
+        thread_id: str,
+        *,
+        metadata: Mapping[str, Any],
+        ttl: int | Mapping[str, Any] | None = None,
+        return_minimal: bool = False,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> Thread | None:
+        """Update a thread.
+
+        Args:
+            thread_id: ID of thread to update.
+            metadata: Metadata to merge with existing thread metadata.
+            ttl: Optional time-to-live in minutes for the thread. You can pass an
+                integer (minutes) or a mapping with keys `ttl` and optional
+                `strategy` (defaults to "delete").
+            return_minimal: If `True`, request a 204 response with no body.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            The updated thread, or `None` when `return_minimal=True`.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost:2024")
+            thread = await client.threads.update(
+                thread_id="my-thread-id",
+                metadata={"number":1},
+                ttl=43_200,
+            )
+            ```
+        """
+        payload: dict[str, Any] = {"metadata": metadata}
+        if ttl is not None:
+            if isinstance(ttl, (int, float)):
+                payload["ttl"] = {"ttl": ttl, "strategy": "delete"}
+            else:
+                payload["ttl"] = ttl
+        request_headers = dict(headers or {})
+        if return_minimal:
+            request_headers["Prefer"] = "return=minimal"
+        return await self.http.patch(
+            f"/threads/{thread_id}",
+            json=payload,
+            headers=request_headers or None,
+            params=params,
+        )
+
+    async def delete(
+        self,
+        thread_id: str,
+        *,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> None:
+        """Delete a thread.
+
+        Args:
+            thread_id: The ID of the thread to delete.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            `None`
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost2024)
+            await client.threads.delete(
+                thread_id="my_thread_id"
+            )
+            ```
+
+        """
+        await self.http.delete(f"/threads/{thread_id}", headers=headers, params=params)
+
+    async def search(
+        self,
+        *,
+        metadata: Json = None,
+        values: Json = None,
+        ids: Sequence[str] | None = None,
+        status: ThreadStatus | None = None,
+        limit: int = 10,
+        offset: int = 0,
+        sort_by: ThreadSortBy | None = None,
+        sort_order: SortOrder | None = None,
+        select: list[ThreadSelectField] | None = None,
+        extract: dict[str, str] | None = None,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> list[Thread]:
+        """Search for threads.
+
+        Args:
+            metadata: Thread metadata to filter on.
+            values: State values to filter on.
+            ids: List of thread IDs to filter by.
+            status: Thread status to filter on.
+                Must be one of 'idle', 'busy', 'interrupted' or 'error'.
+            limit: Limit on number of threads to return.
+            offset: Offset in threads table to start search from.
+            sort_by: Sort by field.
+            sort_order: Sort order.
+            select: List of fields to include in the response.
+            extract: Dictionary mapping aliases to JSONB paths to extract
+                from thread data. Paths use dot notation for nested keys and
+                bracket notation for array indices (e.g.,
+                `{"last_msg": "values.messages[-1]"}`). Extracted values are
+                returned in an `extracted` field on each thread. Maximum 10
+                paths per request.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            List of the threads matching the search parameters.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost:2024")
+            threads = await client.threads.search(
+                metadata={"number":1},
+                status="interrupted",
+                limit=15,
+                offset=5
+            )
+            ```
+
+        """
+        payload: dict[str, Any] = {
+            "limit": limit,
+            "offset": offset,
+        }
+        if metadata:
+            payload["metadata"] = metadata
+        if values:
+            payload["values"] = values
+        if ids:
+            payload["ids"] = ids
+        if status:
+            payload["status"] = status
+        if sort_by:
+            payload["sort_by"] = sort_by
+        if sort_order:
+            payload["sort_order"] = sort_order
+        if select:
+            payload["select"] = select
+        if extract:
+            payload["extract"] = extract
+        return await self.http.post(
+            "/threads/search",
+            json=payload,
+            headers=headers,
+            params=params,
+        )
+
+    async def count(
+        self,
+        *,
+        metadata: Json = None,
+        values: Json = None,
+        status: ThreadStatus | None = None,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> int:
+        """Count threads matching filters.
+
+        Args:
+            metadata: Thread metadata to filter on.
+            values: State values to filter on.
+            status: Thread status to filter on.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            int: Number of threads matching the criteria.
+        """
+        payload: dict[str, Any] = {}
+        if metadata:
+            payload["metadata"] = metadata
+        if values:
+            payload["values"] = values
+        if status:
+            payload["status"] = status
+        return await self.http.post(
+            "/threads/count", json=payload, headers=headers, params=params
+        )
+
+    async def copy(
+        self,
+        thread_id: str,
+        *,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> None:
+        """Copy a thread.
+
+        Args:
+            thread_id: The ID of the thread to copy.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            `None`
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost:2024)
+            await client.threads.copy(
+                thread_id="my_thread_id"
+            )
+            ```
+
+        """
+        return await self.http.post(
+            f"/threads/{thread_id}/copy", json=None, headers=headers, params=params
+        )
+
+    async def prune(
+        self,
+        thread_ids: Sequence[str],
+        *,
+        strategy: PruneStrategy = "delete",
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> dict[str, Any]:
+        """Prune threads by ID.
+
+        Args:
+            thread_ids: List of thread IDs to prune.
+            strategy: The prune strategy. `"delete"` removes threads entirely.
+                `"keep_latest"` prunes old checkpoints but keeps threads and their
+                latest state. Defaults to `"delete"`.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            A dict containing `pruned_count` (number of threads pruned).
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost:2024")
+            result = await client.threads.prune(
+                thread_ids=["thread_1", "thread_2"],
+            )
+            print(result)  # {'pruned_count': 2}
+            ```
+
+        """
+        payload: dict[str, Any] = {
+            "thread_ids": thread_ids,
+        }
+        if strategy != "delete":
+            payload["strategy"] = strategy
+        return await self.http.post(
+            "/threads/prune", json=payload, headers=headers, params=params
+        )
+
+    async def get_state(
+        self,
+        thread_id: str,
+        checkpoint: Checkpoint | None = None,
+        checkpoint_id: str | None = None,  # deprecated
+        *,
+        subgraphs: bool = False,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> ThreadState:
+        """Get the state of a thread.
+
+        Args:
+            thread_id: The ID of the thread to get the state of.
+            checkpoint: The checkpoint to get the state of.
+            checkpoint_id: (deprecated) The checkpoint ID to get the state of.
+            subgraphs: Include subgraphs states.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            The thread of the state.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost:2024)
+            thread_state = await client.threads.get_state(
+                thread_id="my_thread_id",
+                checkpoint_id="my_checkpoint_id"
+            )
+            print(thread_state)
+            ```
+
+            ```shell
+            ----------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+            {
+                'values': {
+                    'messages': [
+                        {
+                            'content': 'how are you?',
+                            'additional_kwargs': {},
+                            'response_metadata': {},
+                            'type': 'human',
+                            'name': None,
+                            'id': 'fe0a5778-cfe9-42ee-b807-0adaa1873c10',
+                            'example': False
+                        },
+                        {
+                            'content': "I'm doing well, thanks for asking! I'm an AI assistant created by Anthropic to be helpful, honest, and harmless.",
+                            'additional_kwargs': {},
+                            'response_metadata': {},
+                            'type': 'ai',
+                            'name': None,
+                            'id': 'run-159b782c-b679-4830-83c6-cef87798fe8b',
+                            'example': False,
+                            'tool_calls': [],
+                            'invalid_tool_calls': [],
+                            'usage_metadata': None
+                        }
+                    ]
+                },
+                'next': [],
+                'checkpoint':
+                    {
+                        'thread_id': 'e2496803-ecd5-4e0c-a779-3226296181c2',
+                        'checkpoint_ns': '',
+                        'checkpoint_id': '1ef4a9b8-e6fb-67b1-8001-abd5184439d1'
+                    }
+                'metadata':
+                    {
+                        'step': 1,
+                        'run_id': '1ef4a9b8-d7da-679a-a45a-872054341df2',
+                        'source': 'loop',
+                        'writes':
+                            {
+                                'agent':
+                                    {
+                                        'messages': [
+                                            {
+                                                'id': 'run-159b782c-b679-4830-83c6-cef87798fe8b',
+                                                'name': None,
+                                                'type': 'ai',
+                                                'content': "I'm doing well, thanks for asking! I'm an AI assistant created by Anthropic to be helpful, honest, and harmless.",
+                                                'example': False,
+                                                'tool_calls': [],
+                                                'usage_metadata': None,
+                                                'additional_kwargs': {},
+                                                'response_metadata': {},
+                                                'invalid_tool_calls': []
+                                            }
+                                        ]
+                                    }
+                            },
+                'user_id': None,
+                'graph_id': 'agent',
+                'thread_id': 'e2496803-ecd5-4e0c-a779-3226296181c2',
+                'created_by': 'system',
+                'assistant_id': 'fe096781-5601-53d2-b2f6-0d3403f7e9ca'},
+                'created_at': '2024-07-25T15:35:44.184703+00:00',
+                'parent_config':
+                    {
+                        'thread_id': 'e2496803-ecd5-4e0c-a779-3226296181c2',
+                        'checkpoint_ns': '',
+                        'checkpoint_id': '1ef4a9b8-d80d-6fa7-8000-9300467fad0f'
+                    }
+            }
+            ```
+        """
+        if checkpoint:
+            return await self.http.post(
+                f"/threads/{thread_id}/state/checkpoint",
+                json={"checkpoint": checkpoint, "subgraphs": subgraphs},
+                headers=headers,
+                params=params,
+            )
+        elif checkpoint_id:
+            get_params = {"subgraphs": subgraphs}
+            if params:
+                get_params = {**get_params, **dict(params)}
+            return await self.http.get(
+                f"/threads/{thread_id}/state/{checkpoint_id}",
+                params=get_params,
+                headers=headers,
+            )
+        else:
+            get_params = {"subgraphs": subgraphs}
+            if params:
+                get_params = {**get_params, **dict(params)}
+            return await self.http.get(
+                f"/threads/{thread_id}/state",
+                params=get_params,
+                headers=headers,
+            )
+
+    async def update_state(
+        self,
+        thread_id: str,
+        values: dict[str, Any] | Sequence[dict] | None,
+        *,
+        as_node: str | None = None,
+        checkpoint: Checkpoint | None = None,
+        checkpoint_id: str | None = None,  # deprecated
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> ThreadUpdateStateResponse:
+        """Update the state of a thread.
+
+        Args:
+            thread_id: The ID of the thread to update.
+            values: The values to update the state with.
+            as_node: Update the state as if this node had just executed.
+            checkpoint: The checkpoint to update the state of.
+            checkpoint_id: (deprecated) The checkpoint ID to update the state of.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            Response after updating a thread's state.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost:2024)
+            response = await client.threads.update_state(
+                thread_id="my_thread_id",
+                values={"messages":[{"role": "user", "content": "hello!"}]},
+                as_node="my_node",
+            )
+            print(response)
+            ```
+            ```shell
+
+            ----------------------------------------------------------------------------------------------------------------------------------------------------------------------
+
+            {
+                'checkpoint': {
+                    'thread_id': 'e2496803-ecd5-4e0c-a779-3226296181c2',
+                    'checkpoint_ns': '',
+                    'checkpoint_id': '1ef4a9b8-e6fb-67b1-8001-abd5184439d1',
+                    'checkpoint_map': {}
+                }
+            }
+            ```
+        """
+        payload: dict[str, Any] = {
+            "values": values,
+        }
+        if checkpoint_id:
+            payload["checkpoint_id"] = checkpoint_id
+        if checkpoint:
+            payload["checkpoint"] = checkpoint
+        if as_node:
+            payload["as_node"] = as_node
+        return await self.http.post(
+            f"/threads/{thread_id}/state", json=payload, headers=headers, params=params
+        )
+
+    async def get_history(
+        self,
+        thread_id: str,
+        *,
+        limit: int = 10,
+        before: str | Checkpoint | None = None,
+        metadata: Mapping[str, Any] | None = None,
+        checkpoint: Checkpoint | None = None,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> list[ThreadState]:
+        """Get the state history of a thread.
+
+        Args:
+            thread_id: The ID of the thread to get the state history for.
+            checkpoint: Return states for this subgraph. If empty defaults to root.
+            limit: The maximum number of states to return.
+            before: Return states before this checkpoint.
+            metadata: Filter states by metadata key-value pairs.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            The state history of the thread.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_client(url="http://localhost:2024)
+            thread_state = await client.threads.get_history(
+                thread_id="my_thread_id",
+                limit=5,
+            )
+            ```
+
+        """
+        payload: dict[str, Any] = {
+            "limit": limit,
+        }
+        if before:
+            payload["before"] = before
+        if metadata:
+            payload["metadata"] = metadata
+        if checkpoint:
+            payload["checkpoint"] = checkpoint
+        return await self.http.post(
+            f"/threads/{thread_id}/history",
+            json=payload,
+            headers=headers,
+            params=params,
+        )
+
+    async def join_stream(
+        self,
+        thread_id: str,
+        *,
+        last_event_id: str | None = None,
+        stream_mode: ThreadStreamMode | Sequence[ThreadStreamMode] = "run_modes",
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> AsyncIterator[StreamPart]:
+        """Get a stream of events for a thread.
+
+        Args:
+            thread_id: The ID of the thread to get the stream for.
+            last_event_id: The ID of the last event to get.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            An iterator of stream parts.
+
+        ???+ example "Example Usage"
+
+            ```python
+
+            for chunk in client.threads.join_stream(
+                thread_id="my_thread_id",
+                last_event_id="my_event_id",
+            ):
+                print(chunk)
+            ```
+
+        """
+        query_params = {
+            "stream_mode": stream_mode,
+        }
+        if params:
+            query_params.update(params)
+        return self.http.stream(
+            f"/threads/{thread_id}/stream",
+            "GET",
+            headers={
+                **({"Last-Event-ID": last_event_id} if last_event_id else {}),
+                **(headers or {}),
+            },
+            params=query_params,
+        )

python/user_packages/Python313/site-packages/langgraph_sdk/_shared/__init__.py

@@ -0,0 +1 @@
+"""Shared utilities for async and sync clients."""

python/user_packages/Python313/site-packages/langgraph_sdk/_shared/types.py

@@ -0,0 +1,10 @@
+"""Type aliases and constants."""
+
+from __future__ import annotations
+
+TimeoutTypes = (
+    None
+    | float
+    | tuple[float | None, float | None]
+    | tuple[float | None, float | None, float | None, float | None]
+)

python/user_packages/Python313/site-packages/langgraph_sdk/_shared/utilities.py

@@ -0,0 +1,217 @@
+"""Shared utility functions for async and sync clients."""
+
+from __future__ import annotations
+
+import functools
+import os
+import re
+from collections.abc import Mapping
+from datetime import tzinfo
+from typing import TYPE_CHECKING, Any, cast
+from urllib.parse import urlparse
+
+import httpx
+
+import langgraph_sdk
+from langgraph_sdk.schema import RunCreateMetadata
+
+if TYPE_CHECKING:
+    from zoneinfo import ZoneInfo
+
+RESERVED_HEADERS = ("x-api-key",)
+
+NOT_PROVIDED = cast(None, object())
+
+
+def _get_api_key(api_key: str | None = NOT_PROVIDED) -> str | None:
+    """Get the API key from the environment.
+    Precedence:
+        1. explicit string argument
+        2. LANGGRAPH_API_KEY (if api_key not provided)
+        3. LANGSMITH_API_KEY (if api_key not provided)
+        4. LANGCHAIN_API_KEY (if api_key not provided)
+
+    Args:
+        api_key: The API key to use. Can be:
+            - A string: use this exact API key
+            - None: explicitly skip loading from environment
+            - NOT_PROVIDED (default): auto-load from environment variables
+    """
+    if isinstance(api_key, str):
+        return api_key
+    if api_key is NOT_PROVIDED:
+        # api_key is not explicitly provided, try to load from environment
+        for prefix in ["LANGGRAPH", "LANGSMITH", "LANGCHAIN"]:
+            if env := os.getenv(f"{prefix}_API_KEY"):
+                return env.strip().strip('"').strip("'")
+    # api_key is explicitly None, don't load from environment
+    return None
+
+
+def _get_headers(
+    api_key: str | None,
+    custom_headers: Mapping[str, str] | None,
+) -> dict[str, str]:
+    """Combine api_key and custom user-provided headers."""
+    custom_headers = custom_headers or {}
+    for header in RESERVED_HEADERS:
+        if header in custom_headers:
+            raise ValueError(f"Cannot set reserved header '{header}'")
+
+    headers = {
+        "User-Agent": f"langgraph-sdk-py/{langgraph_sdk.__version__}",
+        **custom_headers,
+    }
+    resolved_api_key = _get_api_key(api_key)
+    if resolved_api_key:
+        headers["x-api-key"] = resolved_api_key
+
+    return headers
+
+
+def _orjson_default(obj: Any) -> Any:
+    is_class = isinstance(obj, type)
+    if hasattr(obj, "model_dump") and callable(obj.model_dump):
+        if is_class:
+            raise TypeError(
+                f"Cannot JSON-serialize type object: {obj!r}. Did you mean to pass an instance of the object instead?"
+                f"\nReceived type: {obj!r}"
+            )
+        return obj.model_dump()
+    elif hasattr(obj, "dict") and callable(obj.dict):
+        if is_class:
+            raise TypeError(
+                f"Cannot JSON-serialize type object: {obj!r}. Did you mean to pass an instance of the object instead?"
+                f"\nReceived type: {obj!r}"
+            )
+        return obj.dict()
+    elif isinstance(obj, (set, frozenset)):
+        return list(obj)
+    else:
+        raise TypeError(f"Object of type {type(obj)} is not JSON serializable")
+
+
+# Compiled regex pattern for extracting run metadata from Content-Location header
+_RUN_METADATA_PATTERN = re.compile(
+    r"(\/threads\/(?P<thread_id>.+))?\/runs\/(?P<run_id>.+)"
+)
+
+
+def _get_run_metadata_from_response(
+    response: httpx.Response,
+) -> RunCreateMetadata | None:
+    """Extract run metadata from the response headers."""
+    if (content_location := response.headers.get("Content-Location")) and (
+        match := _RUN_METADATA_PATTERN.search(content_location)
+    ):
+        return RunCreateMetadata(
+            run_id=match.group("run_id"),
+            thread_id=match.group("thread_id") or None,
+        )
+
+    return None
+
+
+def _sse_to_v2_dict(event: str, data: Any) -> dict[str, Any] | None:
+    """Convert an SSE event+data pair into a v2 stream part dict.
+
+    Returns None for ``end`` events (signals end of stream).
+    """
+    if event == "end":
+        return None
+    parts = event.split("|")
+    event_type = parts[0]
+    ns = parts[1:] if len(parts) > 1 else []
+    result: dict[str, Any] = {"type": event_type, "ns": ns, "data": data}
+    if event_type == "values" and isinstance(data, dict):
+        result["interrupts"] = data.pop("__interrupt__", [])
+    else:
+        result["interrupts"] = []
+    return result
+
+
+def _resolve_timezone(tz: str | tzinfo | ZoneInfo | None) -> str | None:
+    """Convert a timezone argument to an IANA timezone string.
+
+    Accepts:
+        - A string (returned as-is, assumed to be an IANA timezone name)
+        - A ``datetime.tzinfo`` instance (e.g. ``zoneinfo.ZoneInfo("America/New_York")``,
+          ``datetime.timezone.utc``). The ``key`` attribute is used if available,
+          otherwise ``tzname(None)`` is used.
+        - ``None`` (returned as ``None``)
+    """
+    if tz is None or isinstance(tz, str):
+        return tz
+    if isinstance(tz, tzinfo):
+        # ZoneInfo objects have a .key attribute with the IANA name
+        if hasattr(tz, "key"):
+            return tz.key  # type: ignore[union-attr]
+        # Fall back to tzname for fixed-offset timezones like datetime.timezone.utc
+        name = tz.tzname(None)
+        if name is not None:
+            return name
+        raise ValueError(
+            f"Cannot determine timezone name from {tz!r}. "
+            "Use a zoneinfo.ZoneInfo instance or pass a string like 'America/New_York'."
+        )
+    raise TypeError(
+        f"Expected str, datetime.tzinfo, or None for timezone, got {type(tz).__name__}"
+    )
+
+
+def _default_port(scheme: str) -> int:
+    return 443 if scheme == "https" else 80
+
+
+def _validate_reconnect_location(base_url: httpx.URL, location: str) -> str:
+    """Validate that a reconnect Location URL is same-origin as the base URL.
+
+    Raises ValueError if the Location header points to a different origin
+    (scheme + host + port), which would leak credentials to an external server.
+    """
+    parsed = urlparse(location)
+    # Relative URLs are safe — they resolve against the base
+    if not parsed.scheme and not parsed.netloc:
+        return location
+    # Compare origin components (normalize default ports to avoid mismatches)
+    base_scheme = str(base_url.scheme)
+    base_origin = (
+        base_scheme,
+        str(base_url.host),
+        base_url.port or _default_port(base_scheme),
+    )
+    loc_origin = (
+        parsed.scheme,
+        parsed.hostname or "",
+        parsed.port or _default_port(parsed.scheme),
+    )
+    if base_origin != loc_origin:
+        raise ValueError(
+            f"Refusing to follow cross-origin reconnect Location: {location!r} "
+            f"(origin {loc_origin}) does not match base URL origin {base_origin}"
+        )
+    return location
+
+
+def _provided_vals(d: Mapping[str, Any]) -> dict[str, Any]:
+    return {k: v for k, v in d.items() if v is not None}
+
+
+_registered_transports: list[httpx.ASGITransport] = []
+
+
+# Do not move; this is used in the server.
+def configure_loopback_transports(app: Any) -> None:
+    for transport in _registered_transports:
+        transport.app = app
+
+
+@functools.lru_cache(maxsize=1)
+def get_asgi_transport() -> type[httpx.ASGITransport]:
+    try:
+        from langgraph_api import asgi_transport  # type: ignore[unresolved-import]
+
+        return asgi_transport.ASGITransport
+    except ImportError:
+        # Older versions of the server
+        return httpx.ASGITransport

python/user_packages/Python313/site-packages/langgraph_sdk/_sync/assistants.py

@@ -0,0 +1,731 @@
+"""Synchronous client for managing assistants in LangGraph."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, Literal, cast, overload
+
+import httpx
+
+from langgraph_sdk._sync.http import SyncHttpClient
+from langgraph_sdk.schema import (
+    Assistant,
+    AssistantSelectField,
+    AssistantSortBy,
+    AssistantsSearchResponse,
+    AssistantVersion,
+    Config,
+    Context,
+    GraphSchema,
+    Json,
+    OnConflictBehavior,
+    QueryParamTypes,
+    SortOrder,
+    Subgraphs,
+)
+
+
+class SyncAssistantsClient:
+    """Client for managing assistants in LangGraph synchronously.
+
+    This class provides methods to interact with assistants, which are versioned configurations of your graph.
+
+    ???+ example "Example"
+
+        ```python
+        client = get_sync_client(url="http://localhost:2024")
+        assistant = client.assistants.get("assistant_id_123")
+        ```
+    """
+
+    def __init__(self, http: SyncHttpClient) -> None:
+        self.http = http
+
+    def get(
+        self,
+        assistant_id: str,
+        *,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> Assistant:
+        """Get an assistant by ID.
+
+        Args:
+            assistant_id: The ID of the assistant to get OR the name of the graph (to use the default assistant).
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            `Assistant` Object.
+
+        ???+ example "Example Usage"
+
+            ```python
+            assistant = client.assistants.get(
+                assistant_id="my_assistant_id"
+            )
+            print(assistant)
+            ```
+
+            ```shell
+            ----------------------------------------------------
+
+            {
+                'assistant_id': 'my_assistant_id',
+                'graph_id': 'agent',
+                'created_at': '2024-06-25T17:10:33.109781+00:00',
+                'updated_at': '2024-06-25T17:10:33.109781+00:00',
+                'config': {},
+                'context': {},
+                'metadata': {'created_by': 'system'}
+            }
+            ```
+
+        """
+        return self.http.get(
+            f"/assistants/{assistant_id}", headers=headers, params=params
+        )
+
+    def get_graph(
+        self,
+        assistant_id: str,
+        *,
+        xray: int | bool = False,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> dict[str, list[dict[str, Any]]]:
+        """Get the graph of an assistant by ID.
+
+        Args:
+            assistant_id: The ID of the assistant to get the graph of.
+            xray: Include graph representation of subgraphs. If an integer value is provided, only subgraphs with a depth less than or equal to the value will be included.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            The graph information for the assistant in JSON format.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_sync_client(url="http://localhost:2024")
+            graph_info = client.assistants.get_graph(
+                assistant_id="my_assistant_id"
+            )
+            print(graph_info)
+
+            --------------------------------------------------------------------------------------------------------------------------
+
+            {
+                'nodes':
+                    [
+                        {'id': '__start__', 'type': 'schema', 'data': '__start__'},
+                        {'id': '__end__', 'type': 'schema', 'data': '__end__'},
+                        {'id': 'agent','type': 'runnable','data': {'id': ['langgraph', 'utils', 'RunnableCallable'],'name': 'agent'}},
+                    ],
+                'edges':
+                    [
+                        {'source': '__start__', 'target': 'agent'},
+                        {'source': 'agent','target': '__end__'}
+                    ]
+            }
+            ```
+
+        """
+        query_params = {"xray": xray}
+        if params:
+            query_params.update(params)
+        return self.http.get(
+            f"/assistants/{assistant_id}/graph", params=query_params, headers=headers
+        )
+
+    def get_schemas(
+        self,
+        assistant_id: str,
+        *,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> GraphSchema:
+        """Get the schemas of an assistant by ID.
+
+        Args:
+            assistant_id: The ID of the assistant to get the schema of.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            GraphSchema: The graph schema for the assistant.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_sync_client(url="http://localhost:2024")
+            schema = client.assistants.get_schemas(
+                assistant_id="my_assistant_id"
+            )
+            print(schema)
+            ```
+            ```shell
+            ----------------------------------------------------------------------------------------------------------------------------
+
+            {
+                'graph_id': 'agent',
+                'state_schema':
+                    {
+                        'title': 'LangGraphInput',
+                        '$ref': '#/definitions/AgentState',
+                        'definitions':
+                            {
+                                'BaseMessage':
+                                    {
+                                        'title': 'BaseMessage',
+                                        'description': 'Base abstract Message class. Messages are the inputs and outputs of ChatModels.',
+                                        'type': 'object',
+                                        'properties':
+                                            {
+                                             'content':
+                                                {
+                                                    'title': 'Content',
+                                                    'anyOf': [
+                                                        {'type': 'string'},
+                                                        {'type': 'array','items': {'anyOf': [{'type': 'string'}, {'type': 'object'}]}}
+                                                    ]
+                                                },
+                                            'additional_kwargs':
+                                                {
+                                                    'title': 'Additional Kwargs',
+                                                    'type': 'object'
+                                                },
+                                            'response_metadata':
+                                                {
+                                                    'title': 'Response Metadata',
+                                                    'type': 'object'
+                                                },
+                                            'type':
+                                                {
+                                                    'title': 'Type',
+                                                    'type': 'string'
+                                                },
+                                            'name':
+                                                {
+                                                    'title': 'Name',
+                                                    'type': 'string'
+                                                },
+                                            'id':
+                                                {
+                                                    'title': 'Id',
+                                                    'type': 'string'
+                                                }
+                                            },
+                                        'required': ['content', 'type']
+                                    },
+                                'AgentState':
+                                    {
+                                        'title': 'AgentState',
+                                        'type': 'object',
+                                        'properties':
+                                            {
+                                                'messages':
+                                                    {
+                                                        'title': 'Messages',
+                                                        'type': 'array',
+                                                        'items': {'$ref': '#/definitions/BaseMessage'}
+                                                    }
+                                            },
+                                        'required': ['messages']
+                                    }
+                            }
+                    },
+                'config_schema':
+                    {
+                        'title': 'Configurable',
+                        'type': 'object',
+                        'properties':
+                            {
+                                'model_name':
+                                    {
+                                        'title': 'Model Name',
+                                        'enum': ['anthropic', 'openai'],
+                                        'type': 'string'
+                                    }
+                            }
+                    },
+                'context_schema':
+                    {
+                        'title': 'Context',
+                        'type': 'object',
+                        'properties':
+                            {
+                                'model_name':
+                                    {
+                                        'title': 'Model Name',
+                                        'enum': ['anthropic', 'openai'],
+                                        'type': 'string'
+                                    }
+                            }
+                    }
+            }
+            ```
+
+        """
+        return self.http.get(
+            f"/assistants/{assistant_id}/schemas", headers=headers, params=params
+        )
+
+    def get_subgraphs(
+        self,
+        assistant_id: str,
+        namespace: str | None = None,
+        recurse: bool = False,
+        *,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> Subgraphs:
+        """Get the schemas of an assistant by ID.
+
+        Args:
+            assistant_id: The ID of the assistant to get the schema of.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            Subgraphs: The graph schema for the assistant.
+
+        """
+        get_params = {"recurse": recurse}
+        if params:
+            get_params = {**get_params, **dict(params)}
+        if namespace is not None:
+            return self.http.get(
+                f"/assistants/{assistant_id}/subgraphs/{namespace}",
+                params=get_params,
+                headers=headers,
+            )
+        else:
+            return self.http.get(
+                f"/assistants/{assistant_id}/subgraphs",
+                params=get_params,
+                headers=headers,
+            )
+
+    def create(
+        self,
+        graph_id: str | None,
+        config: Config | None = None,
+        *,
+        context: Context | None = None,
+        metadata: Json = None,
+        assistant_id: str | None = None,
+        if_exists: OnConflictBehavior | None = None,
+        name: str | None = None,
+        headers: Mapping[str, str] | None = None,
+        description: str | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> Assistant:
+        """Create a new assistant.
+
+        Useful when graph is configurable and you want to create different assistants based on different configurations.
+
+        Args:
+            graph_id: The ID of the graph the assistant should use. The graph ID is normally set in your langgraph.json configuration.
+            config: Configuration to use for the graph.
+            context: Static context to add to the assistant.
+                !!! version-added "Added in version 0.6.0"
+            metadata: Metadata to add to assistant.
+            assistant_id: Assistant ID to use, will default to a random UUID if not provided.
+            if_exists: How to handle duplicate creation. Defaults to 'raise' under the hood.
+                Must be either 'raise' (raise error if duplicate), or 'do_nothing' (return existing assistant).
+            name: The name of the assistant. Defaults to 'Untitled' under the hood.
+            headers: Optional custom headers to include with the request.
+            description: Optional description of the assistant.
+                The description field is available for langgraph-api server version>=0.0.45
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            The created assistant.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_sync_client(url="http://localhost:2024")
+            assistant = client.assistants.create(
+                graph_id="agent",
+                context={"model_name": "openai"},
+                metadata={"number":1},
+                assistant_id="my-assistant-id",
+                if_exists="do_nothing",
+                name="my_name"
+            )
+            ```
+        """
+        payload: dict[str, Any] = {
+            "graph_id": graph_id,
+        }
+        if config:
+            payload["config"] = config
+        if context:
+            payload["context"] = context
+        if metadata:
+            payload["metadata"] = metadata
+        if assistant_id:
+            payload["assistant_id"] = assistant_id
+        if if_exists:
+            payload["if_exists"] = if_exists
+        if name:
+            payload["name"] = name
+        if description:
+            payload["description"] = description
+        return self.http.post(
+            "/assistants", json=payload, headers=headers, params=params
+        )
+
+    def update(
+        self,
+        assistant_id: str,
+        *,
+        graph_id: str | None = None,
+        config: Config | None = None,
+        context: Context | None = None,
+        metadata: Json = None,
+        name: str | None = None,
+        headers: Mapping[str, str] | None = None,
+        description: str | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> Assistant:
+        """Update an assistant.
+
+        Use this to point to a different graph, update the configuration, or change the metadata of an assistant.
+
+        Args:
+            assistant_id: Assistant to update.
+            graph_id: The ID of the graph the assistant should use.
+                The graph ID is normally set in your langgraph.json configuration. If `None`, assistant will keep pointing to same graph.
+            config: Configuration to use for the graph.
+            context: Static context to add to the assistant.
+                !!! version-added "Added in version 0.6.0"
+            metadata: Metadata to merge with existing assistant metadata.
+            name: The new name for the assistant.
+            headers: Optional custom headers to include with the request.
+            description: Optional description of the assistant.
+                The description field is available for langgraph-api server version>=0.0.45
+
+        Returns:
+            The updated assistant.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_sync_client(url="http://localhost:2024")
+            assistant = client.assistants.update(
+                assistant_id='e280dad7-8618-443f-87f1-8e41841c180f',
+                graph_id="other-graph",
+                context={"model_name": "anthropic"},
+                metadata={"number":2}
+            )
+            ```
+        """
+        payload: dict[str, Any] = {}
+        if graph_id:
+            payload["graph_id"] = graph_id
+        if config is not None:
+            payload["config"] = config
+        if context is not None:
+            payload["context"] = context
+        if metadata:
+            payload["metadata"] = metadata
+        if name:
+            payload["name"] = name
+        if description:
+            payload["description"] = description
+        return self.http.patch(
+            f"/assistants/{assistant_id}",
+            json=payload,
+            headers=headers,
+            params=params,
+        )
+
+    def delete(
+        self,
+        assistant_id: str,
+        *,
+        delete_threads: bool = False,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> None:
+        """Delete an assistant.
+
+        Args:
+            assistant_id: The assistant ID to delete.
+            delete_threads: If true, delete all threads with `metadata.assistant_id`
+                matching this assistant, along with runs and checkpoints belonging to
+                those threads.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            `None`
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_sync_client(url="http://localhost:2024")
+            client.assistants.delete(
+                assistant_id="my_assistant_id"
+            )
+            ```
+
+        """
+        query_params: dict[str, Any] = {}
+        if delete_threads:
+            query_params["delete_threads"] = True
+        if params:
+            query_params.update(params)
+        self.http.delete(
+            f"/assistants/{assistant_id}",
+            headers=headers,
+            params=query_params or None,
+        )
+
+    @overload
+    def search(
+        self,
+        *,
+        metadata: Json = None,
+        graph_id: str | None = None,
+        name: str | None = None,
+        limit: int = 10,
+        offset: int = 0,
+        sort_by: AssistantSortBy | None = None,
+        sort_order: SortOrder | None = None,
+        select: list[AssistantSelectField] | None = None,
+        response_format: Literal["object"],
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> AssistantsSearchResponse: ...
+
+    @overload
+    def search(
+        self,
+        *,
+        metadata: Json = None,
+        graph_id: str | None = None,
+        name: str | None = None,
+        limit: int = 10,
+        offset: int = 0,
+        sort_by: AssistantSortBy | None = None,
+        sort_order: SortOrder | None = None,
+        select: list[AssistantSelectField] | None = None,
+        response_format: Literal["array"] = "array",
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> list[Assistant]: ...
+
+    def search(
+        self,
+        *,
+        metadata: Json = None,
+        graph_id: str | None = None,
+        name: str | None = None,
+        limit: int = 10,
+        offset: int = 0,
+        sort_by: AssistantSortBy | None = None,
+        sort_order: SortOrder | None = None,
+        select: list[AssistantSelectField] | None = None,
+        response_format: Literal["array", "object"] = "array",
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> AssistantsSearchResponse | list[Assistant]:
+        """Search for assistants.
+
+        Args:
+            metadata: Metadata to filter by. Exact match filter for each KV pair.
+            graph_id: The ID of the graph to filter by.
+                The graph ID is normally set in your langgraph.json configuration.
+            name: The name of the assistant to filter by.
+                The filtering logic will match assistants where 'name' is a substring (case insensitive) of the assistant name.
+            limit: The maximum number of results to return.
+            offset: The number of results to skip.
+            sort_by: The field to sort by.
+            sort_order: The order to sort by.
+            select: Specific assistant fields to include in the response.
+            response_format: Controls the response shape. Use `"array"` (default)
+                to return a bare list of assistants, or `"object"` to return
+                a mapping containing assistants plus pagination metadata.
+                Defaults to "array", though this default will be changed to "object" in a future release.
+            headers: Optional custom headers to include with the request.
+
+        Returns:
+            A list of assistants (when `response_format="array"`) or a mapping
+            with the assistants and the next pagination cursor (when
+            `response_format="object"`).
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_sync_client(url="http://localhost:2024")
+            response = client.assistants.search(
+                metadata = {"name":"my_name"},
+                graph_id="my_graph_id",
+                limit=5,
+                offset=5,
+                response_format="object",
+            )
+            assistants = response["assistants"]
+            next_cursor = response["next"]
+            ```
+        """
+        if response_format not in ("array", "object"):
+            raise ValueError("response_format must be 'array' or 'object'")
+        payload: dict[str, Any] = {
+            "limit": limit,
+            "offset": offset,
+        }
+        if metadata:
+            payload["metadata"] = metadata
+        if graph_id:
+            payload["graph_id"] = graph_id
+        if name:
+            payload["name"] = name
+        if sort_by:
+            payload["sort_by"] = sort_by
+        if sort_order:
+            payload["sort_order"] = sort_order
+        if select:
+            payload["select"] = select
+        next_cursor: str | None = None
+
+        def capture_pagination(response: httpx.Response) -> None:
+            nonlocal next_cursor
+            next_cursor = response.headers.get("X-Pagination-Next")
+
+        assistants = cast(
+            list[Assistant],
+            self.http.post(
+                "/assistants/search",
+                json=payload,
+                headers=headers,
+                params=params,
+                on_response=capture_pagination if response_format == "object" else None,
+            ),
+        )
+        if response_format == "object":
+            return {"assistants": assistants, "next": next_cursor}
+        return assistants
+
+    def count(
+        self,
+        *,
+        metadata: Json = None,
+        graph_id: str | None = None,
+        name: str | None = None,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> int:
+        """Count assistants matching filters.
+
+        Args:
+            metadata: Metadata to filter by. Exact match for each key/value.
+            graph_id: Optional graph id to filter by.
+            name: Optional name to filter by.
+                The filtering logic will match assistants where 'name' is a substring (case insensitive) of the assistant name.
+            headers: Optional custom headers to include with the request.
+            params: Optional query parameters to include with the request.
+
+        Returns:
+            int: Number of assistants matching the criteria.
+        """
+        payload: dict[str, Any] = {}
+        if metadata:
+            payload["metadata"] = metadata
+        if graph_id:
+            payload["graph_id"] = graph_id
+        if name:
+            payload["name"] = name
+        return self.http.post(
+            "/assistants/count", json=payload, headers=headers, params=params
+        )
+
+    def get_versions(
+        self,
+        assistant_id: str,
+        metadata: Json = None,
+        limit: int = 10,
+        offset: int = 0,
+        *,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> list[AssistantVersion]:
+        """List all versions of an assistant.
+
+        Args:
+            assistant_id: The assistant ID to get versions for.
+            metadata: Metadata to filter versions by. Exact match filter for each KV pair.
+            limit: The maximum number of versions to return.
+            offset: The number of versions to skip.
+            headers: Optional custom headers to include with the request.
+
+        Returns:
+            A list of assistants.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_sync_client(url="http://localhost:2024")
+            assistant_versions = client.assistants.get_versions(
+                assistant_id="my_assistant_id"
+            )
+            ```
+
+        """
+
+        payload: dict[str, Any] = {
+            "limit": limit,
+            "offset": offset,
+        }
+        if metadata:
+            payload["metadata"] = metadata
+        return self.http.post(
+            f"/assistants/{assistant_id}/versions",
+            json=payload,
+            headers=headers,
+            params=params,
+        )
+
+    def set_latest(
+        self,
+        assistant_id: str,
+        version: int,
+        *,
+        headers: Mapping[str, str] | None = None,
+        params: QueryParamTypes | None = None,
+    ) -> Assistant:
+        """Change the version of an assistant.
+
+        Args:
+            assistant_id: The assistant ID to delete.
+            version: The version to change to.
+            headers: Optional custom headers to include with the request.
+
+        Returns:
+            `Assistant` Object.
+
+        ???+ example "Example Usage"
+
+            ```python
+            client = get_sync_client(url="http://localhost:2024")
+            new_version_assistant = client.assistants.set_latest(
+                assistant_id="my_assistant_id",
+                version=3
+            )
+            ```
+
+        """
+
+        payload: dict[str, Any] = {"version": version}
+
+        return self.http.post(
+            f"/assistants/{assistant_id}/latest",
+            json=payload,
+            headers=headers,
+            params=params,
+        )

python/user_packages/Python313/site-packages/langgraph_sdk/auth/__init__.py

@@ -0,0 +1,876 @@
+from __future__ import annotations
+
+import inspect
+import typing
+from collections.abc import Callable, Sequence
+
+from langgraph_sdk.auth import exceptions, types
+
+TH = typing.TypeVar("TH", bound=types.Handler)
+AH = typing.TypeVar("AH", bound=types.Authenticator)
+
+
+class Auth:
+    """Add custom authentication and authorization management to your LangGraph application.
+
+    The Auth class provides a unified system for handling authentication and
+    authorization in LangGraph applications. It supports custom user authentication
+    protocols and fine-grained authorization rules for different resources and
+    actions.
+
+    To use, create a separate python file and add the path to the file to your
+    LangGraph API configuration file (`langgraph.json`). Within that file, create
+    an instance of the Auth class and register authentication and authorization
+    handlers as needed.
+
+    Example `langgraph.json` file:
+
+    ```json
+    {
+      "dependencies": ["."],
+      "graphs": {
+        "agent": "./my_agent/agent.py:graph"
+      },
+      "env": ".env",
+      "auth": {
+        "path": "./auth.py:my_auth"
+      }
+    ```
+
+    Then the LangGraph server will load your auth file and run it server-side whenever a request comes in.
+
+    ???+ example "Basic Usage"
+
+        ```python
+        from langgraph_sdk import Auth
+
+        my_auth = Auth()
+
+        @my_auth.authenticate
+        async def authenticate(authorization: str) -> Auth.types.MinimalUserDict:
+            user = await verify_token(authorization)  # Your token verification logic
+            if not user:
+                raise Auth.exceptions.HTTPException(
+                    status_code=401, detail="Unauthorized"
+                )
+            return {
+                "identity": user["id"],
+                "permissions": user.get("permissions", []),
+            }
+
+        # Default deny: reject all requests that don't have a specific handler
+        @my_auth.on
+        async def deny_all(ctx: Auth.types.AuthContext, value: Any) -> False:
+            return False
+
+        # Allow users to create threads with their own identity as owner
+        @my_auth.on.threads.create
+        async def allow_thread_create(
+            ctx: Auth.types.AuthContext, value: Auth.types.on.threads.create.value
+        ):
+            metadata = value.setdefault("metadata", {})
+            metadata["owner"] = ctx.user.identity
+
+        # Allow users to read and search their own threads
+        @my_auth.on.threads.read
+        async def allow_thread_read(
+            ctx: Auth.types.AuthContext, value: Auth.types.on.threads.read.value
+        ) -> Auth.types.FilterType:
+            return {"owner": ctx.user.identity}
+
+        @my_auth.on.threads.search
+        async def allow_thread_search(
+            ctx: Auth.types.AuthContext, value: Auth.types.on.threads.search.value
+        ) -> Auth.types.FilterType:
+            return {"owner": ctx.user.identity}
+
+        # Scope all store operations to the user's namespace
+        @my_auth.on.store
+        async def scope_store(ctx: Auth.types.AuthContext, value: Auth.types.on.store.value):
+            namespace = tuple(value["namespace"]) if value.get("namespace") else ()
+            if not namespace or namespace[0] != ctx.user.identity:
+                namespace = (ctx.user.identity, *namespace)
+            value["namespace"] = namespace
+        ```
+
+    ???+ note "Request Processing Flow"
+
+        1. Authentication (your `@auth.authenticate` handler) is performed first on **every request**
+        2. For authorization, the most specific matching handler is called:
+            * If a handler exists for the exact resource and action, it is used (e.g., `@auth.on.threads.create`)
+            * Otherwise, if a handler exists for the resource with any action, it is used (e.g., `@auth.on.threads`)
+            * Finally, if no specific handlers match, the global handler is used (e.g., `@auth.on`)
+            * If no global handler is set, the request is accepted
+
+        This allows you to set default behavior with a global handler while
+        overriding specific routes as needed.
+    """
+
+    __slots__ = (
+        "_authenticate_handler",
+        "_global_handlers",
+        "_handler_cache",
+        "_handlers",
+        "on",
+    )
+    types = types
+    """Reference to auth type definitions.
+    
+    Provides access to all type definitions used in the auth system,
+    like ThreadsCreate, AssistantsRead, etc."""
+
+    exceptions = exceptions
+    """Reference to auth exception definitions.
+    
+    Provides access to all exception definitions used in the auth system,
+    like HTTPException, etc.    
+    """
+
+    def __init__(self) -> None:
+        self.on = _On(self)
+        """Entry point for authorization handlers that control access to specific resources.
+
+        The on class provides a flexible way to define authorization rules for different
+        resources and actions in your application. It supports three main usage patterns:
+
+        1. Global handlers that run for all resources and actions
+        2. Resource-specific handlers that run for all actions on a resource
+        3. Resource and action specific handlers for fine-grained control
+
+        Each handler must be an async function that accepts two parameters:
+            - ctx (AuthContext): Contains request context and authenticated user info
+            - value: The data being authorized (type varies by endpoint)
+
+        The handler should return one of:
+
+            - None or True: Accept the request
+            - False: Reject with 403 error
+            - FilterType: Apply filtering rules to the response
+        
+        ???+ example "Examples"
+
+            Start by denying all requests by default, then add specific handlers
+            to allow access:
+
+            ```python
+            # Default deny: reject all unhandled requests
+            @auth.on
+            async def deny_all(ctx: AuthContext, value: Any) -> False:
+                return False
+            ```
+
+            Resource-specific handler. This takes precedence over the global handler
+            for all actions on the `threads` resource:
+
+            ```python
+            @auth.on.threads
+            async def allow_thread_access(ctx: AuthContext, value: Any) -> Auth.types.FilterType:
+                # Only allow access to threads owned by the user
+                return {"owner": ctx.user.identity}
+            ```
+
+            Resource and action specific handler:
+
+            ```python
+            @auth.on.threads.delete
+            async def allow_admin_thread_deletion(ctx: AuthContext, value: Any) -> bool:
+                # Only admins can delete threads
+                return "admin" in ctx.user.permissions
+            ```
+
+            Multiple resources or actions:
+
+            ```python
+            @auth.on(resources=["threads", "assistants"], actions=["read", "search"])
+            async def allow_reads(ctx: AuthContext, value: Any) -> Auth.types.FilterType:
+                # Allow read/search access to resources owned by the user
+                return {"owner": ctx.user.identity}
+            ```
+
+            Auth for the `store` resource is a bit different since its structure is developer defined.
+            You typically want to scope store operations by rewriting the namespace to include the user's identity.
+            The `value` dict is mutable — changes to `value["namespace"]` are used by the server for the actual operation.
+
+            ```python
+            @auth.on.store
+            async def scope_store(ctx: AuthContext, value: Auth.types.on.store.value):
+                # Allow store access but scope to user's namespace
+                namespace = tuple(value["namespace"]) if value.get("namespace") else ()
+                if not namespace or namespace[0] != ctx.user.identity:
+                    namespace = (ctx.user.identity, *namespace)
+                value["namespace"] = namespace
+            ```
+
+            You can also register handlers for specific store actions:
+
+            ```python
+            @auth.on.store.put
+            async def allow_put(ctx: AuthContext, value: Auth.types.on.store.put.value):
+                # Allow puts, scoped to user's namespace
+                value["namespace"] = (ctx.user.identity, *value["namespace"])
+
+            @auth.on.store.get
+            async def allow_get(ctx: AuthContext, value: Auth.types.on.store.get.value):
+                # Allow gets, scoped to user's namespace
+                value["namespace"] = (ctx.user.identity, *value["namespace"])
+            ```
+        """
+        # These are accessed by the API. Changes to their names or types is
+        # will be considered a breaking change.
+        self._handlers: dict[tuple[str, str], list[types.Handler]] = {}
+        self._global_handlers: list[types.Handler] = []
+        self._authenticate_handler: types.Authenticator | None = None
+        self._handler_cache: dict[tuple[str, str], types.Handler] = {}
+
+    def authenticate(self, fn: AH) -> AH:
+        """Register an authentication handler function.
+
+        The authentication handler is responsible for verifying credentials
+        and returning user scopes. It can accept any of the following parameters
+        by name:
+
+            - request (Request): The raw ASGI request object
+            - path (str): The request path, e.g., "/threads/abcd-1234-abcd-1234/runs/abcd-1234-abcd-1234/stream"
+            - method (str): The HTTP method, e.g., "GET"
+            - path_params (dict[str, str]): URL path parameters, e.g., {"thread_id": "abcd-1234-abcd-1234", "run_id": "abcd-1234-abcd-1234"}
+            - query_params (dict[str, str]): URL query parameters, e.g., {"stream": "true"}
+            - headers (dict[bytes, bytes]): Request headers
+            - authorization (str | None): The Authorization header value (e.g., "Bearer <token>")
+
+        Args:
+            fn: The authentication handler function to register.
+                Must return a representation of the user. This could be a:
+                    - string (the user id)
+                    - dict containing {"identity": str, "permissions": list[str]}
+                    - or an object with identity and permissions properties
+                Permissions can be optionally used by your handlers downstream.
+
+        Returns:
+            The registered handler function.
+
+        Raises:
+            ValueError: If an authentication handler is already registered.
+
+        ???+ example "Examples"
+
+            Basic token authentication:
+
+            ```python
+            @auth.authenticate
+            async def authenticate(authorization: str) -> str:
+                user_id = verify_token(authorization)
+                return user_id
+            ```
+
+            Accept the full request context:
+
+            ```python
+            @auth.authenticate
+            async def authenticate(
+                method: str,
+                path: str,
+                headers: dict[str, bytes]
+            ) -> str:
+                user = await verify_request(method, path, headers)
+                return user
+            ```
+
+            Return user name and permissions:
+
+            ```python
+            @auth.authenticate
+            async def authenticate(
+                method: str,
+                path: str,
+                headers: dict[str, bytes]
+            ) -> Auth.types.MinimalUserDict:
+                permissions, user = await verify_request(method, path, headers)
+                # Permissions could be things like ["runs:read", "runs:write", "threads:read", "threads:write"]
+                return {
+                    "identity": user["id"],
+                    "permissions": permissions,
+                    "display_name": user["name"],
+                }
+            ```
+        """
+        if self._authenticate_handler is not None:
+            raise ValueError(
+                f"Authentication handler already set as {self._authenticate_handler}."
+            )
+        self._authenticate_handler = fn
+        return fn
+
+
+## Helper types & utilities
+
+V = typing.TypeVar("V", contravariant=True)
+
+
+class _ActionHandler(typing.Protocol[V]):
+    async def __call__(
+        self, *, ctx: types.AuthContext, value: V
+    ) -> types.HandlerResult: ...
+
+
+T = typing.TypeVar("T", covariant=True)
+
+
+class _ResourceActionOn(typing.Generic[T]):
+    def __init__(
+        self,
+        auth: Auth,
+        resource: typing.Literal["threads", "crons", "assistants"],
+        action: typing.Literal[
+            "create", "read", "update", "delete", "search", "create_run"
+        ],
+        value: type[T],
+    ) -> None:
+        self.auth = auth
+        self.resource = resource
+        self.action = action
+        self.value = value
+
+    def __call__(self, fn: _ActionHandler[T]) -> _ActionHandler[T]:
+        _validate_handler(fn)
+        _register_handler(self.auth, self.resource, self.action, fn)
+        return fn
+
+
+VCreate = typing.TypeVar("VCreate", covariant=True)
+VUpdate = typing.TypeVar("VUpdate", covariant=True)
+VRead = typing.TypeVar("VRead", covariant=True)
+VDelete = typing.TypeVar("VDelete", covariant=True)
+VSearch = typing.TypeVar("VSearch", covariant=True)
+
+
+class _ResourceOn(typing.Generic[VCreate, VRead, VUpdate, VDelete, VSearch]):
+    """
+    Generic base class for resource-specific handlers.
+    """
+
+    value: type[VCreate | VUpdate | VRead | VDelete | VSearch]
+
+    Create: type[VCreate]
+    Read: type[VRead]
+    Update: type[VUpdate]
+    Delete: type[VDelete]
+    Search: type[VSearch]
+
+    def __init__(
+        self,
+        auth: Auth,
+        resource: typing.Literal["threads", "crons", "assistants"],
+    ) -> None:
+        self.auth = auth
+        self.resource = resource
+        self.create: _ResourceActionOn[VCreate] = _ResourceActionOn(
+            auth, resource, "create", self.Create
+        )
+        self.read: _ResourceActionOn[VRead] = _ResourceActionOn(
+            auth, resource, "read", self.Read
+        )
+        self.update: _ResourceActionOn[VUpdate] = _ResourceActionOn(
+            auth, resource, "update", self.Update
+        )
+        self.delete: _ResourceActionOn[VDelete] = _ResourceActionOn(
+            auth, resource, "delete", self.Delete
+        )
+        self.search: _ResourceActionOn[VSearch] = _ResourceActionOn(
+            auth, resource, "search", self.Search
+        )
+
+    @typing.overload
+    def __call__(
+        self,
+        fn: (
+            _ActionHandler[VCreate | VUpdate | VRead | VDelete | VSearch]
+            | _ActionHandler[dict[str, typing.Any]]
+        ),
+    ) -> _ActionHandler[VCreate | VUpdate | VRead | VDelete | VSearch]: ...
+
+    @typing.overload
+    def __call__(
+        self,
+        *,
+        resources: str | Sequence[str],
+        actions: str | Sequence[str] | None = None,
+    ) -> Callable[
+        [_ActionHandler[VCreate | VUpdate | VRead | VDelete | VSearch]],
+        _ActionHandler[VCreate | VUpdate | VRead | VDelete | VSearch],
+    ]: ...
+
+    def __call__(
+        self,
+        fn: (
+            _ActionHandler[VCreate | VUpdate | VRead | VDelete | VSearch]
+            | _ActionHandler[dict[str, typing.Any]]
+            | None
+        ) = None,
+        *,
+        resources: str | Sequence[str] | None = None,
+        actions: str | Sequence[str] | None = None,
+    ) -> (
+        _ActionHandler[VCreate | VUpdate | VRead | VDelete | VSearch]
+        | Callable[
+            [_ActionHandler[VCreate | VUpdate | VRead | VDelete | VSearch]],
+            _ActionHandler[VCreate | VUpdate | VRead | VDelete | VSearch],
+        ]
+    ):
+        if fn is not None:
+            _validate_handler(fn)
+            return typing.cast(
+                "_ActionHandler[VCreate | VUpdate | VRead | VDelete | VSearch]",
+                _register_handler(self.auth, self.resource, "*", fn),
+            )
+
+        def decorator(
+            handler: _ActionHandler[VCreate | VUpdate | VRead | VDelete | VSearch],
+        ) -> _ActionHandler[VCreate | VUpdate | VRead | VDelete | VSearch]:
+            _validate_handler(handler)
+            return typing.cast(
+                "_ActionHandler[VCreate | VUpdate | VRead | VDelete | VSearch]",
+                _register_handler(self.auth, self.resource, "*", handler),
+            )
+
+        # Accept keyword-only parameters for future filtering behavior; referenced to satisfy linters.
+        _ = resources, actions
+        return decorator
+
+
+class _AssistantsOn(
+    _ResourceOn[
+        types.AssistantsCreate,
+        types.AssistantsRead,
+        types.AssistantsUpdate,
+        types.AssistantsDelete,
+        types.AssistantsSearch,
+    ]
+):
+    value = (
+        types.AssistantsCreate
+        | types.AssistantsRead
+        | types.AssistantsUpdate
+        | types.AssistantsDelete
+        | types.AssistantsSearch
+    )
+    Create = types.AssistantsCreate
+    Read = types.AssistantsRead
+    Update = types.AssistantsUpdate
+    Delete = types.AssistantsDelete
+    Search = types.AssistantsSearch
+
+
+class _ThreadsOn(
+    _ResourceOn[
+        types.ThreadsCreate,
+        types.ThreadsRead,
+        types.ThreadsUpdate,
+        types.ThreadsDelete,
+        types.ThreadsSearch,
+    ]
+):
+    value = (
+        types.ThreadsCreate
+        | types.ThreadsRead
+        | types.ThreadsUpdate
+        | types.ThreadsDelete
+        | types.ThreadsSearch
+        | types.RunsCreate
+    )
+    Create = types.ThreadsCreate
+    Read = types.ThreadsRead
+    Update = types.ThreadsUpdate
+    Delete = types.ThreadsDelete
+    Search = types.ThreadsSearch
+    CreateRun = types.RunsCreate
+
+    def __init__(
+        self,
+        auth: Auth,
+        resource: typing.Literal["threads", "crons", "assistants"],
+    ) -> None:
+        super().__init__(auth, resource)
+        self.create_run: _ResourceActionOn[types.RunsCreate] = _ResourceActionOn(
+            auth, resource, "create_run", self.CreateRun
+        )
+
+
+class _CronsOn(
+    _ResourceOn[
+        types.CronsCreate,
+        types.CronsRead,
+        types.CronsUpdate,
+        types.CronsDelete,
+        types.CronsSearch,
+    ]
+):
+    value = type[
+        types.CronsCreate
+        | types.CronsRead
+        | types.CronsUpdate
+        | types.CronsDelete
+        | types.CronsSearch
+    ]
+
+    Create = types.CronsCreate
+    Read = types.CronsRead
+    Update = types.CronsUpdate
+    Delete = types.CronsDelete
+    Search = types.CronsSearch
+
+
+class _StoreActionOn(typing.Generic[T]):
+    """Decorator for registering a handler for a specific store action."""
+
+    def __init__(
+        self,
+        auth: Auth,
+        action: typing.Literal["put", "get", "search", "delete", "list_namespaces"],
+        value: type[T],
+    ) -> None:
+        self.auth = auth
+        self.action = action
+        self.value = value
+
+    def __call__(self, fn: _ActionHandler[T]) -> _ActionHandler[T]:
+        _validate_handler(fn)
+        _register_handler(self.auth, "store", self.action, fn)
+        return fn
+
+
+class _StoreOn:
+    def __init__(self, auth: Auth) -> None:
+        self._auth = auth
+        self.put = _StoreActionOn(auth, "put", types.StorePut)
+        """Register a handler for store put operations.
+
+        ???+ example "Example"
+            If using `@auth.on` to deny by default, register this handler to allow
+            put operations (scoped to the user's namespace):
+
+            ```python
+            @auth.on.store.put
+            async def allow_store_put(ctx: Auth.types.AuthContext, value: Auth.types.on.store.put.value):
+                # Allow puts, scoped to user's namespace
+                value["namespace"] = (ctx.user.identity, *value["namespace"])
+            ```
+        """
+        self.get = _StoreActionOn(auth, "get", types.StoreGet)
+        """Register a handler for store get operations.
+
+        ???+ example "Example"
+            If using `@auth.on` to deny by default, register this handler to allow
+            get operations (scoped to the user's namespace):
+
+            ```python
+            @auth.on.store.get
+            async def allow_store_get(ctx: Auth.types.AuthContext, value: Auth.types.on.store.get.value):
+                # Allow gets, scoped to user's namespace
+                value["namespace"] = (ctx.user.identity, *value["namespace"])
+            ```
+        """
+        self.search = _StoreActionOn(auth, "search", types.StoreSearch)
+        """Register a handler for store search operations.
+
+        ???+ example "Example"
+            If using `@auth.on` to deny by default, register this handler to allow
+            search operations (scoped to the user's namespace):
+
+            ```python
+            @auth.on.store.search
+            async def allow_store_search(ctx: Auth.types.AuthContext, value: Auth.types.on.store.search.value):
+                # Allow searches, scoped to user's namespace
+                value["namespace"] = (ctx.user.identity, *value["namespace"])
+            ```
+        """
+        self.delete = _StoreActionOn(auth, "delete", types.StoreDelete)
+        """Register a handler for store delete operations.
+
+        ???+ example "Example"
+            If using `@auth.on` to deny by default, register this handler to allow
+            delete operations (scoped to the user's namespace):
+
+            ```python
+            @auth.on.store.delete
+            async def allow_store_delete(ctx: Auth.types.AuthContext, value: Auth.types.on.store.delete.value):
+                # Allow deletes, scoped to user's namespace
+                value["namespace"] = (ctx.user.identity, *value["namespace"])
+            ```
+        """
+        self.list_namespaces = _StoreActionOn(
+            auth, "list_namespaces", types.StoreListNamespaces
+        )
+        """Register a handler for store list_namespaces operations.
+
+        ???+ example "Example"
+            If using `@auth.on` to deny by default, register this handler to allow
+            namespace listing (scoped to the user's prefix):
+
+            ```python
+            @auth.on.store.list_namespaces
+            async def allow_list_ns(ctx: Auth.types.AuthContext, value: Auth.types.on.store.list_namespaces.value):
+                # Allow listing, scoped to user's namespace prefix
+                value["namespace"] = (ctx.user.identity,)
+            ```
+        """
+
+    @typing.overload
+    def __call__(
+        self,
+        *,
+        actions: (
+            typing.Literal["put", "get", "search", "list_namespaces", "delete"]
+            | Sequence[
+                typing.Literal["put", "get", "search", "list_namespaces", "delete"]
+            ]
+            | None
+        ) = None,
+    ) -> Callable[[AHO], AHO]: ...
+
+    @typing.overload
+    def __call__(self, fn: AHO) -> AHO: ...
+
+    def __call__(
+        self,
+        fn: AHO | None = None,
+        *,
+        actions: (
+            typing.Literal["put", "get", "search", "list_namespaces", "delete"]
+            | Sequence[
+                typing.Literal["put", "get", "search", "list_namespaces", "delete"]
+            ]
+            | None
+        ) = None,
+    ) -> AHO | Callable[[AHO], AHO]:
+        """Register a handler for specific resources and actions.
+
+        Can be used as a decorator or with explicit resource/action parameters:
+
+        @auth.on.store
+        async def handler(): ... # Handle all store ops
+
+        @auth.on.store(actions=("put", "get", "search", "delete"))
+        async def handler(): ... # Handle specific store ops
+
+        @auth.on.store.put
+        async def handler(): ... # Handle store.put ops
+        """
+        if fn is not None:
+            # Used as a plain decorator
+            _register_handler(self._auth, "store", None, fn)
+            return fn
+
+        # Used with parameters, return a decorator
+        def decorator(
+            handler: AHO,
+        ) -> AHO:
+            if isinstance(actions, str):
+                action_list = [actions]
+            else:
+                action_list = list(actions) if actions is not None else ["*"]
+            for action in action_list:
+                _register_handler(self._auth, "store", action, handler)
+            return handler
+
+        return decorator
+
+
+AHO = typing.TypeVar("AHO", bound=_ActionHandler[dict[str, typing.Any]])
+
+
+class _On:
+    """Entry point for authorization handlers that control access to specific resources.
+
+    The _On class provides a flexible way to define authorization rules for different resources
+    and actions in your application. It supports three main usage patterns:
+
+    1. Global handlers that run for all resources and actions
+    2. Resource-specific handlers that run for all actions on a resource
+    3. Resource and action specific handlers for fine-grained control
+
+    Each handler must be an async function that accepts two parameters:
+    - ctx (AuthContext): Contains request context and authenticated user info
+    - value: The data being authorized (type varies by endpoint)
+
+    The handler should return one of:
+        - None or True: Accept the request
+        - False: Reject with 403 error
+        - FilterType: Apply filtering rules to the response
+
+    ???+ example "Examples"
+
+        Start by denying all requests by default with a global handler,
+        then add specific handlers to allow access:
+
+        ```python
+        # Default deny: reject all requests without a specific handler
+        @auth.on
+        async def deny_all(ctx: AuthContext, value: Any) -> False:
+            return False
+        ```
+
+        Resource-specific handler to allow access (takes precedence
+        over the global deny handler):
+
+        ```python
+        @auth.on.threads
+        async def allow_thread_access(ctx: AuthContext, value: Any) -> Auth.types.FilterType:
+            # Allow access only to threads owned by the user
+            return {"owner": ctx.user.identity}
+        ```
+
+        Resource and action specific handler:
+
+        ```python
+        @auth.on.threads.create
+        async def allow_thread_create(ctx: AuthContext, value: Any) -> None:
+            # Allow thread creation, stamping the owner
+            value.setdefault("metadata", {})["owner"] = ctx.user.identity
+        ```
+
+        Multiple resources or actions:
+
+        ```python
+        @auth.on(resources=["threads", "assistants"], actions=["read", "search"])
+        async def allow_reads(ctx: AuthContext, value: Any) -> Auth.types.FilterType:
+            # Allow read/search, scoped to user's resources
+            return {"owner": ctx.user.identity}
+        ```
+    """
+
+    __slots__ = (
+        "_auth",
+        "assistants",
+        "crons",
+        "runs",
+        "store",
+        "threads",
+        "value",
+    )
+
+    def __init__(self, auth: Auth) -> None:
+        self._auth = auth
+        self.assistants = _AssistantsOn(auth, "assistants")
+        self.threads = _ThreadsOn(auth, "threads")
+        self.crons = _CronsOn(auth, "crons")
+        self.store = _StoreOn(auth)
+        self.value = dict[str, typing.Any]
+
+    @typing.overload
+    def __call__(
+        self,
+        *,
+        resources: str | Sequence[str],
+        actions: str | Sequence[str] | None = None,
+    ) -> Callable[[AHO], AHO]: ...
+
+    @typing.overload
+    def __call__(self, fn: AHO) -> AHO: ...
+
+    def __call__(
+        self,
+        fn: AHO | None = None,
+        *,
+        resources: str | Sequence[str] | None = None,
+        actions: str | Sequence[str] | None = None,
+    ) -> AHO | Callable[[AHO], AHO]:
+        """Register a handler for specific resources and actions.
+
+        Can be used as a decorator or with explicit resource/action parameters:
+
+        @auth.on
+        async def handler(): ...  # Global handler
+
+        @auth.on(resources="threads")
+        async def handler(): ...  # types.Handler for all thread actions
+
+        @auth.on(resources="threads", actions="create")
+        async def handler(): ...  # types.Handler for thread creation
+        """
+        if fn is not None:
+            # Used as a plain decorator
+            _register_handler(self._auth, None, None, fn)
+            return fn
+
+        # Used with parameters, return a decorator
+        def decorator(
+            handler: AHO,
+        ) -> AHO:
+            if isinstance(resources, str):
+                resource_list = [resources]
+            else:
+                resource_list = list(resources) if resources is not None else ["*"]
+
+            if isinstance(actions, str):
+                action_list = [actions]
+            else:
+                action_list = list(actions) if actions is not None else ["*"]
+            for resource in resource_list:
+                for action in action_list:
+                    _register_handler(self._auth, resource, action, handler)
+            return handler
+
+        return decorator
+
+
+def _register_handler(
+    auth: Auth,
+    resource: str | None,
+    action: str | None,
+    fn: types.Handler,
+) -> types.Handler:
+    _validate_handler(fn)
+    resource = resource or "*"
+    action = action or "*"
+    if resource == "*" and action == "*":
+        if auth._global_handlers:
+            raise ValueError("Global handler already set.")
+        auth._global_handlers.append(fn)
+    else:
+        r = resource if resource is not None else "*"
+        a = action if action is not None else "*"
+        if (r, a) in auth._handlers:
+            raise ValueError(f"types.Handler already set for {r}, {a}.")
+        auth._handlers[(r, a)] = [fn]
+    return fn
+
+
+def _validate_handler(fn: Callable[..., typing.Any]) -> None:
+    """Validates that an auth handler function meets the required signature.
+
+    Auth handlers must:
+    1. Be async functions
+    2. Accept a ctx parameter of type AuthContext
+    3. Accept a value parameter for the data being authorized
+    """
+    if not inspect.iscoroutinefunction(fn):
+        raise ValueError(
+            f"Auth handler '{getattr(fn, '__name__', fn)}' must be an async function. "
+            "Add 'async' before 'def' to make it asynchronous and ensure"
+            " any IO operations are non-blocking."
+        )
+
+    sig = inspect.signature(fn)
+    if "ctx" not in sig.parameters:
+        raise ValueError(
+            f"Auth handler '{getattr(fn, '__name__', fn)}' must have a 'ctx: AuthContext' parameter. "
+            "Update the function signature to include this required parameter."
+        )
+    if "value" not in sig.parameters:
+        raise ValueError(
+            f"Auth handler '{getattr(fn, '__name__', fn)}' must have a 'value' parameter. "
+            " The value contains the mutable data being sent to the endpoint."
+            "Update the function signature to include this required parameter."
+        )
+
+
+def is_studio_user(
+    user: types.MinimalUser | types.BaseUser | types.MinimalUserDict,
+) -> bool:
+    return (
+        isinstance(user, types.StudioUser)
+        or (isinstance(user, dict) and user.get("kind") == "StudioUser")  # ty: ignore[invalid-argument-type]
+    )
+
+
+__all__ = ["Auth", "exceptions", "types"]

python/user_packages/Python313/site-packages/langgraph_sdk/auth/exceptions.py

@@ -0,0 +1,59 @@
+"""Exceptions used in the auth system."""
+
+from __future__ import annotations
+
+import http
+from collections.abc import Mapping
+
+
+class HTTPException(Exception):
+    """HTTP exception that you can raise to return a specific HTTP error response.
+
+    Since this is defined in the auth module, we default to a 401 status code.
+
+    Args:
+        status_code: HTTP status code for the error. Defaults to 401 "Unauthorized".
+        detail: Detailed error message. If `None`, uses a default
+            message based on the status code.
+        headers: Additional HTTP headers to include in the error response.
+
+    Example:
+        Default:
+        ```python
+        raise HTTPException()
+        # HTTPException(status_code=401, detail='Unauthorized')
+        ```
+
+        Add headers:
+        ```python
+        raise HTTPException(headers={"X-Custom-Header": "Custom Value"})
+        # HTTPException(status_code=401, detail='Unauthorized', headers={"WWW-Authenticate": "Bearer"})
+        ```
+
+        Custom error:
+        ```python
+        raise HTTPException(status_code=404, detail="Not found")
+        ```
+    """
+
+    def __init__(
+        self,
+        status_code: int = 401,
+        detail: str | None = None,
+        headers: Mapping[str, str] | None = None,
+    ) -> None:
+        if detail is None:
+            detail = http.HTTPStatus(status_code).phrase
+        self.status_code = status_code
+        self.detail = detail
+        self.headers = headers
+
+    def __str__(self) -> str:
+        return f"{self.status_code}: {self.detail}"
+
+    def __repr__(self) -> str:
+        class_name = self.__class__.__name__
+        return f"{class_name}(status_code={self.status_code!r}, detail={self.detail!r})"
+
+
+__all__ = ["HTTPException"]

python/user_packages/Python313/site-packages/langgraph_sdk/auth/types.py

@@ -0,0 +1,1162 @@
+"""Authentication and authorization types for LangGraph.
+
+This module defines the core types used for authentication, authorization, and
+request handling in LangGraph. It includes user protocols, authentication contexts,
+and typed dictionaries for various API operations.
+
+Note:
+    All typing.TypedDict classes use total=False to make all fields typing.Optional by default.
+"""
+
+from __future__ import annotations
+
+import typing
+from collections.abc import Awaitable, Callable, Sequence
+from dataclasses import dataclass
+from datetime import datetime
+from uuid import UUID
+
+import typing_extensions
+
+RunStatus = typing.Literal["pending", "error", "success", "timeout", "interrupted"]
+"""Status of a run execution.
+
+Values:
+    - pending: Run is queued or in progress
+    - error: Run failed with an error
+    - success: Run completed successfully  
+    - timeout: Run exceeded time limit
+    - interrupted: Run was manually interrupted
+"""
+
+MultitaskStrategy = typing.Literal["reject", "rollback", "interrupt", "enqueue"]
+"""Strategy for handling multiple concurrent tasks.
+
+Values:
+    - reject: Reject new tasks while one is in progress
+    - rollback: Cancel current task and start new one
+    - interrupt: Interrupt current task and start new one
+    - enqueue: Queue new tasks to run after current one
+"""
+
+OnConflictBehavior = typing.Literal["raise", "do_nothing"]
+"""Behavior when encountering conflicts.
+
+Values:
+    - raise: Raise an exception on conflict
+    - do_nothing: Silently ignore conflicts
+"""
+
+IfNotExists = typing.Literal["create", "reject"]
+"""Behavior when an entity doesn't exist.
+
+Values:
+    - create: Create the entity
+    - reject: Reject the operation
+"""
+
+FilterType = (
+    dict[
+        str,
+        str
+        | dict[typing.Literal["$eq", "$contains"], str]
+        | dict[typing.Literal["$contains"], list[str]],
+    ]
+    | dict[str, str]
+)
+"""Response type for authorization handlers.
+
+Supports exact matches and operators:
+    - Exact match shorthand: {"field": "value"}
+    - Exact match: {"field": {"$eq": "value"}}
+    - Contains (membership): {"field": {"$contains": "value"}}
+    - Contains (subset containment): {"field": {"$contains": ["value1", "value2"]}}
+
+Subset containment is only supported by newer versions of the LangGraph dev server;
+install langgraph-runtime-inmem >= 0.14.1 to use this filter variant.
+
+???+ example "Examples"
+
+    Simple exact match filter for the resource owner:
+
+    ```python
+    filter = {"owner": "user-abcd123"}
+    ```
+
+    Explicit version of the exact match filter:
+
+    ```python
+    filter = {"owner": {"$eq": "user-abcd123"}}
+    ```
+
+    Containment (membership of a single element):
+
+    ```python
+    filter = {"participants": {"$contains": "user-abcd123"}}
+    ```
+
+    Containment (subset containment; all values must be present, but order doesn't matter):
+
+    ```python
+    filter = {"participants": {"$contains": ["user-abcd123", "user-efgh456"]}}
+    ```
+
+    Combining filters (treated as a logical `AND`):
+
+    ```python
+    filter = {"owner": "user-abcd123", "participants": {"$contains": "user-efgh456"}}
+    ```
+"""
+
+ThreadStatus = typing.Literal["idle", "busy", "interrupted", "error"]
+"""Status of a thread.
+
+Values:
+    - idle: Thread is available for work
+    - busy: Thread is currently processing
+    - interrupted: Thread was interrupted
+    - error: Thread encountered an error
+"""
+
+MetadataInput = dict[str, typing.Any]
+"""Type for arbitrary metadata attached to entities.
+
+Allows storing custom key-value pairs with any entity.
+Keys must be strings, values can be any JSON-serializable type.
+
+???+ example "Examples"
+
+    ```python
+    metadata = {
+        "created_by": "user123",
+        "priority": 1,
+        "tags": ["important", "urgent"]
+    }
+    ```
+"""
+
+HandlerResult = None | bool | FilterType
+"""The result of a handler can be:
+    * None | True: accept the request.
+    * False: reject the request with a 403 error
+    * FilterType: filter to apply
+"""
+
+Handler = Callable[..., Awaitable[HandlerResult]]
+
+T = typing.TypeVar("T")
+
+
+@typing.runtime_checkable
+class MinimalUser(typing.Protocol):
+    """User objects must at least expose the identity property."""
+
+    @property
+    def identity(self) -> str:
+        """The unique identifier for the user.
+
+        This could be a username, email, or any other unique identifier used
+        to distinguish between different users in the system.
+        """
+        ...
+
+
+class MinimalUserDict(typing.TypedDict, total=False):
+    """The dictionary representation of a user."""
+
+    identity: typing_extensions.Required[str]
+    """The required unique identifier for the user."""
+    display_name: str
+    """The typing.Optional display name for the user."""
+    is_authenticated: bool
+    """Whether the user is authenticated. Defaults to True."""
+    permissions: Sequence[str]
+    """A list of permissions associated with the user.
+    
+    You can use these in your `@auth.on` authorization logic to determine
+    access permissions to different resources.
+    """
+
+
+@typing.runtime_checkable
+class BaseUser(typing.Protocol):
+    """The base ASGI user protocol"""
+
+    @property
+    def is_authenticated(self) -> bool:
+        """Whether the user is authenticated."""
+        ...
+
+    @property
+    def display_name(self) -> str:
+        """The display name of the user."""
+        ...
+
+    @property
+    def identity(self) -> str:
+        """The unique identifier for the user."""
+        ...
+
+    @property
+    def permissions(self) -> Sequence[str]:
+        """The permissions associated with the user."""
+        ...
+
+    def __getitem__(self, key):
+        """Get a key from your minimal user dict."""
+        ...
+
+    def __contains__(self, key):
+        """Check if a property exists."""
+        ...
+
+    def __iter__(self):
+        """Iterate over the keys of the user."""
+        ...
+
+
+class StudioUser:
+    """A user object that's populated from authenticated requests from the LangGraph studio.
+
+    Note: Studio auth can be disabled in your `langgraph.json` config.
+
+    ```json
+    {
+      "auth": {
+        "disable_studio_auth": true
+      }
+    }
+    ```
+
+    You can use `isinstance` checks in your authorization handlers (`@auth.on`) to control access specifically
+    for developers accessing the instance from the LangGraph Studio UI.
+
+    ???+ example "Examples"
+
+        Use `@auth.on` to deny by default, but allow Studio users through:
+
+        ```python
+        @auth.on
+        async def deny_all_except_studio(ctx: Auth.types.AuthContext, value: Any) -> bool:
+            # Allow Studio users, deny everyone else by default
+            if isinstance(ctx.user, Auth.types.StudioUser):
+                return True
+            return False
+
+        # Then add specific handlers to allow access for non-Studio users
+        @auth.on.threads
+        async def allow_thread_access(ctx: Auth.types.AuthContext, value: Any) -> Auth.types.FilterType:
+            return {"owner": ctx.user.identity}
+        ```
+    """
+
+    __slots__ = ("_is_authenticated", "_permissions", "username")
+
+    def __init__(self, username: str, is_authenticated: bool = False) -> None:
+        self.username = username
+        self._is_authenticated = is_authenticated
+        self._permissions = ["authenticated"] if is_authenticated else []
+
+    @property
+    def is_authenticated(self) -> bool:
+        return self._is_authenticated
+
+    @property
+    def display_name(self) -> str:
+        return self.username
+
+    @property
+    def identity(self) -> str:
+        return self.username
+
+    @property
+    def permissions(self) -> Sequence[str]:
+        return self._permissions
+
+
+Authenticator = Callable[
+    ...,
+    Awaitable[
+        MinimalUser
+        | str
+        | BaseUser
+        | MinimalUserDict
+        | typing.Mapping[str, typing.Any],
+    ],
+]
+"""Type for authentication functions.
+
+An authenticator can return either:
+1. A string (user_id)
+2. A dict containing {"identity": str, "permissions": list[str]}
+3. An object with identity and permissions properties
+
+Permissions can be used downstream by your authorization logic to determine
+access permissions to different resources.
+
+The authenticate decorator will automatically inject any of the following parameters
+by name if they are included in your function signature:
+
+Parameters:
+    request (Request): The raw ASGI request object
+    body (dict): The parsed request body
+    path (str): The request path
+    method (str): The HTTP method (GET, POST, etc.)
+    path_params (dict[str, str] | None): URL path parameters
+    query_params (dict[str, str] | None): URL query parameters
+    headers (dict[str, bytes] | None): Request headers
+    authorization (str | None): The Authorization header value (e.g. "Bearer <token>")
+
+???+ example "Examples"
+
+    Basic authentication with token:
+
+    ```python
+    from langgraph_sdk import Auth
+
+    auth = Auth()
+
+    @auth.authenticate
+    async def authenticate1(authorization: str) -> Auth.types.MinimalUserDict:
+        return await get_user(authorization)
+    ```
+
+    Authentication with multiple parameters:
+
+    ```    
+    @auth.authenticate
+    async def authenticate2(
+        method: str,
+        path: str,
+        headers: dict[str, bytes]
+    ) -> Auth.types.MinimalUserDict:
+        # Custom auth logic using method, path and headers
+        user = verify_request(method, path, headers)
+        return user
+    ```
+
+    Accepting the raw ASGI request:
+
+    ```python
+    MY_SECRET = "my-secret-key"
+    @auth.authenticate
+    async def get_current_user(request: Request) -> Auth.types.MinimalUserDict:
+        try:
+            token = (request.headers.get("authorization") or "").split(" ", 1)[1]
+            payload = jwt.decode(token, MY_SECRET, algorithms=["HS256"])
+        except (IndexError, InvalidTokenError):
+            raise HTTPException(
+                status_code=401,
+                detail="Invalid token",
+                headers={"WWW-Authenticate": "Bearer"},
+            )
+
+        async with httpx.AsyncClient() as client:
+            response = await client.get(
+                f"https://api.myauth-provider.com/auth/v1/user",
+                headers={"Authorization": f"Bearer {MY_SECRET}"}
+            )
+            if response.status_code != 200:
+                raise HTTPException(status_code=401, detail="User not found")
+                
+            user_data = response.json()
+            return {
+                "identity": user_data["id"],
+                "display_name": user_data.get("name"),
+                "permissions": user_data.get("permissions", []),
+                "is_authenticated": True,
+            }
+    ```
+"""
+
+
+@dataclass(slots=True)
+class BaseAuthContext:
+    """Base class for authentication context.
+
+    Provides the fundamental authentication information needed for
+    authorization decisions.
+    """
+
+    permissions: Sequence[str]
+    """The permissions granted to the authenticated user."""
+
+    user: BaseUser
+    """The authenticated user."""
+
+
+@typing.final
+@dataclass(slots=True)
+class AuthContext(BaseAuthContext):
+    """Complete authentication context with resource and action information.
+
+    Extends BaseAuthContext with specific resource and action being accessed,
+    allowing for fine-grained access control decisions.
+    """
+
+    resource: typing.Literal["runs", "threads", "crons", "assistants", "store"]
+    """The resource being accessed."""
+
+    action: typing.Literal[
+        "create",
+        "read",
+        "update",
+        "delete",
+        "search",
+        "create_run",
+        "put",
+        "get",
+        "list_namespaces",
+    ]
+    """The action being performed on the resource.
+
+    Most resources support the following actions:
+    - create: Create a new resource
+    - read: Read information about a resource
+    - update: Update an existing resource
+    - delete: Delete a resource
+    - search: Search for resources
+
+    The store supports the following actions:
+    - put: Add or update an item in the store
+    - get: Get an item from the store
+    - search: Search for items within a namespace prefix
+    - delete: Delete an item from the store
+    - list_namespaces: List the namespaces in the store
+    """
+
+
+class ThreadTTL(typing.TypedDict, total=False):
+    """Time-to-live configuration for a thread.
+
+    Matches the OpenAPI schema where TTL is represented as an object with
+    an optional strategy and a time value in minutes.
+    """
+
+    strategy: typing.Literal["delete"]
+    """TTL strategy. Currently only 'delete' is supported."""
+
+    ttl: int
+    """Time-to-live in minutes from now until the thread should be swept."""
+
+
+class ThreadsCreate(typing.TypedDict, total=False):
+    """Parameters for creating a new thread.
+
+    ???+ example "Examples"
+
+        ```python
+        create_params = {
+            "thread_id": UUID("123e4567-e89b-12d3-a456-426614174000"),
+            "metadata": {"owner": "user123"},
+            "if_exists": "do_nothing"
+        }
+        ```
+    """
+
+    thread_id: UUID
+    """Unique identifier for the thread."""
+
+    metadata: MetadataInput
+    """typing.Optional metadata to attach to the thread."""
+
+    if_exists: OnConflictBehavior
+    """Behavior when a thread with the same ID already exists."""
+
+    ttl: ThreadTTL
+    """Optional TTL configuration for the thread."""
+
+
+class ThreadsRead(typing.TypedDict, total=False):
+    """Parameters for reading thread state or run information.
+
+    This type is used in three contexts:
+    1. Reading thread, thread version, or thread state information: Only thread_id is provided
+    2. Reading run information: Both thread_id and run_id are provided
+    """
+
+    thread_id: UUID
+    """Unique identifier for the thread."""
+
+    run_id: UUID | None
+    """Run ID to filter by. Only used when reading run information within a thread."""
+
+
+class ThreadsUpdate(typing.TypedDict, total=False):
+    """Parameters for updating a thread or run.
+
+    Called for updates to a thread, thread version, or run
+    cancellation.
+    """
+
+    thread_id: UUID
+    """Unique identifier for the thread."""
+
+    metadata: MetadataInput
+    """typing.Optional metadata to update."""
+
+    action: typing.Literal["interrupt", "rollback"] | None
+    """typing.Optional action to perform on the thread."""
+
+
+class ThreadsDelete(typing.TypedDict, total=False):
+    """Parameters for deleting a thread.
+
+    Called for deletes to a thread, thread version, or run
+    """
+
+    thread_id: UUID
+    """Unique identifier for the thread."""
+
+    run_id: UUID | None
+    """typing.Optional run ID to filter by."""
+
+
+class ThreadsSearch(typing.TypedDict, total=False):
+    """Parameters for searching threads.
+
+    Called for searches to threads or runs.
+    """
+
+    metadata: MetadataInput
+    """typing.Optional metadata to filter by."""
+
+    values: MetadataInput
+    """typing.Optional values to filter by."""
+
+    status: ThreadStatus | None
+    """typing.Optional status to filter by."""
+
+    limit: int
+    """Maximum number of results to return."""
+
+    offset: int
+    """Offset for pagination."""
+
+    ids: Sequence[UUID] | None
+    """typing.Optional list of thread IDs to filter by."""
+
+    thread_id: UUID | None
+    """typing.Optional thread ID to filter by."""
+
+
+class RunsCreate(typing.TypedDict, total=False):
+    """Payload for creating a run.
+
+    ???+ example "Examples"
+
+        ```python
+        create_params = {
+            "assistant_id": UUID("123e4567-e89b-12d3-a456-426614174000"),
+            "thread_id": UUID("123e4567-e89b-12d3-a456-426614174001"),
+            "run_id": UUID("123e4567-e89b-12d3-a456-426614174002"),
+            "status": "pending",
+            "metadata": {"owner": "user123"},
+            "prevent_insert_if_inflight": True,
+            "multitask_strategy": "reject",
+            "if_not_exists": "create",
+            "after_seconds": 10,
+            "kwargs": {"key": "value"},
+            "action": "interrupt"
+        }
+        ```
+    """
+
+    assistant_id: UUID | None
+    """typing.Optional assistant ID to use for this run."""
+
+    thread_id: UUID | None
+    """typing.Optional thread ID to use for this run."""
+
+    run_id: UUID | None
+    """typing.Optional run ID to use for this run."""
+
+    status: RunStatus | None
+    """typing.Optional status for this run."""
+
+    metadata: MetadataInput
+    """typing.Optional metadata for the run."""
+
+    prevent_insert_if_inflight: bool
+    """Prevent inserting a new run if one is already in flight."""
+
+    multitask_strategy: MultitaskStrategy
+    """Multitask strategy for this run."""
+
+    if_not_exists: IfNotExists
+    """IfNotExists for this run."""
+
+    after_seconds: int
+    """Number of seconds to wait before creating the run."""
+
+    kwargs: dict[str, typing.Any]
+    """Keyword arguments to pass to the run."""
+
+    action: typing.Literal["interrupt", "rollback"] | None
+    """Action to take if updating an existing run."""
+
+
+class AssistantsCreate(typing.TypedDict, total=False):
+    """Payload for creating an assistant.
+
+    ???+ example "Examples"
+
+        ```python
+        create_params = {
+            "assistant_id": UUID("123e4567-e89b-12d3-a456-426614174000"),
+            "graph_id": "graph123",
+            "config": {"tags": ["tag1", "tag2"]},
+            "context": {"key": "value"},
+            "metadata": {"owner": "user123"},
+            "if_exists": "do_nothing",
+            "name": "Assistant 1"
+        }
+        ```
+    """
+
+    assistant_id: UUID
+    """Unique identifier for the assistant."""
+
+    graph_id: str
+    """Graph ID to use for this assistant."""
+
+    config: dict[str, typing.Any]
+    """typing.Optional configuration for the assistant."""
+
+    context: dict[str, typing.Any]
+
+    metadata: MetadataInput
+    """typing.Optional metadata to attach to the assistant."""
+
+    if_exists: OnConflictBehavior
+    """Behavior when an assistant with the same ID already exists."""
+
+    name: str
+    """Name of the assistant."""
+
+
+class AssistantsRead(typing.TypedDict, total=False):
+    """Payload for reading an assistant.
+
+    ???+ example "Examples"
+
+        ```python
+        read_params = {
+            "assistant_id": UUID("123e4567-e89b-12d3-a456-426614174000"),
+            "metadata": {"owner": "user123"}
+        }
+        ```
+    """
+
+    assistant_id: UUID
+    """Unique identifier for the assistant."""
+
+    metadata: MetadataInput
+    """typing.Optional metadata to filter by."""
+
+
+class AssistantsUpdate(typing.TypedDict, total=False):
+    """Payload for updating an assistant.
+
+    ???+ example "Examples"
+
+        ```python
+        update_params = {
+            "assistant_id": UUID("123e4567-e89b-12d3-a456-426614174000"),
+            "graph_id": "graph123",
+            "config": {"tags": ["tag1", "tag2"]},
+            "context": {"key": "value"},
+            "metadata": {"owner": "user123"},
+            "name": "Assistant 1",
+            "version": 1
+        }
+        ```
+    """
+
+    assistant_id: UUID
+    """Unique identifier for the assistant."""
+
+    graph_id: str | None
+    """typing.Optional graph ID to update."""
+
+    config: dict[str, typing.Any]
+    """typing.Optional configuration to update."""
+
+    context: dict[str, typing.Any]
+    """The static context of the assistant."""
+
+    metadata: MetadataInput
+    """typing.Optional metadata to update."""
+
+    name: str | None
+    """typing.Optional name to update."""
+
+    version: int | None
+    """typing.Optional version to update."""
+
+
+class AssistantsDelete(typing.TypedDict):
+    """Payload for deleting an assistant.
+
+    ???+ example "Examples"
+
+        ```python
+        delete_params = {
+            "assistant_id": UUID("123e4567-e89b-12d3-a456-426614174000")
+        }
+        ```
+    """
+
+    assistant_id: UUID
+    """Unique identifier for the assistant."""
+
+
+class AssistantsSearch(typing.TypedDict):
+    """Payload for searching assistants.
+
+    ???+ example "Examples"
+
+        ```python
+        search_params = {
+            "graph_id": "graph123",
+            "metadata": {"owner": "user123"},
+            "limit": 10,
+            "offset": 0
+        }
+        ```
+    """
+
+    graph_id: str | None
+    """typing.Optional graph ID to filter by."""
+
+    metadata: MetadataInput
+    """typing.Optional metadata to filter by."""
+
+    limit: int
+    """Maximum number of results to return."""
+
+    offset: int
+    """Offset for pagination."""
+
+
+class CronsCreate(typing.TypedDict, total=False):
+    """Payload for creating a cron job.
+
+    ???+ example "Examples"
+
+        ```python
+        create_params = {
+            "payload": {"key": "value"},
+            "schedule": "0 0 * * *",
+            "cron_id": UUID("123e4567-e89b-12d3-a456-426614174000"),
+            "thread_id": UUID("123e4567-e89b-12d3-a456-426614174001"),
+            "user_id": "user123",
+            "end_time": datetime(2024, 3, 16, 10, 0, 0)
+        }
+        ```
+    """
+
+    payload: dict[str, typing.Any]
+    """Payload for the cron job."""
+
+    schedule: str
+    """Schedule for the cron job."""
+
+    cron_id: UUID | None
+    """typing.Optional unique identifier for the cron job."""
+
+    thread_id: UUID | None
+    """typing.Optional thread ID to use for this cron job."""
+
+    user_id: str | None
+    """typing.Optional user ID to use for this cron job."""
+
+    end_time: datetime | None
+    """typing.Optional end time for the cron job."""
+
+
+class CronsDelete(typing.TypedDict):
+    """Payload for deleting a cron job.
+
+    ???+ example "Examples"
+
+        ```python
+        delete_params = {
+            "cron_id": UUID("123e4567-e89b-12d3-a456-426614174000")
+        }
+        ```
+    """
+
+    cron_id: UUID
+    """Unique identifier for the cron job."""
+
+
+class CronsRead(typing.TypedDict):
+    """Payload for reading a cron job.
+
+    ???+ example "Examples"
+
+        ```python
+        read_params = {
+            "cron_id": UUID("123e4567-e89b-12d3-a456-426614174000")
+        }
+        ```
+    """
+
+    cron_id: UUID
+    """Unique identifier for the cron job."""
+
+
+class CronsUpdate(typing.TypedDict, total=False):
+    """Payload for updating a cron job.
+
+    ???+ example "Examples"
+
+        ```python
+        update_params = {
+            "cron_id": UUID("123e4567-e89b-12d3-a456-426614174000"),
+            "payload": {"key": "value"},
+            "schedule": "0 0 * * *"
+        }
+        ```
+    """
+
+    cron_id: UUID
+    """Unique identifier for the cron job."""
+
+    payload: dict[str, typing.Any] | None
+    """typing.Optional payload to update."""
+
+    schedule: str | None
+    """typing.Optional schedule to update."""
+
+
+class CronsSearch(typing.TypedDict, total=False):
+    """Payload for searching cron jobs.
+
+    ???+ example "Examples"
+
+        ```python
+        search_params = {
+            "assistant_id": UUID("123e4567-e89b-12d3-a456-426614174000"),
+            "thread_id": UUID("123e4567-e89b-12d3-a456-426614174001"),
+            "limit": 10,
+            "offset": 0
+        }
+        ```
+    """
+
+    assistant_id: UUID | None
+    """typing.Optional assistant ID to filter by."""
+
+    thread_id: UUID | None
+    """typing.Optional thread ID to filter by."""
+
+    limit: int
+    """Maximum number of results to return."""
+
+    offset: int
+    """Offset for pagination."""
+
+
+class StoreGet(typing.TypedDict):
+    """Operation to retrieve a specific item by its namespace and key.
+
+    This dict is mutable — auth handlers can modify `namespace` to enforce
+    access scoping (e.g., prepending the user's identity).
+    """
+
+    namespace: tuple[str, ...]
+    """Hierarchical path that uniquely identifies the item's location.
+
+    Auth handlers can modify this to enforce per-user scoping.
+    """
+
+    key: str
+    """Unique identifier for the item within its specific namespace."""
+
+
+class StoreSearch(typing.TypedDict):
+    """Operation to search for items within a specified namespace hierarchy.
+
+    This dict is mutable — auth handlers can modify `namespace` to enforce
+    access scoping (e.g., prepending the user's identity).
+    """
+
+    namespace: tuple[str, ...]
+    """Prefix filter for defining the search scope.
+
+    Auth handlers can modify this to enforce per-user scoping.
+    """
+
+    filter: dict[str, typing.Any] | None
+    """Key-value pairs for filtering results based on exact matches or comparison operators."""
+
+    limit: int
+    """Maximum number of items to return in the search results."""
+
+    offset: int
+    """Number of matching items to skip for pagination."""
+
+    query: str | None
+    """Natural language search query for semantic search capabilities."""
+
+
+class StoreListNamespaces(typing.TypedDict):
+    """Operation to list and filter namespaces in the store.
+
+    This dict is mutable — auth handlers can modify `namespace` (the prefix)
+    to enforce access scoping (e.g., prepending the user's identity).
+    """
+
+    namespace: tuple[str, ...] | None
+    """Prefix filter for namespaces. Can be `None` if no prefix was provided.
+
+    Auth handlers can modify this to enforce per-user scoping. When `None`,
+    handlers should set it to `(user_id,)` to scope listing to the user's namespaces.
+    """
+
+    suffix: tuple[str, ...] | None
+    """Optional conditions for filtering namespaces."""
+
+    max_depth: int | None
+    """Maximum depth of namespace hierarchy to return.
+
+    Note:
+        Namespaces deeper than this level will be truncated.
+    """
+
+    limit: int
+    """Maximum number of namespaces to return."""
+
+    offset: int
+    """Number of namespaces to skip for pagination."""
+
+
+class StorePut(typing.TypedDict):
+    """Operation to store, update, or delete an item in the store.
+
+    This dict is mutable — auth handlers can modify `namespace` to enforce
+    access scoping (e.g., prepending the user's identity).
+    """
+
+    namespace: tuple[str, ...]
+    """Hierarchical path that identifies the location of the item.
+
+    Auth handlers can modify this to enforce per-user scoping.
+    """
+
+    key: str
+    """Unique identifier for the item within its namespace."""
+
+    value: dict[str, typing.Any] | None
+    """The data to store, or `None` to mark the item for deletion."""
+
+    index: typing.Literal[False] | list[str] | None
+    """Optional index configuration for full-text search."""
+
+
+class StoreDelete(typing.TypedDict):
+    """Operation to delete an item from the store.
+
+    This dict is mutable — auth handlers can modify `namespace` to enforce
+    access scoping (e.g., prepending the user's identity).
+    """
+
+    namespace: tuple[str, ...]
+    """Hierarchical path that uniquely identifies the item's location.
+
+    Auth handlers can modify this to enforce per-user scoping.
+    """
+
+    key: str
+    """Unique identifier for the item within its specific namespace."""
+
+
+class on:
+    """Namespace for type definitions of different API operations.
+
+    This class organizes type definitions for create, read, update, delete,
+    and search operations across different resources (threads, assistants, crons).
+
+    ???+ note "Usage"
+        Start by denying all requests by default, then add handlers to allow access:
+
+        ```python
+        from langgraph_sdk import Auth
+
+        auth = Auth()
+
+        # Default deny: reject all requests without a specific handler
+        @auth.on
+        async def deny_all(ctx: Auth.types.AuthContext, value: Auth.on.value):
+            return False
+
+        # Allow thread creation, stamping the owner
+        @auth.on.threads.create
+        async def allow_thread_create(ctx: Auth.types.AuthContext, value: Auth.on.threads.create.value):
+            value.setdefault("metadata", {})["owner"] = ctx.user.identity
+
+        # Allow assistant search, scoped to user's resources
+        @auth.on.assistants.search
+        async def allow_assistant_search(ctx: Auth.types.AuthContext, value: Auth.on.assistants.search.value):
+            return {"owner": ctx.user.identity}
+        ```
+    """
+
+    value = dict[str, typing.Any]
+
+    class threads:
+        """Types for thread-related operations."""
+
+        value = (
+            ThreadsCreate | ThreadsRead | ThreadsUpdate | ThreadsDelete | ThreadsSearch
+        )
+
+        class create:
+            """Type for thread creation parameters."""
+
+            value = ThreadsCreate
+
+        class create_run:
+            """Type for creating or streaming a run."""
+
+            value = RunsCreate
+
+        class read:
+            """Type for thread read parameters."""
+
+            value = ThreadsRead
+
+        class update:
+            """Type for thread update parameters."""
+
+            value = ThreadsUpdate
+
+        class delete:
+            """Type for thread deletion parameters."""
+
+            value = ThreadsDelete
+
+        class search:
+            """Type for thread search parameters."""
+
+            value = ThreadsSearch
+
+    class assistants:
+        """Types for assistant-related operations."""
+
+        value = (
+            AssistantsCreate
+            | AssistantsRead
+            | AssistantsUpdate
+            | AssistantsDelete
+            | AssistantsSearch
+        )
+
+        class create:
+            """Type for assistant creation parameters."""
+
+            value = AssistantsCreate
+
+        class read:
+            """Type for assistant read parameters."""
+
+            value = AssistantsRead
+
+        class update:
+            """Type for assistant update parameters."""
+
+            value = AssistantsUpdate
+
+        class delete:
+            """Type for assistant deletion parameters."""
+
+            value = AssistantsDelete
+
+        class search:
+            """Type for assistant search parameters."""
+
+            value = AssistantsSearch
+
+    class crons:
+        """Types for cron-related operations."""
+
+        value = CronsCreate | CronsRead | CronsUpdate | CronsDelete | CronsSearch
+
+        class create:
+            """Type for cron creation parameters."""
+
+            value = CronsCreate
+
+        class read:
+            """Type for cron read parameters."""
+
+            value = CronsRead
+
+        class update:
+            """Type for cron update parameters."""
+
+            value = CronsUpdate
+
+        class delete:
+            """Type for cron deletion parameters."""
+
+            value = CronsDelete
+
+        class search:
+            """Type for cron search parameters."""
+
+            value = CronsSearch
+
+    class store:
+        """Types for store-related operations."""
+
+        value = StoreGet | StoreSearch | StoreListNamespaces | StorePut | StoreDelete
+
+        class put:
+            """Type for store put parameters."""
+
+            value = StorePut
+
+        class get:
+            """Type for store get parameters."""
+
+            value = StoreGet
+
+        class search:
+            """Type for store search parameters."""
+
+            value = StoreSearch
+
+        class delete:
+            """Type for store delete parameters."""
+
+            value = StoreDelete
+
+        class list_namespaces:
+            """Type for store list namespaces parameters."""
+
+            value = StoreListNamespaces
+
+
+__all__ = [
+    "AssistantsCreate",
+    "AssistantsDelete",
+    "AssistantsRead",
+    "AssistantsSearch",
+    "AssistantsUpdate",
+    "MetadataInput",
+    "RunsCreate",
+    "StoreDelete",
+    "StoreGet",
+    "StoreListNamespaces",
+    "StorePut",
+    "StoreSearch",
+    "ThreadsCreate",
+    "ThreadsDelete",
+    "ThreadsRead",
+    "ThreadsSearch",
+    "ThreadsUpdate",
+    "on",
+]

python/user_packages/Python313/site-packages/langgraph_sdk/encryption/__init__.py

@@ -0,0 +1,466 @@
+"""Custom encryption support for LangGraph.
+
+.. warning::
+    This API is in beta and may change in future versions.
+
+This module provides a framework for implementing custom at-rest encryption
+in LangGraph applications. Similar to the Auth system, it allows developers
+to define custom encryption and decryption handlers that are executed
+server-side.
+"""
+
+from __future__ import annotations
+
+import functools
+import inspect
+import typing
+import warnings
+
+from langgraph_sdk.encryption import types
+
+
+class LangGraphBetaWarning(UserWarning):
+    """Warning for beta features in LangGraph SDK."""
+
+
+@functools.lru_cache(maxsize=1)
+def _warn_encryption_beta() -> None:
+    warnings.warn(
+        "The Encryption API is in beta and may change in future versions.",
+        LangGraphBetaWarning,
+        stacklevel=4,
+    )
+
+
+class DuplicateHandlerError(Exception):
+    """Raised when attempting to register a duplicate encryption/decryption handler."""
+
+    pass
+
+
+def _validate_handler(fn: typing.Callable, handler_type: str) -> None:
+    """Validate that a handler function has the correct signature.
+
+    Args:
+        fn: The handler function to validate
+        handler_type: Description of the handler for error messages
+
+    Raises:
+        TypeError: If the handler is not an async function or has wrong parameter count
+    """
+    if not inspect.iscoroutinefunction(fn):
+        raise TypeError(f"{handler_type} must be an async function, got {type(fn)}")
+
+    sig = inspect.signature(fn)
+    params = [
+        p
+        for p in sig.parameters.values()
+        if p.kind in (p.POSITIONAL_ONLY, p.POSITIONAL_OR_KEYWORD)
+    ]
+    if len(params) != 2:
+        raise TypeError(
+            f"{handler_type} must accept exactly 2 parameters "
+            f"(ctx, data), got {len(params)}"
+        )
+
+
+class _EncryptDecorators:
+    """Decorators for encryption handlers.
+
+    Provides @encryption.encrypt.blob and @encryption.encrypt.json decorators for
+    registering encryption functions.
+    """
+
+    def __init__(self, parent: Encryption):
+        self._parent = parent
+
+    def blob(self, fn: types.BlobEncryptor) -> types.BlobEncryptor:
+        """Register a blob encryption handler.
+
+        The handler will be called to encrypt opaque data like checkpoint blobs.
+
+        Example:
+            ```python
+            @encryption.encrypt.blob
+            async def encrypt_blob(ctx: EncryptionContext, blob: bytes) -> bytes:
+                # Encrypt the blob using your encryption service
+                return encrypted_blob
+            ```
+
+        Args:
+            fn: The encryption handler function
+
+        Returns:
+            The registered handler function
+
+        Raises:
+            DuplicateHandlerError: If blob encryptor already registered
+            TypeError: If handler has invalid signature
+        """
+        if self._parent._blob_encryptor is not None:
+            raise DuplicateHandlerError("Blob encryptor already registered")
+        _validate_handler(fn, "Blob encryptor")
+        self._parent._blob_encryptor = fn
+        return fn
+
+    def json(self, fn: types.JsonEncryptor) -> types.JsonEncryptor:
+        """Register the JSON encryption handler.
+
+        Example:
+            ```python
+            @encryption.encrypt.json
+            async def encrypt_json(ctx: EncryptionContext, data: dict) -> dict:
+                # Encrypt the data
+                return encrypt_data(data)
+            ```
+
+        Args:
+            fn: The encryption handler function
+
+        Returns:
+            The registered handler function
+
+        Raises:
+            DuplicateHandlerError: If JSON encryptor already registered
+            TypeError: If handler has invalid signature
+        """
+        if self._parent._json_encryptor is not None:
+            raise DuplicateHandlerError("JSON encryptor already registered")
+        _validate_handler(fn, "JSON encryptor")
+        self._parent._json_encryptor = fn
+        return fn
+
+
+class _DecryptDecorators:
+    """Decorators for decryption handlers.
+
+    Provides @encryption.decrypt.blob and @encryption.decrypt.json decorators for
+    registering decryption functions.
+    """
+
+    def __init__(self, parent: Encryption):
+        self._parent = parent
+
+    def blob(self, fn: types.BlobDecryptor) -> types.BlobDecryptor:
+        """Register a blob decryption handler.
+
+        The handler will be called to decrypt opaque data like checkpoint blobs.
+
+        Example:
+            ```python
+            @encryption.decrypt.blob
+            async def decrypt_blob(ctx: EncryptionContext, blob: bytes) -> bytes:
+                # Decrypt the blob using your encryption service
+                return decrypted_blob
+            ```
+
+        Args:
+            fn: The decryption handler function
+
+        Returns:
+            The registered handler function
+
+        Raises:
+            DuplicateHandlerError: If blob decryptor already registered
+            TypeError: If handler has invalid signature
+        """
+        if self._parent._blob_decryptor is not None:
+            raise DuplicateHandlerError("Blob decryptor already registered")
+        _validate_handler(fn, "Blob decryptor")
+        self._parent._blob_decryptor = fn
+        return fn
+
+    def json(self, fn: types.JsonDecryptor) -> types.JsonDecryptor:
+        """Register the JSON decryption handler.
+
+        Example:
+            ```python
+            @encryption.decrypt.json
+            async def decrypt_json(ctx: EncryptionContext, data: dict) -> dict:
+                # Decrypt the data
+                return decrypt_data(data)
+            ```
+
+        Args:
+            fn: The decryption handler function
+
+        Returns:
+            The registered handler function
+
+        Raises:
+            DuplicateHandlerError: If JSON decryptor already registered
+            TypeError: If handler has invalid signature
+        """
+        if self._parent._json_decryptor is not None:
+            raise DuplicateHandlerError("JSON decryptor already registered")
+        _validate_handler(fn, "JSON decryptor")
+        self._parent._json_decryptor = fn
+        return fn
+
+
+class Encryption:
+    """Add custom at-rest encryption to your LangGraph application.
+
+    .. warning::
+        This API is in beta and may change in future versions.
+
+    The Encryption class provides a system for implementing custom encryption
+    of data at rest in LangGraph applications. It supports encryption of
+    both opaque blobs (like checkpoints) and structured JSON data (like
+    metadata, context, kwargs, values, etc.).
+
+    To use, create a separate Python file and add the path to the file to your
+    LangGraph API configuration file (`langgraph.json`). Within that file, create
+    an instance of the Encryption class and register encryption and decryption
+    handlers as needed.
+
+    Example `langgraph.json` file:
+
+    ```json
+    {
+      "dependencies": ["."],
+      "graphs": {
+        "agent": "./my_agent/agent.py:graph"
+      },
+      "env": ".env",
+      "encryption": {
+        "path": "./encryption.py:my_encryption"
+      }
+    }
+    ```
+
+    Then the LangGraph server will load your encryption file and use it to
+    encrypt/decrypt data at rest.
+
+    !!! warning "JSON Encryptors Must Preserve Keys"
+
+        JSON encryptors **must not add or remove keys** from the input dict.
+        Only values may be transformed. This constraint is **enforced at runtime
+        by the server** and exists because SQL JSONB merge operations (used for
+        partial updates) work at the key level.
+
+        **Correct (per-key encryption):**
+        ```python
+        # Input:  {"secret": "value", "plain": "x"}
+        # Output: {"secret": "<encrypted>", "plain": "x"}  ✓ Keys preserved
+        ```
+
+        **Incorrect (key consolidation):**
+        ```python
+        # Input:  {"secret": "value", "plain": "x"}
+        # Output: {"__encrypted__": "<blob>", "plain": "x"}  ✗ Key changed
+        ```
+
+        If your encryptor needs to store auxiliary data (DEK, IV, etc.), embed it
+        within the encrypted value itself, not as separate keys.
+
+    ???+ example "Basic Usage"
+
+        ```python
+        from langgraph_sdk import Encryption, EncryptionContext
+
+        my_encryption = Encryption()
+
+        SKIP_FIELDS = {"tenant_id", "owner", "thread_id", "assistant_id"}
+        ENCRYPTED_PREFIX = "encrypted:"
+
+        @my_encryption.encrypt.blob
+        async def encrypt_blob(ctx: EncryptionContext, blob: bytes) -> bytes:
+            return your_encrypt_bytes(blob)
+
+        @my_encryption.decrypt.blob
+        async def decrypt_blob(ctx: EncryptionContext, blob: bytes) -> bytes:
+            return your_decrypt_bytes(blob)
+
+        @my_encryption.encrypt.json
+        async def encrypt_json(ctx: EncryptionContext, data: dict) -> dict:
+            result = {}
+            for k, v in data.items():
+                if k in SKIP_FIELDS or v is None:
+                    result[k] = v
+                else:
+                    result[k] = ENCRYPTED_PREFIX + your_encrypt_string(v)
+            return result
+
+        @my_encryption.decrypt.json
+        async def decrypt_json(ctx: EncryptionContext, data: dict) -> dict:
+            result = {}
+            for k, v in data.items():
+                if isinstance(v, str) and v.startswith(ENCRYPTED_PREFIX):
+                    result[k] = your_decrypt_string(v[len(ENCRYPTED_PREFIX):])
+                else:
+                    result[k] = v
+            return result
+        ```
+
+    ???+ example "Field-Specific Logic"
+
+        The `ctx.model` and `ctx.field` attributes tell you which model type and
+        specific field is being encrypted, allowing different logic:
+
+        ```python
+        @my_encryption.encrypt.json
+        async def encrypt_json(ctx: EncryptionContext, data: dict) -> dict:
+            if ctx.field == "metadata":
+                # Metadata - standard encryption
+                return encrypt_standard(data)
+            elif ctx.field == "values":
+                # Thread values - more sensitive, use stronger encryption
+                return encrypt_sensitive(data)
+            else:
+                return encrypt_standard(data)
+        ```
+
+        !!! warning "Model/Field May Differ Between Encrypt and Decrypt"
+
+            Data encrypted with one `(model, field)` pair is **not guaranteed**
+            to be decrypted with the same pair. The server performs SQL JSONB
+            merges that can move encrypted values between models (e.g., cron
+            metadata → run metadata). Your decryption logic must handle data
+            regardless of the `ctx.model` or `ctx.field` values at decrypt time.
+
+            **Safe:** Use `ctx.model`/`ctx.field` for logging or metrics only.
+
+            **Safe:** Encrypt different keys based on `ctx.field`, but use a
+            single decrypt handler that decrypts any value with the encrypted
+            prefix (and passes through plaintext unchanged):
+
+            ```python
+            ENCRYPTED_PREFIX = "enc:"
+
+            @my_encryption.encrypt.json
+            async def encrypt_json(ctx: EncryptionContext, data: dict) -> dict:
+                # Encrypt different keys depending on the field
+                if ctx.field == "context":
+                    keys_to_encrypt = {"api_key", "secret_token"}
+                else:
+                    keys_to_encrypt = {"email", "ssn"}
+                return {
+                    k: ENCRYPTED_PREFIX + encrypt(v) if k in keys_to_encrypt else v
+                    for k, v in data.items()
+                }
+
+            @my_encryption.decrypt.json
+            async def decrypt_json(ctx: EncryptionContext, data: dict) -> dict:
+                # Decrypt ANY value with the prefix, regardless of model/field
+                return {
+                    k: decrypt(v[len(ENCRYPTED_PREFIX):])
+                       if isinstance(v, str) and v.startswith(ENCRYPTED_PREFIX)
+                       else v
+                    for k, v in data.items()
+                }
+            ```
+
+            **Unsafe:** Using different encryption keys or algorithms based on
+            `ctx.model`/`ctx.field` will cause decryption failures.
+    """
+
+    __slots__ = (
+        "_blob_decryptor",
+        "_blob_encryptor",
+        "_context_handler",
+        "_json_decryptor",
+        "_json_encryptor",
+        "decrypt",
+        "encrypt",
+    )
+
+    types = types
+    """Reference to encryption type definitions.
+
+    Provides access to all type definitions used in the encryption system,
+    including EncryptionContext, BlobEncryptor, BlobDecryptor,
+    JsonEncryptor, and JsonDecryptor.
+    """
+
+    def __init__(self) -> None:
+        """Initialize the Encryption instance."""
+        _warn_encryption_beta()
+        self.encrypt = _EncryptDecorators(self)
+        self.decrypt = _DecryptDecorators(self)
+        self._blob_encryptor: types.BlobEncryptor | None = None
+        self._blob_decryptor: types.BlobDecryptor | None = None
+        self._json_encryptor: types.JsonEncryptor | None = None
+        self._json_decryptor: types.JsonDecryptor | None = None
+        self._context_handler: types.ContextHandler | None = None
+
+    def context(self, fn: types.ContextHandler) -> types.ContextHandler:
+        """Register a context handler to derive encryption context from auth.
+
+        The handler receives the authenticated user and current EncryptionContext,
+        and returns a dict that becomes ctx.metadata for encrypt/decrypt handlers.
+
+        This allows encryption context to be derived from JWT claims or other
+        auth-derived data instead of requiring a separate X-Encryption-Context header.
+
+        Note: The context handler is called once per request in middleware,
+        so ctx.model and ctx.field will be None in the handler.
+
+        Example:
+            ```python
+            from langgraph_sdk import Encryption, EncryptionContext
+            from starlette.authentication import BaseUser
+
+            encryption = Encryption()
+
+            @encryption.context
+            async def get_context(user: BaseUser, ctx: EncryptionContext) -> dict:
+                # Derive encryption context from authenticated user
+                return {
+                    **ctx.metadata,  # preserve X-Encryption-Context header if present
+                    "tenant_id": user.tenant_id,
+                }
+            ```
+
+        Args:
+            fn: The context handler function
+
+        Returns:
+            The registered handler function
+        """
+        self._context_handler = fn
+        return fn
+
+    def get_json_encryptor(
+        self,
+        _model: str | None = None,  # kept for langgraph-api compat
+    ) -> types.JsonEncryptor | None:
+        """Get the JSON encryptor.
+
+        Args:
+            _model: Ignored. Kept for backwards compatibility with langgraph-api
+                which passes model_type to this method.
+
+        Returns:
+            The JSON encryptor, or None if not registered.
+        """
+        return self._json_encryptor
+
+    def get_json_decryptor(
+        self,
+        _model: str | None = None,  # kept for langgraph-api compat
+    ) -> types.JsonDecryptor | None:
+        """Get the JSON decryptor.
+
+        Args:
+            _model: Ignored. Kept for backwards compatibility with langgraph-api
+                which passes model_type to this method.
+
+        Returns:
+            The JSON decryptor, or None if not registered.
+        """
+        return self._json_decryptor
+
+    def __repr__(self) -> str:
+        handlers = []
+        if self._blob_encryptor:
+            handlers.append("blob_encryptor")
+        if self._blob_decryptor:
+            handlers.append("blob_decryptor")
+        if self._json_encryptor:
+            handlers.append("json_encryptor")
+        if self._json_decryptor:
+            handlers.append("json_decryptor")
+        if self._context_handler:
+            handlers.append("context_handler")
+        return f"Encryption(handlers=[{', '.join(handlers)}])"

python/user_packages/Python313/site-packages/langgraph_sdk/encryption/types.py

@@ -0,0 +1,147 @@
+"""Encryption and decryption types for LangGraph.
+
+This module defines the core types used for custom at-rest encryption
+in LangGraph. It includes context types and typed dictionaries for
+encryption operations.
+"""
+
+from __future__ import annotations
+
+import typing
+from collections.abc import Awaitable, Callable
+
+Json = dict[str, typing.Any]
+"""JSON-serializable dictionary type for structured data encryption."""
+
+
+class EncryptionContext:
+    """Context passed to encryption/decryption handlers.
+
+    Contains arbitrary non-secret key-values that will be stored on encrypt.
+    These key-values are intended to be sent to an external service that
+    manages keys and handles the actual encryption and decryption of data.
+
+    Attributes:
+        model: The model type being encrypted (e.g., "assistant", "thread", "run", "checkpoint")
+        field: The specific field being encrypted (e.g., "metadata", "context", "kwargs", "values")
+        metadata: Additional context metadata that can be used for encryption decisions
+    """
+
+    __slots__ = ("field", "metadata", "model")
+
+    def __init__(
+        self,
+        model: str | None = None,
+        metadata: dict[str, typing.Any] | None = None,
+        field: str | None = None,
+    ):
+        self.model = model
+        self.field = field
+        self.metadata = metadata or {}
+
+    def __repr__(self) -> str:
+        return f"EncryptionContext(model={self.model!r}, field={self.field!r}, metadata={self.metadata!r})"
+
+
+BlobEncryptor = Callable[[EncryptionContext, bytes], Awaitable[bytes]]
+"""Handler for encrypting opaque blob data like checkpoints.
+
+Note: Must be an async function. Encryption typically involves I/O operations
+(calling external KMS services), which should be async.
+
+Args:
+    ctx: Encryption context with model type and metadata
+    blob: The raw bytes to encrypt
+
+Returns:
+    Awaitable that resolves to encrypted bytes
+"""
+
+BlobDecryptor = Callable[[EncryptionContext, bytes], Awaitable[bytes]]
+"""Handler for decrypting opaque blob data like checkpoints.
+
+Note: Must be an async function. Decryption typically involves I/O operations
+(calling external KMS services), which should be async.
+
+Args:
+    ctx: Encryption context with model type and metadata
+    blob: The encrypted bytes to decrypt
+
+Returns:
+    Awaitable that resolves to decrypted bytes
+"""
+
+JsonEncryptor = Callable[[EncryptionContext, Json], Awaitable[Json]]
+"""Handler for encrypting structured JSON data.
+
+Note: Must be an async function. Encryption typically involves I/O operations
+(calling external KMS services), which should be async.
+
+Used for encrypting structured data like metadata, context, kwargs, values,
+and other JSON-serializable fields across different model types.
+
+Maps plaintext fields to encrypted fields. A practical approach:
+- Keep "owner" field unencrypted for search/filtering
+- Encrypt VALUES (not keys) for fields with specific prefix (e.g., "my.customer.org/")
+- Pass through all other fields unencrypted
+
+Example:
+    Input:  {"owner": "user123", "my.customer.org/email": "john@example.com", "tenant_id": "t-456"}
+    Output: {"owner": "user123", "my.customer.org/email": "ENCRYPTED", "tenant_id": "t-456"}
+
+Note: Encrypted field VALUES cannot be reliably searched, as most real-world
+encryption implementations use nonces (non-deterministic encryption).
+Only unencrypted fields can be used in search queries.
+
+Args:
+    ctx: Encryption context with model type, field name, and metadata
+    data: The plaintext JSON dictionary
+
+Returns:
+    Awaitable that resolves to encrypted JSON dictionary
+"""
+
+JsonDecryptor = Callable[[EncryptionContext, Json], Awaitable[Json]]
+"""Handler for decrypting structured JSON data.
+
+Note: Must be an async function. Decryption typically involves I/O operations
+(calling external KMS services), which should be async.
+
+Inverse of JsonEncryptor. Must be able to decrypt data that
+was encrypted by the corresponding encryptor.
+
+Args:
+    ctx: Encryption context with model type, field name, and metadata
+    data: The encrypted JSON dictionary
+
+Returns:
+    Awaitable that resolves to decrypted JSON dictionary
+"""
+
+if typing.TYPE_CHECKING:
+    from starlette.authentication import BaseUser
+
+ContextHandler = Callable[
+    ["BaseUser", EncryptionContext], Awaitable[dict[str, typing.Any]]
+]
+"""Handler for deriving encryption context from authenticated user info.
+
+Note: Must be an async function as it may involve I/O operations.
+
+The context handler is called once per request in middleware (after auth),
+allowing encryption context to be derived from JWT claims, user properties,
+or other auth-derived data instead of requiring a separate X-Encryption-Context header.
+
+The return value becomes ctx.metadata for subsequent encrypt/decrypt operations
+and is persisted with encrypted data for later decryption.
+
+Note: ctx.model and ctx.field will be None in context handlers since
+the handler runs once per request before any specific model/field is known.
+
+Args:
+    user: The authenticated user (from Starlette's AuthenticationMiddleware)
+    ctx: Current encryption context with metadata from X-Encryption-Context header
+
+Returns:
+    Awaitable that resolves to dict that becomes the new ctx.metadata
+"""

python/user_packages/Python313/site-packages/langsmith/_internal/_aiter.py

@@ -0,0 +1,382 @@
+"""Adapted.
+
+Original source:
+https://github.com/maxfischer2781/asyncstdlib/blob/master/asyncstdlib/itertools.py
+MIT License
+"""
+
+from __future__ import annotations
+
+import asyncio
+import contextvars
+import functools
+import inspect
+from collections import deque
+from collections.abc import (
+    AsyncGenerator,
+    AsyncIterable,
+    AsyncIterator,
+    Awaitable,
+    Coroutine,
+    Iterable,
+    Iterator,
+)
+from contextlib import AbstractAsyncContextManager
+from typing import (
+    Any,
+    Callable,
+    Generic,
+    Optional,
+    TypeVar,
+    Union,
+    cast,
+    overload,
+)
+
+from langsmith._runtime_overrides import get_runtime_overrides
+
+T = TypeVar("T")
+
+_no_default = object()
+
+
+# https://github.com/python/cpython/blob/main/Lib/test/test_asyncgen.py#L54
+# before 3.10, the builtin anext() was not available
+def py_anext(
+    iterator: AsyncIterator[T], default: Union[T, Any] = _no_default
+) -> Awaitable[Union[T, None, Any]]:
+    """Pure-Python implementation of anext() for testing purposes.
+
+    Closely matches the builtin anext() C implementation.
+    Can be used to compare the built-in implementation of the inner
+    coroutines machinery to C-implementation of __anext__() and send()
+    or throw() on the returned generator.
+    """
+    try:
+        __anext__ = cast(
+            Callable[[AsyncIterator[T]], Awaitable[T]], type(iterator).__anext__
+        )
+    except AttributeError:
+        raise TypeError(f"{iterator!r} is not an async iterator")
+
+    if default is _no_default:
+        return __anext__(iterator)
+
+    async def anext_impl() -> Union[T, Any]:
+        try:
+            # The C code is way more low-level than this, as it implements
+            # all methods of the iterator protocol. In this implementation
+            # we're relying on higher-level coroutine concepts, but that's
+            # exactly what we want -- crosstest pure-Python high-level
+            # implementation and low-level C anext() iterators.
+            return await __anext__(iterator)
+        except StopAsyncIteration:
+            return default
+
+    return anext_impl()
+
+
+class NoLock:
+    """Dummy lock that provides the proper interface but no protection."""
+
+    async def __aenter__(self) -> None:
+        pass
+
+    async def __aexit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> bool:
+        return False
+
+
+async def tee_peer(
+    iterator: AsyncIterator[T],
+    # the buffer specific to this peer
+    buffer: deque[T],
+    # the buffers of all peers, including our own
+    peers: list[deque[T]],
+    lock: AbstractAsyncContextManager[Any],
+) -> AsyncGenerator[T, None]:
+    """Iterate over :py:func:`~.tee`."""
+    try:
+        while True:
+            if not buffer:
+                async with lock:
+                    # Another peer produced an item while we were waiting for the lock.
+                    # Proceed with the next loop iteration to yield the item.
+                    if buffer:
+                        continue
+                    try:
+                        item = await iterator.__anext__()
+                    except StopAsyncIteration:
+                        break
+                    else:
+                        # Append to all buffers, including our own. We'll fetch our
+                        # item from the buffer again, instead of yielding it directly.
+                        # This ensures the proper item ordering if any of our peers
+                        # are fetching items concurrently. They may have buffered their
+                        # item already.
+                        for peer_buffer in peers:
+                            peer_buffer.append(item)
+            yield buffer.popleft()
+    finally:
+        async with lock:
+            # this peer is done – remove its buffer
+            for idx, peer_buffer in enumerate(peers):  # pragma: no branch
+                if peer_buffer is buffer:
+                    peers.pop(idx)
+                    break
+            # if we are the last peer, try and close the iterator
+            if not peers and hasattr(iterator, "aclose"):
+                await iterator.aclose()
+
+
+class Tee(Generic[T]):
+    """Create ``n`` separate asynchronous iterators over ``iterable``.
+
+    This splits a single ``iterable`` into multiple iterators, each providing
+    the same items in the same order.
+    All child iterators may advance separately but pare the same items
+    from ``iterable`` -- when the most advanced iterator retrieves an item,
+    it is buffered until the least advanced iterator has yielded it as well.
+    A ``tee`` works lazily and can handle an infinite ``iterable``, provided
+    that all iterators advance.
+
+    ```python
+    async def derivative(sensor_data):
+        previous, current = a.tee(sensor_data, n=2)
+        await a.anext(previous)  # advance one iterator
+        return a.map(operator.sub, previous, current)
+    ```
+
+    Unlike :py:func:`itertools.tee`, :py:func:`~.tee` returns a custom type instead
+    of a :py:class:`tuple`. Like a tuple, it can be indexed, iterated and unpacked
+    to get the child iterators. In addition, its :py:meth:`~.tee.aclose` method
+    immediately closes all children, and it can be used in an ``async with`` context
+    for the same effect.
+
+    If ``iterable`` is an iterator and read elsewhere, ``tee`` will *not*
+    provide these items. Also, ``tee`` must internally buffer each item until the
+    last iterator has yielded it; if the most and least advanced iterator differ
+    by most data, using a :py:class:`list` is more efficient (but not lazy).
+
+    If the underlying iterable is concurrency safe (``anext`` may be awaited
+    concurrently) the resulting iterators are concurrency safe as well. Otherwise,
+    the iterators are safe if there is only ever one single "most advanced" iterator.
+    To enforce sequential use of ``anext``, provide a ``lock``
+    - e.g. an :py:class:`asyncio.Lock` instance in an :py:mod:`asyncio` application -
+    and access is automatically synchronised.
+    """
+
+    def __init__(
+        self,
+        iterable: AsyncIterator[T],
+        n: int = 2,
+        *,
+        lock: Optional[AbstractAsyncContextManager[Any]] = None,
+    ):
+        self._iterator = iterable.__aiter__()  # before 3.10 aiter() doesn't exist
+        self._buffers: list[deque[T]] = [deque() for _ in range(n)]
+        self._children = tuple(
+            tee_peer(
+                iterator=self._iterator,
+                buffer=buffer,
+                peers=self._buffers,
+                lock=lock if lock is not None else NoLock(),
+            )
+            for buffer in self._buffers
+        )
+
+    def __len__(self) -> int:
+        return len(self._children)
+
+    @overload
+    def __getitem__(self, item: int) -> AsyncIterator[T]: ...
+
+    @overload
+    def __getitem__(self, item: slice) -> tuple[AsyncIterator[T], ...]: ...
+
+    def __getitem__(
+        self, item: Union[int, slice]
+    ) -> Union[AsyncIterator[T], tuple[AsyncIterator[T], ...]]:
+        return self._children[item]
+
+    def __iter__(self) -> Iterator[AsyncIterator[T]]:
+        yield from self._children
+
+    async def __aenter__(self) -> Tee[T]:
+        return self
+
+    async def __aexit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> bool:
+        await self.aclose()
+        return False
+
+    async def aclose(self) -> None:
+        for child in self._children:
+            await child.aclose()
+
+
+atee = Tee
+
+
+async def async_zip(*async_iterables):
+    """Async version of zip."""
+    # Before Python 3.10, aiter() was not available
+    iterators = [iterable.__aiter__() for iterable in async_iterables]
+    while True:
+        try:
+            items = await asyncio.gather(
+                *(py_anext(iterator) for iterator in iterators)
+            )
+            yield tuple(items)
+        except StopAsyncIteration:
+            break
+
+
+def ensure_async_iterator(
+    iterable: Union[Iterable, AsyncIterable],
+) -> AsyncIterator:
+    if hasattr(iterable, "__anext__"):
+        return cast(AsyncIterator, iterable)
+    elif hasattr(iterable, "__aiter__"):
+        return cast(AsyncIterator, iterable.__aiter__())
+    else:
+
+        class AsyncIteratorWrapper:
+            def __init__(self, iterable: Iterable):
+                self._iterator = iter(iterable)
+
+            async def __anext__(self):
+                try:
+                    return next(self._iterator)
+                except StopIteration:
+                    raise StopAsyncIteration
+
+            def __aiter__(self):
+                return self
+
+        return AsyncIteratorWrapper(iterable)
+
+
+def aiter_with_concurrency(
+    n: Optional[int],
+    generator: AsyncIterator[Coroutine[None, None, T]],
+    *,
+    _eager_consumption_timeout: float = 0,
+) -> AsyncGenerator[T, None]:
+    """Process async generator with max parallelism.
+
+    Args:
+        n: The number of tasks to run concurrently.
+        generator: The async generator to process.
+        _eager_consumption_timeout: If set, check for completed tasks after
+            each iteration and yield their results. This can be used to
+            consume the generator eagerly while still respecting the concurrency
+            limit.
+
+    Yields:
+        The processed items yielded by the async generator.
+    """
+    if n == 0:
+
+        async def consume():
+            async for item in generator:
+                yield await item
+
+        return consume()
+    semaphore = cast(
+        asyncio.Semaphore, asyncio.Semaphore(n) if n is not None else NoLock()
+    )
+
+    async def process_item(ix: int, item):
+        async with semaphore:
+            res = await item
+            return (ix, res)
+
+    async def process_generator():
+        tasks = {}
+        accepts_context = asyncio_accepts_context()
+        ix = 0
+        async for item in generator:
+            if accepts_context:
+                context = contextvars.copy_context()
+                task = asyncio.create_task(process_item(ix, item), context=context)
+            else:
+                task = asyncio.create_task(process_item(ix, item))
+            tasks[ix] = task
+            ix += 1
+            if _eager_consumption_timeout > 0:
+                try:
+                    for _fut in asyncio.as_completed(
+                        tasks.values(),
+                        timeout=_eager_consumption_timeout,
+                    ):
+                        task_idx, res = await _fut
+                        yield res
+                        del tasks[task_idx]
+                except asyncio.TimeoutError:
+                    pass
+            if n is not None and len(tasks) >= n:
+                done, _ = await asyncio.wait(
+                    tasks.values(), return_when=asyncio.FIRST_COMPLETED
+                )
+                for task in done:
+                    task_idx, res = task.result()
+                    yield res
+                    del tasks[task_idx]
+
+        for task in asyncio.as_completed(tasks.values()):
+            _, res = await task
+            yield res
+
+    return process_generator()
+
+
+def accepts_context(callable: Callable[..., Any]) -> bool:
+    """Check if a callable accepts a context argument."""
+    try:
+        return inspect.signature(callable).parameters.get("context") is not None
+    except ValueError:
+        return False
+
+
+# Ported from Python 3.9+ to support Python 3.8
+async def aio_to_thread(
+    ctx: contextvars.Context,
+    func,
+    /,
+    *args,
+    **kwargs,
+):
+    """Run ``func`` in a separate thread, inside ``ctx``.
+
+    ``ctx`` is the :class:`~contextvars.Context` in which ``func`` is invoked.
+    Callers that want default isolation should pass
+    ``contextvars.copy_context()``; callers with a specific Context
+    (e.g. :func:`trace`) pass it directly so subsequent reads from that
+    Context see the mutations.
+
+    Return a coroutine that can be awaited to get the eventual result of ``func``.
+    """
+    overrides = get_runtime_overrides()
+    if overrides.aio_to_thread is not None:
+        return await overrides.aio_to_thread(
+            _default_aio_to_thread, ctx, func, *args, **kwargs
+        )
+    return await _default_aio_to_thread(ctx, func, *args, **kwargs)
+
+
+async def _default_aio_to_thread(
+    ctx: contextvars.Context,
+    func,
+    /,
+    *args,
+    **kwargs,
+):
+    """Default implementation of aio_to_thread using run_in_executor."""
+    loop = asyncio.get_running_loop()
+    func_call = functools.partial(ctx.run, func, *args, **kwargs)
+    return await loop.run_in_executor(None, func_call)
+
+
+@functools.lru_cache(maxsize=1)
+def asyncio_accepts_context():
+    """Check if the current asyncio event loop accepts a context argument."""
+    return accepts_context(asyncio.create_task)