langgraph-api 0.2.129__py3-none-any.whl → 0.2.132__py3-none-any.whl

langgraph_api/stream.py

@@ -1,3 +1,4 @@
+import uuid
 from collections.abc import AsyncIterator, Callable
 from contextlib import AsyncExitStack, aclosing, asynccontextmanager
 from functools import lru_cache
@@ -93,21 +94,23 @@ def _preproces_debug_checkpoint_task(task: dict[str, Any]) -> dict[str, Any]:
     return task
 
 
-def _preprocess_debug_checkpoint(payload: CheckpointPayload | None) -> dict[str, Any]:
+def _preprocess_debug_checkpoint(
+    payload: CheckpointPayload | None,
+) -> dict[str, Any] | None:
     from langgraph_api.state import runnable_config_to_checkpoint
 
     if not payload:
         return None
 
-    payload["checkpoint"] = runnable_config_to_checkpoint(payload["config"])
-    payload["parent_checkpoint"] = runnable_config_to_checkpoint(
-        payload["parent_config"] if "parent_config" in payload else None
-    )
-
-    payload["tasks"] = [_preproces_debug_checkpoint_task(t) for t in payload["tasks"]]
-
     # TODO: deprecate the `config`` and `parent_config`` fields
-    return payload
+    return {
+        **payload,
+        "checkpoint": runnable_config_to_checkpoint(payload["config"]),
+        "parent_checkpoint": runnable_config_to_checkpoint(
+            payload["parent_config"] if "parent_config" in payload else None
+        ),
+        "tasks": [_preproces_debug_checkpoint_task(t) for t in payload["tasks"]],
+    }
 
 
 @asynccontextmanager
