langgraph-api 0.0.15__py3-none-any.whl → 0.0.16__py3-none-any.whl

langgraph_api/api/store.py

@@ -1,7 +1,12 @@
+from typing import Any
+
+from langgraph_sdk.auth import Auth
 from starlette.responses import Response
 from starlette.routing import BaseRoute
 
+from langgraph_api.auth.custom import handle_event as _handle_event
 from langgraph_api.route import ApiRequest, ApiResponse, ApiRoute
+from langgraph_api.utils import get_auth_ctx
 from langgraph_api.validation import (
     StoreDeleteRequest,
     StoreListNamespacesRequest,
@@ -21,6 +26,24 @@ def _validate_namespace(namespace: tuple[str, ...]) -> Response | None:
             )
 
 
+async def handle_event(
+    action: str,
+    value: Any,
+) -> None:
+    ctx = get_auth_ctx()
+    if not ctx:
+        return
+    await _handle_event(
+        Auth.types.AuthContext(
+            user=ctx.user,
+            permissions=ctx.permissions,
+            resource="store",
+            action=action,
+        ),
+        value,
+    )
+
+
 @retry_db
 async def put_item(request: ApiRequest):
     """Store or update an item."""
@@ -28,9 +51,13 @@ async def put_item(request: ApiRequest):
     namespace = tuple(payload["namespace"]) if payload.get("namespace") else ()
     if err := _validate_namespace(namespace):
         return err
-    key = payload["key"]
-    value = payload["value"]
-    await Store().aput(namespace, key, value)
+    handler_payload = {
+        "namespace": namespace,
+        "key": payload["key"],
+        "value": payload["value"],
+    }
+    await handle_event("put", handler_payload)
+    await Store().aput(namespace, handler_payload["key"], handler_payload["value"])
     return Response(status_code=204)
 
 
@@ -43,6 +70,11 @@ async def get_item(request: ApiRequest):
     key = request.query_params.get("key")
     if not key:
         return ApiResponse({"error": "Key is required"}, status_code=400)
+    handler_payload = {
+        "namespace": namespace,
+        "key": key,
+    }
+    await handle_event("get", handler_payload)
     result = await Store().aget(namespace, key)
     return ApiResponse(result.dict() if result is not None else None)
 
@@ -54,8 +86,12 @@ async def delete_item(request: ApiRequest):
     namespace = tuple(payload["namespace"]) if payload.get("namespace") else ()
     if err := _validate_namespace(namespace):
         return err
-    key = payload["key"]
-    await Store().adelete(namespace, key)
+    handler_payload = {
+        "namespace": namespace,
+        "key": payload["key"],
+    }
+    await handle_event("delete", handler_payload)
+    await Store().adelete(handler_payload["namespace"], handler_payload["key"])
     return Response(status_code=204)
 
 
@@ -70,12 +106,20 @@ async def search_items(request: ApiRequest):
     limit = payload.get("limit") or 10
     offset = payload.get("offset") or 0
     query = payload.get("query")
+    handler_payload = {
+        "namespace": namespace_prefix,
+        "filter": filter,
+        "limit": limit,
+        "offset": offset,
+        "query": query,
+    }
+    await handle_event("search", handler_payload)
     items = await Store().asearch(
-        namespace_prefix,
-        filter=filter,
-        limit=limit,
-        offset=offset,
-        query=query,
+        handler_payload["namespace"],
+        filter=handler_payload["filter"],
+        limit=handler_payload["limit"],
+        offset=handler_payload["offset"],
+        query=handler_payload["query"],
     )
     return ApiResponse({"items": [item.dict() for item in items]})
 
@@ -93,12 +137,20 @@ async def list_namespaces(request: ApiRequest):
     max_depth = payload.get("max_depth")
     limit = payload.get("limit", 100)
     offset = payload.get("offset", 0)
+    handler_payload = {
+        "namespace": prefix,
+        "suffix": suffix,
+        "max_depth": max_depth,
+        "limit": limit,
+        "offset": offset,
+    }
+    await handle_event("list_namespaces", handler_payload)
     result = await Store().alist_namespaces(
-        prefix=prefix,
-        suffix=suffix,
-        max_depth=max_depth,
-        limit=limit,
-        offset=offset,
+        prefix=handler_payload["namespace"],
+        suffix=handler_payload["suffix"],
+        max_depth=handler_payload["max_depth"],
+        limit=handler_payload["limit"],
+        offset=handler_payload["offset"],
     )
     return ApiResponse({"namespaces": result})
 

langgraph_api/asyncio.py

@@ -60,6 +60,11 @@ async def wait_if_not_done(coro: Coroutine[Any, Any, T], done: ValueEvent) -> T:
             try:
                 return await coro_task
             except asyncio.CancelledError as e:
+                if e.args and asyncio.isfuture(e.args[-1]):
+                    await logger.ainfo(
+                        "Awaiting future upon cancellation", task=str(e.args[-1])
+                    )
+                    await e.args[-1]
                 if e.args and isinstance(e.args[0], Exception):
                     raise e.args[0] from None
                 raise

langgraph_api/auth/custom.py

@@ -398,6 +398,16 @@ class DotDict:
             raise AttributeError(f"'DotDict' object has no attribute '{name}'")
         return self._dict[name]
 
