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

langgraph_api/js/tests/api.test.mts

@@ -686,6 +686,40 @@ describe("runs", () => {
     expect(run.status).toBe("success");
   });
 
+  it.concurrent("stream messages tuple", async () => {
+    const assistant = await client.assistants.create({ graphId: "agent" });
+    const thread = await client.threads.create();
+    const input = {
+      messages: [{ type: "human", content: "foo", id: "initial-message" }],
+    };
+    const stream = await client.runs.stream(
+      thread.thread_id,
+      assistant.assistant_id,
+      { input, streamMode: "messages-tuple", config: globalConfig }
+    );
+
+    const chunks = await gatherIterator(stream);
+    const runId = findLast(chunks, (i) => i.event === "metadata")?.data.run_id;
+    expect(runId).not.toBeNull();
+
+    const messages = chunks
+      .filter((i) => i.event === "messages")
+      .map((i) => i.data[0]);
+
+    expect(messages).toHaveLength("begin".length + "end".length + 1);
+    expect(messages).toMatchObject([
+      ..."begin".split("").map((c) => ({ content: c })),
+      { content: "tool_call__begin" },
+      ..."end".split("").map((c) => ({ content: c })),
+    ]);
+
+    const seenEventTypes = new Set(chunks.map((i) => i.event));
+    expect(seenEventTypes).toEqual(new Set(["metadata", "messages"]));
+
+    const run = await client.runs.get(thread.thread_id, runId as string);
+    expect(run.status).toBe("success");
+  });
+
   it.concurrent("stream mixed modes", async () => {
     const assistant = await client.assistants.create({ graphId: "agent" });
     const thread = await client.threads.create();
@@ -753,13 +787,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 +851,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 +871,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 +1739,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

@@ -6,11 +6,13 @@ import {
   END,
   messagesStateReducer,
   SharedValue,
-  LangGraphRunnableConfig,
   interrupt,
+  type LangGraphRunnableConfig,
 } from "@langchain/langgraph";
 import { FakeListChatModel } from "@langchain/core/utils/testing";
-
+import { ChatGenerationChunk } from "@langchain/core/outputs";
+import { v4 as uuidv4 } from "uuid";
+import { CallbackManagerForLLMRun } from "@langchain/core/callbacks/manager";
 const GraphAnnotationOutput = Annotation.Root({
   messages: Annotation<BaseMessage[]>({
     reducer: messagesStateReducer,
@@ -18,6 +20,9 @@ const GraphAnnotationOutput = Annotation.Root({
   }),
   sharedStateValue: Annotation<string | null>(),
   interrupt: Annotation<boolean>(),
+  keyOne: Annotation<string | null>(),
+  keyTwo: Annotation<string | null>(),
+  sleep: Annotation<number | null>(),
 });
 
 const GraphAnnotationInput = Annotation.Root({
@@ -26,13 +31,58 @@ const GraphAnnotationInput = Annotation.Root({
   sharedStateFromStoreConfig: Annotation<Record<string, any> | null>,
 });
 
+class StableFakeListChatModel extends FakeListChatModel {
+  streamMessageId: string = uuidv4();
+
+  async *_streamResponseChunks(
+    _messages: BaseMessage[],
+    options: this["ParsedCallOptions"],
+    runManager?: CallbackManagerForLLMRun
+  ): AsyncGenerator<ChatGenerationChunk> {
+    const response = this._currentResponse();
+    this._incrementResponse();
+    this.streamMessageId = uuidv4();
+
+    if (this.emitCustomEvent) {
+      await runManager?.handleCustomEvent("some_test_event", {
+        someval: true,
+      });
+    }
+
+    for await (const text of response) {
+      await this._sleepIfRequested();
+      if (options?.thrownErrorString) {
+        throw new Error(options.thrownErrorString);
+      }
+      const chunk = this._createResponseChunk(text);
+
+      // ensure stable ID
+      chunk.message.id = this.streamMessageId;
+      chunk.message.lc_kwargs.id = this.streamMessageId;
+
+      yield chunk;
+
+      void runManager?.handleLLMNewToken(
+        text,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        { chunk }
+      );
+    }
+  }
+}
+
 // For shared state
 const namespace = ["sharedState", "data"];
 const key = "user_id";
 
 const modelMap: Record<string, FakeListChatModel> = {};
 const getModel = (threadId: string) => {
-  modelMap[threadId] ??= new FakeListChatModel({ responses: ["begin", "end"] });
+  modelMap[threadId] ??= new StableFakeListChatModel({
+    responses: ["begin", "end"],
+  });
   return modelMap[threadId];
 };
 
@@ -42,6 +92,11 @@ const agentNode = async (
 ) => {
   if (state.interrupt) interrupt("i want to interrupt");
 
+  if (state.sleep != null && state.messages.at(-1)?.getType() === "human") {
+    const sleep = state.sleep;
+    await new Promise((resolve) => setTimeout(resolve, sleep * 1000));
+  }
+
   const model = getModel(config.configurable?.thread_id ?? "$");
   const response = await model.invoke(state.messages);
   const sharedStateValue = state.sharedState?.data?.user_id ?? null;

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"
@@ -1486,10 +1486,10 @@ nanoid@^3.3.7:
   resolved "https://registry.yarnpkg.com/nanoid/-/nanoid-3.3.7.tgz#d0c301a691bc8d54efa0a2226ccf3fe2fd656bd8"
   integrity sha512-eSRppjcPIatRIMC1U6UngP8XFcz8MQWGQdt1MTBQ7NaAmvXDfvNxbvWV3x2y6CdEUciCSsDHDQZbhYaB8QEo2g==
 
-node-addon-api@^8.2.1:
-  version "8.2.1"
-  resolved "https://registry.yarnpkg.com/node-addon-api/-/node-addon-api-8.2.1.tgz#43a993f110b88e22ba48bcd65e16b92165a6b002"
-  integrity sha512-vmEOvxwiH8tlOcv4SyE8RH34rI5/nWVaigUeAUPawC6f0+HoDthwI0vkMu4tbtsZrXq6QXFfrkhjofzKEs5tpA==
+node-addon-api@^8.3.0:
+  version "8.3.0"
+  resolved "https://registry.yarnpkg.com/node-addon-api/-/node-addon-api-8.3.0.tgz#ec3763f18befc1cdf66d11e157ce44d5eddc0603"
+  integrity sha512-8VOpLHFrOQlAH+qA0ZzuGRlALRA6/LVh8QJldbrC4DY0hXoMP0l4Acq8TzFC018HztWiRqyCEj2aTWY2UvnJUg==
 
 node-int64@^0.4.0:
   version "0.4.0"
@@ -2173,13 +2173,13 @@ yallist@^4.0.0:
   resolved "https://registry.yarnpkg.com/yallist/-/yallist-4.0.0.tgz#9bb92790d9c0effec63be73519e11a35019a3a72"
   integrity sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==
 
-zeromq@^6.1.1:
-  version "6.1.2"
-  resolved "https://registry.yarnpkg.com/zeromq/-/zeromq-6.1.2.tgz#89f1cae83f1a4615dab02dbc7881b10ea1a33c73"
-  integrity sha512-5lqsW2UXnKhFhBbIm0wzrRnZmWaGI2b2bm4E03rYMK1c1jBMN0wbPnuyqqhGg7QkzBUmpqf+LyjLhg2TRJmvow==
+zeromq@^6.3.0:
+  version "6.3.0"
+  resolved "https://registry.yarnpkg.com/zeromq/-/zeromq-6.3.0.tgz#19ffa286d128cc317847b5d615c079a67e3bae48"
+  integrity sha512-PG61AT4Y37NGJHSrp5SG2m4cKtRirso/5mm4Yf7l+upgNZZAugrGdhENsM5IcLS+WVVzbWVjEsLKpgLj/31SWQ==
   dependencies:
     "@aminya/cmake-ts" "^0.3.0-aminya.7"
-    node-addon-api "^8.2.1"
+    node-addon-api "^8.3.0"
 
 zod-to-json-schema@^3.22.3:
   version "3.23.5"

langgraph_api/models/run.py

@@ -8,7 +8,7 @@ from langgraph.checkpoint.base.id import uuid6
 from starlette.authentication import BaseUser
 from starlette.exceptions import HTTPException
 
-from langgraph_api.graph import get_assistant_id
+from langgraph_api.graph import GRAPHS, get_assistant_id
 from langgraph_api.schema import (
     All,
     Config,
@@ -92,7 +92,13 @@ def ensure_ids(
             assistant_id if isinstance(assistant_id, UUID) else UUID(assistant_id)
         ]
     except ValueError:
-        raise HTTPException(status_code=422, detail="Invalid assistant ID") from None
+        keys = ", ".join(GRAPHS.keys())
+        raise HTTPException(
+            status_code=422,
+            detail=f"Invalid assistant: '{assistant_id}'. Must be either:\n"
+            f"- A valid assistant UUID, or\n"
+            f"- One of the registered graphs: {keys}",
+        ) from None
     if thread_id:
         try:
             results.append(
@@ -191,6 +197,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,13 +1,14 @@
 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
 
 import structlog
 from langgraph.pregel.debug import CheckpointPayload, TaskResultPayload
 
-from langgraph_api.config import BG_JOB_NO_DELAY, STATS_INTERVAL_SECS
+from langgraph_api.auth.custom import SimpleUser, normalize_user
+from langgraph_api.config import BG_JOB_DELAY, STATS_INTERVAL_SECS
 from langgraph_api.errors import (
     UserInterrupt,
     UserRollback,
@@ -20,11 +21,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()
@@ -120,13 +126,13 @@ async def queue(concurrency: int, timeout: float):
                 else:
                     semaphore.release()
                     await exit.aclose()
-                    await asyncio.sleep(0 if BG_JOB_NO_DELAY else random())
+                    await asyncio.sleep(BG_JOB_DELAY)
             except Exception as exc:
                 # keep trying to run the scheduler indefinitely
                 logger.exception("Background worker scheduler failed", exc_info=exc)
                 semaphore.release()
                 await exit.aclose()
-                await asyncio.sleep(0 if BG_JOB_NO_DELAY else random())
+                await asyncio.sleep(BG_JOB_DELAY)
     finally:
         logger.info("Shutting down background workers")
         for task in WORKERS:
@@ -149,6 +155,35 @@ class WorkerResult(TypedDict):
     run_ended_at: str | None
 
 
+@asynccontextmanager
+async def set_auth_ctx_for_run(
+    run_kwargs: dict, user_id: str | None = None
+) -> AsyncGenerator[None, None]:
+    # user_id is a fallback.
+    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:
+        if user_id is not None:
+            await logger.ainfo(
+                "Setting auth to backup user_id",
+                user_id=user_id,
+            )
+            async with with_user(SimpleUser(user_id)):
+                yield None
+        else:
+            yield None
+    except Exception:
+        pass
+
+
 async def worker(
     timeout: float,
     exit: AsyncExitStack,
@@ -165,7 +200,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["kwargs"]), 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 +281,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 +341,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"])
@@ -123,7 +130,7 @@ async def astream_state(
     stream_modes_set: set[StreamMode] = set(stream_mode) - {"events"}
     if "debug" not in stream_modes_set:
         stream_modes_set.add("debug")
-    if "messages-tuple" in stream_modes_set:
+    if "messages-tuple" in stream_modes_set and not isinstance(graph, BaseRemotePregel):
         stream_modes_set.remove("messages-tuple")
         stream_modes_set.add("messages")
     # attach attempt metadata

langgraph_api/utils.py

@@ -6,9 +6,11 @@ from datetime import datetime
 from typing import Any, Protocol, TypeAlias, TypeVar
 
 from langgraph_sdk import Auth
-from starlette.authentication import AuthCredentials, BaseUser, SimpleUser
+from starlette.authentication import AuthCredentials, BaseUser
 from starlette.exceptions import HTTPException
 
+from langgraph_api.auth.custom import SimpleUser
+
 T = TypeVar("T")
 Row: TypeAlias = dict[str, Any]
 AuthContext = contextvars.ContextVar[Auth.types.BaseAuthContext | None](
@@ -17,22 +19,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.17.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langgraph-api
-Version: 0.0.15
+Version: 0.0.17
 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)