@langchain/langgraph-api 1.1.14 → 1.1.16

package/dist/api/assistants.mjs

@@ -1,6 +1,6 @@
 import { zValidator } from "@hono/zod-validator";
 import { Hono } from "hono";
-import { v4 as uuid } from "uuid";
+import { v7 as uuid } from "uuid";
 import { z } from "zod/v3";
 import { getAssistantId, getCachedStaticGraphSchema, getGraph, } from "../graph/load.mjs";
 import { getRuntimeGraphSchema } from "../graph/parser/index.mjs";

package/dist/api/runs.mjs

@@ -2,7 +2,7 @@ import { zValidator } from "@hono/zod-validator";
 import { Hono } from "hono";
 import { HTTPException } from "hono/http-exception";
 import { streamSSE } from "hono/streaming";
-import { v4 as uuid4 } from "uuid";
+import { v7 as uuid7 } from "uuid";
 import { z } from "zod/v3";
 import { getAssistantId } from "../graph/load.mjs";
 import { logError, logger } from "../logging.mjs";
@@ -14,7 +14,7 @@ const api = new Hono();
 const createValidRun = async (threadId, payload, kwargs) => {
     const { assistant_id: assistantId, ...run } = payload;
     const { auth, headers } = kwargs ?? {};
-    const runId = uuid4();
+    const runId = uuid7();
     const streamMode = Array.isArray(payload.stream_mode)
         ? payload.stream_mode
         : payload.stream_mode != null

package/dist/api/threads.mjs

@@ -1,6 +1,6 @@
 import { zValidator } from "@hono/zod-validator";
 import { Hono } from "hono";
-import { v4 as uuid4 } from "uuid";
+import { v7 as uuid7 } from "uuid";
 import { z } from "zod/v3";
 import * as schemas from "../schemas.mjs";
 import { stateSnapshotToThreadState } from "../state.mjs";
@@ -11,7 +11,7 @@ const api = new Hono();
 api.post("/threads", zValidator("json", schemas.ThreadCreate), async (c) => {
     // Create Thread
     const payload = c.req.valid("json");
-    const thread = await threads().put(payload.thread_id || uuid4(), { metadata: payload.metadata, if_exists: payload.if_exists ?? "raise" }, c.var.auth);
+    const thread = await threads().put(payload.thread_id || uuid7(), { metadata: payload.metadata, if_exists: payload.if_exists ?? "raise" }, c.var.auth);
     if (payload.supersteps?.length) {
         await threads().state.bulk({ configurable: { thread_id: thread.thread_id } }, payload.supersteps, c.var.auth);
     }

package/dist/experimental/embed.mjs

@@ -1,7 +1,7 @@
 import { Hono } from "hono";
 import { zValidator } from "@hono/zod-validator";
 import { streamSSE } from "hono/streaming";
-import { v4 as uuidv4 } from "uuid";
+import { v7 as uuidv7 } from "uuid";
 import * as schemas from "../schemas.mjs";
 import { z } from "zod/v3";
 import { streamState } from "../stream.mjs";
@@ -9,9 +9,9 @@ import { serialiseAsDict, serializeError } from "../utils/serde.mjs";
 import { getDisconnectAbortSignal, jsonExtra } from "../utils/hono.mjs";
 import { stateSnapshotToThreadState } from "../state.mjs";
 import { ensureContentType } from "../http/middleware.mjs";
-function createStubRun(threadId, payload) {
+function createStubRun(threadId, payload, overrides) {
     const now = new Date();
-    const runId = uuidv4();
+    const runId = uuidv7();
     let streamMode = Array.isArray(payload.stream_mode)
         ? payload.stream_mode
         : payload.stream_mode
@@ -41,7 +41,7 @@ function createStubRun(threadId, payload) {
         thread_id: threadId,
         assistant_id: payload.assistant_id,
         metadata: payload.metadata ?? {},
-        status: "running",
+        status: overrides?.status ?? "running",
         kwargs: {
             input: payload.input,
             command: payload.command,
@@ -54,7 +54,9 @@ function createStubRun(threadId, payload) {
             subgraphs: payload.stream_subgraphs,
             temporary: false,
         },
-        multitask_strategy: "reject",
+        multitask_strategy: (overrides?.multitask_strategy ??
+            payload.multitask_strategy ??
+            "reject"),
         created_at: now,
         updated_at: now,
     };
@@ -65,6 +67,32 @@ function createStubRun(threadId, payload) {
  * @experimental Does not follow semver.
  */
 export function createEmbedServer(options) {
+    const threadRunState = new Map();
+    function getThreadState(threadId) {
+        let state = threadRunState.get(threadId);
+        if (!state) {
+            state = { activeRunId: null, pendingRuns: [] };
+            threadRunState.set(threadId, state);
+        }
+        return state;
+    }
+    async function waitForRunReady(threadId, runId, signal) {
+        const state = getThreadState(threadId);
+        const run = state.pendingRuns.find((r) => r.run_id === runId);
+        if (!run)
+            return null;
+        while (true) {
+            if (signal?.aborted) {
+                throw new DOMException("Aborted", "AbortError");
+            }
+            const isHead = state.pendingRuns[0]?.run_id === runId;
+            const noActive = !state.activeRunId;
+            if (isHead && noActive)
+                break;
+            await new Promise((r) => setTimeout(r, 50));
+        }
+        return run;
+    }
     async function getGraph(graphId) {
         const targetGraph = options.graph[graphId];
         targetGraph.store = options.store;
@@ -76,7 +104,7 @@ export function createEmbedServer(options) {
     api.post("/threads", zValidator("json", schemas.ThreadCreate), async (c) => {
         // create a new thread
         const payload = c.req.valid("json");
-        const threadId = payload.thread_id || uuidv4();
+        const threadId = payload.thread_id || uuidv7();
         return jsonExtra(c, await options.threads.set(threadId, {
             kind: "put",
             metadata: payload.metadata,
@@ -222,16 +250,102 @@ export function createEmbedServer(options) {
         }
         return jsonExtra(c, result);
     });
+    api.post("/threads/:thread_id/runs", zValidator("param", z.object({ thread_id: z.string().uuid() })), zValidator("json", schemas.RunCreate), async (c) => {
+        const { thread_id } = c.req.valid("param");
+        const payload = c.req.valid("json");
+        const thread = await options.threads.get(thread_id);
+        if (thread == null)
+            return c.json({ error: "Thread not found" }, 404);
+        const state = getThreadState(thread_id);
+        const multitaskStrategy = payload.multitask_strategy ?? "reject";
+        const shouldEnqueue = multitaskStrategy === "enqueue" && state.activeRunId != null;
+        const run = createStubRun(thread_id, payload, {
+            status: shouldEnqueue ? "pending" : "running",
+            multitask_strategy: multitaskStrategy,
+        });
+        state.pendingRuns.push(run);
+        c.header("Content-Location", `/threads/${thread_id}/runs/${run.run_id}`);
+        return jsonExtra(c, run);
+    });
+    api.get("/threads/:thread_id/runs/:run_id/stream", zValidator("param", z.object({
+        thread_id: z.string().uuid(),
+        run_id: z.string().uuid(),
+    })), async (c) => {
+        const { thread_id, run_id } = c.req.valid("param");
+        const thread = await options.threads.get(thread_id);
+        if (thread == null)
+            return c.json({ error: "Thread not found" }, 404);
+        return streamSSE(c, async (stream) => {
+            const signal = getDisconnectAbortSignal(c, stream);
+            const state = getThreadState(thread_id);
+            try {
+                const run = await waitForRunReady(thread_id, run_id, signal);
+                if (!run) {
+                    await stream.writeSSE({
+                        data: serialiseAsDict({ error: "Run not found" }),
+                        event: "error",
+                    });
+                    return;
+                }
+                const idx = state.pendingRuns.findIndex((r) => r.run_id === run_id);
+                if (idx >= 0)
+                    state.pendingRuns.splice(idx, 1);
+                state.activeRunId = run_id;
+                run.status = "running";
+                try {
+                    for await (const { event, data } of streamState(run, {
+                        attempt: 1,
+                        getGraph,
+                        signal,
+                    })) {
+                        await stream.writeSSE({ data: serialiseAsDict(data), event });
+                    }
+                }
+                catch (error) {
+                    await stream.writeSSE({
+                        data: serialiseAsDict(serializeError(error)),
+                        event: "error",
+                    });
+                }
+                finally {
+                    if (state.activeRunId === run_id) {
+                        state.activeRunId = null;
+                    }
+                }
+            }
+            catch (err) {
+                if (err instanceof DOMException && err.name === "AbortError") {
+                    return;
+                }
+                throw err;
+            }
+        });
+    });
+    api.post("/threads/:thread_id/runs/:run_id/cancel", zValidator("param", z.object({
+        thread_id: z.string().uuid(),
+        run_id: z.string().uuid(),
+    })), async (c) => {
+        const { thread_id, run_id } = c.req.valid("param");
+        const state = getThreadState(thread_id);
+        const idx = state.pendingRuns.findIndex((r) => r.run_id === run_id);
+        if (idx >= 0) {
+            state.pendingRuns.splice(idx, 1);
+        }
+        return new Response(null, { status: 204 });
+    });
     api.post("/threads/:thread_id/runs/stream", zValidator("param", z.object({ thread_id: z.string().uuid() })), zValidator("json", schemas.RunCreate), async (c) => {
-        // Stream Run
+        // Stream Run (create + stream in one request)
         const { thread_id } = c.req.valid("param");
         const payload = c.req.valid("json");
         const thread = await options.threads.get(thread_id);
         if (thread == null)
             return c.json({ error: "Thread not found" }, 404);
+        const state = getThreadState(thread_id);
+        const run = createStubRun(thread_id, payload);
+        c.header("Content-Location", `/threads/${thread_id}/runs/${run.run_id}`);
         return streamSSE(c, async (stream) => {
             const signal = getDisconnectAbortSignal(c, stream);
-            const run = createStubRun(thread_id, payload);
+            state.activeRunId = run.run_id;
             await options.threads.set(thread_id, {
                 kind: "patch",
                 metadata: {
@@ -254,14 +368,21 @@ export function createEmbedServer(options) {
                     event: "error",
                 });
             }
+            finally {
+                if (state.activeRunId === run.run_id) {
+                    state.activeRunId = null;
+                }
+            }
         });
     });
     api.post("/runs/stream", zValidator("json", schemas.RunCreate), async (c) => {
         // Stream Stateless Run
+        const payload = c.req.valid("json");
+        const threadId = uuidv7();
+        const run = createStubRun(threadId, payload);
+        c.header("Content-Location", `/threads/${threadId}/runs/${run.run_id}`);
         return streamSSE(c, async (stream) => {
-            const payload = c.req.valid("json");
             const signal = getDisconnectAbortSignal(c, stream);
-            const threadId = uuidv4();
             await options.threads.set(threadId, {
                 kind: "put",
                 metadata: {
@@ -270,7 +391,6 @@ export function createEmbedServer(options) {
                 },
             });
             try {
-                const run = createStubRun(threadId, payload);
                 try {
                     for await (const { event, data } of streamState(run, {
                         attempt: 1,

package/dist/storage/ops.mjs

@@ -1,5 +1,5 @@
 import { HTTPException } from "hono/http-exception";
-import { v4 as uuid4, v5 as uuid5 } from "uuid";
+import { v7 as uuid7, v5 as uuid5 } from "uuid";
 import { handleAuthEvent, isAuthMatching } from "../auth/index.mjs";
 import { getLangGraphCommand } from "../command.mjs";
 import { getGraph, NAMESPACE_GRAPH } from "../graph/load.mjs";
@@ -650,7 +650,7 @@ export class FileSystemThreads {
             }
             return thread;
         });
-        const newThreadId = uuid4();
+        const newThreadId = uuid7();
         const now = new Date();
         const newMetadata = { ...fromThread.metadata, thread_id: newThreadId };
         await handleAuthEvent(auth, "threads:create", {
@@ -948,7 +948,7 @@ export class FileSystemRuns {
             }
             const now = new Date();
             if (!existingThread && (threadId == null || ifNotExists === "create")) {
-                threadId ??= uuid4();
+                threadId ??= uuid7();
                 const thread = {
                     thread_id: threadId,
                     status: "busy",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/langgraph-api",
-  "version": "1.1.14",
+  "version": "1.1.16",
   "type": "module",
   "engines": {
     "node": "^18.19.0 || >=20.16.0"
@@ -70,13 +70,13 @@
     "winston": "^3.17.0",
     "winston-console-format": "^1.0.8",
     "zod": "^3.25.76 || ^4",
-    "@langchain/langgraph-ui": "1.1.14"
+    "@langchain/langgraph-ui": "1.1.16"
   },
   "peerDependencies": {
     "@langchain/core": "^0.3.59 || ^1.0.1",
     "@langchain/langgraph": "^0.2.57 || ^0.3.0 || ^0.4.0 || ^1.0.0-alpha || ^1.0.0",
     "@langchain/langgraph-checkpoint": "~0.0.16 || ^0.1.0 || ~1.0.0",
-    "@langchain/langgraph-sdk": "~1.6.5",
+    "@langchain/langgraph-sdk": "^1.6.5",
     "typescript": "^5.5.4"
   },
   "peerDependenciesMeta": {
@@ -98,9 +98,9 @@
     "typescript": "^4.9.5 || ^5.4.5",
     "vitest": "^3.2.4",
     "wait-port": "^1.1.0",
-    "@langchain/langgraph": "1.2.0",
-    "@langchain/langgraph-checkpoint": "1.0.0",
-    "@langchain/langgraph-sdk": "1.6.5"
+    "@langchain/langgraph": "1.2.3",
+    "@langchain/langgraph-checkpoint": "1.0.1",
+    "@langchain/langgraph-sdk": "1.7.3"
   },
   "scripts": {
     "clean": "rm -rf dist/ .turbo/ ./tests/graphs/.langgraph_api/",