langgraph-api 0.2.125__py3-none-any.whl → 0.2.128__py3-none-any.whl

langgraph_api/__init__.py

@@ -1 +1 @@
-__version__ = "0.2.125"
+__version__ = "0.2.128"

langgraph_api/config.py

@@ -180,6 +180,7 @@ REDIS_MAX_CONNECTIONS = env("REDIS_MAX_CONNECTIONS", cast=int, default=2000)
 REDIS_CONNECT_TIMEOUT = env("REDIS_CONNECT_TIMEOUT", cast=float, default=10.0)
 REDIS_MAX_IDLE_TIME = env("REDIS_MAX_IDLE_TIME", cast=float, default=120.0)
 REDIS_KEY_PREFIX = env("REDIS_KEY_PREFIX", cast=str, default="")
+RUN_STATS_CACHE_SECONDS = env("RUN_STATS_CACHE_SECONDS", cast=int, default=60)
 
 # server
 ALLOW_PRIVATE_NETWORK = env("ALLOW_PRIVATE_NETWORK", cast=bool, default=False)

langgraph_api/middleware/http_logger.py

@@ -6,6 +6,7 @@ from starlette.requests import ClientDisconnect
 from starlette.types import Message, Receive, Scope, Send
 
 from langgraph_api.http_metrics import HTTP_METRICS_COLLECTOR
+from langgraph_api.utils.headers import should_include_header
 
 asgi = structlog.stdlib.get_logger("asgi")
 
@@ -99,12 +100,24 @@ class AccessLoggerMiddleware:
             )
 
 
-HEADERS_IGNORE = {b"authorization", b"cookie", b"set-cookie", b"x-api-key"}
+IGNORE_HEADERS = {
+    b"authorization",
+    b"cookie",
+    b"set-cookie",
+    b"x-api-key",
+}
 
 
 def _headers_to_dict(headers: list[tuple[bytes, bytes]] | None) -> dict[str, str]:
     if headers is None:
         return {}
-    return {
-        k.decode(): v.decode() for k, v in headers if k.lower() not in HEADERS_IGNORE
-    }
+
+    result = {}
+    for k, v in headers:
+        if k in IGNORE_HEADERS:
+            continue
+        key = k.decode()
+        if should_include_header(key):
+            result[key] = v.decode()
+
+    return result

langgraph_api/models/run.py

@@ -1,6 +1,4 @@
 import asyncio
-import functools
-import re
 import time
 import urllib.parse
 import uuid
@@ -28,6 +26,7 @@ from langgraph_api.schema import (
     StreamMode,
 )
 from langgraph_api.utils import AsyncConnectionProto, get_auth_ctx
+from langgraph_api.utils.headers import should_include_header
 from langgraph_runtime.ops import Runs, logger
 
 
@@ -180,82 +179,61 @@ LANGSMITH_TAGS = "langsmith-tags"
 LANGSMITH_PROJECT = "langsmith-project"
 
 
-def translate_pattern(pat: str) -> re.Pattern[str]:
-    """Translate a pattern to regex, supporting only literals and * wildcards to avoid RE DoS."""
-    res = []
-    i = 0
-    n = len(pat)
-
-    while i < n:
-        c = pat[i]
-        i += 1
-
-        if c == "*":
-            res.append(".*")
-        else:
-            res.append(re.escape(c))
-
-    pattern = "".join(res)
-    return re.compile(rf"(?s:{pattern})\Z")
-
-
-@functools.lru_cache(maxsize=1)
-def get_header_patterns() -> tuple[
-    list[re.Pattern[str] | None], list[re.Pattern[str] | None]
-]:
-    from langgraph_api import config
-
-    if not config.HTTP_CONFIG:
-        return None, None
-    configurable = config.HTTP_CONFIG.get("configurable_headers")
-    if not configurable:
-        return None, None
-    header_includes = configurable.get("includes") or configurable.get("include") or []
-    include_patterns = []
-    for include in header_includes:
-        include_patterns.append(translate_pattern(include))
-    header_excludes = configurable.get("excludes") or configurable.get("exclude") or []
-    exclude_patterns = []
-    for exclude in header_excludes:
-        exclude_patterns.append(translate_pattern(exclude))
-    return include_patterns, exclude_patterns
+# Default headers to exclude from run configuration for security
+DEFAULT_RUN_HEADERS_EXCLUDE = {"x-api-key", "x-tenant-id", "x-service-key"}
 
 
 def get_configurable_headers(headers: dict[str, str]) -> dict[str, str]:
+    """Extract headers that should be added to run configuration.
+
+    This function handles special cases like langsmith-trace and baggage headers,
+    while respecting the configurable header patterns.
+    """
     configurable = {}