+    def __getitem__(self, key):
+        return self._dict[key]
+
+    def __setitem__(self, key, value):
+        self._dict[key] = value
+        if isinstance(value, dict):
+            setattr(self, key, DotDict(value))
+        else:
+            setattr(self, key, value)
+
     def __deepcopy__(self, memo):
         return DotDict(copy.deepcopy(self._dict))
 
@@ -457,6 +467,12 @@ class ProxyUser(BaseUser):
             **d,
         }
 
+    def __getitem__(self, key):
+        return self._user[key]
+
+    def __setitem__(self, key, value):
+        self._user[key] = value
+
     def __getattr__(self, name: str) -> Any:
         """Proxy any other attributes to the underlying user object."""
         return getattr(self._user, name)
@@ -481,10 +497,10 @@ def _normalize_auth_response(
         user = response
         permissions = []
 
-    return AuthCredentials(permissions), _normalize_user(user)
+    return AuthCredentials(permissions), normalize_user(user)
 
 
-def _normalize_user(user: Any) -> BaseUser:
+def normalize_user(user: Any) -> BaseUser:
     """Normalize user into a BaseUser instance."""
     if isinstance(user, BaseUser):
         return user
@@ -571,9 +587,8 @@ def _get_handler(auth: Auth, ctx: Auth.types.AuthContext) -> Auth.types.Handler
     ]
     for key in keys:
         if key in auth._handlers:
-            result = auth._handlers[key][
-                -1
-            ]  # Get the last defined, most specific handler
+            # Get the last defined, most specific handler
+            result = auth._handlers[key][-1]
             auth._handler_cache[key] = result
             return result
     if auth._global_handlers:

langgraph_api/js/package.json

@@ -10,7 +10,7 @@
     "@hono/node-server": "^1.12.0",
     "@hono/zod-validator": "^0.2.2",
     "@langchain/core": "^0.3.22",
-    "@langchain/langgraph": "^0.2.31",
+    "@langchain/langgraph": "^0.2.35",
     "@types/json-schema": "^7.0.15",
     "@typescript/vfs": "^1.6.0",
     "dedent": "^1.5.3",

langgraph_api/js/remote_new.py

@@ -23,6 +23,7 @@ from langgraph.pregel.types import PregelTask, StateSnapshot
 from langgraph.store.base import GetOp, Item, ListNamespacesOp, PutOp, SearchOp
 from langgraph.types import Command, Interrupt
 from pydantic import BaseModel
+from starlette.exceptions import HTTPException
 from zmq.utils.monitor import recv_monitor_message
 
 from langgraph_api.js.base import BaseRemotePregel
@@ -681,5 +682,12 @@ async def js_healthcheck():
     try:
         await _client_invoke("ok", {})
         return True
-    except (RemoteException, TimeoutError, zmq.error.ZMQBaseError):
-        return False
+    except (RemoteException, TimeoutError, zmq.error.ZMQBaseError) as exc:
+        logger.warning(
+            "JS healthcheck failed. Either the JS server is not running or the event loop is blocked by a CPU-intensive task.",
+            error=exc,
+        )
+        raise HTTPException(
+            status_code=500,
+            detail="JS healthcheck failed. Either the JS server is not running or the event loop is blocked by a CPU-intensive task.",
+        ) from exc

langgraph_api/js/remote_old.py

@@ -22,6 +22,7 @@ from langgraph.store.base import GetOp, Item, ListNamespacesOp, PutOp, SearchOp
 from langgraph.types import Command, Interrupt
 from pydantic import BaseModel
 from starlette.applications import Starlette
+from starlette.exceptions import HTTPException
 from starlette.requests import Request
 from starlette.routing import Route
 
@@ -653,5 +654,12 @@ async def js_healthcheck():
             res = await checkpointer_client.get("/ok")
             res.raise_for_status()
             return True
-        except httpx.HTTPError:
-            return False
+        except httpx.HTTPError as exc:
+            logger.warning(
+                "JS healthcheck failed. Either the JS server is not running or the event loop is blocked by a CPU-intensive task.",
+                error=exc,
+            )
+            raise HTTPException(
+                status_code=500,
+                detail="JS healthcheck failed. Either the JS server is not running or the event loop is blocked by a CPU-intensive task.",
+            ) from exc

langgraph_api/js/tests/api.test.mts

