langgraph-api 0.2.30__tar.gz → 0.2.34__tar.gz

{langgraph_api-0.2.30 → langgraph_api-0.2.34}/Makefile

@@ -67,6 +67,7 @@ start:
 		--reload \
 		--port 9123 \
 		--reload-dir langgraph_api \
+		--reload-dir ../runtime_inmem \
 		--no-access-log
 
 
@@ -89,6 +90,7 @@ start-auth-jwt:
 		--reload \
 		--port 9123 \
 		--reload-dir langgraph_api \
+		--reload-dir ../runtime_inmem \
 		--no-access-log
 
 start-auth-fastapi-jwt:
@@ -106,6 +108,7 @@ start-auth-fastapi-jwt:
 		--reload \
 		--port 9123 \
 		--reload-dir langgraph_api \
+		--reload-dir ../runtime_inmem \
 		--no-access-log
 
 VERSION_KIND ?= patch

{langgraph_api-0.2.30 → langgraph_api-0.2.34}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langgraph-api
-Version: 0.2.30
+Version: 0.2.34
 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.2.38
 Requires-Dist: langgraph-checkpoint>=2.0.23
-Requires-Dist: langgraph-runtime-inmem<0.2,>=0.1.0
+Requires-Dist: langgraph-runtime-inmem<0.3,>=0.2.0
 Requires-Dist: langgraph-sdk>=0.1.66
 Requires-Dist: langgraph>=0.3.27
 Requires-Dist: langsmith>=0.1.112

langgraph_api-0.2.34/langgraph_api/__init__.py

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

{langgraph_api-0.2.30 → langgraph_api-0.2.34}/langgraph_api/api/runs.py

@@ -39,7 +39,10 @@ async def create_run(request: ApiRequest):
             payload,
             request.headers,
         )
-    return ApiResponse(run)
+    return ApiResponse(
+        run,
+        headers={"Content-Location": f"/threads/{thread_id}/runs/{run['run_id']}"},
+    )
 
 
 @retry_db
@@ -53,7 +56,10 @@ async def create_stateless_run(request: ApiRequest):
             payload,
             request.headers,
         )
-    return ApiResponse(run)
+    return ApiResponse(
+        run,
+        headers={"Content-Location": f"/runs/{run['run_id']}"},
+    )
 
 
 async def create_stateless_run_batch(request: ApiRequest):
@@ -107,8 +113,12 @@ async def stream_run(
             thread_id=thread_id,
             cancel_on_disconnect=on_disconnect == "cancel",
             stream_mode=await sub,
+            last_event_id=None,
         ),
-        headers={"Location": f"/threads/{thread_id}/runs/{run['run_id']}/stream"},
+        headers={
+            "Location": f"/threads/{thread_id}/runs/{run['run_id']}/stream",
+            "Content-Location": f"/threads/{thread_id}/runs/{run['run_id']}",
+        },
     )
 
 
@@ -143,9 +153,11 @@ async def stream_run_stateless(
             ignore_404=True,
             cancel_on_disconnect=on_disconnect == "cancel",
             stream_mode=await sub,
+            last_event_id=None,
         ),
         headers={
-            "Location": f"/threads/{run['thread_id']}/runs/{run['run_id']}/stream"
+            "Location": f"/runs/{run['run_id']}/stream",
+            "Content-Location": f"/runs/{run['run_id']}",
         },
     )
 
@@ -182,7 +194,7 @@ async def wait_run(request: ApiRequest):
                 run["run_id"], thread_id=run["thread_id"], stream_mode=await sub
             )
         ) as stream:
-            async for mode, chunk in stream:
+            async for mode, chunk, _ in stream:
                 if mode == b"values":
                     vchunk = chunk
                 elif mode == b"error":
@@ -216,7 +228,10 @@ async def wait_run(request: ApiRequest):
     return StreamingResponse(
         body(),
         media_type="application/json",
-        headers={"Location": f"/threads/{thread_id}/runs/{run['run_id']}/join"},
+        headers={
+            "Location": f"/threads/{thread_id}/runs/{run['run_id']}/join",
+            "Content-Location": f"/threads/{thread_id}/runs/{run['run_id']}",
+        },
     )
 
 
