@langchain/langgraph-api 0.0.40 → 0.0.41

package/dist/api/runs.mjs

@@ -13,7 +13,7 @@ import { serialiseAsDict } from "../utils/serde.mjs";
 const api = new Hono();
 const createValidRun = async (threadId, payload, kwargs) => {
     const { assistant_id: assistantId, ...run } = payload;
-    const { auth, headers } = kwargs;
+    const { auth, headers } = kwargs ?? {};
     const runId = uuid4();
     const streamMode = Array.isArray(payload.stream_mode)
         ? payload.stream_mode

package/dist/api/threads.mjs

@@ -111,18 +111,7 @@ api.get("/threads/:thread_id/history", zValidator("param", z.object({ thread_id:
     const states = await Threads.State.list({ configurable: { thread_id, checkpoint_ns: "" } }, { limit, before }, c.var.auth);
     return jsonExtra(c, states.map(stateSnapshotToThreadState));
 });
-api.post("/threads/:thread_id/history", zValidator("param", z.object({ thread_id: z.string().uuid() })), zValidator("json", z.object({
-    limit: z.number().optional().default(10),
-    before: z.string().optional(),
-    metadata: z.record(z.string(), z.unknown()).optional(),
-    checkpoint: z
-        .object({
-        checkpoint_id: z.string().uuid().optional(),
-        checkpoint_ns: z.string().optional(),
-        checkpoint_map: z.record(z.string(), z.unknown()).optional(),
-    })
-        .optional(),
-})), async (c) => {
+api.post("/threads/:thread_id/history", zValidator("param", z.object({ thread_id: z.string().uuid() })), zValidator("json", schemas.ThreadHistoryRequest), async (c) => {
     // Get Thread History Post
     const { thread_id } = c.req.valid("param");
     const { limit, before, metadata, checkpoint } = c.req.valid("json");
@@ -140,7 +129,7 @@ api.delete("/threads/:thread_id", zValidator("param", z.object({ thread_id: z.st
     await Threads.delete(thread_id, c.var.auth);
     return new Response(null, { status: 204 });
 });
-api.patch("/threads/:thread_id", zValidator("param", z.object({ thread_id: z.string().uuid() })), zValidator("json", z.object({ metadata: z.record(z.string(), z.unknown()) })), async (c) => {
+api.patch("/threads/:thread_id", zValidator("param", z.object({ thread_id: z.string().uuid() })), zValidator("json", schemas.ThreadPatchRequest), async (c) => {
     // Patch Thread
     const { thread_id } = c.req.valid("param");
     const { metadata } = c.req.valid("json");

package/dist/experimental/embed.d.mts

@@ -0,0 +1,26 @@
+import type { BaseCheckpointSaver, BaseStore, Pregel } from "@langchain/langgraph";
+import { Hono } from "hono";
+import type { Metadata } from "../storage/ops.mjs";
+type AnyPregel = Pregel<any, any, any, any, any>;
+interface Thread {
+    thread_id: string;
+    metadata: Metadata;
+}
+interface ThreadSaver {
+    get: (id: string) => Promise<Thread>;
+    put: (id: string, options: {
+        metadata?: Metadata;
+    }) => Promise<void>;
+    delete: (id: string) => Promise<void>;
+}
+/**
+ * Attach LangGraph Platform-esque routes to a given Hono instance.
+ * @experimental Does not follow semver.
+ */
+export declare function createEmbedServer(options: {
+    graph: Record<string, AnyPregel>;
+    threads: ThreadSaver;
+    checkpointer: BaseCheckpointSaver;
+    store?: BaseStore;
+}): Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+export {};

package/dist/experimental/embed.mjs

@@ -0,0 +1,167 @@
+import { Hono } from "hono";
+import { zValidator } from "@hono/zod-validator";
+import { streamSSE } from "hono/streaming";
+import { v4 as uuidv4 } from "uuid";
+import * as schemas from "../schemas.mjs";
+import { z } from "zod";
+import { streamState } from "../stream.mjs";
+import { serialiseAsDict } 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) {
+    const now = new Date();
+    const runId = uuidv4();
+    const streamMode = Array.isArray(payload.stream_mode)
+        ? payload.stream_mode
+        : payload.stream_mode
+            ? [payload.stream_mode]
+            : undefined;
+    const config = Object.assign({}, payload.config ?? {}, {
+        configurable: {
+            run_id: runId,
+            thread_id: threadId,
+            graph_id: payload.assistant_id,
+        },
+    }, { metadata: payload.metadata ?? {} });
+    return {
+        run_id: runId,
+        thread_id: threadId,
+        assistant_id: payload.assistant_id,
+        metadata: payload.metadata ?? {},
+        status: "running",
+        kwargs: {
+            input: payload.input,
+            command: payload.command,
+            config,
+            stream_mode: streamMode,
+            interrupt_before: payload.interrupt_before,
+            interrupt_after: payload.interrupt_after,
+            feedback_keys: payload.feedback_keys,
+            subgraphs: payload.stream_subgraphs,
+            temporary: false,
+        },
+        multitask_strategy: "reject",
+        created_at: now,
+        updated_at: now,
+    };
+}
+/**
+ * Attach LangGraph Platform-esque routes to a given Hono instance.
+ * @experimental Does not follow semver.
+ */
+export function createEmbedServer(options) {
+    async function getGraph(graphId) {
+        const targetGraph = options.graph[graphId];
+        targetGraph.store = options.store;
+        targetGraph.checkpointer = options.checkpointer;
+        return targetGraph;
+    }
+    const api = new Hono();
+    api.use(ensureContentType());
+    api.post("/threads", zValidator("json", schemas.ThreadCreate), async (c) => {
+        // create a new threaad
+        const payload = c.req.valid("json");
+        const threadId = payload.thread_id || uuidv4();
+        await options.threads.put(threadId, payload);
+        return jsonExtra(c, { thread_id: threadId });
+    });
+    api.get("/threads/:thread_id/state", zValidator("param", z.object({ thread_id: z.string().uuid() })), zValidator("query", z.object({ subgraphs: schemas.coercedBoolean.optional() })), async (c) => {
+        // Get Latest Thread State
+        const { thread_id } = c.req.valid("param");
+        const { subgraphs } = c.req.valid("query");
+        const thread = await options.threads.get(thread_id);
+        const graphId = thread.metadata?.graph_id;
+        const graph = graphId ? options.graph[graphId] : undefined;
+        if (graph == null) {
+            return jsonExtra(c, stateSnapshotToThreadState({
+                values: {},
+                next: [],
+                config: {},
+                metadata: undefined,
+                createdAt: undefined,
+                parentConfig: undefined,
+                tasks: [],
+            }));
+        }
+        const config = { configurable: { thread_id } };
+        const result = await graph.getState(config, { subgraphs });
+        return jsonExtra(c, stateSnapshotToThreadState(result));
+    });
+    api.post("/threads/:thread_id/history", zValidator("param", z.object({ thread_id: z.string().uuid() })), zValidator("json", schemas.ThreadHistoryRequest), async (c) => {
+        // Get Thread History Post
+        const { thread_id } = c.req.valid("param");
+        const { limit, before, metadata, checkpoint } = c.req.valid("json");
+        const thread = await options.threads.get(thread_id);
+        const graphId = thread.metadata?.graph_id;
+        const graph = graphId ? options.graph[graphId] : undefined;
+        if (graph == null)
+            return jsonExtra(c, []);
+        const config = { configurable: { thread_id, ...checkpoint } };
+        const result = [];
+        const beforeConfig = typeof before === "string"
+            ? { configurable: { checkpoint_id: before } }
+            : before;
+        for await (const state of graph.getStateHistory(config, {
+            limit,
+            before: beforeConfig,
+            filter: metadata,
+        })) {
+            result.push(stateSnapshotToThreadState(state));
+        }
+        return jsonExtra(c, result);
+    });
+    api.post("/threads/:thread_id/runs/stream", zValidator("param", z.object({ thread_id: z.string().uuid() })), zValidator("json", schemas.RunCreate), async (c) => {
+        // Stream Run
+        return streamSSE(c, async (stream) => {
+            const { thread_id } = c.req.valid("param");
+            const payload = c.req.valid("json");
+            const signal = getDisconnectAbortSignal(c, stream);
+            const run = createStubRun(thread_id, payload);
+            // update thread with new graph_id
+            const thread = await options.threads.get(thread_id);
+            await options.threads.put(thread_id, {
+                metadata: {
+                    ...thread.metadata,
+                    graph_id: payload.assistant_id,
+                    assistant_id: payload.assistant_id,
+                },
+            });
+            for await (const { event, data } of streamState(run, {
+                attempt: 1,
+                getGraph,
+                signal,
+            })) {
+                await stream.writeSSE({ data: serialiseAsDict(data), event });
+            }
+        });
+    });
+    api.post("/runs/stream", zValidator("json", schemas.RunCreate), async (c) => {
+        // Stream Stateless Run
+        return streamSSE(c, async (stream) => {
+            const payload = c.req.valid("json");
+            const signal = getDisconnectAbortSignal(c, stream);
+            const threadId = uuidv4();
+            await options.threads.put(threadId, {
+                metadata: {
+                    graph_id: payload.assistant_id,
+                    assistant_id: payload.assistant_id,
+                },
+            });
+            try {
+                const run = createStubRun(threadId, payload);
+                for await (const { event, data } of streamState(run, {
+                    attempt: 1,
+                    getGraph,
+                    signal,
+                })) {
+                    await stream.writeSSE({ data: serialiseAsDict(data), event });
+                }
+            }
+            finally {
+                await options.threads.delete(threadId);
+            }
+        });
+    });
+    return api;
+}

package/dist/queue.mjs

@@ -3,6 +3,7 @@ import { streamState, } from "./stream.mjs";
 import { logError, logger } from "./logging.mjs";
 import { serializeError } from "./utils/serde.mjs";
 import { callWebhook } from "./webhook.mjs";
+import { getGraph } from "./graph/load.mjs";
 const MAX_RETRY_ATTEMPTS = 3;
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 export const queue = async () => {
@@ -14,7 +15,7 @@ export const queue = async () => {
         await sleep(1000 * Math.random());
     }
 };
-const worker = async (run, attempt, abortSignal) => {
+const worker = async (run, attempt, signal) => {
     const startedAt = new Date();
     let endedAt = undefined;
     let checkpoint = undefined;
@@ -48,8 +49,10 @@ const worker = async (run, attempt, abortSignal) => {
         const runId = run.run_id;
         const resumable = run.kwargs?.resumable ?? false;
         try {
-            const stream = streamState(run, attempt, {
-                signal: abortSignal,
+            const stream = streamState(run, {
+                getGraph,
+                attempt,
+                signal,
                 ...(!temporary ? { onCheckpoint, onTaskResult } : undefined),
             });
             for await (const { event, data } of stream) {

package/dist/schemas.d.mts

@@ -1340,6 +1340,49 @@ export declare const ThreadStateUpdate: z.ZodObject<{
     checkpoint_id?: string | undefined;
     as_node?: string | undefined;
 }>;
+export declare const ThreadHistoryRequest: z.ZodObject<{
+    limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    before: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    checkpoint: z.ZodOptional<z.ZodObject<{
+        checkpoint_id: z.ZodOptional<z.ZodString>;
+        checkpoint_ns: z.ZodOptional<z.ZodString>;
+        checkpoint_map: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        checkpoint_ns?: string | undefined;
+        checkpoint_id?: string | undefined;
+        checkpoint_map?: Record<string, unknown> | undefined;
+    }, {
+        checkpoint_ns?: string | undefined;
+        checkpoint_id?: string | undefined;
+        checkpoint_map?: Record<string, unknown> | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    limit: number;
+    metadata?: Record<string, unknown> | undefined;
+    checkpoint?: {
+        checkpoint_ns?: string | undefined;
+        checkpoint_id?: string | undefined;
+        checkpoint_map?: Record<string, unknown> | undefined;
+    } | undefined;
+    before?: string | undefined;
+}, {
+    metadata?: Record<string, unknown> | undefined;
+    checkpoint?: {
+        checkpoint_ns?: string | undefined;
+        checkpoint_id?: string | undefined;
+        checkpoint_map?: Record<string, unknown> | undefined;
+    } | undefined;
+    limit?: number | undefined;
+    before?: string | undefined;
+}>;
+export declare const ThreadPatchRequest: z.ZodObject<{
+    metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    metadata: Record<string, unknown>;
+}, {
+    metadata: Record<string, unknown>;
+}>;
 export declare const AssistantLatestVersion: z.ZodObject<{
     version: z.ZodNumber;
 }, "strip", z.ZodTypeAny, {

package/dist/schemas.mjs

@@ -388,6 +388,21 @@ export const ThreadStateUpdate = z
     as_node: z.string().optional(),
 })
     .describe("Payload for adding state to a thread.");
+export const ThreadHistoryRequest = z.object({
+    limit: z.number().optional().default(10),
+    before: z.string().optional(),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+    checkpoint: z
+        .object({
+        checkpoint_id: z.string().uuid().optional(),
+        checkpoint_ns: z.string().optional(),
+        checkpoint_map: z.record(z.string(), z.unknown()).optional(),
+    })
+        .optional(),
+});
+export const ThreadPatchRequest = z.object({
+    metadata: z.record(z.string(), z.unknown()),
+});
 export const AssistantLatestVersion = z.object({
     version: z.number(),
 });

package/dist/storage/ops.mjs

@@ -744,27 +744,37 @@ export class Runs {
     static async *next() {
         yield* conn.withGenerator(async function* (STORE, options) {
             const now = new Date();
-            const pendingRuns = Object.values(STORE.runs)
+            const pendingRunIds = Object.values(STORE.runs)
                 .filter((run) => run.status === "pending" && run.created_at < now)
-                .sort((a, b) => a.created_at.getTime() - b.created_at.getTime());
-            if (!pendingRuns.length) {
+                .sort((a, b) => a.created_at.getTime() - b.created_at.getTime())
+                .map((run) => run.run_id);
+            if (!pendingRunIds.length) {
                 return;
             }
-            for (const run of pendingRuns) {
-                const runId = run.run_id;
-                const threadId = run.thread_id;
-                const thread = STORE.threads[threadId];
-                if (!thread) {
-                    await console.warn(`Unexpected missing thread in Runs.next: ${threadId}`);
-                    continue;
-                }
+            for (const runId of pendingRunIds) {
                 if (StreamManager.isLocked(runId))
                     continue;
                 try {
                     const signal = StreamManager.lock(runId);
+                    const run = STORE.runs[runId];
+                    if (!run)
+                        continue;
+                    const threadId = run.thread_id;
+                    const thread = STORE.threads[threadId];
+                    if (!thread) {
+                        logger.warn(`Unexpected missing thread in Runs.next: ${threadId}`);
+                        continue;
+                    }
+                    // is the run still valid?
+                    if (run.status !== "pending")
+                        continue;
+                    if (Object.values(STORE.runs).some((run) => run.thread_id === threadId && run.status === "running")) {
+                        continue;
+                    }
                     options.schedulePersist();
                     STORE.retry_counter[runId] ??= 0;
                     STORE.retry_counter[runId] += 1;
+                    STORE.runs[runId].status = "running";
                     yield { run, attempt: STORE.retry_counter[runId], signal };
                 }
                 finally {
@@ -842,7 +852,8 @@ export class Runs {
             }
             // if multitask_mode = reject, check for inflight runs
             // and if there are any, return them to reject putting a new run
-            const inflightRuns = Object.values(STORE.runs).filter((run) => run.thread_id === threadId && run.status === "pending");
+            const inflightRuns = Object.values(STORE.runs).filter((run) => run.thread_id === threadId &&
+                (run.status === "pending" || run.status === "running"));
             if (options?.preventInsertInInflight) {
                 if (inflightRuns.length > 0)
                     return inflightRuns;
@@ -1090,7 +1101,7 @@ export class Runs {
                                 yield { event: "error", data: "Run not found" };
                             break;
                         }
-                        else if (run.status !== "pending") {
+                        else if (run.status !== "pending" && run.status !== "running") {
                             break;
                         }
                     }

package/dist/stream.d.mts

@@ -1,4 +1,5 @@
-import { type CheckpointMetadata, type Interrupt, type StateSnapshot } from "@langchain/langgraph";
+import type { BaseCheckpointSaver, LangGraphRunnableConfig, CheckpointMetadata, Interrupt, StateSnapshot } from "@langchain/langgraph";
+import type { Pregel } from "@langchain/langgraph/pregel";
 import type { Checkpoint, Run, RunnableConfig } from "./storage/ops.mjs";
 interface DebugTask {
     id: string;
@@ -27,7 +28,11 @@ export type StreamTaskResult = Prettify<Omit<DebugTask, "state"> & {
     state?: StateSnapshot;
     checkpoint?: Checkpoint;
 }>;
-export declare function streamState(run: Run, attempt?: number, options?: {
+export declare function streamState(run: Run, options: {
+    attempt: number;
+    getGraph: (graphId: string, config: LangGraphRunnableConfig | undefined, options?: {
+        checkpointer?: BaseCheckpointSaver | null;
+    }) => Promise<Pregel<any, any, any, any, any>>;
     onCheckpoint?: (checkpoint: StreamCheckpoint) => void;
     onTaskResult?: (taskResult: StreamTaskResult) => void;
     signal?: AbortSignal;

package/dist/stream.mjs

@@ -2,7 +2,6 @@ import { isBaseMessage } from "@langchain/core/messages";
 import { LangChainTracer } from "@langchain/core/tracers/tracer_langchain";
 import { Client as LangSmithClient, getDefaultProjectName } from "langsmith";
 import { getLangGraphCommand } from "./command.mjs";
-import { getGraph } from "./graph/load.mjs";
 import { checkLangGraphSemver } from "./semver/index.mjs";
 import { runnableConfigToCheckpoint, taskRunnableConfigToCheckpoint, } from "./utils/runnableConfig.mjs";
 const isRunnableConfig = (config) => {
@@ -54,13 +53,13 @@ function preprocessDebugCheckpoint(payload) {
     return result;
 }
 let LANGGRAPH_VERSION;
-export async function* streamState(run, attempt = 1, options) {
+export async function* streamState(run, options) {
     const kwargs = run.kwargs;
     const graphId = kwargs.config?.configurable?.graph_id;
     if (!graphId || typeof graphId !== "string") {
         throw new Error("Invalid or missing graph_id");
     }
-    const graph = await getGraph(graphId, kwargs.config, {
+    const graph = await options.getGraph(graphId, kwargs.config, {
         checkpointer: kwargs.temporary ? null : undefined,
     });
     const userStreamMode = kwargs.stream_mode ?? [];
@@ -75,7 +74,7 @@ export async function* streamState(run, attempt = 1, options) {
         libStreamMode.add("debug");
     yield {
         event: "metadata",
-        data: { run_id: run.run_id, attempt },
+        data: { run_id: run.run_id, attempt: options.attempt },
     };
     if (!LANGGRAPH_VERSION) {
         const version = await checkLangGraphSemver();
@@ -83,7 +82,7 @@ export async function* streamState(run, attempt = 1, options) {
     }
     const metadata = {
         ...kwargs.config?.metadata,
-        run_attempt: attempt,
+        run_attempt: options.attempt,
         langgraph_version: LANGGRAPH_VERSION?.version ?? "0.0.0",
         langgraph_plan: "developer",
         langgraph_host: "self-hosted",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/langgraph-api",
-  "version": "0.0.40",
+  "version": "0.0.41",
   "type": "module",
   "engines": {
     "node": "^18.19.0 || >=20.16.0"
@@ -27,6 +27,10 @@
       "types": "./dist/graph/parser/index.d.mts",
       "default": "./dist/graph/parser/index.mjs"
     },
+    "./experimental/embed": {
+      "types": "./dist/experimental/embed.d.mts",
+      "default": "./dist/experimental/embed.mjs"
+    },
     "./package.json": "./package.json"
   },
   "repository": {
@@ -49,7 +53,7 @@
     "@babel/code-frame": "^7.26.2",
     "@hono/node-server": "^1.12.0",
     "@hono/zod-validator": "^0.2.2",
-    "@langchain/langgraph-ui": "0.0.40",
+    "@langchain/langgraph-ui": "0.0.41",
     "@types/json-schema": "^7.0.15",
     "@typescript/vfs": "^1.6.0",
     "dedent": "^1.5.3",