langgraph-api 0.4.1__tar.gz → 0.4.7__tar.gz

{langgraph_api-0.4.1 → langgraph_api-0.4.7}/PKG-INFO

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

{langgraph_api-0.4.1 → langgraph_api-0.4.7}/benchmark/ramp.js

@@ -10,6 +10,7 @@ const failedRuns = new Counter('failed_runs');
 const timeoutErrors = new Counter('timeout_errors');
 const connectionErrors = new Counter('connection_errors');
 const serverErrors = new Counter('server_errors');
+const missingMessageErrors = new Counter('missing_message_errors');
 const otherErrors = new Counter('other_errors');
 
 // URL of your LangGraph server
@@ -36,6 +37,13 @@ for (let i = 1; i <= LEVELS; i++) {
 stages.push({ duration: `${PLATEAU_DURATION}s`, target: LOAD_SIZE * LEVELS});
 stages.push({ duration: '60s', target: 0 }); // Ramp down
 
+// These are rough estimates from running in github actions. Actual results should be better so long as load is 1-1 with jobs available.
+const p95_run_duration = {
+  'sequential': 18000,
+  'parallel': 8500,
+  'single': 1500,
+}
+
 // Test configuration
 export let options = {
   scenarios: {
@@ -47,16 +55,16 @@ export let options = {
     },
   },
   thresholds: {
-    // These are the first set of goals I'd like to hit. To get the job just working and ramp on main, leaving them off for now.
-    // 'run_duration': ['p(95)<10000'],  // 95% of runs should complete within 10s
-    // 'successful_runs': ['count>100000'],  // At least 100,000 successful runs
-    // 'http_req_failed': ['rate<0.05'],   // Error rate should be less than 5%
+    'run_duration': [`p(95)<${p95_run_duration[MODE]}`],
+    'successful_runs': [`count>${(PLATEAU_DURATION / (p95_run_duration[MODE] / 1000)) * LOAD_SIZE * LEVELS * 2}`],  // Number of expected successful runs per user worst caseduring plateau * max number of users * 2 cause that feels about right
+    'http_req_failed': ['rate<0.01'],   // Error rate should be less than 1%
   },
 };
 
 // Main test function
 export default function() {
   const startTime = new Date().getTime();
+  let response;
 
   try {
     // Prepare the request payload
@@ -91,7 +99,7 @@ export default function() {
     }
 
     // Make a single request to the wait endpoint
-    const response = http.post(url, payload, {
+    response = http.post(url, payload, {
       headers,
       timeout: '120s'  // k6 request timeout slightly longer than the server timeout
     });
@@ -110,9 +118,6 @@ export default function() {
       // Record success metrics
       runDuration.add(duration);
       successfulRuns.add(1);
-
-      // Optional: Log successful run details
-      console.log(`Run completed successfully in ${duration/1000}s`);
     } else {
       // Handle failure
       failedRuns.add(1);
@@ -124,12 +129,15 @@ export default function() {
       } else if (response.status === 408 || response.error === 'timeout') {
         timeoutErrors.add(1);
         console.log(`Timeout error: ${response.error}`);
+      } else if (response.status === 200 && response?.body?.messages?.length !== expected_length) {
+        missingMessageErrors.add(1);
+        console.log(response);
+        console.log(`Missing message error: Status ${response.status}, ${JSON.stringify(response.body)}`);
       } else {
         otherErrors.add(1);
-        console.log(`Other error: Status ${response.status}, ${JSON.stringify(response)}`);
+        console.log(`Other error: Status ${response.status}, ${JSON.stringify(response.body)}`);
       }
     }
-
   } catch (error) {
     // Handle exceptions (network errors, etc.)
     failedRuns.add(1);
@@ -142,7 +150,9 @@ export default function() {
       console.log(`Connection error: ${error.message}`);
     } else {
       otherErrors.add(1);
-      console.log(`Unexpected error: ${error.message}`);
+      // Usually we end up with HTML error pages here
+      console.log(response);
+      console.log(`Unexpected error: ${error.message}, Response Body: ${response?.body}`);
     }
   }
 
@@ -180,6 +190,7 @@ export function handleSummary(data) {
         timeout: data.metrics.timeout_errors ? data.metrics.timeout_errors.values.count : 0,
         connection: data.metrics.connection_errors ? data.metrics.connection_errors.values.count : 0,
         server: data.metrics.server_errors ? data.metrics.server_errors.values.count : 0,
+        missingMessage: data.metrics.missing_message_errors ? data.metrics.missing_message_errors.values.count : 0,
         other: data.metrics.other_errors ? data.metrics.other_errors.values.count : 0
       }
     }

langgraph_api-0.4.7/langgraph_api/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.4.7"

{langgraph_api-0.4.1 → langgraph_api-0.4.7}/langgraph_api/api/runs.py

@@ -4,11 +4,12 @@ from typing import Literal, cast
 from uuid import uuid4
 
 import orjson
+import structlog
 from starlette.exceptions import HTTPException
 from starlette.responses import Response, StreamingResponse
 
 from langgraph_api import config
-from langgraph_api.asyncio import ValueEvent, aclosing
+from langgraph_api.asyncio import ValueEvent
 from langgraph_api.models.run import create_valid_run
 from langgraph_api.route import ApiRequest, ApiResponse, ApiRoute
 from langgraph_api.schema import CRON_FIELDS, RUN_FIELDS
@@ -34,6 +35,8 @@ from langgraph_runtime.database import connect
 from langgraph_runtime.ops import Crons, Runs, Threads
 from langgraph_runtime.retry import retry_db
 
+logger = structlog.stdlib.get_logger(__name__)
+
 
 @retry_db
 async def create_run(request: ApiRequest):
@@ -101,9 +104,7 @@ async def stream_run(
     payload = await request.json(RunCreateStateful)
     on_disconnect = payload.get("on_disconnect", "continue")
     run_id = uuid7()
-    sub = asyncio.create_task(Runs.Stream.subscribe(run_id, thread_id))
-
-    try:
+    async with await Runs.Stream.subscribe(run_id, thread_id) as sub:
         async with connect() as conn:
             run = await create_valid_run(
                 conn,
@@ -113,25 +114,20 @@ async def stream_run(
                 run_id=run_id,
                 request_start_time=request.scope.get("request_start_time_ms"),
             )
-    except Exception:
-        if not sub.cancelled():
-            handle = await sub
-            await handle.__aexit__(None, None, None)
-        raise
 
-    return EventSourceResponse(
-        Runs.Stream.join(
-            run["run_id"],
-            thread_id=thread_id,
-            cancel_on_disconnect=on_disconnect == "cancel",
-            stream_channel=await sub,
-            last_event_id=None,
-        ),
-        headers={
-            "Location": f"/threads/{thread_id}/runs/{run['run_id']}/stream",
-            "Content-Location": f"/threads/{thread_id}/runs/{run['run_id']}",
-        },
-    )
+        return EventSourceResponse(
+            Runs.Stream.join(
+                run["run_id"],
+                thread_id=thread_id,
+                cancel_on_disconnect=on_disconnect == "cancel",
+                stream_channel=sub,
+                last_event_id=None,
+            ),
+            headers={
+                "Location": f"/threads/{thread_id}/runs/{run['run_id']}/stream",
+                "Content-Location": f"/threads/{thread_id}/runs/{run['run_id']}",
+            },
+        )
 
 
 async def stream_run_stateless(
@@ -143,8 +139,7 @@ async def stream_run_stateless(
     on_disconnect = payload.get("on_disconnect", "continue")
     run_id = uuid7()
     thread_id = uuid4()
-    sub = asyncio.create_task(Runs.Stream.subscribe(run_id, thread_id))
-    try:
+    async with await Runs.Stream.subscribe(run_id, thread_id) as sub:
         async with connect() as conn:
             run = await create_valid_run(
                 conn,
@@ -155,26 +150,21 @@ async def stream_run_stateless(
                 request_start_time=request.scope.get("request_start_time_ms"),
                 temporary=True,
             )
-    except Exception:
-        if not sub.cancelled():
-            handle = await sub
-            await handle.__aexit__(None, None, None)
-        raise
 
-    return EventSourceResponse(
-        Runs.Stream.join(
-            run["run_id"],
-            thread_id=run["thread_id"],
-            ignore_404=True,
-            cancel_on_disconnect=on_disconnect == "cancel",
-            stream_channel=await sub,
-            last_event_id=None,
-        ),
-        headers={
-            "Location": f"/runs/{run['run_id']}/stream",
-            "Content-Location": f"/runs/{run['run_id']}",
-        },
-    )
+        return EventSourceResponse(
+            Runs.Stream.join(
+                run["run_id"],
+                thread_id=run["thread_id"],
+                ignore_404=True,
+                cancel_on_disconnect=on_disconnect == "cancel",
+                stream_channel=sub,
+                last_event_id=None,
+            ),
+            headers={
+                "Location": f"/runs/{run['run_id']}/stream",
+                "Content-Location": f"/runs/{run['run_id']}",
+            },
+        )
 
 
 @retry_db
@@ -184,9 +174,7 @@ async def wait_run(request: ApiRequest):
     payload = await request.json(RunCreateStateful)
     on_disconnect = payload.get("on_disconnect", "continue")
     run_id = uuid7()
-    sub = asyncio.create_task(Runs.Stream.subscribe(run_id, thread_id))
-
-    try:
+    async with await Runs.Stream.subscribe(run_id, thread_id) as sub:
         async with connect() as conn:
             run = await create_valid_run(
                 conn,
@@ -196,25 +184,17 @@ async def wait_run(request: ApiRequest):
                 run_id=run_id,
                 request_start_time=request.scope.get("request_start_time_ms"),
             )
-    except Exception:
-        if not sub.cancelled():
-            handle = await sub
-            await handle.__aexit__(None, None, None)
-        raise
 
-    last_chunk = ValueEvent()
+        last_chunk = ValueEvent()
 
-    async def consume():
-        vchunk: bytes | None = None
-        async with aclosing(
-            Runs.Stream.join(
+        async def consume():
+            vchunk: bytes | None = None
+            async for mode, chunk, _ in Runs.Stream.join(
                 run["run_id"],
                 thread_id=run["thread_id"],
-                stream_channel=await sub,
+                stream_channel=sub,
                 cancel_on_disconnect=on_disconnect == "cancel",
-            )
-        ) as stream:
-            async for mode, chunk, _ in stream:
+            ):
                 if (
                     mode == b"values"
                     or mode == b"updates"
@@ -223,43 +203,47 @@ async def wait_run(request: ApiRequest):
                     vchunk = chunk
                 elif mode == b"error":
                     vchunk = orjson.dumps({"__error__": orjson.Fragment(chunk)})
-        if vchunk is not None:
-            last_chunk.set(vchunk)
-        else:
-            async with connect() as conn:
-                thread_iter = await Threads.get(conn, thread_id)
+            if vchunk is not None:
+                last_chunk.set(vchunk)
+            else:
+                async with connect() as conn:
+                    thread_iter = await Threads.get(conn, thread_id)
+                    try:
+                        thread = await anext(thread_iter)
+                        last_chunk.set(thread["values"])
+                    except StopAsyncIteration:
+                        await logger.awarning(
+                            f"No checkpoint found for thread {thread_id}",
+                            thread_id=thread_id,
+                        )
+                        last_chunk.set(b"{}")
+
+        # keep the connection open by sending whitespace every 5 seconds
+        # leading whitespace will be ignored by json parsers
+        async def body() -> AsyncIterator[bytes]:
+            stream = asyncio.create_task(consume())
+            while True:
                 try:
-                    thread = await anext(thread_iter)
-                    last_chunk.set(thread["values"])
-                except StopAsyncIteration:
-                    last_chunk.set(b"{}")
-
-    # keep the connection open by sending whitespace every 5 seconds
-    # leading whitespace will be ignored by json parsers
-    async def body() -> AsyncIterator[bytes]:
-        stream = asyncio.create_task(consume())
-        while True:
-            try:
-                if stream.done():
-                    # raise stream exception if any
-                    stream.result()
-                yield await asyncio.wait_for(last_chunk.wait(), timeout=5)
-                break
-            except TimeoutError:
-                yield b"\n"
-            except asyncio.CancelledError:
-                stream.cancel()
-                await stream
-                raise
-
-    return StreamingResponse(
-        body(),
-        media_type="application/json",
-        headers={
-            "Location": f"/threads/{thread_id}/runs/{run['run_id']}/join",
-            "Content-Location": f"/threads/{thread_id}/runs/{run['run_id']}",
-        },
-    )
+                    if stream.done():
+                        # raise stream exception if any
+                        stream.result()
+                    yield await asyncio.wait_for(last_chunk.wait(), timeout=5)
+                    break
+                except TimeoutError:
+                    yield b"\n"
+                except asyncio.CancelledError:
+                    stream.cancel()
+                    await stream
+                    raise
+
+        return StreamingResponse(
+            body(),
+            media_type="application/json",
+            headers={
+                "Location": f"/threads/{thread_id}/runs/{run['run_id']}/join",
+                "Content-Location": f"/threads/{thread_id}/runs/{run['run_id']}",
+            },
+        )
 
 
 @retry_db
@@ -270,9 +254,7 @@ async def wait_run_stateless(request: ApiRequest):
     on_disconnect = payload.get("on_disconnect", "continue")
     run_id = uuid7()
     thread_id = uuid4()
-    sub = asyncio.create_task(Runs.Stream.subscribe(run_id, thread_id))
-
-    try:
+    async with await Runs.Stream.subscribe(run_id, thread_id) as sub:
         async with connect() as conn:
             run = await create_valid_run(
                 conn,
@@ -283,25 +265,18 @@ async def wait_run_stateless(request: ApiRequest):
                 request_start_time=request.scope.get("request_start_time_ms"),
                 temporary=True,
             )
-    except Exception:
-        if not sub.cancelled():
-            handle = await sub
-            await handle.__aexit__(None, None, None)
-        raise
-    last_chunk = ValueEvent()
-
-    async def consume():
-        vchunk: bytes | None = None
-        async with aclosing(
-            Runs.Stream.join(
+
+        last_chunk = ValueEvent()
+
+        async def consume():
+            vchunk: bytes | None = None
+            async for mode, chunk, _ in Runs.Stream.join(
                 run["run_id"],
                 thread_id=run["thread_id"],
-                stream_channel=await sub,
+                stream_channel=sub,
                 ignore_404=True,
                 cancel_on_disconnect=on_disconnect == "cancel",
-            )
-        ) as stream:
-            async for mode, chunk, _ in stream:
+            ):
                 if (
                     mode == b"values"
                     or mode == b"updates"
@@ -310,38 +285,43 @@ async def wait_run_stateless(request: ApiRequest):
                     vchunk = chunk
                 elif mode == b"error":
                     vchunk = orjson.dumps({"__error__": orjson.Fragment(chunk)})
-        if vchunk is not None:
-            last_chunk.set(vchunk)
-        else:
-            # we can't fetch the thread (it was deleted), so just return empty values
-            last_chunk.set(b"{}")
-
-    # keep the connection open by sending whitespace every 5 seconds
-    # leading whitespace will be ignored by json parsers
-    async def body() -> AsyncIterator[bytes]:
-        stream = asyncio.create_task(consume())
-        while True:
-            try:
-                if stream.done():
-                    # raise stream exception if any
-                    stream.result()
-                yield await asyncio.wait_for(last_chunk.wait(), timeout=5)
-                break
-            except TimeoutError:
-                yield b"\n"
-            except asyncio.CancelledError:
-                stream.cancel("Run stream cancelled")
-                await stream
-                raise
-
-    return StreamingResponse(
-        body(),
-        media_type="application/json",
-        headers={
-            "Location": f"/threads/{run['thread_id']}/runs/{run['run_id']}/join",
-            "Content-Location": f"/threads/{run['thread_id']}/runs/{run['run_id']}",
-        },
-    )
+            if vchunk is not None:
+                last_chunk.set(vchunk)
+            else:
+                # we can't fetch the thread (it was deleted), so just return empty values
+                await logger.awarning(
+                    "No checkpoint emitted for stateless run",
+                    run_id=run["run_id"],
+                    thread_id=run["thread_id"],
+                )
+                last_chunk.set(b"{}")
+
+        # keep the connection open by sending whitespace every 5 seconds
+        # leading whitespace will be ignored by json parsers
+        async def body() -> AsyncIterator[bytes]:
+            stream = asyncio.create_task(consume())
+            while True:
+                try:
+                    if stream.done():
+                        # raise stream exception if any
+                        stream.result()
+                    yield await asyncio.wait_for(last_chunk.wait(), timeout=5)
+                    break
+                except TimeoutError:
+                    yield b"\n"
+                except asyncio.CancelledError:
+                    stream.cancel("Run stream cancelled")
+                    await stream
+                    raise
+
+        return StreamingResponse(
+            body(),
+            media_type="application/json",
+            headers={
+                "Location": f"/threads/{run['thread_id']}/runs/{run['run_id']}/join",
+                "Content-Location": f"/threads/{run['thread_id']}/runs/{run['run_id']}",
+            },
+        )
 
 
 @retry_db

{langgraph_api-0.4.1 → langgraph_api-0.4.7}/langgraph_api/api/threads.py

@@ -1,3 +1,4 @@
+from typing import get_args
 from uuid import uuid4
 
 from starlette.exceptions import HTTPException
@@ -5,7 +6,7 @@ from starlette.responses import Response
 from starlette.routing import BaseRoute
 
 from langgraph_api.route import ApiRequest, ApiResponse, ApiRoute
-from langgraph_api.schema import THREAD_FIELDS
+from langgraph_api.schema import THREAD_FIELDS, ThreadStreamMode
 from langgraph_api.sse import EventSourceResponse
 from langgraph_api.state import state_snapshot_to_thread_state
 from langgraph_api.utils import (
@@ -293,10 +294,31 @@ async def join_thread_stream(request: ApiRequest):
     validate_stream_id(
         last_event_id, "Invalid last-event-id: must be a valid Redis stream ID"
     )
+
+    # Parse stream_modes parameter - can be single string or comma-separated list
+    stream_modes_param = request.query_params.get("stream_modes")
+    if stream_modes_param:
+        if "," in stream_modes_param:
+            # Handle comma-separated list
+            stream_modes = [mode.strip() for mode in stream_modes_param.split(",")]
+        else:
+            # Handle single value
+            stream_modes = [stream_modes_param]
+        # Validate each mode
+        for mode in stream_modes:
+            if mode not in get_args(ThreadStreamMode):
+                raise HTTPException(
+                    status_code=422, detail=f"Invalid stream mode: {mode}"
+                )
+    else:
+        # Default to run_modes
+        stream_modes = ["run_modes"]
+
     return EventSourceResponse(
         Threads.Stream.join(
             thread_id,
             last_event_id=last_event_id,
+            stream_modes=stream_modes,
         ),
     )
 

{langgraph_api-0.4.1 → langgraph_api-0.4.7}/langgraph_api/asyncio.py

@@ -162,7 +162,8 @@ class SimpleTaskGroup(AbstractAsyncContextManager["SimpleTaskGroup"]):
         taskset: set[asyncio.Task] | None = None,
         taskgroup_name: str | None = None,
     ) -> None:
-        self.tasks = taskset if taskset is not None else set()
+        # Copy the taskset to avoid modifying the original set unintentionally (like in lifespan)
+        self.tasks = taskset.copy() if taskset is not None else set()
         self.cancel = cancel
         self.wait = wait
         if taskset:

{langgraph_api-0.4.1 → langgraph_api-0.4.7}/langgraph_api/feature_flags.py

@@ -6,3 +6,4 @@ LANGGRAPH_PY_MINOR = tuple(map(int, __version__.split(".")[:2]))
 OMIT_PENDING_SENDS = LANGGRAPH_PY_MINOR >= (0, 5)
 USE_RUNTIME_CONTEXT_API = LANGGRAPH_PY_MINOR >= (0, 6)
 USE_NEW_INTERRUPTS = LANGGRAPH_PY_MINOR >= (0, 6)
+USE_DURABILITY = LANGGRAPH_PY_MINOR >= (0, 6)

{langgraph_api-0.4.1 → langgraph_api-0.4.7}/langgraph_api/logging.py

@@ -69,9 +69,12 @@ class AddApiVersion:
     def __call__(
         self, logger: logging.Logger, method_name: str, event_dict: EventDict
     ) -> EventDict:
-        from langgraph_api import __version__
+        try:
+            from langgraph_api import __version__
 
-        event_dict["langgraph_api_version"] = __version__
+            event_dict["langgraph_api_version"] = __version__
+        except ImportError:
+            pass
         return event_dict
 
 

{langgraph_api-0.4.1 → langgraph_api-0.4.7}/langgraph_api/models/run.py

@@ -106,6 +106,8 @@ class RunCreateDict(TypedDict):
     """Create the thread if it doesn't exist. If False, reply with 404."""
     langsmith_tracer: LangSmithTracer | None
     """Configuration for additional tracing with LangSmith."""
+    durability: str | None
+    """Durability level for the run. Must be one of 'sync', 'async', or 'exit'."""
 
 
 def ensure_ids(
@@ -322,6 +324,11 @@ async def create_valid_run(
     put_time_start = time.time()
     if_not_exists = payload.get("if_not_exists", "reject")
 
+    durability = payload.get("durability")
+    if durability is None:
+        checkpoint_during = payload.get("checkpoint_during")
+        durability = "async" if checkpoint_during in (None, True) else "exit"
+
     run_coro = Runs.put(
         conn,
         assistant_id,
@@ -339,6 +346,7 @@ async def create_valid_run(
             "subgraphs": payload.get("stream_subgraphs", False),
             "resumable": stream_resumable,
             "checkpoint_during": payload.get("checkpoint_during", True),
+            "durability": durability,
         },
         metadata=payload.get("metadata"),
         status="pending",

{langgraph_api-0.4.1 → langgraph_api-0.4.7}/langgraph_api/schema.py

@@ -19,6 +19,8 @@ StreamMode = Literal[
     "values", "messages", "updates", "events", "debug", "tasks", "checkpoints", "custom"
 ]
 
+ThreadStreamMode = Literal["lifecycle", "run_modes", "state_update"]
+
 MultitaskStrategy = Literal["reject", "rollback", "interrupt", "enqueue"]
 
 OnConflictBehavior = Literal["raise", "do_nothing"]

{langgraph_api-0.4.1 → langgraph_api-0.4.7}/langgraph_api/stream.py

@@ -30,7 +30,7 @@ from langgraph_api import __version__
 from langgraph_api import store as api_store
 from langgraph_api.asyncio import ValueEvent, wait_if_not_done
 from langgraph_api.command import map_cmd
-from langgraph_api.feature_flags import USE_RUNTIME_CONTEXT_API
+from langgraph_api.feature_flags import USE_DURABILITY, USE_RUNTIME_CONTEXT_API
 from langgraph_api.graph import get_graph
 from langgraph_api.js.base import BaseRemotePregel
 from langgraph_api.metadata import HOST, PLAN, USER_API_URL, incr_nodes
@@ -134,6 +134,14 @@ async def astream_state(
     kwargs = run["kwargs"].copy()
     kwargs.pop("webhook", None)
     kwargs.pop("resumable", False)
+    if USE_DURABILITY:
+        checkpoint_during = kwargs.pop("checkpoint_during")
+        if not kwargs.get("durability") and checkpoint_during:
+            kwargs["durability"] = "async" if checkpoint_during else "exit"
+    else:
+        durability = kwargs.pop("durability")
+        if not kwargs.get("checkpoint_during") and durability in ("async", "exit"):
+            kwargs["checkpoint_during"] = durability == "async"
     subgraphs = kwargs.get("subgraphs", False)
     temporary = kwargs.pop("temporary", False)
     context = kwargs.pop("context", None)

{langgraph_api-0.4.1 → langgraph_api-0.4.7}/langgraph_api/utils/headers.py

@@ -59,6 +59,14 @@ def should_include_header(key: str) -> bool:
     Returns:
         True if the header should be included, False otherwise
     """
+    if (
+        key == "x-api-key"
+        or key == "x-service-key"
+        or key == "x-tenant-id"
+        or key == "authorization"
+    ):
+        return False
+
     include_patterns, exclude_patterns = get_header_patterns("configurable_headers")
 
     return pattern_matches(key, include_patterns, exclude_patterns)

{langgraph_api-0.4.1 → langgraph_api-0.4.7}/openapi.json

@@ -1550,6 +1550,29 @@
             },
             "name": "Last-Event-ID",
             "in": "header"
+          },
+          {
+            "required": false,
+            "schema": {
+              "anyOf": [
+                {
+                  "type": "string",
+                  "enum": ["lifecycle", "run_modes", "state_update"]
+                },
+                {
+                  "type": "array",
+                  "items": {
+                    "type": "string",
+                    "enum": ["lifecycle", "run_modes", "state_update"]
+                  }
+                }
+              ],
+              "default": ["run_modes"],
+              "title": "Stream Modes",
+              "description": "Stream modes to control which events are returned. 'lifecycle' returns only run start/end events, 'run_modes' returns all run events (default behavior), 'state_update' returns only state update events."
+            },
+            "name": "stream_modes",
+            "in": "query"
           }
         ],
         "responses": {
@@ -4413,6 +4436,17 @@
             "title": "Checkpoint During",
             "description": "Whether to checkpoint during the run.",
             "default": false
+          },
+          "durability": {
+            "type": "string",
+            "enum": [
+              "sync",
+              "async",
+              "exit"
+            ],
+            "title": "Durability",
+            "description": "Durability level for the run. Must be one of 'sync', 'async', or 'exit'.",
+            "default": "async"
           }
         },
         "type": "object",
@@ -4649,6 +4683,17 @@
             "title": "Checkpoint During",
             "description": "Whether to checkpoint during the run.",
             "default": false
+          },
+          "durability": {
+            "type": "string",
+            "enum": [
+              "sync",
+              "async",
+              "exit"
+            ],
+            "title": "Durability",
+            "description": "Durability level for the run. Must be one of 'sync', 'async', or 'exit'.",
+            "default": "async"
           }
         },
         "type": "object",

langgraph_api-0.4.1/langgraph_api/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.4.1"