langgraph-api 0.0.5__tar.gz → 0.0.7__tar.gz

{langgraph_api-0.0.5 → langgraph_api-0.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langgraph-api
-Version: 0.0.5
+Version: 0.0.7
 Summary: 
 License: Elastic-2.0
 Author: Nuno Campos
@@ -14,7 +14,7 @@ Requires-Dist: cryptography (>=43.0.3,<44.0.0)
 Requires-Dist: httpx (>=0.27.0)
 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.52,<0.3.0)
+Requires-Dist: langgraph (>=0.2.56,<0.3.0)
 Requires-Dist: langgraph-checkpoint (>=2.0.7,<3.0)
 Requires-Dist: langsmith (>=0.1.63,<0.2.0)
 Requires-Dist: orjson (>=3.10.1)

{langgraph_api-0.0.5 → langgraph_api-0.0.7}/langgraph_api/api/runs.py

@@ -283,10 +283,18 @@ async def list_runs_http(
     validate_uuid(thread_id, "Invalid thread ID: must be a UUID")
     limit = int(request.query_params.get("limit", 10))
     offset = int(request.query_params.get("offset", 0))
+    status = request.query_params.get("status")
     async with connect() as conn, conn.pipeline():
         thread, runs = await asyncio.gather(
             Threads.get(conn, thread_id),
-            Runs.search(conn, thread_id, limit=limit, offset=offset, metadata=None),
+            Runs.search(
+                conn,
+                thread_id,
+                limit=limit,
+                offset=offset,
+                status=status,
+                metadata=None,
+            ),
         )
     await fetchone(thread)
     return ApiResponse([run async for run in runs])
@@ -323,9 +331,15 @@ async def join_run_stream_endpoint(request: ApiRequest):
     """Wait for a run to finish."""
     thread_id = request.path_params["thread_id"]
     run_id = request.path_params["run_id"]
+    cancel_on_disconnect_str = request.query_params.get("cancel_on_disconnect", "false")
+    cancel_on_disconnect = cancel_on_disconnect_str.lower() in {"true", "yes", "1"}
     validate_uuid(thread_id, "Invalid thread ID: must be a UUID")
     validate_uuid(run_id, "Invalid run ID: must be a UUID")
-    return EventSourceResponse(Runs.Stream.join(run_id, thread_id=thread_id))
+    return EventSourceResponse(
+        Runs.Stream.join(
+            run_id, thread_id=thread_id, cancel_on_disconnect=cancel_on_disconnect
+        )
+    )
 
 
 @retry_db

{langgraph_api-0.0.5 → langgraph_api-0.0.7}/langgraph_api/api/store.py

@@ -8,7 +8,6 @@ from langgraph_api.validation import (
     StorePutRequest,
     StoreSearchRequest,
 )
-from langgraph_storage.database import connect
 from langgraph_storage.retry import retry_db
 from langgraph_storage.store import Store
 
@@ -31,8 +30,7 @@ async def put_item(request: ApiRequest):
         return err
     key = payload["key"]
     value = payload["value"]
-    async with connect() as conn:
-        await Store(conn).aput(namespace, key, value)
+    await Store().aput(namespace, key, value)
     return Response(status_code=204)
 
 
@@ -45,8 +43,7 @@ async def get_item(request: ApiRequest):
     key = request.query_params.get("key")
     if not key:
         return ApiResponse({"error": "Key is required"}, status_code=400)
-    async with connect() as conn:
-        result = await Store(conn).aget(namespace, key)
+    result = await Store().aget(namespace, key)
     return ApiResponse(result.dict() if result is not None else None)
 
 
@@ -58,8 +55,7 @@ async def delete_item(request: ApiRequest):
     if err := _validate_namespace(namespace):
         return err
     key = payload["key"]
-    async with connect() as conn:
-        await Store(conn).adelete(namespace, key)
+    await Store().adelete(namespace, key)
     return Response(status_code=204)
 
 
@@ -74,14 +70,13 @@ async def search_items(request: ApiRequest):
     limit = payload.get("limit") or 10
     offset = payload.get("offset") or 0
     query = payload.get("query")
-    async with connect() as conn:
-        items = await Store(conn).asearch(
-            namespace_prefix,
-            filter=filter,
-            limit=limit,
-            offset=offset,
-            query=query,
-        )
+    items = await Store().asearch(
+        namespace_prefix,
+        filter=filter,
+        limit=limit,
+        offset=offset,
+        query=query,
+    )
     return ApiResponse({"items": [item.dict() for item in items]})
 
 
@@ -98,14 +93,13 @@ async def list_namespaces(request: ApiRequest):
     max_depth = payload.get("max_depth")
     limit = payload.get("limit", 100)
     offset = payload.get("offset", 0)
-    async with connect() as conn:
-        result = await Store(conn).alist_namespaces(
-            prefix=prefix,
-            suffix=suffix,
-            max_depth=max_depth,
-            limit=limit,
-            offset=offset,
-        )
+    result = await Store().alist_namespaces(
+        prefix=prefix,
+        suffix=suffix,
+        max_depth=max_depth,
+        limit=limit,
+        offset=offset,
+    )
     return ApiResponse({"namespaces": result})
 
 

{langgraph_api-0.0.5 → langgraph_api-0.0.7}/langgraph_api/cli.py

@@ -94,10 +94,6 @@ class StoreConfig(TypedDict, total=False):
     index: IndexConfig
 
 
-class Config(TypedDict, total=False):
-    store: StoreConfig | None
-
-
 def run_server(
     host: str = "127.0.0.1",
     port: int = 2024,
@@ -107,10 +103,11 @@ def run_server(
     env_file: str | None = None,
     open_browser: bool = False,
     debug_port: int | None = None,
+    wait_for_client: bool = False,
     env: str | pathlib.Path | Mapping[str, str] | None = None,
     reload_includes: Sequence[str] | None = None,
     reload_excludes: Sequence[str] | None = None,
-    config: Config | None = None,
+    store: StoreConfig | None = None,
     **kwargs: Any,
 ):
     """Run the LangGraph API server."""
@@ -148,8 +145,9 @@ def run_server(
         logger.info("   - Host: 0.0.0.0")
         logger.info(f"   - Port: {debug_port}")
         logger.info("3. Start the debugger to connect to the server.")
-        debugpy.wait_for_client()
-        logger.info("Debugger attached. Starting server...")
+        if wait_for_client:
+            debugpy.wait_for_client()
+            logger.info("Debugger attached. Starting server...")
 
     local_url = f"http://{host}:{port}"
     studio_url = f"https://smith.langchain.com/studio/?baseUrl={local_url}"
@@ -213,7 +211,7 @@ For production use, please use LangGraph Cloud.
         DATABASE_URI=":memory:",
         REDIS_URI="fake",
         N_JOBS_PER_WORKER=str(n_jobs_per_worker if n_jobs_per_worker else 1),
-        LANGGRAPH_CONFIG=json.dumps(config) if config else None,
+        LANGGRAPH_STORE=json.dumps(store) if store else None,
         LANGSERVE_GRAPHS=json.dumps(graphs) if graphs else None,
         LANGSMITH_LANGGRAPH_API_VARIANT="local_dev",
         **(env_vars or {}),
@@ -274,6 +272,11 @@ def main():
     parser.add_argument(
         "--debug-port", type=int, help="Port for debugger to listen on (default: none)"
     )
+    parser.add_argument(
+        "--wait-for-client",
+        action="store_true",
+        help="Whether to break and wait for a debugger to attach",
+    )
 
     args = parser.parse_args()
 
@@ -289,6 +292,7 @@ def main():
         n_jobs_per_worker=args.n_jobs_per_worker,
         open_browser=not args.no_browser,
         debug_port=args.debug_port,
+        wait_for_client=args.wait_for_client,
         env=config_data.get("env", None),
     )
 

{langgraph_api-0.0.5 → langgraph_api-0.0.7}/langgraph_api/graph.py

@@ -196,6 +196,12 @@ async def collect_graphs_from_env(register: bool = False) -> None:
     py_specs = list(filterfalse(is_js_spec, specs))
 
     if js_specs:
+        if os.environ.get("LANGSMITH_LANGGRAPH_API_VARIANT") == "local_dev":
+            raise NotImplementedError(
+                "LangGraph.JS graphs are not yet supported in local development mode. "
+                "To run your JS graphs, either use the LangGraph Studio application "
+                "or run `langgraph up` to start the server in a Docker container."
+            )
         import sys
 
         from langgraph_api.js.remote import (

{langgraph_api-0.0.5 → langgraph_api-0.0.7}/langgraph_api/js/client.mts

@@ -9,6 +9,7 @@ import {
   BaseStore,
   Item,
   Operation,
+  Command,
   OperationResults,
   type Checkpoint,
   type CheckpointMetadata,
@@ -459,7 +460,7 @@ async function main() {
 
   const specs = z
     .record(z.string())
-    .parse(JSON.parse(process.env.LANGSERVE_GRAPHS));
+    .parse(JSON.parse(process.env.LANGSERVE_GRAPHS ?? "{}"));
 
   if (!process.argv.includes("--skip-schema-cache")) {
     try {
@@ -495,6 +496,7 @@ async function main() {
       "json",
       z.object({
         input: z.unknown(),
+        command: z.object({ resume: z.unknown() }).nullish(),
         stream_mode: z
           .union([ExtraStreamModeSchema, z.array(ExtraStreamModeSchema)])
           .optional(),
@@ -512,6 +514,11 @@ async function main() {
       const graph = getGraph(c.req.param("graphId"));
       const payload = c.req.valid("json");
 
+      const input = payload.command
+        ? // @ts-expect-error Update LG.js to mark `resume as optional
+          new Command(payload.command)
+        : payload.input;
+
       const userStreamMode =
         payload.stream_mode == null
           ? []
@@ -551,7 +558,7 @@ async function main() {
         const streamMode = [...graphStreamMode];
 
         try {
-          for await (const data of graph.streamEvents(payload.input, {
+          for await (const data of graph.streamEvents(input, {
             ...config,
             version: "v2",
             streamMode,

{langgraph_api-0.0.5 → langgraph_api-0.0.7}/langgraph_api/js/package.json

@@ -9,8 +9,8 @@
   "dependencies": {
     "@hono/node-server": "^1.12.0",
     "@hono/zod-validator": "^0.2.2",
-    "@langchain/core": "^0.3.17",
-    "@langchain/langgraph": "^0.2.23",
+    "@langchain/core": "^0.3.22",
+    "@langchain/langgraph": "^0.2.26",
     "@types/json-schema": "^7.0.15",
     "@typescript/vfs": "^1.6.0",
     "dedent": "^1.5.3",
@@ -24,7 +24,7 @@
     "zod": "^3.23.8"
   },
   "devDependencies": {
-    "@langchain/langgraph-sdk": "^0.0.19",
+    "@langchain/langgraph-sdk": "^0.0.31",
     "@types/node": "^22.2.0",
     "postgres": "^3.4.4",
     "prettier": "^3.3.3",

{langgraph_api-0.0.5 → langgraph_api-0.0.7}/langgraph_api/js/remote.py

@@ -20,7 +20,7 @@ from langchain_core.runnables.schema import (
 from langgraph.checkpoint.serde.base import SerializerProtocol
 from langgraph.pregel.types import PregelTask, StateSnapshot
 from langgraph.store.base import GetOp, Item, ListNamespacesOp, PutOp, SearchOp
-from langgraph.types import Interrupt
+from langgraph.types import Command, Interrupt
 from pydantic import BaseModel
 from starlette.applications import Starlette
 from starlette.requests import Request
@@ -91,12 +91,18 @@ class RemotePregel(Runnable):
         if version != "v2":
             raise ValueError("Only v2 of astream_events is supported")
 
+        data = {
+            "command" if isinstance(input, Command) else "input": input,
+            "config": config,
+            **kwargs,
+        }
+
         async with aconnect_sse(
             self._async_client,
             "POST",
             f"/{self.graph_id}/streamEvents",
             headers={"Content-Type": "application/json"},
-            data=orjson.dumps({"input": input, "config": config, **kwargs}),
+            data=orjson.dumps(data),
         ) as event_source:
             async for sse in event_source.aiter_sse():
                 event = orjson.loads(sse["data"])
@@ -173,15 +179,19 @@ class RemotePregel(Runnable):
                         tuple(task["path"]) if task.get("path") else tuple(),
                         # TODO: figure out how to properly deserialise errors
                         task.get("error"),
-                        tuple(
-                            Interrupt(
-                                value=interrupt["value"],
-                                when=interrupt["when"],
+                        (
+                            tuple(
+                                Interrupt(
+                                    value=interrupt["value"],
+                                    when=interrupt["when"],
+                                    resumable=interrupt.get("resumable", True),
+                                    ns=interrupt.get("ns"),
+                                )
+                                for interrupt in task.get("interrupts")
                             )
-                            for interrupt in task.get("interrupts")
-                        )
-                        if task.get("interrupts")
-                        else [],
+                            if task.get("interrupts")
+                            else []
+                        ),
                         state,
                     )
                 )
@@ -413,17 +423,13 @@ async def run_remote_checkpointer():
     await server.serve()
 
 
-def _get_passthrough_store(conn: AsyncConnectionProto):
+def _get_passthrough_store():
     from langgraph_storage.store import Store
 
-    store = Store(conn)
-
-    return store
+    return Store()
 
 
 async def run_remote_store():
-    from langgraph_storage.database import connect
-
     async def abatch(request: Request):
         payload = orjson.loads(await request.body())
         operations = payload.get("operations", [])
@@ -470,9 +476,8 @@ async def run_remote_store():
                     {"error": f"Unknown operation type: {op}"}, status_code=400
                 )
 
-        async with connect() as conn:
-            store = _get_passthrough_store(conn)
-            results = await store.abatch(processed_operations)
+        store = _get_passthrough_store()
+        results = await store.abatch(processed_operations)
 
         # Handle potentially undefined or non-dict results
         processed_results = []
@@ -512,9 +517,8 @@ async def run_remote_store():
 
         namespaces = namespaces_str.split(".")
 
-        async with connect() as conn:
-            store = _get_passthrough_store(conn)
-            result = await store.aget(namespaces, key)
+        store = _get_passthrough_store()
+        result = await store.aget(namespaces, key)
 
         return ApiResponse(result)
 
@@ -524,10 +528,10 @@ async def run_remote_store():
         namespace = tuple(payload["namespace"].split("."))
         key = payload["key"]
         value = payload["value"]
+        index = payload.get("index")
 
-        async with connect() as conn:
-            store = _get_passthrough_store(conn)
-            await store.aput(namespace, key, value)
+        store = _get_passthrough_store()
+        await store.aput(namespace, key, value, index=index)
 
         return ApiResponse({"success": True})
 
@@ -538,12 +542,12 @@ async def run_remote_store():
         filter = payload.get("filter")
         limit = payload.get("limit", 10)
         offset = payload.get("offset", 0)
+        query = payload.get("query")
 
-        async with connect() as conn:
-            store = _get_passthrough_store(conn)
-            result = await store.asearch(
-                namespace_prefix, filter=filter, limit=limit, offset=offset
-            )
+        store = _get_passthrough_store()
+        result = await store.asearch(
+            namespace_prefix, filter=filter, limit=limit, offset=offset, query=query
+        )
 
         return ApiResponse([item.dict() for item in result])
 
@@ -553,9 +557,8 @@ async def run_remote_store():
         namespace = tuple(payload["namespace"])
         key = payload["key"]
 
-        async with connect() as conn:
-            store = _get_passthrough_store(conn)
-            await store.adelete(namespace, key)
+        store = _get_passthrough_store()
+        await store.adelete(namespace, key)
 
         return ApiResponse({"success": True})
 
@@ -568,15 +571,14 @@ async def run_remote_store():
         limit = payload.get("limit", 100)
         offset = payload.get("offset", 0)
 
-        async with connect() as conn:
-            store = _get_passthrough_store(conn)
-            result = await store.alist_namespaces(
-                prefix=prefix,
-                suffix=suffix,
-                max_depth=max_depth,
-                limit=limit,
-                offset=offset,
-            )
+        store = _get_passthrough_store()
+        result = await store.alist_namespaces(
+            prefix=prefix,
+            suffix=suffix,
+            max_depth=max_depth,
+            limit=limit,
+            offset=offset,
+        )
 
         return ApiResponse([list(ns) for ns in result])
 

{langgraph_api-0.0.5 → langgraph_api-0.0.7}/langgraph_api/js/src/graph.mts

@@ -20,6 +20,20 @@ export interface GraphSpec {
   exportSymbol: string;
 }
 
+export async function resolveGraph(
+  spec: string,
+  options?: { onlyFilePresence?: false }
+): Promise<{
+  sourceFile: string;
+  exportSymbol: string;
+  resolved: CompiledGraph<string>;
+}>;
+
+export async function resolveGraph(
+  spec: string,
+  options: { onlyFilePresence: true }
+): Promise<{ sourceFile: string; exportSymbol: string; resolved: undefined }>;
+
 export async function resolveGraph(
   spec: string,
   options?: { onlyFilePresence?: boolean }

{langgraph_api-0.0.5 → langgraph_api-0.0.7}/langgraph_api/js/src/hooks.mjs

@@ -1,16 +1,17 @@
 // This hook is to ensure that @langchain/langgraph package
 // found in /api folder has precendence compared to user-provided package
 // found in /deps. Does not attempt to semver check for too old packages.
-export async function resolve(specifier, context, nextResolve) {
+const OVERRIDE_RESOLVE = [
+  "@langchain/langgraph",
+  "@langchain/langgraph-checkpoint",
+];
+
+export const resolve = async (specifier, context, nextResolve) => {
   const parentURL = new URL("./graph.mts", import.meta.url).toString();
 
-  if (specifier.startsWith("@langchain/langgraph")) {
-    try {
-      return nextResolve(specifier, { ...context, parentURL });
-    } catch (error) {
-      return nextResolve(specifier, context);
-    }
+  if (OVERRIDE_RESOLVE.includes(specifier)) {
+    return nextResolve(specifier, { ...context, parentURL });
   }
 
   return nextResolve(specifier, context);
-}
+};

{langgraph_api-0.0.5 → langgraph_api-0.0.7}/langgraph_api/js/tests/api.test.mts

@@ -447,6 +447,35 @@ describe("runs", () => {
     await sql`DELETE FROM store`;
   });
 
+  it.skip.concurrent("list runs", async () => {
+    const assistant = await client.assistants.create({ graphId: "agent" });
+    const thread = await client.threads.create();
+    await client.runs.wait(thread.thread_id, assistant.assistant_id, {
+      input: { messages: [{ type: "human", content: "foo" }] },
+      config: globalConfig,
+    });
+
+    const pendingRun = await client.runs.create(
+      thread.thread_id,
+      assistant.assistant_id,
+      {
+        input: { messages: [{ type: "human", content: "bar" }] },
+        config: globalConfig,
+      }
+    );
+
+    let runs = await client.runs.list(thread.thread_id);
+    expect(runs.length).toBe(2);
+
+    runs = await client.runs.list(thread.thread_id, { status: "pending" });
+    expect(runs.length).toBe(1);
+
+    await client.runs.cancel(thread.thread_id, pendingRun.run_id);
+
+    runs = await client.runs.list(thread.thread_id, { status: "interrupted" });
+    expect(runs.length).toBe(1);
+  });
+
   it.concurrent("stream values", async () => {
     const assistant = await client.assistants.create({ graphId: "agent" });
     const thread = await client.threads.create();
@@ -1500,6 +1529,63 @@ describe("subgraphs", () => {
     expect(innerHistory[0].values.messages.length).toBe(2);
     expect(innerHistory[innerHistory.length - 1].next).toEqual(["__start__"]);
   });
+
+  it.concurrent("interrupt inside node", async () => {
+    const assistant = await client.assistants.create({ graphId: "agent" });
+
+    let thread = await client.threads.create();
+    await client.runs.wait(thread.thread_id, assistant.assistant_id, {
+      input: {
+        messages: [{ role: "human", content: "SF", id: "initial-message" }],
+        interrupt: true,
+      },
+      config: globalConfig,
+    });
+
+    const state = await client.threads.getState(thread.thread_id);
+    expect(state.next).toEqual(["agent"]);
+    expect(state.tasks).toMatchObject([
+      {
+        id: expect.any(String),
+        name: "agent",
+        path: ["__pregel_pull", "agent"],
+        error: null,
+        interrupts: [
+          {
+            value: "i want to interrupt",
+            when: "during",
+            resumable: true,
+            ns: [expect.stringMatching(/^agent:/)],
+          },
+        ],
+        checkpoint: null,
+        state: null,
+        result: null,
+      },
+    ]);
+
+    thread = await client.threads.get(thread.thread_id);
+    expect(thread.status).toBe("interrupted");
+    expect(thread.interrupts).toMatchObject({
+      [state.tasks[0].id]: [
+        {
+          value: "i want to interrupt",
+          when: "during",
+          resumable: true,
+          ns: [expect.stringMatching(/^agent:/)],
+        },
+      ],
+    });
+
+    const stream = await gatherIterator(
+      client.runs.stream(thread.thread_id, assistant.assistant_id, {
+        command: { resume: "i want to resume" },
+      })
+    );
+
+    expect(stream.at(-1)?.event).toBe("values");
+    expect(stream.at(-1)?.data.messages.length).toBe(4);
+  });
 });
 
 describe("errors", () => {

{langgraph_api-0.0.5 → langgraph_api-0.0.7}/langgraph_api/js/tests/graphs/agent.mts

@@ -7,6 +7,7 @@ import {
   messagesStateReducer,
   SharedValue,
   LangGraphRunnableConfig,
+  interrupt,
 } from "@langchain/langgraph";
 import { FakeListChatModel } from "@langchain/core/utils/testing";
 
@@ -16,6 +17,7 @@ const GraphAnnotationOutput = Annotation.Root({
     default: () => [],
   }),
   sharedStateValue: Annotation<string | null>(),
+  interrupt: Annotation<boolean>(),
 });
 
 const GraphAnnotationInput = Annotation.Root({
@@ -36,8 +38,10 @@ const getModel = (threadId: string) => {
 
 const agentNode = async (
   state: typeof GraphAnnotationInput.State,
-  config: LangGraphRunnableConfig,
+  config: LangGraphRunnableConfig
 ) => {
+  if (state.interrupt) interrupt("i want to interrupt");
+
   const model = getModel(config.configurable?.thread_id ?? "$");
   const response = await model.invoke(state.messages);
   const sharedStateValue = state.sharedState?.data?.user_id ?? null;
@@ -52,6 +56,7 @@ const agentNode = async (
   }
 
   return {
+    interrupt: false,
     messages: [response],
     sharedState: { data: { user_id: config?.configurable?.user_id } },
     sharedStateValue,
@@ -60,7 +65,7 @@ const agentNode = async (
 
 const toolNode = async (
   state: typeof GraphAnnotationInput.State,
-  config: LangGraphRunnableConfig,
+  config: LangGraphRunnableConfig
 ) => {
   const store = config.store;
   let sharedStateFromStoreConfig: Record<string, any> | null = null;
@@ -84,7 +89,7 @@ const toolNode = async (
 
 const checkSharedStateNode = async (
   _: typeof GraphAnnotationInput.State,
-  config: LangGraphRunnableConfig,
+  config: LangGraphRunnableConfig
 ): Promise<Partial<typeof GraphAnnotationInput.State>> => {
   const store = config.store;
   const namespace = ["inputtedState", "data"];
@@ -114,7 +119,7 @@ const workflow = new StateGraph(
     input: GraphAnnotationInput,
     output: GraphAnnotationOutput,
   },
-  Annotation.Root({ model_name: Annotation<string> }),
+  Annotation.Root({ model_name: Annotation<string> })
 )
   .addNode("agent", agentNode)
   .addNode("tool", toolNode)

langgraph_api-0.0.7/langgraph_api/js/tests/graphs/package.json

@@ -0,0 +1,7 @@
+{
+  "private": true,
+  "dependencies": {
+    "@langchain/core": "^0.3.22",
+    "@langchain/langgraph": "^0.2.26"
+  }
+}