-    include_patterns, exclude_patterns = get_header_patterns()
+
     for key, value in headers.items():
-        # First handle tracing stuff; not configurable
+        # First handle tracing stuff - always included regardless of patterns
         if key == "langsmith-trace":
             configurable[key] = value
             if baggage := headers.get("baggage"):
                 for item in baggage.split(","):
-                    key, value = item.split("=")
-                    if key == LANGSMITH_METADATA and key not in configurable:
-                        configurable[key] = orjson.loads(urllib.parse.unquote(value))
-                    elif key == LANGSMITH_TAGS:
-                        configurable[key] = urllib.parse.unquote(value).split(",")
-                    elif key == LANGSMITH_PROJECT:
-                        configurable[key] = urllib.parse.unquote(value)
-        # Then handle overridable behavior
-        if exclude_patterns and any(pattern.match(key) for pattern in exclude_patterns):
-            continue
-        if include_patterns and any(pattern.match(key) for pattern in include_patterns):
-            configurable[key] = value
+                    baggage_key, baggage_value = item.split("=")
+                    if (
+                        baggage_key == LANGSMITH_METADATA
+                        and baggage_key not in configurable
+                    ):
+                        configurable[baggage_key] = orjson.loads(
+                            urllib.parse.unquote(baggage_value)
+                        )
+                    elif baggage_key == LANGSMITH_TAGS:
+                        configurable[baggage_key] = urllib.parse.unquote(
+                            baggage_value
+                        ).split(",")
+                    elif baggage_key == LANGSMITH_PROJECT:
+                        configurable[baggage_key] = urllib.parse.unquote(baggage_value)
             continue
 
-        # Then handle default behavior
+        # Check if header should be included based on patterns
+        # For run configuration, we have specific default behavior for x-* headers
         if key.startswith("x-"):
-            if key in (
-                "x-api-key",
-                "x-tenant-id",
-                "x-service-key",
-            ):
+            # Check against default excludes for x-* headers
+            if key in DEFAULT_RUN_HEADERS_EXCLUDE:
+                # Check if explicitly included via patterns
+                if should_include_header(key):
+                    configurable[key] = value
                 continue
-            configurable[key] = value
-
+            # Other x-* headers are included by default unless patterns exclude them
+            if should_include_header(key):
+                configurable[key] = value
         elif key == "user-agent":
-            configurable[key] = value
+            # user-agent is included by default unless excluded by patterns
+            if should_include_header(key):
+                configurable[key] = value
+        else:
+            # All other headers only included if patterns allow
+            if should_include_header(key):
+                configurable[key] = value
+
     return configurable
 
 