@@ -251,7 +266,7 @@ async def wait_run_stateless(request: ApiRequest):
                 run["run_id"], thread_id=run["thread_id"], stream_mode=await sub
             )
         ) as stream:
-            async for mode, chunk in stream:
+            async for mode, chunk, _ in stream:
                 if mode == b"values":
                     vchunk = chunk
                 elif mode == b"error":
@@ -280,7 +295,10 @@ async def wait_run_stateless(request: ApiRequest):
     return StreamingResponse(
         body(),
         media_type="application/json",
-        headers={"Location": f"/threads/{run['thread_id']}/runs/{run['run_id']}/join"},
+        headers={
+            "Location": f"/threads/{run['thread_id']}/runs/{run['run_id']}/join",
+            "Content-Location": f"/threads/{run['thread_id']}/runs/{run['run_id']}",
+        },
     )
 
 
@@ -358,13 +376,15 @@ async def join_run_stream(request: ApiRequest):
     validate_uuid(thread_id, "Invalid thread ID: must be a UUID")
     validate_uuid(run_id, "Invalid run ID: must be a UUID")
     stream_mode = request.query_params.get("stream_mode") or None
+    last_event_id = request.headers.get("last-event-id") or None
     return EventSourceResponse(
         Runs.Stream.join(
             run_id,
             thread_id=thread_id,
             cancel_on_disconnect=cancel_on_disconnect,
             stream_mode=stream_mode,
-        )
+            last_event_id=last_event_id,
+        ),
     )
 
 

{langgraph_api-0.2.30 → langgraph_api-0.2.34}/langgraph_api/js/build.mts

@@ -7,7 +7,10 @@ import * as path from "node:path";
 import { type GraphSchema, resolveGraph } from "./src/graph.mts";
 import { build } from "@langchain/langgraph-ui";
 import { checkLangGraphSemver } from "@langchain/langgraph-api/semver";
-import { getStaticGraphSchema } from "@langchain/langgraph-api/schema";
+import {
+  getStaticGraphSchema,
+  GraphSpec,
+} from "@langchain/langgraph-api/schema";
 import { filterValidExportPath } from "./src/utils/files.mts";
 
 const __dirname = new URL(".", import.meta.url).pathname;
@@ -17,7 +20,7 @@ async function main() {
     z.record(z.string()).parse(JSON.parse(process.env.LANGSERVE_GRAPHS)),
   ).filter(([_, spec]) => filterValidExportPath(spec));
 