@@ -753,13 +753,13 @@ describe("runs", () => {
       messages = findLast(chunks, (i) => i.event === "values")?.data.messages;
 
       const threadAfterInterrupt = await client.threads.get(thread.thread_id);
-      expect(threadAfterInterrupt.status).toBe("idle");
+      expect(threadAfterInterrupt.status).toBe("interrupted");
 
       expect(messages.at(-1)).not.toBeNull();
-      expect(messages.at(-1)?.content).toBe("end");
+      expect(messages.at(-1)?.content).toBe("begin");
 
       const state = await client.threads.getState(thread.thread_id);
-      expect(state.next).toEqual([]);
+      expect(state.next).toEqual(["tool"]);
 
       // continue after interrupt
       chunks = await gatherIterator(
@@ -817,6 +817,7 @@ describe("runs", () => {
     });
 
     const modifiedThread = await client.threads.get(thread.thread_id);
+    expect(modifiedThread.status).toBe("interrupted");
     expect(modifiedThread.metadata?.modified).toBe(true);
 
     const stateAfterModify = await client.threads.getState<AgentState>(
@@ -836,22 +837,42 @@ describe("runs", () => {
       })
     );
 
+    const threadAfterContinue = await client.threads.get(thread.thread_id);
+    expect(threadAfterContinue.status).toBe("idle");
+
     expect(chunks.filter((i) => i.event === "error").length).toBe(0);
     messages = findLast(chunks, (i) => i.event === "values")?.data.messages;
 
-    expect(messages.length).toBe(8);
-    expect(messages[4].content).toBe(`tool_call__modified`);
+    expect(messages.length).toBe(4);
+    expect(messages[2].content).toBe(`tool_call__modified`);
     expect(messages.at(-1)?.content).toBe("end");
 
     // get the history
     const history = await client.threads.getHistory<AgentState>(
       thread.thread_id
     );
-    expect(history.length).toBe(10);
+    expect(history.length).toBe(6);
     expect(history[0].next.length).toBe(0);
-    expect(history[0].values.messages.length).toBe(8);
+    expect(history[0].values.messages.length).toBe(4);
     expect(history.at(-1)?.next).toEqual(["__start__"]);
   });
+
+  it.concurrent("interrupt before", async () => {
+    const assistant = await client.assistants.create({ graphId: "agent" });
+    let thread = await client.threads.create();
+    const input = {
+      messages: [{ type: "human", content: "foo", id: "initial-message" }],
+    };
+
+    await client.runs.wait(thread.thread_id, assistant.assistant_id, {
+      input,
+      interruptBefore: ["agent"],
+      config: globalConfig,
+    });
+
+    thread = await client.threads.get(thread.thread_id);
+    expect(thread.status).toBe("interrupted");
+  });
 });
 
 describe("shared state", () => {
@@ -1684,3 +1705,65 @@ describe("long running tasks", () => {
     }
   );
 });
+
+// Not implemented in JS yet
+describe.skip("command update state", () => {
+  it("updates state via commands", async () => {
+    const assistant = await client.assistants.create({ graphId: "agent" });
+    const thread = await client.threads.create();
+
+    const input = { messages: [{ role: "human", content: "foo" }] };
+
+    // dict-based updates
+    await client.runs.wait(thread.thread_id, assistant.assistant_id, {
+      input,
+      config: globalConfig,
+    });
+    let stream = await gatherIterator(
+      client.runs.stream(thread.thread_id, assistant.assistant_id, {
+        command: { update: { keyOne: "value3", keyTwo: "value4" } },
+        config: globalConfig,
+      })
+    );
+    expect(stream.filter((chunk) => chunk.event === "error")).toEqual([]);
+
+    let state = await client.threads.getState<{
+      keyOne: string;
+      keyTwo: string;
+    }>(thread.thread_id);
+
+    expect(state.values).toMatchObject({
+      keyOne: "value3",
+      keyTwo: "value4",
+    });
+
+    // list-based updates
+    await client.runs.wait(thread.thread_id, assistant.assistant_id, {
+      input,
+      config: globalConfig,
+    });
+    stream = await gatherIterator(
+      client.runs.stream(thread.thread_id, assistant.assistant_id, {
+        command: {
+          update: [
+            ["keyOne", "value1"],
+            ["keyTwo", "value2"],
+          ],
+        },
+        config: globalConfig,
+      })
+    );
+
+    expect(stream.filter((chunk) => chunk.event === "error")).toEqual([]);
+
+    state = await client.threads.getState<{
+      keyOne: string;
+      keyTwo: string;
+    }>(thread.thread_id);
+
+    expect(state.values).toMatchObject({
+      keyOne: "value1",
+      keyTwo: "value2",
+    });
+  });
+});

langgraph_api/js/tests/graphs/agent.mts

@@ -18,6 +18,8 @@ const GraphAnnotationOutput = Annotation.Root({
   }),
   sharedStateValue: Annotation<string | null>(),
   interrupt: Annotation<boolean>(),