@@ -216,7 +219,7 @@ async def astream_state(
     if use_astream_events:
         async with (
             stack,
-            aclosing(
+            aclosing(  # type: ignore[invalid-argument-type]
                 graph.astream_events(
                     input,
                     config,
@@ -231,6 +234,7 @@ async def astream_state(
                 event = await wait_if_not_done(anext(stream, sentinel), done)
                 if event is sentinel:
                     break
+                event = cast(dict, event)
                 if event.get("tags") and "langsmith:hidden" in event["tags"]:
                     continue
                 if "messages" in stream_mode and isinstance(graph, BaseRemotePregel):
@@ -251,6 +255,7 @@ async def astream_state(
                     if mode == "debug":
                         if chunk["type"] == "checkpoint":
                             checkpoint = _preprocess_debug_checkpoint(chunk["payload"])
+                            chunk["payload"] = checkpoint
                             on_checkpoint(checkpoint)
                         elif chunk["type"] == "task_result":
                             on_task_result(chunk["payload"])
@@ -261,11 +266,14 @@ async def astream_state(
                             else:
                                 yield "messages", chunk
                         else:
-                            msg, meta = cast(
+                            msg_, meta = cast(
                                 tuple[BaseMessage | dict, dict[str, Any]], chunk
                             )
-                            if isinstance(msg, dict):
-                                msg = convert_to_messages([msg])[0]
+                            msg = (
+                                convert_to_messages([msg_])[0]
+                                if isinstance(msg_, dict)
+                                else cast(BaseMessage, msg_)
+                            )
                             if msg.id in messages:
                                 messages[msg.id] += msg
                             else:
@@ -323,14 +331,15 @@ async def astream_state(
                 if event is sentinel:
                     break
                 if subgraphs:
-                    ns, mode, chunk = event
+                    ns, mode, chunk = cast(tuple[str, str, dict[str, Any]], event)
                 else:
-                    mode, chunk = event
+                    mode, chunk = cast(tuple[str, dict[str, Any]], event)
                     ns = None
                 # --- begin shared logic with astream_events ---
                 if mode == "debug":
                     if chunk["type"] == "checkpoint":
                         checkpoint = _preprocess_debug_checkpoint(chunk["payload"])
+                        chunk["payload"] = checkpoint
                         on_checkpoint(checkpoint)
                     elif chunk["type"] == "task_result":
                         on_task_result(chunk["payload"])
@@ -341,11 +350,15 @@ async def astream_state(
                         else:
                             yield "messages", chunk
                     else:
-                        msg, meta = cast(
+                        msg_, meta = cast(
                             tuple[BaseMessage | dict, dict[str, Any]], chunk
                         )
-                        if isinstance(msg, dict):
-                            msg = convert_to_messages([msg])[0]
+                        msg = (
+                            convert_to_messages([msg_])[0]
+                            if isinstance(msg_, dict)
+                            else cast(BaseMessage, msg_)
+                        )
+
                         if msg.id in messages:
                             messages[msg.id] += msg
                         else:
@@ -386,6 +399,8 @@ async def astream_state(
             incr_nodes(None, incr=nodes_executed)
         except Exception as e:
             logger.warning(f"Failed to fetch nodes executed for {graph.graph_id}: {e}")
+    else:
+        await logger.adebug("Graph is not an instance of BaseRemotePregel")
 
     # Get feedback URLs
     if feedback_keys:
@@ -397,7 +412,7 @@ async def astream_state(
 
 async def consume(
     stream: AnyStream,
-    run_id: str,
+    run_id: str | uuid.UUID,
     resumable: bool = False,
     stream_modes: set[StreamMode] | None = None,
 ) -> None:
@@ -406,7 +421,7 @@ async def consume(
         stream_modes.add("messages")
     stream_modes.add("metadata")
 
-    async with aclosing(stream):
+    async with aclosing(stream):  # type: ignore[invalid-argument-type]
         try:
             async for mode, payload in stream:
                 await Runs.Stream.publish(

langgraph_api/traceblock.py

@@ -19,4 +19,4 @@ def patch_requests():
                 raise RuntimeError(f"POST to {url} blocked by policy")
         return _orig(self, method, url, *a, **kw)
 
-    Session.request = _guard
+    Session.request = _guard  # type: ignore[invalid-assignment]

langgraph_api/utils/__init__.py

@@ -1,9 +1,9 @@
 import contextvars
 import uuid
-from collections.abc import AsyncGenerator, AsyncIterator
+from collections.abc import AsyncIterator
 from contextlib import asynccontextmanager
 from datetime import datetime
-from typing import Any, Protocol, TypeAlias, TypeVar
+from typing import Any, Protocol, TypeAlias, TypeVar, cast
 
 import structlog
 from langgraph_sdk import Auth
@@ -12,6 +12,7 @@ from starlette.exceptions import HTTPException
 from starlette.schemas import BaseSchemaGenerator
 
 from langgraph_api.auth.custom import SimpleUser
+from langgraph_api.utils.uuids import uuid7
 
 logger = structlog.stdlib.get_logger(__name__)
 
@@ -32,7 +33,9 @@ async def with_user(
     yield
     if current is None:
         return
-    set_auth_ctx(current.user, AuthCredentials(scopes=current.permissions))
+    set_auth_ctx(
+        cast(BaseUser, current.user), AuthCredentials(scopes=current.permissions)
+    )
 
 
 def set_auth_ctx(
@@ -99,7 +102,7 @@ def validate_uuid(uuid_str: str, invalid_uuid_detail: str | None) -> uuid.UUID:
 
 
 def next_cron_date(schedule: str, base_time: datetime) -> datetime:
-    import croniter
+    import croniter  # type: ignore[unresolved-import]
 
     cron_iter = croniter.croniter(schedule, base_time)
     return cron_iter.get_next(datetime)
@@ -130,7 +133,7 @@ class SchemaGenerator(BaseSchemaGenerator):
 
 
 async def get_pagination_headers(
-    resource: AsyncGenerator[T],
+    resource: AsyncIterator[T],
     next_offset: int | None,
     offset: int,
 ) -> tuple[list[T], dict[str, str]]:
@@ -143,3 +146,16 @@ async def get_pagination_headers(
             "X-Pagination-Next": str(next_offset),
         }
     return resources, response_headers
+
+
+__all__ = [
+    "AsyncCursorProto",
+    "AsyncPipelineProto",
+    "AsyncConnectionProto",
+    "fetchone",
+    "validate_uuid",
+    "next_cron_date",
+    "SchemaGenerator",
+    "get_pagination_headers",
+    "uuid7",
+]

langgraph_api/utils/config.py

@@ -7,9 +7,10 @@ from collections import ChainMap
 from concurrent.futures import Executor
 from contextvars import copy_context
 from os import getenv
-from typing import Any, ParamSpec, TypeVar, cast
+from typing import Any, ParamSpec, TypeVar
 
 from langgraph.constants import CONF
+from typing_extensions import TypedDict
 
 if typing.TYPE_CHECKING:
     from langchain_core.runnables import RunnableConfig
@@ -19,7 +20,7 @@ try:
         var_child_runnable_config,
     )
 except ImportError:
-    var_child_runnable_config = None
+    var_child_runnable_config = None  # type: ignore[invalid-assignment]
 
 CONFIG_KEYS = [
     "tags",
@@ -52,6 +53,14 @@ def _is_not_empty(value: Any) -> bool:
         return value is not None
 
 
+class _Config(TypedDict):
+    tags: list[str]
+    metadata: ChainMap
+    callbacks: None
+    recursion_limit: int
+    configurable: dict[str, Any]
+
+
 def ensure_config(*configs: RunnableConfig | None) -> RunnableConfig:
     """Return a config with all keys, merging any provided configs.
 
@@ -61,7 +70,7 @@ def ensure_config(*configs: RunnableConfig | None) -> RunnableConfig:
     Returns:
         RunnableConfig: The merged and ensured config.
     """
-    empty = dict(
+    empty = _Config(
         tags=[],
         metadata=ChainMap(),
         callbacks=None,
@@ -84,7 +93,7 @@ def ensure_config(*configs: RunnableConfig | None) -> RunnableConfig:
         for k, v in config.items():
             if _is_not_empty(v) and k in CONFIG_KEYS:
                 if k == CONF:
-                    empty[k] = cast(dict, v).copy()
+                    empty[k] = v.copy()  # type: ignore
                 else:
                     empty[k] = v  # type: ignore[literal-required]
         for k, v in config.items():

langgraph_api/utils/future.py

@@ -167,7 +167,7 @@ def _ensure_future(
         elif EAGER_NOT_SUPPORTED or lazy:
             return loop.create_task(coro_or_future, name=name, context=context)
         else:
-            return asyncio.eager_task_factory(
+            return asyncio.eager_task_factory(  # type: ignore[unresolved-attribute]
                 loop, coro_or_future, name=name, context=context
             )
     except RuntimeError:

langgraph_api/utils/headers.py

@@ -24,15 +24,15 @@ def translate_pattern(pat: str) -> re.Pattern[str]:
 
 
 @functools.lru_cache(maxsize=1)
-def get_header_patterns() -> tuple[
-    list[re.Pattern[str]] | None, list[re.Pattern[str]] | None
-]:
+def get_header_patterns(
+    key: str,
+) -> tuple[list[re.Pattern[str]] | None, list[re.Pattern[str]] | None]:
     """Get the configured header include/exclude patterns."""
     from langgraph_api import config
 
     if not config.HTTP_CONFIG:
         return None, None
-    configurable = config.HTTP_CONFIG.get("configurable_headers")
+    configurable = config.HTTP_CONFIG.get(key)
     if not configurable:
         return None, None
     header_includes = configurable.get("includes") or configurable.get("include") or []
@@ -59,8 +59,25 @@ def should_include_header(key: str) -> bool:
     Returns:
         True if the header should be included, False otherwise
     """
-    include_patterns, exclude_patterns = get_header_patterns()
+    include_patterns, exclude_patterns = get_header_patterns("configurable_headers")
 
+    return pattern_matches(key, include_patterns, exclude_patterns)
+
+
+@functools.lru_cache(maxsize=512)
+def should_include_header_in_logs(key: str) -> bool:
+    """Check if header should be included in logs specifically."""
+
+    include_patterns, exclude_patterns = get_header_patterns("logging_headers")
+
+    return pattern_matches(key, include_patterns, exclude_patterns)
+
+
+def pattern_matches(
+    key: str,
+    include_patterns: list[re.Pattern[str]] | None,
+    exclude_patterns: list[re.Pattern[str]] | None,
+) -> bool:
     # Handle configurable behavior
     if exclude_patterns and any(pattern.match(key) for pattern in exclude_patterns):
         return False

langgraph_api/utils/uuids.py

@@ -0,0 +1,87 @@
+import os
+import time
+from uuid import UUID, SafeUUID
+
+_last_timestamp_v7 = None
+_last_counter_v7 = 0  # 42-bit counter
+_RFC_4122_VERSION_7_FLAGS = (7 << 76) | (0x8000 << 48)
+
+
+def _uuid7_get_counter_and_tail():
+    rand = int.from_bytes(os.urandom(10))
+    # 42-bit counter with MSB set to 0
+    counter = (rand >> 32) & 0x1FF_FFFF_FFFF
+    # 32-bit random data
+    tail = rand & 0xFFFF_FFFF
+    return counter, tail
+
+
+def _from_int(value: int) -> UUID:
+    uid = object.__new__(UUID)
+    object.__setattr__(uid, "int", value)
+    object.__setattr__(uid, "is_safe", SafeUUID.unknown)
+    return uid
+
+
+def uuid7():
+    """Generate a UUID from a Unix timestamp in milliseconds and random bits.
+
+    UUIDv7 objects feature monotonicity within a millisecond.
+    """
+    # --- 48 ---   -- 4 --   --- 12 ---   -- 2 --   --- 30 ---   - 32 -
+    # unix_ts_ms | version | counter_hi | variant | counter_lo | random
+    #
+    # 'counter = counter_hi | counter_lo' is a 42-bit counter constructed
+    # with Method 1 of RFC 9562, §6.2, and its MSB is set to 0.
+    #
+    # 'random' is a 32-bit random value regenerated for every new UUID.
+    #
+    # If multiple UUIDs are generated within the same millisecond, the LSB
+    # of 'counter' is incremented by 1. When overflowing, the timestamp is
+    # advanced and the counter is reset to a random 42-bit integer with MSB
+    # set to 0.
+
+    global _last_timestamp_v7
+    global _last_counter_v7
+
+    nanoseconds = time.time_ns()
+    timestamp_ms = nanoseconds // 1_000_000
+
+    if _last_timestamp_v7 is None or timestamp_ms > _last_timestamp_v7:
+        counter, tail = _uuid7_get_counter_and_tail()
+    else:
+        if timestamp_ms < _last_timestamp_v7:
+            timestamp_ms = _last_timestamp_v7 + 1
+        # advance the 42-bit counter
+        counter = _last_counter_v7 + 1
+        if counter > 0x3FF_FFFF_FFFF:
+            # advance the 48-bit timestamp
+            timestamp_ms += 1
+            counter, tail = _uuid7_get_counter_and_tail()
+        else:
+            # 32-bit random data
+            tail = int.from_bytes(os.urandom(4))
+
+    unix_ts_ms = timestamp_ms & 0xFFFF_FFFF_FFFF
+    counter_msbs = counter >> 30
+    # keep 12 counter's MSBs and clear variant bits
+    counter_hi = counter_msbs & 0x0FFF
+    # keep 30 counter's LSBs and clear version bits
+    counter_lo = counter & 0x3FFF_FFFF
+    # ensure that the tail is always a 32-bit integer (by construction,
+    # it is already the case, but future interfaces may allow the user
+    # to specify the random tail)
+    tail &= 0xFFFF_FFFF
+
+    int_uuid_7 = unix_ts_ms << 80
+    int_uuid_7 |= counter_hi << 64
+    int_uuid_7 |= counter_lo << 32
+    int_uuid_7 |= tail
+    # by construction, the variant and version bits are already cleared
+    int_uuid_7 |= _RFC_4122_VERSION_7_FLAGS
+    res = _from_int(int_uuid_7)
+
+    # defer global update until all computations are done
+    _last_timestamp_v7 = timestamp_ms
+    _last_counter_v7 = counter
+    return res

langgraph_api/webhook.py

@@ -27,23 +27,23 @@ async def call_webhook(result: "WorkerResult") -> None:
     }
     if exception := result["exception"]:
         payload["error"] = str(exception)
-
-    try:
-        webhook = result["webhook"]
-        if webhook.startswith("/"):
-            # Call into this own app
-            webhook_client = get_loopback_client()
-        else:
-            webhook_client = get_http_client()
-        await http_request("POST", webhook, json=payload, client=webhook_client)
-        await logger.ainfo(
-            "Background worker called webhook",
-            webhook=result["webhook"],
-            run_id=result["run"]["run_id"],
-        )
-    except Exception as exc:
-        logger.exception(
-            f"Background worker failed to call webhook {result['webhook']}",
-            exc_info=exc,
-            webhook=result["webhook"],
-        )
+    webhook = result.get("webhook")
+    if webhook:
+        try:
+            if webhook.startswith("/"):
+                # Call into this own app
+                webhook_client = get_loopback_client()
+            else:
+                webhook_client = get_http_client()
+            await http_request("POST", webhook, json=payload, client=webhook_client)
+            await logger.ainfo(
+                "Background worker called webhook",
+                webhook=result["webhook"],
+                run_id=result["run"]["run_id"],
+            )
+        except Exception as exc:
+            logger.exception(
+                f"Background worker failed to call webhook {result['webhook']}",
+                exc_info=exc,
+                webhook=result["webhook"],
+            )

langgraph_api/worker.py

@@ -1,9 +1,9 @@
 import asyncio
 import time
+import uuid
 from collections.abc import AsyncGenerator
 from contextlib import asynccontextmanager
 from datetime import UTC, datetime
-from typing import cast
 
 import structlog
 from langgraph.pregel.debug import CheckpointPayload, TaskResultPayload
@@ -73,7 +73,7 @@ async def worker(
     if attempt == 1:
         incr_runs()
     checkpoint: CheckpointPayload | None = None
-    exception: Exception | None = None
+    exception: Exception | asyncio.CancelledError | None = None
     status: str | None = None
     webhook = run["kwargs"].get("webhook", None)
     request_created_at: int | None = run["kwargs"]["config"]["configurable"].get(
@@ -131,7 +131,10 @@ async def worker(
 
     # Wrap the graph execution to separate user errors from server errors
     async def wrap_user_errors(
-        stream: AnyStream, run_id: str, resumable: bool, stream_modes: set[StreamMode]
+        stream: AnyStream,
+        run_id: str | uuid.UUID,
+        resumable: bool,
+        stream_modes: set[StreamMode],
     ):
         try:
             await consume(stream, run_id, resumable, stream_modes)
@@ -177,10 +180,10 @@ async def worker(
                 raise RuntimeError(error_message)
             async with set_auth_ctx_for_run(run["kwargs"]):
                 if temporary:
-                    stream = astream_state(cast(Run, run), attempt, done)
+                    stream = astream_state(run, attempt, done)
                 else:
                     stream = astream_state(
-                        cast(Run, run),
+                        run,
                         attempt,
                         done,
                         on_checkpoint=on_checkpoint,
@@ -209,6 +212,7 @@ async def worker(
 
         # handle exceptions and set status
         async with connect() as conn:
+            graph_id = run["kwargs"]["config"]["configurable"]["graph_id"]
             log_info = {
                 "run_id": str(run_id),
                 "run_attempt": attempt,
@@ -252,7 +256,12 @@ async def worker(
                         )
                 if not temporary:
                     await Threads.set_joint_status(
-                        conn, run["thread_id"], run_id, status, checkpoint=checkpoint
+                        conn,
+                        run["thread_id"],
+                        run_id,
+                        status,
+                        graph_id=graph_id,
+                        checkpoint=checkpoint,
                     )
             elif isinstance(exception, TimeoutError):
                 status = "timeout"
@@ -262,7 +271,12 @@ async def worker(
                 )
                 if not temporary:
                     await Threads.set_joint_status(
-                        conn, run["thread_id"], run_id, status, checkpoint=checkpoint
+                        conn,
+                        run["thread_id"],
+                        run_id,
+                        status,
+                        graph_id=graph_id,
+                        checkpoint=checkpoint,
                     )
             elif isinstance(exception, UserRollback):
                 status = "rollback"
@@ -273,6 +287,7 @@ async def worker(
                             run["thread_id"],
                             run_id,
                             status,
+                            graph_id=graph_id,
                             checkpoint=checkpoint,
                         )
                         await logger.ainfo(
@@ -297,7 +312,13 @@ async def worker(
                 )
                 if not temporary:
                     await Threads.set_joint_status(
-                        conn, run["thread_id"], run_id, status, checkpoint, exception
+                        conn,
+                        run["thread_id"],
+                        run_id,
+                        status,
+                        graph_id,
+                        checkpoint,
+                        exception,
                     )
             elif isinstance(exception, ALL_RETRIABLE_EXCEPTIONS):
                 status = "retry"
@@ -322,7 +343,13 @@ async def worker(
                 )
                 if not temporary:
                     await Threads.set_joint_status(
-                        conn, run["thread_id"], run_id, status, checkpoint, exception
+                        conn,
+                        run["thread_id"],
+                        run_id,
+                        status,
+                        graph_id,
+                        checkpoint,
+                        exception,
                     )
 
             # delete thread if it's temporary and we don't want to retry

{langgraph_api-0.2.129.dist-info → langgraph_api-0.2.132.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langgraph-api
-Version: 0.2.129
+Version: 0.2.132
 Author-email: Nuno Campos <nuno@langchain.dev>, Will Fu-Hinthorn <will@langchain.dev>
 License: Elastic-2.0
 License-File: LICENSE
@@ -11,7 +11,7 @@ Requires-Dist: httpx>=0.25.0
 Requires-Dist: jsonschema-rs<0.30,>=0.20.0
 Requires-Dist: langchain-core>=0.3.64
 Requires-Dist: langgraph-checkpoint>=2.0.23
-Requires-Dist: langgraph-runtime-inmem<0.7,>=0.6.9
+Requires-Dist: langgraph-runtime-inmem<0.7,>=0.6.13
 Requires-Dist: langgraph-sdk>=0.2.0
 Requires-Dist: langgraph>=0.4.0
 Requires-Dist: langsmith>=0.3.45