@@ -297,6 +275,13 @@ async def create_valid_run(
     config = payload.get("config") or {}
     context = payload.get("context") or {}
     configurable = config.setdefault("configurable", {})
+
+    if configurable and context:
+        raise HTTPException(
+            status_code=400,
+            detail="Cannot specify both configurable and context. Prefer setting context alone. Context was introduced in LangGraph 0.6.0 and is the long term planned replacement for configurable.",
+        )
+
     if checkpoint_id:
         configurable["checkpoint_id"] = str(checkpoint_id)
     if checkpoint := payload.get("checkpoint"):
@@ -322,6 +307,12 @@ async def create_valid_run(
     configurable["__after_seconds__"] = after_seconds
     put_time_start = time.time()
     if_not_exists = payload.get("if_not_exists", "reject")
+
+    # Keep config and context in sync
+    # Configurable is either A) just internal config or B) internal config + user config (and context is empty). Either way, configurable is the default.
+    context = {**context, **configurable}
+    config["configurable"] = context
+
     run_coro = Runs.put(
         conn,
         assistant_id,

langgraph_api/stream.py

@@ -348,7 +348,17 @@ async def astream_state(
         yield "feedback", feedback_urls
 
 
-async def consume(stream: AnyStream, run_id: str, resumable: bool = False) -> None:
+async def consume(
+    stream: AnyStream,
+    run_id: str,
+    resumable: bool = False,
+    stream_modes: set[StreamMode] | None = None,
+) -> None:
+    stream_modes = stream_modes or set()
+    if "messages-tuple" in stream_modes:
+        stream_modes.add("messages")
+    stream_modes.add("metadata")
+
     async with aclosing(stream):
         try:
             async for mode, payload in stream:
@@ -356,7 +366,7 @@ async def consume(stream: AnyStream, run_id: str, resumable: bool = False) -> No
                     run_id,
                     mode,
                     await run_in_executor(None, json_dumpb, payload),
-                    resumable=resumable,
+                    resumable=resumable and mode.split("|")[0] in stream_modes,
                 )
         except Exception as e:
             if isinstance(e, ExceptionGroup):
@@ -365,7 +375,6 @@ async def consume(stream: AnyStream, run_id: str, resumable: bool = False) -> No
                 run_id,
                 "error",
                 await run_in_executor(None, json_dumpb, e),
-                resumable=resumable,
             )
             raise e
 

langgraph_api/utils/headers.py

@@ -0,0 +1,72 @@
+"""Shared utilities for configurable header filtering."""
+
+import functools
+import re
+
+
+def translate_pattern(pat: str) -> re.Pattern[str]:
+    """Translate a pattern to regex, supporting only literals and * wildcards to avoid RE DoS."""
+    res = []
+    i = 0
+    n = len(pat)
+
+    while i < n:
+        c = pat[i]
+        i += 1
+
+        if c == "*":
+            res.append(".*")
+        else:
+            res.append(re.escape(c))
+
+    pattern = "".join(res)
+    return re.compile(rf"(?s:{pattern})\Z")
+
+
+@functools.lru_cache(maxsize=1)
+def get_header_patterns() -> 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")
+    if not configurable:
+        return None, None
+    header_includes = configurable.get("includes") or configurable.get("include") or []
+    include_patterns = []
+    for include in header_includes:
+        include_patterns.append(translate_pattern(include))
+    header_excludes = configurable.get("excludes") or configurable.get("exclude") or []
+    exclude_patterns = []
+    for exclude in header_excludes:
+        exclude_patterns.append(translate_pattern(exclude))
+    return include_patterns or None, exclude_patterns or None
+
+
+@functools.lru_cache(maxsize=512)
+def should_include_header(key: str) -> bool:
+    """Check if a header should be included based on cached patterns.
+
+    This function uses cached patterns from get_header_patterns() and
+    provides efficient header filtering.
+
+    Args:
+        key: The header key to check
+
+    Returns:
+        True if the header should be included, False otherwise
+    """
+    include_patterns, exclude_patterns = get_header_patterns()
+
+    # Handle configurable behavior
+    if exclude_patterns and any(pattern.match(key) for pattern in exclude_patterns):
+        return False
+    if include_patterns:
+        # If include patterns are specified, only include headers matching them
+        return any(pattern.match(key) for pattern in include_patterns)
+
+    # Default behavior - include if not excluded
+    return True

langgraph_api/worker.py

@@ -20,7 +20,7 @@ from langgraph_api.config import (
 from langgraph_api.errors import UserInterrupt, UserRollback, UserTimeout
 from langgraph_api.js.errors import RemoteException
 from langgraph_api.metadata import incr_runs
-from langgraph_api.schema import Run
+from langgraph_api.schema import Run, StreamMode
 from langgraph_api.state import state_snapshot_to_thread_state
 from langgraph_api.stream import AnyStream, astream_state, consume
 from langgraph_api.utils import with_user
@@ -54,6 +54,7 @@ async def set_auth_ctx_for_run(
         user = normalize_user(user)
         # Reapply normalization to the kwargs
         run_kwargs["config"]["configurable"]["langgraph_auth_user"] = user
+        run_kwargs["context"]["langgraph_auth_user"] = user
     except Exception:
         user = SimpleUser(user_id) if user_id is not None else None
         permissions = None
@@ -130,9 +131,11 @@ async def worker(
                     break
 
     # Wrap the graph execution to separate user errors from server errors
-    async def wrap_user_errors(stream: AnyStream, run_id: str, resumable: bool):
+    async def wrap_user_errors(
+        stream: AnyStream, run_id: str, resumable: bool, stream_modes: set[StreamMode]
+    ):
         try:
-            await consume(stream, run_id, resumable)
+            await consume(stream, run_id, resumable, stream_modes)
         except Exception as e:
             if not isinstance(e, UserRollback | UserInterrupt):
                 logger.error(
@@ -184,8 +187,11 @@ async def worker(
                         on_checkpoint=on_checkpoint,
                         on_task_result=on_task_result,
                     )
+                stream_modes: set[StreamMode] = set(
+                    run["kwargs"].get("stream_mode", [])
+                )
                 await asyncio.wait_for(
-                    wrap_user_errors(stream, run_id, resumable),
+                    wrap_user_errors(stream, run_id, resumable, stream_modes),
                     BG_JOB_TIMEOUT_SECS,
                 )
         except (Exception, asyncio.CancelledError) as ee:

{langgraph_api-0.2.125.dist-info → langgraph_api-0.2.128.dist-info}/METADATA

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

{langgraph_api-0.2.125.dist-info → langgraph_api-0.2.128.dist-info}/RECORD

@@ -1,9 +1,9 @@
-langgraph_api/__init__.py,sha256=bcQUJPOGIDh7Iu1C7gCmymyGyrOInGOeeO_ttoZlkyA,24
+langgraph_api/__init__.py,sha256=mxT2nps5QgA-B4fLdRmfWEWc4sx0YKxh3Dl4H6yEbUQ,24
 langgraph_api/asgi_transport.py,sha256=eqifhHxNnxvI7jJqrY1_8RjL4Fp9NdN4prEub2FWBt8,5091
 langgraph_api/asyncio.py,sha256=Wv4Rwm-a-Cf6JpfgJmVuVlXQ7SlwrjbTn0eq1ux8I2Q,9652
 langgraph_api/cli.py,sha256=xQojITwmmKSJw48Lr2regcnRPRq2FJqWlPpeyr5TgbU,16158
 langgraph_api/command.py,sha256=3O9v3i0OPa96ARyJ_oJbLXkfO8rPgDhLCswgO9koTFA,768
-langgraph_api/config.py,sha256=Nxhx6fOsxk_u-Aae54JAGn46JQ1wKXPjeu_KX_3d4wQ,11918
+langgraph_api/config.py,sha256=P89uB2IOycXW0qD0bb3stiaN2xAv7ixw_vqBWHM94Bw,11997
 langgraph_api/cron_scheduler.py,sha256=CiwZ-U4gDOdG9zl9dlr7mH50USUgNB2Fvb8YTKVRBN4,2625
 langgraph_api/errors.py,sha256=zlnl3xXIwVG0oGNKKpXf1an9Rn_SBDHSyhe53hU6aLw,1858
 langgraph_api/feature_flags.py,sha256=GjwmNjfg0Jhs3OzR2VbK2WgrRy3o5l8ibIYiUtQkDPA,363
@@ -21,13 +21,13 @@ langgraph_api/server.py,sha256=KBnMFt3f9RVLVu_NqyeRc13D_Lq62Rk_2czZKEUMU5E,6994
 langgraph_api/sse.py,sha256=SLdtZmTdh5D8fbWrQjuY9HYLd2dg8Rmi6ZMmFMVc2iE,4204
 langgraph_api/state.py,sha256=P2mCo-0bqPu2v9FSFGJtUCjPPNvv6wLUKQh8SdxAtc8,4387
 langgraph_api/store.py,sha256=srRI0fQXNFo_RSUs4apucr4BEp_KrIseJksZXs32MlQ,4635
-langgraph_api/stream.py,sha256=RvO0mYEzU7XTSQz2PDvj3KzMO_T2Hpmsbwff0GoRDmI,15741
+langgraph_api/stream.py,sha256=tZfwOvG-wQNURdfQ_chfUO93JGZYc8iShlkbgukrQhY,15960
 langgraph_api/thread_ttl.py,sha256=7H3gFlWcUiODPoaEzcwB0LR61uvcuyjD0ew_4BztB7k,1902
 langgraph_api/traceblock.py,sha256=2aWS6TKGTcQ0G1fOtnjVrzkpeGvDsR0spDbfddEqgRU,594
 langgraph_api/utils.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langgraph_api/validation.py,sha256=zMuKmwUEBjBgFMwAaeLZmatwGVijKv2sOYtYg7gfRtc,4950
 langgraph_api/webhook.py,sha256=VCJp4dI5E1oSJ15XP34cnPiOi8Ya8Q1BnBwVGadOpLI,1636
-langgraph_api/worker.py,sha256=LVvjvigurlDgpNjFcbAvRH7744fE01Lirrg2ZlHtORE,14245
+langgraph_api/worker.py,sha256=psxipp6bFlJrN5erGKV7D1wm2olrfggPvMqKoWk7SE4,14518
 langgraph_api/api/__init__.py,sha256=WHy6oNLWtH1K7AxmmsU9RD-Vm6WP-Ov16xS8Ey9YCmQ,6090
 langgraph_api/api/assistants.py,sha256=ecHaID71ReTAZF4qsJzDe5L-2T5iOL2v8p6kQVHLKFk,16009
 langgraph_api/api/mcp.py,sha256=qe10ZRMN3f-Hli-9TI8nbQyWvMeBb72YB1PZVbyqBQw,14418
@@ -70,16 +70,17 @@ langgraph_api/js/src/utils/importMap.mts,sha256=pX4TGOyUpuuWF82kXcxcv3-8mgusRezO
 langgraph_api/js/src/utils/pythonSchemas.mts,sha256=98IW7Z_VP7L_CHNRMb3_MsiV3BgLE2JsWQY_PQcRR3o,685
 langgraph_api/js/src/utils/serde.mts,sha256=D9o6MwTgwPezC_DEmsWS5NnLPnjPMVWIb1I1D4QPEPo,743
 langgraph_api/middleware/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-langgraph_api/middleware/http_logger.py,sha256=L7ZhypmQjlHBfm93GqZaqUXzu0r-ieaoO1lY7t1jGb0,3701
+langgraph_api/middleware/http_logger.py,sha256=tUdWuIKtDa2EkFtG_kCjw1Wkgv7gbGH3hZSgWM5Pta4,3892
 langgraph_api/middleware/private_network.py,sha256=eYgdyU8AzU2XJu362i1L8aSFoQRiV7_aLBPw7_EgeqI,2111
 langgraph_api/middleware/request_id.py,sha256=SDj3Yi3WvTbFQ2ewrPQBjAV8sYReOJGeIiuoHeZpR9g,1242
 langgraph_api/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-langgraph_api/models/run.py,sha256=RX2LaE1kmTruX8o8HgvqeEt5YpPGHILWByChjMZVJ58,15035
+langgraph_api/models/run.py,sha256=UmkZm9IL_ET3QNA8xVPFHTAcXXZ4htQDMQuPKzaWKPA,15383
 langgraph_api/tunneling/cloudflare.py,sha256=iKb6tj-VWPlDchHFjuQyep2Dpb-w2NGfJKt-WJG9LH0,3650
 langgraph_api/utils/__init__.py,sha256=EQu0PShwHhxUI_9mDFgqlAf5_y5bX8TEk723P5iby24,4161
 langgraph_api/utils/cache.py,sha256=SrtIWYibbrNeZzLXLUGBFhJPkMVNQnVxR5giiYGHEfI,1810
 langgraph_api/utils/config.py,sha256=gONI0UsoSpuR72D9lSGAmpr-_iSMDFdD4M_tiXXjmNk,3936
 langgraph_api/utils/future.py,sha256=CGhUb_Ht4_CnTuXc2kI8evEn1gnMKYN0ce9ZyUkW5G4,7251
+langgraph_api/utils/headers.py,sha256=fRZWsR279KOlbfbdcoajguVDDgVdN7V2OYkWxnHeXCE,2239
 langgraph_license/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langgraph_license/validation.py,sha256=CU38RUZ5xhP1S8F_y8TNeV6OmtO-tIGjCXbXTwJjJO4,612
 langgraph_runtime/__init__.py,sha256=O4GgSmu33c-Pr8Xzxj_brcK5vkm70iNTcyxEjICFZxA,1075
@@ -94,8 +95,8 @@ langgraph_runtime/store.py,sha256=7mowndlsIroGHv3NpTSOZDJR0lCuaYMBoTnTrewjslw,11
 LICENSE,sha256=ZPwVR73Biwm3sK6vR54djCrhaRiM4cAD2zvOQZV8Xis,3859
 logging.json,sha256=3RNjSADZmDq38eHePMm1CbP6qZ71AmpBtLwCmKU9Zgo,379
 openapi.json,sha256=SPCrzYpta2xTl-WE2W6qwosYdQqLeB8qpzaYEbcK44k,150725
-langgraph_api-0.2.125.dist-info/METADATA,sha256=nf3cx_h7rAHCrc6PLmUvnzQk21W-B5ugdabVU9VoiDU,3890
-langgraph_api-0.2.125.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-langgraph_api-0.2.125.dist-info/entry_points.txt,sha256=hGedv8n7cgi41PypMfinwS_HfCwA7xJIfS0jAp8htV8,78
-langgraph_api-0.2.125.dist-info/licenses/LICENSE,sha256=ZPwVR73Biwm3sK6vR54djCrhaRiM4cAD2zvOQZV8Xis,3859
-langgraph_api-0.2.125.dist-info/RECORD,,
+langgraph_api-0.2.128.dist-info/METADATA,sha256=1gOWC24pl8KN1ymA6h8ONc4DhnTkFWH-fLf5ILi6Oo4,3890
+langgraph_api-0.2.128.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+langgraph_api-0.2.128.dist-info/entry_points.txt,sha256=hGedv8n7cgi41PypMfinwS_HfCwA7xJIfS0jAp8htV8,78
+langgraph_api-0.2.128.dist-info/licenses/LICENSE,sha256=ZPwVR73Biwm3sK6vR54djCrhaRiM4cAD2zvOQZV8Xis,3859
+langgraph_api-0.2.128.dist-info/RECORD,,