-  const GRAPH_SCHEMAS: Record<string, Record<string, GraphSchema> | false> = {};
+  let GRAPH_SCHEMAS: Record<string, Record<string, GraphSchema> | false> = {};
 
   const semver = await checkLangGraphSemver();
   const invalidPackages = semver.filter(
@@ -42,28 +45,42 @@ async function main() {
 
   let failed = false;
   try {
-    await Promise.all(
-      specs.map(async ([graphId, rawSpec]) => {
-        console.info(`[${graphId}]: Checking for source file existence`);
-        const { resolved, ...spec } = await resolveGraph(rawSpec, {
-          onlyFilePresence: true,
-        });
-
-        try {
-          console.info(`[${graphId}]: Extracting schema`);
-          GRAPH_SCHEMAS[graphId] = await getStaticGraphSchema(spec, {
-            timeoutMs: 120_000,
+    const resolveSpecs = Object.fromEntries<GraphSpec>(
+      await Promise.all(
+        specs.map(async ([graphId, rawSpec]) => {
+          console.info(`[${graphId}]: Checking for source file existence`);
+          const { resolved, ...spec } = await resolveGraph(rawSpec, {
+            onlyFilePresence: true,
           });
-        } catch (error) {
-          console.error(`[${graphId}]: Error extracting schema: ${error}`);
-          GRAPH_SCHEMAS[graphId] = false;
-        }
-      }),
+
+          return [graphId, spec] as [string, GraphSpec];
+        }),
+      ),
     );
 
+    try {
+      console.info("Extracting schemas");
+      GRAPH_SCHEMAS = await getStaticGraphSchema(resolveSpecs, {
+        timeoutMs: 120_000,
+      });
+    } catch (error) {
+      console.error(`Error extracting schema: ${error}`);
+    }
+
     await fs.writeFile(
       path.resolve(__dirname, "client.schemas.json"),
-      JSON.stringify(GRAPH_SCHEMAS),
+      JSON.stringify(
+        Object.fromEntries(
+          specs.map(([graphId]) => {
+            const valid = GRAPH_SCHEMAS[graphId];
+            if (valid == null || Object.values(valid).every((x) => x == null)) {
+              return [graphId, false];
+            }
+
+            return [graphId, valid];
+          }),
+        ),
+      ),
       { encoding: "utf-8" },
     );
   } catch (error) {

{langgraph_api-0.2.30 → langgraph_api-0.2.34}/langgraph_api/js/package.json

@@ -24,8 +24,8 @@
     "undici": "^6.21.1",
     "uuid": "^10.0.0",
     "winston": "^3.17.0",
-    "@langchain/langgraph-api": "~0.0.32",
-    "@langchain/langgraph-ui": "~0.0.32",
+    "@langchain/langgraph-api": "~0.0.37",
+    "@langchain/langgraph-ui": "~0.0.37",
     "zod": "^3.23.8"
   },
   "resolutions": {
@@ -33,7 +33,7 @@
   },
   "devDependencies": {
     "jose": "^6.0.10",
-    "@langchain/langgraph-sdk": "^0.0.73",
+    "@langchain/langgraph-sdk": "^0.0.77",
     "@types/react": "^19.0.8",
     "@types/react-dom": "^19.0.3",
     "@types/node": "^22.2.0",

{langgraph_api-0.2.30 → langgraph_api-0.2.34}/langgraph_api/js/yarn.lock

@@ -203,15 +203,15 @@
     zod "^3.22.4"
     zod-to-json-schema "^3.22.3"
 
-"@langchain/langgraph-api@~0.0.32":
-  version "0.0.32"
-  resolved "https://registry.yarnpkg.com/@langchain/langgraph-api/-/langgraph-api-0.0.32.tgz#65f41373318055b330fa64e7d4ccd7c994f7dc8d"
-  integrity sha512-wYflud8iCGjwh3/GtzrTeWlwcc91kXBa49Goc2iaHcJRjMnTbl+loE3eklegDPnQGx1VKUCiB9qW/HutxuqXGA==
+"@langchain/langgraph-api@~0.0.37":
+  version "0.0.37"
+  resolved "https://registry.yarnpkg.com/@langchain/langgraph-api/-/langgraph-api-0.0.37.tgz#52b3a62ac56dc56e239b76953ccc5b42a5aa1396"
+  integrity sha512-0mMmjA0KSYx/oKm6a+KSjWj7hneWsGlTDuwIaEnpauFLo5FCx3bZ8yQSPNFprvgHgJkxYWLjnVuXS+y/V1kLqg==
   dependencies:
     "@babel/code-frame" "^7.26.2"
     "@hono/node-server" "^1.12.0"
     "@hono/zod-validator" "^0.2.2"
-    "@langchain/langgraph-ui" "0.0.32"
+    "@langchain/langgraph-ui" "0.0.37"
     "@types/json-schema" "^7.0.15"
     "@typescript/vfs" "^1.6.0"
     dedent "^1.5.3"
@@ -236,10 +236,10 @@
   dependencies:
     uuid "^10.0.0"
 
-"@langchain/langgraph-sdk@^0.0.73":
-  version "0.0.73"
-  resolved "https://registry.yarnpkg.com/@langchain/langgraph-sdk/-/langgraph-sdk-0.0.73.tgz#6f5cb44fb306461182df55be4cf1d263c5ce3e16"
-  integrity sha512-V3E7Bd1KNcTpnEglZqKpnQtth62WHf+Dxq5V+0CqMxbzPHnW9I4eynCO4c1/HSY/rHgEtvgj7fMvCAb6I5R+lQ==
+"@langchain/langgraph-sdk@^0.0.77":
+  version "0.0.77"
+  resolved "https://registry.yarnpkg.com/@langchain/langgraph-sdk/-/langgraph-sdk-0.0.77.tgz#adcd978843e61bbf09b9625d519dda16d27cec09"
+  integrity sha512-DMCONENhhaMS+Buw8s2UkKjAa9I6cT1aVJEDOmTO2lpon4Dqz/jiYUVJK7pTlNVSNvSx0E8aOmtT7NgGBcWflg==
   dependencies:
     "@types/json-schema" "^7.0.15"
     p-queue "^6.6.2"
@@ -256,10 +256,10 @@
     p-retry "4"
     uuid "^9.0.0"
 
-"@langchain/langgraph-ui@0.0.32", "@langchain/langgraph-ui@~0.0.32":
-  version "0.0.32"
-  resolved "https://registry.yarnpkg.com/@langchain/langgraph-ui/-/langgraph-ui-0.0.32.tgz#7e0cab750ba1e65f47d7b1d2adf955a36e50664e"
-  integrity sha512-65QZpouvw4P+hCpklYebNiwR88M84h7awjNB6FaKWHvCZa6NcSzlruFa/PnvU1o/kRK5NNpXNPyDUQLhT3tmTA==
+"@langchain/langgraph-ui@0.0.37", "@langchain/langgraph-ui@~0.0.37":
+  version "0.0.37"
+  resolved "https://registry.yarnpkg.com/@langchain/langgraph-ui/-/langgraph-ui-0.0.37.tgz#02bfdcc6ef1f518d3810afe298d6862d82100c58"
+  integrity sha512-eHsm+bjxXYzHsWa3WjlYiHd7a5PMaLgH1U0B5Ox+p43QnCE+mUCm82dWvvvXQ+FO/RktPk8kjbswwK/y/0Zk5A==
   dependencies:
     "@commander-js/extra-typings" "^13.0.0"
     commander "^13.0.0"

{langgraph_api-0.2.30 → langgraph_api-0.2.34}/langgraph_api/metadata.py

@@ -1,6 +1,5 @@
 import asyncio
 import os
-from collections import defaultdict
 from datetime import UTC, datetime
 
 import langgraph.version
@@ -37,8 +36,8 @@ PLAN = "enterprise" if plus_features_enabled() else "developer"
 USER_API_URL = os.getenv("LANGGRAPH_API_URL", None)
 
 LOGS: list[dict] = []
-RUN_COUNTER = defaultdict(int)
-NODE_COUNTER = defaultdict(int)
+RUN_COUNTER = 0
+NODE_COUNTER = 0
 FROM_TIMESTAMP = datetime.now(UTC).isoformat()
 
 if (
@@ -50,12 +49,14 @@ else:
     METADATA_ENDPOINT = "https://api.smith.langchain.com/v1/metadata/submit"
 
 
-def incr_runs(*, graph_id: str | None = None, incr: int = 1) -> None:
-    RUN_COUNTER[graph_id] += incr
+def incr_runs(*, incr: int = 1) -> None:
+    global RUN_COUNTER
+    RUN_COUNTER += incr
 
 
-def incr_nodes(*_, graph_id: str | None = None, incr: int = 1) -> None:
-    NODE_COUNTER[graph_id] += incr
+def incr_nodes(_, *, incr: int = 1) -> None:
+    global NODE_COUNTER
+    NODE_COUNTER += incr
 
 
 def append_log(log: dict) -> None:
@@ -88,23 +89,13 @@ async def metadata_loop() -> None:
         # we don't need a lock as long as there's no awaits in this block
         from_timestamp = FROM_TIMESTAMP
         to_timestamp = datetime.now(UTC).isoformat()
-        nodes = NODE_COUNTER.copy()
-        runs = RUN_COUNTER.copy()
+        nodes = NODE_COUNTER
+        runs = RUN_COUNTER
         logs = LOGS.copy()
         LOGS.clear()
-        RUN_COUNTER.clear()
-        NODE_COUNTER.clear()
+        RUN_COUNTER = 0
+        NODE_COUNTER = 0
         FROM_TIMESTAMP = to_timestamp
-        graph_measures = {
-            f"langgraph.platform.graph_runs.{graph_id}": runs.get(graph_id, 0)
-            for graph_id in runs
-        }
-        graph_measures.update(
-            {
-                f"langgraph.platform.graph_nodes.{graph_id}": nodes.get(graph_id, 0)
-                for graph_id in nodes
-            }
-        )
 
         payload = {
             "license_key": LANGGRAPH_CLOUD_LICENSE_KEY,
@@ -129,9 +120,8 @@ async def metadata_loop() -> None:
                 "user_app.uses_store_ttl": str(USES_STORE_TTL),
             },
             "measures": {
-                "langgraph.platform.runs": sum(runs.values()),
-                "langgraph.platform.nodes": sum(nodes.values()),
-                **graph_measures,
+                "langgraph.platform.runs": runs,
+                "langgraph.platform.nodes": nodes,
             },
             "logs": logs,
         }
@@ -144,10 +134,8 @@ async def metadata_loop() -> None:
             )
         except Exception as e:
             # retry on next iteration
-            for graph_id, incr in runs.items():
-                incr_runs(graph_id=graph_id, incr=incr)
-            for graph_id, incr in nodes.items():
-                incr_nodes(graph_id=graph_id, incr=incr)
+            incr_runs(incr=runs)
+            incr_nodes("", incr=nodes)
             FROM_TIMESTAMP = from_timestamp
             await logger.ainfo("Metadata submission skipped.", error=str(e))
         await asyncio.sleep(INTERVAL)

{langgraph_api-0.2.30 → langgraph_api-0.2.34}/langgraph_api/models/run.py

@@ -77,6 +77,8 @@ class RunCreateDict(TypedDict):
     """
     stream_subgraphs: bool | None
     """Stream output from subgraphs. By default, streams only the top graph."""
+    stream_resumable: bool | None
+    """Whether to persist the stream chunks in order to resume the stream later."""
     feedback_keys: list[str] | None
     """Pass one or more feedback_keys if you want to request short-lived signed URLs
     for submitting feedback to LangSmith with this key for this run."""
@@ -305,6 +307,7 @@ async def create_valid_run(
             "feedback_keys": payload.get("feedback_keys"),
             "temporary": temporary,
             "subgraphs": payload.get("stream_subgraphs", False),
+            "resumable": payload.get("stream_resumable", False),
             "checkpoint_during": payload.get("checkpoint_during", True),
         },
         metadata=payload.get("metadata"),

{langgraph_api-0.2.30 → langgraph_api-0.2.34}/langgraph_api/sse.py

@@ -18,7 +18,9 @@ logger = structlog.stdlib.get_logger(__name__)
 class EventSourceResponse(sse_starlette.EventSourceResponse):
     def __init__(
         self,
-        content: AsyncIterator[bytes | tuple[bytes, Any | bytes]],
+        content: AsyncIterator[
+            bytes | tuple[bytes, Any | bytes] | tuple[bytes, Any | bytes, bytes | None]
+        ],
         status_code: int = 200,
         headers: Mapping[str, str] | None = None,
     ) -> None:
@@ -101,11 +103,12 @@ async def sse_heartbeat(send: Send) -> None:
 SEP = b"\r\n"
 EVENT = b"event: "
 DATA = b"data: "
+ID = b"id: "
 BYTES_LIKE = (bytes, bytearray, memoryview)
 
 
-def json_to_sse(event: bytes, data: Any | bytes) -> bytes:
-    return b"".join(
+def json_to_sse(event: bytes, data: Any | bytes, id: bytes | None = None) -> bytes:
+    result = b"".join(
         (
             EVENT,
             event,
@@ -113,6 +116,11 @@ def json_to_sse(event: bytes, data: Any | bytes) -> bytes:
             DATA,
             data if isinstance(data, BYTES_LIKE) else json_dumpb(data),
             SEP,
-            SEP,
         )
     )
+
+    if id is not None:
+        result += b"".join((ID, id, SEP))
+
+    result += SEP
+    return result

{langgraph_api-0.2.30 → langgraph_api-0.2.34}/langgraph_api/stream.py

@@ -1,6 +1,6 @@
-import functools
 from collections.abc import AsyncIterator, Callable
 from contextlib import AsyncExitStack, aclosing
+from functools import lru_cache
 from typing import Any, cast
 
 import langgraph.version
@@ -87,6 +87,7 @@ async def astream_state(
     # extract args from run
     kwargs = run["kwargs"].copy()
     kwargs.pop("webhook", None)
+    kwargs.pop("resumable", False)
     subgraphs = kwargs.get("subgraphs", False)
     temporary = kwargs.pop("temporary", False)
     config = kwargs.pop("config")
@@ -119,9 +120,7 @@ async def astream_state(
     # attach node counter
     is_remote_pregel = isinstance(graph, BaseRemotePregel)
     if not is_remote_pregel:
-        config["configurable"]["__pregel_node_finished"] = functools.partial(
-            incr_nodes, graph_id=_get_graph_id(run)
-        )
+        config["configurable"]["__pregel_node_finished"] = incr_nodes
 
     # attach run_id to config
     # for attempts beyond the first, use a fresh, unique run_id
@@ -265,10 +264,10 @@ async def astream_state(
                         yield mode, chunk
                 # --- end shared logic with astream_events ---
     if is_remote_pregel:
-        # increment the remote runs
+        # increament the remote runs
         try:
             nodes_executed = await graph.fetch_nodes_executed()
-            incr_nodes(graph_id=graph.graph_id, incr=nodes_executed)
+            incr_nodes(None, incr=nodes_executed)
         except Exception as e:
             logger.warning(f"Failed to fetch nodes executed for {graph.graph_id}: {e}")
 
@@ -280,19 +279,25 @@ async def astream_state(
         yield "feedback", feedback_urls
 
 
-async def consume(stream: AnyStream, run_id: str) -> None:
+async def consume(stream: AnyStream, run_id: str, resumable: bool = False) -> None:
     async with aclosing(stream):
         try:
             async for mode, payload in stream:
                 await Runs.Stream.publish(
-                    run_id, mode, await run_in_executor(None, json_dumpb, payload)
+                    run_id,
+                    mode,
+                    await run_in_executor(None, json_dumpb, payload),
+                    resumable=resumable,
                 )
         except Exception as e:
             g = e
             if isinstance(e, ExceptionGroup):
                 e = e.exceptions[0]
             await Runs.Stream.publish(
-                run_id, "error", await run_in_executor(None, json_dumpb, e)
+                run_id,
+                "error",
+                await run_in_executor(None, json_dumpb, e),
+                resumable=resumable,
             )
             raise e from g
 
@@ -303,7 +308,7 @@ def get_feedback_urls(run_id: str, feedback_keys: list[str]) -> dict[str, str]:
     return {key: token.url for key, token in zip(feedback_keys, tokens, strict=False)}
 
 
-@functools.lru_cache(maxsize=1)
+@lru_cache(maxsize=1)
 def get_langsmith_client() -> langsmith.Client:
     return langsmith.Client()
 
@@ -317,11 +322,3 @@ EXPECTED_ERRORS = (
     ValidationError,
     ValidationErrorLegacy,
 )
-
-
-def _get_graph_id(run: Run) -> str | None:
-    try:
-        return run["kwargs"]["config"]["configurable"]["graph_id"]
-    except Exception:
-        logger.info(f"Failed to get graph_id from run {run['run_id']}")
-        return "Unknown"

{langgraph_api-0.2.30 → langgraph_api-0.2.34}/langgraph_api/worker.py

@@ -69,7 +69,7 @@ async def worker(
 ) -> WorkerResult:
     run_id = run["run_id"]
     if attempt == 1:
-        incr_runs(graph_id=_get_graph_id(run))
+        incr_runs()
     checkpoint: CheckpointPayload | None = None
     exception: Exception | None = None
     status: str | None = None
@@ -83,8 +83,8 @@ async def worker(
         Runs.enter(run_id, main_loop) as done,
     ):
         temporary = run["kwargs"].get("temporary", False)
+        resumable = run["kwargs"].get("resumable", False)
         run_created_at = run["created_at"].isoformat()
-        run["kwargs"]
         lg_logging.set_logging_context(
             {
                 "run_id": str(run_id),
@@ -145,7 +145,10 @@ async def worker(
                     on_checkpoint=on_checkpoint,
                     on_task_result=on_task_result,
                 )
-            await asyncio.wait_for(consume(stream, run_id), BG_JOB_TIMEOUT_SECS)
+            await asyncio.wait_for(
+                consume(stream, run_id, resumable),
+                BG_JOB_TIMEOUT_SECS,
+            )
             run_ended_at = datetime.now(UTC).isoformat()
             await logger.ainfo(
                 "Background run succeeded",

{langgraph_api-0.2.30 → langgraph_api-0.2.34}/openapi.json

@@ -886,73 +886,73 @@
         }
       }
     },
-  "/threads/{thread_id}/state/{checkpoint_id}": {
-    "get": {
-      "tags": ["Threads"],
-      "summary": "Get Thread State At Checkpoint",
-      "description": "Get state for a thread at a specific checkpoint.",
-      "operationId": "get_thread_state_at_checkpoint_threads__thread_id__state__checkpoint_id__get",
-      "parameters": [
-        {
-          "description": "The ID of the thread.",
-          "required": true,
-          "schema": {
-            "type": "string",
-            "format": "uuid",
-            "title": "Thread Id",
-            "description": "The ID of the thread."
-          },
-          "name": "thread_id",
-          "in": "path"
-        },
-        {
-          "description": "The ID of the checkpoint.",
-          "required": true,
-          "schema": {
-            "type": "string",
-            "format": "uuid",
-            "title": "Checkpoint Id",
-            "description": "The ID of the checkpoint."
+    "/threads/{thread_id}/state/{checkpoint_id}": {
+      "get": {
+        "tags": ["Threads"],
+        "summary": "Get Thread State At Checkpoint",
+        "description": "Get state for a thread at a specific checkpoint.",
+        "operationId": "get_thread_state_at_checkpoint_threads__thread_id__state__checkpoint_id__get",
+        "parameters": [
+          {
+            "description": "The ID of the thread.",
+            "required": true,
+            "schema": {
+              "type": "string",
+              "format": "uuid",
+              "title": "Thread Id",
+              "description": "The ID of the thread."
+            },
+            "name": "thread_id",
+            "in": "path"
           },
-          "name": "checkpoint_id",
-          "in": "path"
-        },
-        {
-          "description": "Whether to include subgraphs in the response.",
-          "required": false,
-          "schema": {
-            "type": "boolean",
-            "title": "Subgraphs",
-            "description": "Whether to include subgraphs in the response."
+          {
+            "description": "The ID of the checkpoint.",
+            "required": true,
+            "schema": {
+              "type": "string",
+              "format": "uuid",
+              "title": "Checkpoint Id",
+              "description": "The ID of the checkpoint."
+            },
+            "name": "checkpoint_id",
+            "in": "path"
           },
-          "name": "subgraphs",
-          "in": "query"
-        }
-      ],
-      "responses": {
-        "200": {
-          "description": "Success",
-          "content": {
-            "application/json": {
-              "schema": {
-                "$ref": "#/components/schemas/ThreadState"
+          {
+            "description": "Whether to include subgraphs in the response.",
+            "required": false,
+            "schema": {
+              "type": "boolean",
+              "title": "Subgraphs",
+              "description": "Whether to include subgraphs in the response."
+            },
+            "name": "subgraphs",
+            "in": "query"
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Success",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ThreadState"
+                }
               }
             }
-          }
-        },
-        "422": {
-          "description": "Validation Error",
-          "content": {
-            "application/json": {
-              "schema": {
-                "$ref": "#/components/schemas/ErrorResponse"
+          },
+          "422": {
+            "description": "Validation Error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ErrorResponse"
+                }
               }
             }
           }
         }
       }
-    }
-  },
+    },
     "/threads/{thread_id}/state/checkpoint": {
       "post": {
         "tags": ["Threads"],
@@ -1483,6 +1483,14 @@
                   "$ref": "#/components/schemas/Run"
                 }
               }
+            },
+            "headers": {
+              "Content-Location": {
+                "description": "The URL of the run that was created. Can be used to later join the stream.",
+                "schema": {
+                  "type": "string"
+                }
+              }
             }
           },
           "404": {
@@ -1622,6 +1630,14 @@
                   "description": "The server will send a stream of events in SSE format.\n\n**Example event**:\n\nid: 1\n\nevent: message\n\ndata: {}"
                 }
               }
+            },
+            "headers": {
+              "Content-Location": {
+                "description": "The URL of the run that was created. Can be used to later join the stream.",
+                "schema": {
+                  "type": "string"
+                }
+              }
             }
           },
           "404": {
@@ -1694,6 +1710,14 @@
               "application/json": {
                 "schema": {}
               }
+            },
+            "headers": {
+              "Content-Location": {
+                "description": "The URL of the run that was created. Can be used to later join the stream.",
+                "schema": {
+                  "type": "string"
+                }
+              }
             }
           },
           "404": {
@@ -1936,7 +1960,7 @@
       "get": {
         "tags": ["Thread Runs"],
         "summary": "Join Run Stream",
-        "description": "Join a run stream. This endpoint streams output in real-time from a run similar to the /threads/__THREAD_ID__/runs/stream endpoint. Only output produced after this endpoint is called will be streamed.",
+        "description": "Join a run stream. This endpoint streams output in real-time from a run similar to the /threads/__THREAD_ID__/runs/stream endpoint. If the run has been created with `stream_resumable=true`, the stream can be resumed from the last seen event ID.",
         "operationId": "stream_run_http_threads__thread_id__runs__run_id__join_get",
         "parameters": [
           {
@@ -1962,6 +1986,16 @@
             },
             "name": "run_id",
             "in": "path"
+          },
+          {
+            "required": false,
+            "schema": {
+              "type": "string",
+              "title": "Last Event ID",
+              "description": "The ID of the last event received. Set to -1 if you want to stream all events. Requires `stream_resumable=true` to be set when creating the run."
+            },
+            "name": "Last-Event-ID",
+            "in": "header"
           }
         ],
         "responses": {
@@ -2204,6 +2238,14 @@
                   "description": "The server will send a stream of events in SSE format.\n\n**Example event**:\n\nid: 1\n\nevent: message\n\ndata: {}"
                 }
               }
+            },
+            "headers": {
+              "Content-Location": {
+                "description": "The URL of the run that was created. Can be used to later join the stream.",
+                "schema": {
+                  "type": "string"
+                }
+              }
             }
           },
           "404": {
@@ -2319,6 +2361,14 @@
               "application/json": {
                 "schema": {}
               }
+            },
+            "headers": {
+              "Content-Location": {
+                "description": "The URL of the run that was created. Can be used to later join the stream.",
+                "schema": {
+                  "type": "string"
+                }
+              }
             }
           },
           "404": {
@@ -2377,6 +2427,14 @@
               "application/json": {
                 "schema": {}
               }
+            },
+            "headers": {
+              "Content-Location": {
+                "description": "The URL of the run that was created. Can be used to later join the stream.",
+                "schema": {
+                  "type": "string"
+                }
+              }
             }
           },
           "404": {
@@ -3569,6 +3627,12 @@
             "description": "Whether to stream output from subgraphs.",
             "default": false
           },
+          "stream_resumable": {
+            "type": "boolean",
+            "title": "Stream Resumable",
+            "description": "Whether to persist the stream chunks in order to resume the stream later.",
+            "default": false
+          },
           "on_disconnect": {
             "type": "string",
             "enum": ["cancel", "continue"],
@@ -3791,6 +3855,12 @@
             "description": "Whether to stream output from subgraphs.",
             "default": false
           },
+          "stream_resumable": {
+            "type": "boolean",
+            "title": "Stream Resumable",
+            "description": "Whether to persist the stream chunks in order to resume the stream later.",
+            "default": false
+          },
           "on_completion": {
             "type": "string",
             "enum": ["delete", "keep"],

{langgraph_api-0.2.30 → langgraph_api-0.2.34}/pyproject.toml

@@ -31,7 +31,7 @@ dependencies = [
     "cryptography>=42.0.0,<45.0",
     "langgraph-sdk>=0.1.66",
     "cloudpickle>=3.0.0",
-    "langgraph-runtime-inmem>=0.1.0,<0.2",
+    "langgraph-runtime-inmem>=0.2.0,<0.3",
     "truststore>=0.1",
 ]
 

langgraph_api-0.2.30/langgraph_api/__init__.py

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