+  keyOne: Annotation<string | null>(),
+  keyTwo: Annotation<string | null>(),
 });
 
 const GraphAnnotationInput = Annotation.Root({

langgraph_api/js/tests/graphs/delay.mts

@@ -14,6 +14,11 @@ const StateSchema = Annotation.Root({
 const longRunning = async (
   state: typeof StateSchema.State
 ): Promise<typeof StateSchema.Update> => {
+  if (state.delay === -1) {
+    while (true) {
+      // hang the event loop
+    }
+  }
   await new Promise((resolve) => setTimeout(resolve, state.delay));
   return { messages: [`finished after ${state.delay}ms`] };
 };

langgraph_api/js/yarn.lock

@@ -389,10 +389,10 @@
     p-retry "4"
     uuid "^9.0.0"
 
-"@langchain/langgraph@^0.2.31":
-  version "0.2.31"
-  resolved "https://registry.yarnpkg.com/@langchain/langgraph/-/langgraph-0.2.31.tgz#2cb2faac1d02a7ccf47559aec87aae7f44dc7d3f"
-  integrity sha512-/otJC3/P3Pt58eVZz1gxC3sBiC0N0HhOaAbOBKxckskhayBO6OC6ZDHtH9a+rxEIlreBoninR1/At1Gj/3liFA==
+"@langchain/langgraph@^0.2.35":
+  version "0.2.35"
+  resolved "https://registry.yarnpkg.com/@langchain/langgraph/-/langgraph-0.2.35.tgz#e2dc4d07b3080570ef63b1a5a98a4e2b1e1cc630"
+  integrity sha512-h209sOZGgbKpdkc+5WgjiBH0Fe8zLmPv+ff/RnXGEr+phrXwUNQnx5iu4HexVd7P6gxM9Ymt1iZBCBXpgRbK8A==
   dependencies:
     "@langchain/langgraph-checkpoint" "~0.0.13"
     "@langchain/langgraph-sdk" "~0.0.21"

langgraph_api/models/run.py

@@ -191,6 +191,7 @@ async def create_valid_run(
         user_id = get_user_id(user)
         config["configurable"]["langgraph_auth_user"] = user
         config["configurable"]["langgraph_auth_user_id"] = user_id
+        config["configurable"]["langgraph_auth_permissions"] = ctx.permissions
     else:
         user_id = None
     run_coro = Runs.put(

langgraph_api/queue.py

@@ -1,5 +1,6 @@
 import asyncio
-from contextlib import AsyncExitStack
+from collections.abc import AsyncGenerator
+from contextlib import AsyncExitStack, asynccontextmanager
 from datetime import UTC, datetime
 from random import random
 from typing import TypedDict, cast
@@ -7,6 +8,7 @@ from typing import TypedDict, cast
 import structlog
 from langgraph.pregel.debug import CheckpointPayload, TaskResultPayload
 
+from langgraph_api.auth.custom import normalize_user
 from langgraph_api.config import BG_JOB_NO_DELAY, STATS_INTERVAL_SECS
 from langgraph_api.errors import (
     UserInterrupt,
@@ -20,11 +22,16 @@ from langgraph_api.stream import (
     astream_state,
     consume,
 )
-from langgraph_api.utils import AsyncConnectionProto
+from langgraph_api.utils import AsyncConnectionProto, set_auth_ctx, with_user
 from langgraph_storage.database import connect
 from langgraph_storage.ops import Runs, Threads
 from langgraph_storage.retry import RETRIABLE_EXCEPTIONS
 
+try:
+    from psycopg.errors import InFailedSqlTransaction
+except ImportError:
+    InFailedSqlTransaction = ()
+
 logger = structlog.stdlib.get_logger(__name__)
 
 WORKERS: set[asyncio.Task] = set()
@@ -149,6 +156,24 @@ class WorkerResult(TypedDict):
     run_ended_at: str | None
 
 
+@asynccontextmanager
+async def set_auth_ctx_for_run(run: Run) -> AsyncGenerator[None, None]:
+    try:
+        user = run["kwargs"]["config"]["configurable"]["langgraph_auth_user"]
+        permissions = run["kwargs"]["config"]["configurable"][
+            "langgraph_auth_permissions"
+        ]
+        if user is not None:
+            user = normalize_user(user)
+            async with with_user(user, permissions):
+                yield None
+        else:
+            yield None
+
+    except KeyError:
+        pass
+
+
 async def worker(
     timeout: float,
     exit: AsyncExitStack,
@@ -165,7 +190,8 @@ async def worker(
     webhook = run["kwargs"].pop("webhook", None)
     run_started_at = datetime.now(UTC)
     run_ended_at: str | None = None
-    async with Runs.enter(run_id) as done, exit:
+
+    async with set_auth_ctx_for_run(run), Runs.enter(run_id) as done, exit:
         temporary = run["kwargs"].get("temporary", False)
         run_created_at = run["created_at"].isoformat()
         await logger.ainfo(
@@ -245,7 +271,20 @@ async def worker(
                 run_ended_at=run_ended_at,
                 run_exec_ms=ms(datetime.now(UTC), run_started_at),
             )
-            await Runs.delete(conn, run_id, thread_id=run["thread_id"])
+            try:
+                await Runs.delete(conn, run_id, thread_id=run["thread_id"])
+            except InFailedSqlTransaction as e:
+                await logger.ainfo(
+                    "Ignoring rollback error",
+                    run_id=str(run_id),
+                    run_attempt=attempt,
+                    run_created_at=run_created_at,
+                    exc=str(e),
+                )
+                # We need to clean up the transaction early if we want to
+                # update the thread status with the same connection
+                await exit.aclose()
+            checkpoint = None  # reset the checkpoint
         except UserInterrupt as e:
             exception = e
             status = "interrupted"
@@ -292,6 +331,7 @@ async def worker(
                 run_exec_ms=ms(datetime.now(UTC), run_started_at),
             )
             await Runs.set_status(conn, run_id, "error")
+        set_auth_ctx(None, None)
         # delete or set status of thread
         if temporary:
             await Threads.delete(conn, run["thread_id"])

langgraph_api/route.py

@@ -14,7 +14,7 @@ from starlette.routing import Route, compile_path, get_name
 from starlette.types import ASGIApp, Receive, Scope, Send
 
 from langgraph_api.serde import json_dumpb
-from langgraph_api.utils import set_auth_ctx
+from langgraph_api.utils import get_auth_ctx, with_user
 
 
 def api_request_response(
@@ -116,5 +116,10 @@ class ApiRoute(Route):
     async def handle(self, scope: Scope, receive: Receive, send: Send) -> None:
         # https://asgi.readthedocs.io/en/latest/specs/www.html#http-connection-scope
         scope["route"] = self.path
-        set_auth_ctx(scope.get("user"), scope.get("auth"))
-        return await super().handle(scope, receive, send)
+        ctx = get_auth_ctx()
+        if ctx:
+            user, auth = ctx.user, ctx.permissions
+        else:
+            user, auth = scope.get("user"), scope.get("auth")
+        async with with_user(user, auth):
+            return await super().handle(scope, receive, send)

langgraph_api/schema.py

@@ -157,7 +157,7 @@ class RunSend(TypedDict):
 
 class RunCommand(TypedDict):
     goto: str | RunSend | Sequence[RunSend | str] | None
-    update: dict[str, Any] | None
+    update: dict[str, Any] | Sequence[tuple[str, Any]] | None
     resume: Any | None
 
 

langgraph_api/stream.py

@@ -75,8 +75,15 @@ def _map_cmd(cmd: RunCommand) -> Command:
     if goto is not None and not isinstance(goto, list):
         goto = [cmd.get("goto")]
 
+    update = cmd.get("update")
+    if isinstance(update, tuple | list) and all(
+        isinstance(t, tuple | list) and len(t) == 2 and isinstance(t[0], str)
+        for t in update
+    ):
+        update = [tuple(t) for t in update]
+
     return Command(
-        update=cmd.get("update"),
+        update=update,
         goto=(
             [
                 it if isinstance(it, str) else Send(it["node"], it["input"])

langgraph_api/utils.py

@@ -17,22 +17,28 @@ AuthContext = contextvars.ContextVar[Auth.types.BaseAuthContext | None](
 
 
 @asynccontextmanager
-async def with_user(user: BaseUser | None = None, auth: AuthCredentials | None = None):
+async def with_user(
+    user: BaseUser | None = None, auth: AuthCredentials | list[str] | None = None
+):
     current = get_auth_ctx()
     set_auth_ctx(user, auth)
     yield
     if current is None:
         return
-    set_auth_ctx(current.user, AuthCredentials(scopes=current.scopes))
+    set_auth_ctx(current.user, AuthCredentials(scopes=current.permissions))
 
 
-def set_auth_ctx(user: BaseUser | None, auth: AuthCredentials | None) -> None:
-    if not user or not auth:
+def set_auth_ctx(
+    user: BaseUser | None, auth: AuthCredentials | list[str] | None
+) -> None:
+    if user is None and auth is None:
         AuthContext.set(None)
     else:
         AuthContext.set(
             Auth.types.BaseAuthContext(
-                permissions=auth.scopes,
+                permissions=(
+                    auth.scopes if isinstance(auth, AuthCredentials) else (auth or [])
+                ),
                 user=user or SimpleUser(""),
             )
         )

{langgraph_api-0.0.15.dist-info → langgraph_api-0.0.16.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langgraph-api
-Version: 0.0.15
+Version: 0.0.16
 Summary: 
 License: Elastic-2.0
 Author: Nuno Campos
@@ -16,7 +16,7 @@ Requires-Dist: jsonschema-rs (>=0.25.0,<0.26.0)
 Requires-Dist: langchain-core (>=0.2.38,<0.4.0)
 Requires-Dist: langgraph (>=0.2.56,<0.3.0)
 Requires-Dist: langgraph-checkpoint (>=2.0.7,<3.0)
-Requires-Dist: langgraph-sdk (>=0.1.48,<0.2.0)
+Requires-Dist: langgraph-sdk (>=0.1.51,<0.2.0)
 Requires-Dist: langsmith (>=0.1.63,<0.3.0)
 Requires-Dist: orjson (>=3.10.1)
 Requires-Dist: pyjwt (>=2.9.0,<3.0.0)

{langgraph_api-0.0.15.dist-info → langgraph_api-0.0.16.dist-info}/RECORD

@@ -5,11 +5,11 @@ langgraph_api/api/assistants.py,sha256=nn-0Q5FTaEbdPq-oesrpVzqu223PDSzeejFy9fd5X
 langgraph_api/api/meta.py,sha256=hueasWpTDQ6xYLo9Bzt2jhNH8XQRzreH8FTeFfnRoxQ,2700
 langgraph_api/api/openapi.py,sha256=AUxfnD5hlRp7s-0g2hBC5dNSNk3HTwOLeJiF489DT44,2762
 langgraph_api/api/runs.py,sha256=wAzPXi_kcYB9BcLBL4FXgkBohWwCPIpe4XERnsnWnsA,16042
-langgraph_api/api/store.py,sha256=y7VIejpsE7rpPF-tiMGBqqBwWPZ1wb3o48th6NUvb5I,3849
+langgraph_api/api/store.py,sha256=VzAJVOwO0IxosBB7km5TTf2rhlWGyPkVz_LpvbxetVY,5437
 langgraph_api/api/threads.py,sha256=taU61XPcCEhBPCYPZcMDsgVDwwWUWJs8p-PrXFXWY48,8661
-langgraph_api/asyncio.py,sha256=XiFEllu-Kg4zAO084npHPYOPnLQRire3V75XrVQYMxE,6023
+langgraph_api/asyncio.py,sha256=2fOlx-cZvuj1gQ867Kw1R_wsBsl9jdHYHcUtK2a-x-U,6264
 langgraph_api/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-langgraph_api/auth/custom.py,sha256=_BlII18X8ji_t8qA9FIUq_ip99dMQGkNscjsuEiLHus,20527
+langgraph_api/auth/custom.py,sha256=g_u7FdKm1Qj8eu_MZdnJeMsI4DlWyU5Mg0rPJzdOTSE,20913
 langgraph_api/auth/langsmith/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langgraph_api/auth/langsmith/backend.py,sha256=InScaL-HYCnxYEauhxU198gRZV9pJn9SzzBoR9Edn7g,2654
 langgraph_api/auth/langsmith/client.py,sha256=eKchvAom7hdkUXauD8vHNceBDDUijrFgdTV8bKd7x4Q,3998
@@ -30,10 +30,10 @@ langgraph_api/js/client.mts,sha256=ksiytm222KTUWj92ZnajqFku_y2AkRmfENmKie5LSPw,2
 langgraph_api/js/client.new.mts,sha256=9FrArkM20IeD176Q7u5lJNruaQXqAfAdDcqJkF0TPPA,23493
 langgraph_api/js/errors.py,sha256=Cm1TKWlUCwZReDC5AQ6SgNIVGD27Qov2xcgHyf8-GXo,361
 langgraph_api/js/global.d.ts,sha256=zR_zLYfpzyPfxpEFth5RgZoyfGulIXyZYPRf7cU0K0Y,106
-langgraph_api/js/package.json,sha256=QvZQVTWP0uYnPD_o7ETIuv9Hczn98bWfMEwTgjbBYCs,840
+langgraph_api/js/package.json,sha256=BGnWhiMMvxocEuPciTq14fEHp5NFmHo6fYV8q62n3t4,840
 langgraph_api/js/remote.py,sha256=D9cqcEgXau-fm_trpNwCHMra5BXntgUa469lgs_a9JQ,622
-langgraph_api/js/remote_new.py,sha256=LfCY7DIsJ6DulepYIPmvjIKb3kyDUD9lYrpekXhTF-E,22277
-langgraph_api/js/remote_old.py,sha256=mzM-AwYSRZQQTZvbmd680RIIVlSrO9amMtOHq3DQRcI,22088
+langgraph_api/js/remote_new.py,sha256=T_Vr8459bax1C9xxqz_ZYmGivq5Vhspg2Iu9TL0Qc-Q,22707
+langgraph_api/js/remote_old.py,sha256=2a-3ooAYUZs8aPsfnXafbBd4pP7lRmokoU7TiO7P9Js,22546
 langgraph_api/js/schema.py,sha256=7idnv7URlYUdSNMBXQcw7E4SxaPxCq_Oxwnlml8q5ik,408
 langgraph_api/js/server_sent_events.py,sha256=DLgXOHauemt7706vnfDUCG1GI3TidKycSizccdz9KgA,3702
 langgraph_api/js/src/graph.mts,sha256=EO1ITYoKiUykzO_8V8mnQb6NYybooR1VXIovThZzywc,2998
@@ -45,11 +45,11 @@ langgraph_api/js/src/schema/types.template.mts,sha256=c-FA0Ykzp4KvPyYA6a-hDf60Kd
 langgraph_api/js/src/utils/importMap.mts,sha256=pX4TGOyUpuuWF82kXcxcv3-8mgusRezOGe6Uklm2O5A,1644
 langgraph_api/js/src/utils/pythonSchemas.mts,sha256=98IW7Z_VP7L_CHNRMb3_MsiV3BgLE2JsWQY_PQcRR3o,685
 langgraph_api/js/src/utils/serde.mts,sha256=OuyyO9btvwWd55rU_H4x91dFEJiaPxL-lL9O6Zgo908,742
-langgraph_api/js/tests/api.test.mts,sha256=sFUW1_ffW3IUsQCdU7ToJ67QiTcwiYlxDJuUVbFh4_I,53215
+langgraph_api/js/tests/api.test.mts,sha256=2EpDEs888pJGdZnsyc76GdMp7uuRxM_SNlHBwITU-5I,55668
 langgraph_api/js/tests/compose-postgres.yml,sha256=pbNfeqVUqhWILBuUdwAgQOYsVU_fgkCVm0YlTgU8og8,1721
 langgraph_api/js/tests/graphs/.gitignore,sha256=26J8MarZNXh7snXD5eTpV3CPFTht5Znv8dtHYCLNfkw,12
-langgraph_api/js/tests/graphs/agent.mts,sha256=i2s0GOnydW88laDGBatYkQnjUe9Q44RNHDhdEGIcT8w,3811
-langgraph_api/js/tests/graphs/delay.mts,sha256=QByzUlICCBhaOBYG1Yi9TSl8Ss6w8sx0lETCCTu0kjY,617
+langgraph_api/js/tests/graphs/agent.mts,sha256=fFHm9vW04UN_2mGcHVHqtFIvPhjyFurBg62DAW-GJd4,3889
+langgraph_api/js/tests/graphs/delay.mts,sha256=CFneKxqI4bGGK0lYjSbe80QirowPQlsRSuhDUKfydhk,703
 langgraph_api/js/tests/graphs/error.mts,sha256=l4tk89449dj1BnEF_0ZcfPt0Ikk1gl8L1RaSnRfr3xo,487
 langgraph_api/js/tests/graphs/langgraph.json,sha256=frxd7ZWILdeMYSZgUBH6UO-IR7I2YJSOfOlx2mnO1sI,189
 langgraph_api/js/tests/graphs/nested.mts,sha256=4G7jSOSaFVQAza-_ARbK-Iai1biLlF2DIPDZXf7PLIY,1245
@@ -58,22 +58,22 @@ langgraph_api/js/tests/graphs/weather.mts,sha256=A7mLK3xW8h5B-ZyJNAyX2M2fJJwzPJz
 langgraph_api/js/tests/graphs/yarn.lock,sha256=q-1S--E5VWLYtkSv03shqtNzeDDv-N_J-N26FszLsjs,7903
 langgraph_api/js/tests/parser.test.mts,sha256=3zAbboUNhI-cY3hj4Ssr7J-sQXCBTeeI1ItrkG0Ftuk,26257
 langgraph_api/js/tests/utils.mts,sha256=2kTybJ3O7Yfe1q3ehDouqV54ibXkNzsPZ_wBZLJvY-4,421
-langgraph_api/js/yarn.lock,sha256=OD3NXIjBlUlbb6t8vFhOKlnQm4CvGWhB9Ns9W5omPlo,103690
+langgraph_api/js/yarn.lock,sha256=JtRgt5AXlsD4qBm1Nrtzxg-TLtZkFWtRKCvyS-V8CLg,103690
 langgraph_api/lifespan.py,sha256=Uj7NV-NqxxD1fgx_umM9pVqclcy-VlqrIxDljyj2he0,1820
 langgraph_api/logging.py,sha256=tiDNrEFwqaIdL5ywZv908OXlzzfXsPCws9GXeoFtBV8,3367
 langgraph_api/metadata.py,sha256=mih2G7ScQxiqyUlbksVXkqR3Oo-pM1b6lXtzOsgR1sw,3044
 langgraph_api/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-langgraph_api/models/run.py,sha256=qGTcgQjnzmXrxer5VPaGHoGwifV1nyE4ZCXtBiZH1bc,9546
+langgraph_api/models/run.py,sha256=qBN_w8mUpSbAZNVL1683_DfZHQ0zvYMNyqGg-g1sz6Y,9625
 langgraph_api/patch.py,sha256=94ddcTSZJe22JcpjxiSNjFZdYVnmeoWjk4IX4iBSoyk,1249
-langgraph_api/queue.py,sha256=pB2IGzArlmUzKOewJ7ejIOVDPGCYSzG6Mok1gXtsjdA,11955
-langgraph_api/route.py,sha256=HnAcWeStCrWNe37YUXIqEsjsrCPCIPGijHG7pM9ga28,4251
-langgraph_api/schema.py,sha256=EiCWRR2GmGrBrOYcuK9SeVQS5b98SdaJlKaqOL7t-WQ,5263
+langgraph_api/queue.py,sha256=nYtcjbqjwvELK5OXxD2aw5BWAlSJ-VPyCXSODMMXIj0,13353
+langgraph_api/route.py,sha256=fM4qYCGbmH0a3_cV8uKocb1sLklehxO6HhdRXqLK6OM,4421
+langgraph_api/schema.py,sha256=4aZCFY-dxd_nTot71bdcd9S8QCIgKajuRyj0p2QfgJ4,5291
 langgraph_api/serde.py,sha256=VoJ7Z1IuqrQGXFzEP1qijAITtWCrmjtVqlCRuScjXJI,3533
 langgraph_api/server.py,sha256=afHDnL6b_fAIu_q4icnK60a74lHTTZOMIe1egdhRXIk,1522
 langgraph_api/sse.py,sha256=2wNodCOP2eg7a9mpSu0S3FQ0CHk2BBV_vv0UtIgJIcc,4034
 langgraph_api/state.py,sha256=8jx4IoTCOjTJuwzuXJKKFwo1VseHjNnw_CCq4x1SW14,2284
-langgraph_api/stream.py,sha256=fedsd2rJu9sao6ez4P-_n3Z4jsMzQxxqwssoVr-vbLo,11677
-langgraph_api/utils.py,sha256=o7TFlY25IjujeKdXgtyE2mMLPETIlrbOc3w6giYBq2Y,2509
+langgraph_api/stream.py,sha256=Uygx6zcY5Wi9lBhRjtxqVDyLZSF1bsaqxg6mYoYVYcY,11900
+langgraph_api/utils.py,sha256=fMl3DHOQEwAqkFtrnP0Alfbrqw1UvwZ_JVLm-WTSQJk,2654
 langgraph_api/validation.py,sha256=McizHlz-Ez8Jhdbc79mbPSde7GIuf2Jlbjx2yv_l6dA,4475
 langgraph_license/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langgraph_license/middleware.py,sha256=_ODIYzQkymr6W9_Fp9wtf1kAQspnpsmr53xuzyF2GA0,612
@@ -81,15 +81,15 @@ langgraph_license/validation.py,sha256=Uu_G8UGO_WTlLsBEY0gTVWjRR4czYGfw5YAD3HLZo
 langgraph_storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langgraph_storage/checkpoint.py,sha256=V4t2GwYEJdPCHbhq_4Udhlv0TWKDzlMu_rlNPdTDc50,3589
 langgraph_storage/database.py,sha256=Nr5zE9Fur3-tESkqe7xNXMf2QlBuw3H0CUie7jVa6Q4,6003
-langgraph_storage/ops.py,sha256=l6sL3wq9vp2OJwhRbdNkPozi-bi2ma-yXHBNGRbmQzk,67985
+langgraph_storage/ops.py,sha256=7kmfm7EO7YbP_ItEjMvFPKPsM0a2X6RMhjaKof63HaQ,68206
 langgraph_storage/queue.py,sha256=6cTZ0ubHu3S1T43yxHMVOwsQsDaJupByiU0sTUFFls8,3261
 langgraph_storage/retry.py,sha256=uvYFuXJ-T6S1QY1ZwkZHyZQbsvS-Ab68LSbzbUUSI2E,696
 langgraph_storage/store.py,sha256=D-p3cWc_umamkKp-6Cz3cAriSACpvM5nxUIvND6PuxE,2710
 langgraph_storage/ttl_dict.py,sha256=FlpEY8EANeXWKo_G5nmIotPquABZGyIJyk6HD9u6vqY,1533
 logging.json,sha256=3RNjSADZmDq38eHePMm1CbP6qZ71AmpBtLwCmKU9Zgo,379
-openapi.json,sha256=gh6FxpyQqspAuQQH3O22qqGW5owtFj45gyR15QAcS9k,124729
-langgraph_api-0.0.15.dist-info/LICENSE,sha256=ZPwVR73Biwm3sK6vR54djCrhaRiM4cAD2zvOQZV8Xis,3859
-langgraph_api-0.0.15.dist-info/METADATA,sha256=Z_TZtWNrQ6jCCYhOHrV3zxhk4Dghxj-YZkyjKu_rqyQ,4041
-langgraph_api-0.0.15.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-langgraph_api-0.0.15.dist-info/entry_points.txt,sha256=3EYLgj89DfzqJHHYGxPH4A_fEtClvlRbWRUHaXO7hj4,77
-langgraph_api-0.0.15.dist-info/RECORD,,
+openapi.json,sha256=qf2Rw3ieawlAcSJu4mGonh9mNOb6solBD70CGL3w24A,124699
+langgraph_api-0.0.16.dist-info/LICENSE,sha256=ZPwVR73Biwm3sK6vR54djCrhaRiM4cAD2zvOQZV8Xis,3859
+langgraph_api-0.0.16.dist-info/METADATA,sha256=HLMkdfTmxuTMN59uOzDQ4VCRILZvgslETZShl2Mdruw,4041
+langgraph_api-0.0.16.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+langgraph_api-0.0.16.dist-info/entry_points.txt,sha256=3EYLgj89DfzqJHHYGxPH4A_fEtClvlRbWRUHaXO7hj4,77
+langgraph_api-0.0.16.dist-info/RECORD,,

langgraph_storage/ops.py

@@ -1325,7 +1325,10 @@ class Runs(Authenticated):
             thread = Thread(
                 thread_id=thread_id,
                 status="busy",
-                metadata={"graph_id": assistant["graph_id"]},
+                metadata={
+                    "graph_id": assistant["graph_id"],
+                    "assistant_id": str(assistant_id),
+                },
                 config=Runs._merge_jsonb(
                     assistant["config"],
                     config,
@@ -1345,7 +1348,11 @@ class Runs(Authenticated):
             if existing_thread["status"] != "busy":
                 existing_thread["status"] = "busy"
                 existing_thread["metadata"] = Runs._merge_jsonb(
-                    existing_thread["metadata"], {"graph_id": assistant["graph_id"]}
+                    existing_thread["metadata"],
+                    {
+                        "graph_id": assistant["graph_id"],
+                        "assistant_id": str(assistant_id),
+                    },
                 )
                 existing_thread["config"] = Runs._merge_jsonb(
                     assistant["config"],

openapi.json

@@ -22,7 +22,7 @@
       "description": "A run is an invocation of a graph / assistant, with no state or memory persistence."
     },
     {
-      "name": "Crons (Enterprise-only)",
+      "name": "Crons (Plus tier)",
       "description": "A cron is a periodic run that recurs on a given schedule. The repeats can be isolated, or share state in a thread"
     },
     {
@@ -1473,7 +1473,7 @@
     "/threads/{thread_id}/runs/crons": {
       "post": {
         "tags": [
-          "Crons (Enterprise-only)"
+          "Crons (Plus tier)"
         ],
         "summary": "Create Thread Cron",
         "description": "Create a cron to schedule runs on a thread.",
@@ -2058,7 +2058,7 @@
     "/runs/crons": {
       "post": {
         "tags": [
-          "Crons (Enterprise-only)"
+          "Crons (Plus tier)"
         ],
         "summary": "Create Cron",
         "description": "Create a cron to schedule runs on new threads.",
@@ -2110,7 +2110,7 @@
     "/runs/crons/search": {
       "post": {
         "tags": [
-          "Crons (Enterprise-only)"
+          "Crons (Plus tier)"
         ],
         "summary": "Search Crons",
         "description": "Search all active crons",
@@ -2399,7 +2399,7 @@
     "/runs/crons/{cron_id}": {
       "delete": {
         "tags": [
-          "Crons (Enterprise-only)"
+          "Crons (Plus tier)"
         ],
         "summary": "Delete Cron",
         "description": "Delete a cron by ID.",