@langchain/langgraph-cli 0.0.0-preview.4

package/README.md

@@ -0,0 +1,24 @@
+# LangGraph.js API
+
+This package implements the LangGraph API for rapid development and testing. Build and iterate on LangGraph.js agents with a tight feedback loop. The server is backed by a predominently in-memory data store that is persisted to local disk.
+
+For production use, see the various [deployment options](https://langchain-ai.github.io/langgraph/concepts/deployment_options/) for the LangGraph API, which are backed by a production-grade database.
+
+## Installation
+
+Install the `@langchain/langgraph-api` package via your package manager of choice.
+
+```bash
+npm install @langchain/langgraph-api
+```
+
+## Usage
+
+Start the development server:
+
+```bash
+npm run langgraph dev
+```
+
+Your agent's state (threads, runs, assistants, store) persists in memory while the server is running - perfect for development and testing. Each run's state is tracked and can be inspected, making it easy to debug and improve your agent's behavior.
+

package/dist/api/assistants.mjs

@@ -0,0 +1,144 @@
+import { Hono } from "hono";
+import { zValidator } from "@hono/zod-validator";
+import { v4 as uuid } from "uuid";
+import { z } from "zod";
+import { getAssistantId, getGraph, getGraphSchema } from "../graph/load.mjs";
+import { Assistants } from "../storage/ops.mjs";
+import * as schemas from "../schemas.mjs";
+import { HTTPException } from "hono/http-exception";
+const api = new Hono();
+api.post("/assistants", zValidator("json", schemas.AssistantCreate), async (c) => {
+    // Create Assistant
+    const payload = c.req.valid("json");
+    const assistant = await Assistants.put(payload.assistant_id ?? uuid(), {
+        config: payload.config ?? {},
+        graph_id: payload.graph_id,
+        metadata: payload.metadata ?? {},
+        if_exists: payload.if_exists ?? "raise",
+        name: payload.name ?? "Untitled",
+    });
+    return c.json(assistant);
+});
+api.post("/assistants/search", zValidator("json", schemas.AssistantSearchRequest), async (c) => {
+    // Search Assistants
+    const payload = c.req.valid("json");
+    const result = [];
+    for await (const item of Assistants.search({
+        graph_id: payload.graph_id,
+        metadata: payload.metadata,
+        limit: payload.limit ?? 10,
+        offset: payload.offset ?? 0,
+    })) {
+        result.push(item);
+    }
+    return c.json(result);
+});
+api.get("/assistants/:assistant_id", async (c) => {
+    // Get Assistant
+    const assistantId = getAssistantId(c.req.param("assistant_id"));
+    return c.json(await Assistants.get(assistantId));
+});
+api.delete("/assistants/:assistant_id", async (c) => {
+    // Delete Assistant
+    const assistantId = getAssistantId(c.req.param("assistant_id"));
+    return c.json(await Assistants.delete(assistantId));
+});
+api.patch("/assistants/:assistant_id", zValidator("json", schemas.AssistantPatch), async (c) => {
+    // Patch Assistant
+    const assistantId = getAssistantId(c.req.param("assistant_id"));
+    const payload = c.req.valid("json");
+    return c.json(await Assistants.patch(assistantId, payload));
+});
+const RunnableConfigSchema = z.object({
+    tags: z.array(z.string()).optional(),
+    metadata: z.record(z.unknown()).optional(),
+    run_name: z.string().optional(),
+    max_concurrency: z.number().optional(),
+    recursion_limit: z.number().optional(),
+    configurable: z.record(z.unknown()).optional(),
+    run_id: z.string().uuid().optional(),
+});
+const getRunnableConfig = (userConfig) => {
+    if (!userConfig)
+        return {};
+    return {
+        configurable: userConfig.configurable,
+        tags: userConfig.tags,
+        metadata: userConfig.metadata,
+        runName: userConfig.run_name,
+        maxConcurrency: userConfig.max_concurrency,
+        recursionLimit: userConfig.recursion_limit,
+        runId: userConfig.run_id,
+    };
+};
+api.get("/assistants/:assistant_id/graph", zValidator("query", z.object({ xray: schemas.coercedBoolean.optional() })), async (c) => {
+    // Get Assistant Graph
+    const assistantId = getAssistantId(c.req.param("assistant_id"));
+    const assistant = await Assistants.get(assistantId);
+    const { xray } = c.req.valid("query");
+    const graph = getGraph(assistant.graph_id);
+    return c.json(graph.getGraph({ ...getRunnableConfig(assistant.config), xray }).toJSON());
+});
+api.get("/assistants/:assistant_id/schemas", async (c) => {
+    // Get Assistant Schemas
+    const assistantId = getAssistantId(c.req.param("assistant_id"));
+    const assistant = await Assistants.get(assistantId);
+    const graphSchema = await getGraphSchema(assistant.graph_id);
+    const rootGraphId = Object.keys(graphSchema).find((i) => !i.includes("|"));
+    if (!rootGraphId)
+        throw new Error("Failed to find root graph");
+    const rootGraphSchema = graphSchema[rootGraphId];
+    return c.json({
+        graph_id: assistant.graph_id,
+        input_schema: rootGraphSchema.input,
+        output_schema: rootGraphSchema.output,
+        state_schema: rootGraphSchema.state,
+        config_schema: rootGraphSchema.config,
+    });
+});
+api.get("/assistants/:assistant_id/subgraphs/:namespace?", zValidator("param", z.object({ assistant_id: z.string(), namespace: z.string().optional() })), zValidator("query", z.object({ recurse: schemas.coercedBoolean.optional() })), async (c) => {
+    // Get Assistant Subgraphs
+    const { assistant_id, namespace } = c.req.valid("param");
+    const { recurse } = c.req.valid("query");
+    const assistantId = getAssistantId(assistant_id);
+    const assistant = await Assistants.get(assistantId);
+    const graph = getGraph(assistant.graph_id);
+    const graphSchema = await getGraphSchema(assistant.graph_id);
+    const rootGraphId = Object.keys(graphSchema).find((i) => !i.includes("|"));
+    if (!rootGraphId) {
+        throw new HTTPException(404, { message: "Failed to find root graph" });
+    }
+    const result = [];
+    const subgraphsGenerator = "getSubgraphsAsync" in graph
+        ? graph.getSubgraphsAsync.bind(graph)
+        : // @ts-expect-error older versions of langgraph don't have getSubgraphsAsync
+            graph.getSubgraphs.bind(graph);
+    for await (const [ns] of subgraphsGenerator(namespace, recurse)) {
+        result.push([
+            ns,
+            graphSchema[`${rootGraphId}|${ns}`] || graphSchema[rootGraphId],
+        ]);
+    }
+    return c.json(Object.fromEntries(result));
+});
+api.post("/assistants/:assistant_id/latest", zValidator("json", schemas.AssistantLatestVersion), async (c) => {
+    // Set Latest Assistant Version
+    const assistantId = getAssistantId(c.req.param("assistant_id"));
+    const { version } = c.req.valid("json");
+    return c.json(await Assistants.setLatest(assistantId, version));
+});
+api.post("/assistants/:assistant_id/versions", zValidator("json", z.object({
+    limit: z.number().min(1).max(1000).optional().default(10),
+    offset: z.number().min(0).optional().default(0),
+    metadata: z.record(z.unknown()).optional(),
+})), async (c) => {
+    // Get Assistant Versions
+    const assistantId = getAssistantId(c.req.param("assistant_id"));
+    const { limit, offset, metadata } = c.req.valid("json");
+    return c.json(await Assistants.getVersions(assistantId, {
+        limit,
+        offset,
+        metadata,
+    }));
+});
+export default api;

package/dist/api/runs.mjs

@@ -0,0 +1,239 @@
+import { Hono } from "hono";
+import { HTTPException } from "hono/http-exception";
+import { streamSSE } from "hono/streaming";
+import { getAssistantId } from "../graph/load.mjs";
+import { zValidator } from "@hono/zod-validator";
+import * as schemas from "../schemas.mjs";
+import { z } from "zod";
+import { Runs, Threads } from "../storage/ops.mjs";
+import { serialiseAsDict } from "../utils/serde.mjs";
+import { getDisconnectAbortSignal, jsonExtra, waitKeepAlive, } from "../utils/hono.mjs";
+import { logger } from "../logging.mjs";
+import { v4 as uuid4 } from "uuid";
+const api = new Hono();
+const createValidRun = async (threadId, payload) => {
+    const { assistant_id: assistantId, ...run } = payload;
+    const runId = uuid4();
+    const streamMode = Array.isArray(payload.stream_mode)
+        ? payload.stream_mode
+        : payload.stream_mode != null
+            ? [payload.stream_mode]
+            : [];
+    if (streamMode.length === 0)
+        streamMode.push("values");
+    const multitaskStrategy = payload.multitask_strategy ?? "reject";
+    const preventInsertInInflight = multitaskStrategy === "reject";
+    const config = { ...run.config };
+    if (run.checkpoint_id) {
+        config.configurable ??= {};
+        config.configurable.checkpoint_id = run.checkpoint_id;
+    }
+    if (run.checkpoint) {
+        config.configurable ??= {};
+        Object.assign(config.configurable, run.checkpoint);
+    }
+    let feedbackKeys = run.feedback_keys != null
+        ? Array.isArray(run.feedback_keys)
+            ? run.feedback_keys
+            : [run.feedback_keys]
+        : undefined;
+    if (!feedbackKeys?.length)
+        feedbackKeys = undefined;
+    const [first, ...inflight] = await Runs.put(runId, getAssistantId(assistantId), {
+        input: run.input,
+        command: run.command,
+        config,
+        stream_mode: streamMode,
+        interrupt_before: run.interrupt_before,
+        interrupt_after: run.interrupt_after,
+        webhook: run.webhook,
+        feedback_keys: feedbackKeys,
+        temporary: threadId == null && (run.on_completion ?? "delete") === "delete",
+        subgraphs: run.stream_subgraphs ?? false,
+    }, {
+        threadId,
+        metadata: run.metadata,
+        status: "pending",
+        multitaskStrategy,
+        preventInsertInInflight,
+        afterSeconds: payload.after_seconds,
+        ifNotExists: payload.if_not_exists,
+    });
+    if (first?.run_id === runId) {
+        logger.info("Created run", { run_id: runId, thread_id: threadId });
+        if ((multitaskStrategy === "interrupt" || multitaskStrategy === "rollback") &&
+            inflight.length > 0) {
+            try {
+                await Runs.cancel(threadId, inflight.map((run) => run.run_id), { action: multitaskStrategy });
+            }
+            catch (error) {
+                logger.warn("Failed to cancel inflight runs, might be already cancelled", {
+                    error,
+                    run_ids: inflight.map((run) => run.run_id),
+                    thread_id: threadId,
+                });
+            }
+        }
+        return first;
+    }
+    else if (multitaskStrategy === "reject") {
+        throw new HTTPException(422, {
+            message: "Thread is already running a task. Wait for it to finish or choose a different multitask strategy.",
+        });
+    }
+    throw new HTTPException(500, {
+        message: "Unreachable state when creating run",
+    });
+};
+api.post("/runs/crons", zValidator("json", schemas.CronCreate), async () => {
+    // Create Thread Cron
+    throw new HTTPException(500, { message: "Not implemented" });
+});
+api.post("/runs/crons/search", zValidator("json", schemas.CronSearch), async () => {
+    // Search Crons
+    throw new HTTPException(500, { message: "Not implemented" });
+});
+api.delete("/runs/crons/:cron_id", zValidator("param", z.object({ cron_id: z.string().uuid() })), async () => {
+    // Delete Cron
+    throw new HTTPException(500, { message: "Not implemented" });
+});
+api.post("/threads/:thread_id/runs/crons", zValidator("param", z.object({ thread_id: z.string().uuid() })), zValidator("json", schemas.CronCreate), async () => {
+    // Create Thread Cron
+    throw new HTTPException(500, { message: "Not implemented" });
+});
+api.post("/runs/stream", zValidator("json", schemas.RunCreate), async (c) => {
+    // Stream Run
+    const payload = c.req.valid("json");
+    const run = await createValidRun(undefined, payload);
+    return streamSSE(c, async (stream) => {
+        const cancelOnDisconnect = payload.on_disconnect === "cancel"
+            ? getDisconnectAbortSignal(c, stream)
+            : undefined;
+        try {
+            for await (const { event, data } of Runs.Stream.join(run.run_id, undefined, { cancelOnDisconnect })) {
+                await stream.writeSSE({ data: serialiseAsDict(data), event });
+            }
+        }
+        catch (error) {
+            logger.error("Error streaming run", { error });
+        }
+    });
+});
+api.post("/runs/wait", zValidator("json", schemas.RunCreate), async (c) => {
+    // Wait Run
+    const payload = c.req.valid("json");
+    const run = await createValidRun(undefined, payload);
+    return waitKeepAlive(c, Runs.wait(run.run_id, undefined));
+});
+api.post("/runs", zValidator("json", schemas.RunCreate), async (c) => {
+    // Create Stateless Run
+    const payload = c.req.valid("json");
+    const run = await createValidRun(undefined, payload);
+    return jsonExtra(c, run);
+});
+api.post("/runs/batch", zValidator("json", schemas.RunBatchCreate), async (c) => {
+    // Batch Runs
+    const payload = c.req.valid("json");
+    const runs = await Promise.all(payload.map((run) => createValidRun(undefined, run)));
+    return jsonExtra(c, runs);
+});
+api.get("/threads/:thread_id/runs", zValidator("param", z.object({ thread_id: z.string().uuid() })), zValidator("query", z.object({
+    limit: z.coerce.number().nullish(),
+    offset: z.coerce.number().nullish(),
+    status: z.string().nullish(),
+    metadata: z.record(z.string(), z.unknown()).nullish(),
+})), async (c) => {
+    // List runs
+    const { thread_id } = c.req.valid("param");
+    const { limit, offset, status, metadata } = c.req.valid("query");
+    const [runs] = await Promise.all([
+        Runs.search(thread_id, {
+            limit,
+            offset,
+            status,
+            metadata,
+        }),
+        Threads.get(thread_id),
+    ]);
+    return jsonExtra(c, runs);
+});
+api.post("/threads/:thread_id/runs", zValidator("param", z.object({ thread_id: z.string().uuid() })), zValidator("json", schemas.RunCreate), async (c) => {
+    // Create Run
+    const { thread_id } = c.req.valid("param");
+    const payload = c.req.valid("json");
+    const run = await createValidRun(thread_id, payload);
+    return jsonExtra(c, run);
+});
+api.post("/threads/:thread_id/runs/stream", zValidator("param", z.object({ thread_id: z.string().uuid() })), zValidator("json", schemas.RunCreate), async (c) => {
+    // Stream Run
+    const { thread_id } = c.req.valid("param");
+    const payload = c.req.valid("json");
+    const run = await createValidRun(thread_id, payload);
+    return streamSSE(c, async (stream) => {
+        const cancelOnDisconnect = payload.on_disconnect === "cancel"
+            ? getDisconnectAbortSignal(c, stream)
+            : undefined;
+        try {
+            for await (const { event, data } of Runs.Stream.join(run.run_id, thread_id, { cancelOnDisconnect })) {
+                await stream.writeSSE({ data: serialiseAsDict(data), event });
+            }
+        }
+        catch (error) {
+            logger.error("Error streaming run", { error });
+        }
+    });
+});
+api.post("/threads/:thread_id/runs/wait", zValidator("param", z.object({ thread_id: z.string().uuid() })), zValidator("json", schemas.RunCreate), async (c) => {
+    // Wait Run
+    const { thread_id } = c.req.valid("param");
+    const payload = c.req.valid("json");
+    const run = await createValidRun(thread_id, payload);
+    return waitKeepAlive(c, Runs.join(run.run_id, thread_id));
+});
+api.get("/threads/:thread_id/runs/:run_id", 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 [run] = await Promise.all([
+        Runs.get(run_id, thread_id),
+        Threads.get(thread_id),
+    ]);
+    return jsonExtra(c, run);
+});
+api.delete("/threads/:thread_id/runs/:run_id", zValidator("param", z.object({ thread_id: z.string().uuid(), run_id: z.string().uuid() })), async (c) => {
+    // Delete Run
+    const { thread_id, run_id } = c.req.valid("param");
+    await Runs.delete(run_id, thread_id);
+    return c.body(null, 204);
+});
+api.get("/threads/:thread_id/runs/:run_id/join", zValidator("param", z.object({ thread_id: z.string().uuid(), run_id: z.string().uuid() })), async (c) => {
+    // Join Run Http
+    const { thread_id, run_id } = c.req.valid("param");
+    return jsonExtra(c, await Runs.join(run_id, thread_id));
+});
+api.get("/threads/:thread_id/runs/:run_id/stream", zValidator("param", z.object({ thread_id: z.string().uuid(), run_id: z.string().uuid() })), zValidator("query", z.object({ cancel_on_disconnect: schemas.coercedBoolean.optional() })), async (c) => {
+    // Stream Run Http
+    const { thread_id, run_id } = c.req.valid("param");
+    const { cancel_on_disconnect } = c.req.valid("query");
+    return streamSSE(c, async (stream) => {
+        const signal = cancel_on_disconnect
+            ? getDisconnectAbortSignal(c, stream)
+            : undefined;
+        for await (const { event, data } of Runs.Stream.join(run_id, thread_id, {
+            cancelOnDisconnect: signal,
+        })) {
+            await stream.writeSSE({ data: serialiseAsDict(data), event });
+        }
+    });
+});
+api.post("/threads/:thread_id/runs/:run_id/cancel", zValidator("param", z.object({ thread_id: z.string().uuid(), run_id: z.string().uuid() })), zValidator("query", z.object({
+    wait: z.coerce.boolean().optional().default(false),
+    action: z.enum(["interrupt", "rollback"]).optional().default("interrupt"),
+})), async (c) => {
+    // Cancel Run Http
+    const { thread_id, run_id } = c.req.valid("param");
+    const { wait, action } = c.req.valid("query");
+    await Runs.cancel(thread_id, [run_id], { action });
+    if (wait)
+        await Runs.join(run_id, thread_id);
+    return c.body(null, wait ? 204 : 202);
+});
+export default api;

package/dist/api/store.mjs

@@ -0,0 +1,83 @@
+import { Hono } from "hono";
+import { zValidator } from "@hono/zod-validator";
+import * as schemas from "../schemas.mjs";
+import { HTTPException } from "hono/http-exception";
+import { store as storageStore } from "../storage/store.mjs";
+const api = new Hono();
+const validateNamespace = (namespace) => {
+    if (!namespace || namespace.length === 0) {
+        throw new HTTPException(400, { message: "Namespace is required" });
+    }
+    for (const label of namespace) {
+        if (!label || label.includes(".")) {
+            throw new HTTPException(422, {
+                message: "Namespace labels cannot be empty or contain periods. Received: " +
+                    namespace.join("."),
+            });
+        }
+    }
+};
+const mapItemsToApi = (item) => {
+    if (item == null)
+        return null;
+    const clonedItem = { ...item };
+    delete clonedItem.createdAt;
+    delete clonedItem.updatedAt;
+    clonedItem.created_at = item.createdAt;
+    clonedItem.updated_at = item.updatedAt;
+    return clonedItem;
+};
+api.post("/store/namespaces", zValidator("json", schemas.StoreListNamespaces), async (c) => {
+    // List Namespaces
+    const payload = c.req.valid("json");
+    if (payload.prefix)
+        validateNamespace(payload.prefix);
+    if (payload.suffix)
+        validateNamespace(payload.suffix);
+    return c.json({
+        namespaces: await storageStore.listNamespaces({
+            limit: payload.limit ?? 100,
+            offset: payload.offset ?? 0,
+            prefix: payload.prefix,
+            suffix: payload.suffix,
+            maxDepth: payload.max_depth,
+        }),
+    });
+});
+api.post("/store/items/search", zValidator("json", schemas.StoreSearchItems), async (c) => {
+    // Search Items
+    const payload = c.req.valid("json");
+    if (payload.namespace_prefix)
+        validateNamespace(payload.namespace_prefix);
+    const items = await storageStore.search(payload.namespace_prefix, {
+        filter: payload.filter,
+        limit: payload.limit ?? 10,
+        offset: payload.offset ?? 0,
+        query: payload.query,
+    });
+    return c.json({ items: items.map(mapItemsToApi) });
+});
+api.put("/store/items", zValidator("json", schemas.StorePutItem), async (c) => {
+    // Put Item
+    const payload = c.req.valid("json");
+    if (payload.namespace)
+        validateNamespace(payload.namespace);
+    await storageStore.put(payload.namespace, payload.key, payload.value);
+    return c.body(null, 204);
+});
+api.delete("/store/items", zValidator("json", schemas.StoreDeleteItem), async (c) => {
+    // Delete Item
+    const payload = c.req.valid("json");
+    if (payload.namespace)
+        validateNamespace(payload.namespace);
+    await storageStore.delete(payload.namespace ?? [], payload.key);
+    return c.body(null, 204);
+});
+api.get("/store/items", zValidator("query", schemas.StoreGetItem), async (c) => {
+    // Get Item
+    const payload = c.req.valid("query");
+    const key = payload.key;
+    const namespace = payload.namespace;
+    return c.json(mapItemsToApi(await storageStore.get(namespace, key)));
+});
+export default api;

package/dist/api/threads.mjs

@@ -0,0 +1,145 @@
+import { zValidator } from "@hono/zod-validator";
+import { Hono } from "hono";
+import { v4 as uuid4 } from "uuid";
+import * as schemas from "../schemas.mjs";
+import { Threads } from "../storage/ops.mjs";
+import { z } from "zod";
+import { stateSnapshotToThreadState } from "../state.mjs";
+import { jsonExtra } from "../utils/hono.mjs";
+const api = new Hono();
+// Threads Routes
+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",
+    });
+    return jsonExtra(c, thread);
+});
+api.post("/threads/search", zValidator("json", schemas.ThreadSearchRequest), async (c) => {
+    // Search Threads
+    const payload = c.req.valid("json");
+    const result = [];
+    for await (const item of Threads.search({
+        status: payload.status,
+        values: payload.values,
+        metadata: payload.metadata,
+        limit: payload.limit ?? 10,
+        offset: payload.offset ?? 0,
+    })) {
+        result.push({
+            ...item,
+            created_at: item.created_at.toISOString(),
+            updated_at: item.updated_at.toISOString(),
+        });
+    }
+    return jsonExtra(c, result);
+});
+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 state = stateSnapshotToThreadState(await Threads.State.get({ configurable: { thread_id } }, { subgraphs }));
+    return jsonExtra(c, state);
+});
+api.post("/threads/:thread_id/state", zValidator("param", z.object({ thread_id: z.string().uuid() })), zValidator("json", z.object({
+    values: z.union([
+        z.record(z.string(), z.unknown()),
+        z.array(z.record(z.string(), z.unknown())),
+    ]),
+    as_node: z.string().optional(),
+    checkpoint_id: z.string().optional(),
+    checkpoint: z.record(z.string(), z.unknown()).optional(),
+})), async (c) => {
+    // Update Thread State
+    const { thread_id } = c.req.valid("param");
+    const payload = c.req.valid("json");
+    const config = { configurable: { thread_id } };
+    if (payload.checkpoint_id) {
+        config.configurable ??= {};
+        config.configurable.checkpoint_id = payload.checkpoint_id;
+    }
+    if (payload.checkpoint) {
+        config.configurable ??= {};
+        Object.assign(config.configurable, payload.checkpoint);
+    }
+    const inserted = await Threads.State.post(config, payload.values, payload.as_node);
+    return jsonExtra(c, inserted);
+});
+api.get("/threads/:thread_id/state/:checkpoint_id", zValidator("param", z.object({ thread_id: z.string().uuid(), checkpoint_id: z.string().uuid() })), zValidator("query", z.object({ subgraphs: schemas.coercedBoolean.optional() })), async (c) => {
+    // Get Thread State At Checkpoint
+    const { thread_id, checkpoint_id } = c.req.valid("param");
+    const { subgraphs } = c.req.valid("query");
+    const state = stateSnapshotToThreadState(await Threads.State.get({ configurable: { thread_id, checkpoint_id } }, { subgraphs }));
+    return jsonExtra(c, state);
+});
+api.post("/threads/:thread_id/state/checkpoint", zValidator("param", z.object({ thread_id: z.string().uuid() })), zValidator("json", z.object({
+    subgraphs: schemas.coercedBoolean.optional(),
+    checkpoint: z.object({
+        checkpoint_id: z.string().uuid().optional(),
+        checkpoint_ns: z.string().optional(),
+        checkpoint_map: z.record(z.string(), z.unknown()).optional(),
+    }),
+})), async (c) => {
+    // Get Thread State At Checkpoint Post
+    const { thread_id } = c.req.valid("param");
+    const { checkpoint, subgraphs } = c.req.valid("json");
+    const state = stateSnapshotToThreadState(await Threads.State.get({ configurable: { thread_id, ...checkpoint } }, { subgraphs }));
+    return jsonExtra(c, state);
+});
+api.get("/threads/:thread_id/history", zValidator("param", z.object({ thread_id: z.string().uuid() })), zValidator("query", z.object({
+    limit: z
+        .string()
+        .optional()
+        .default("10")
+        .transform((value) => parseInt(value, 10)),
+    before: z.string().optional(),
+})), async (c) => {
+    // Get Thread History
+    const { thread_id } = c.req.valid("param");
+    const { limit, before } = c.req.valid("query");
+    const states = await Threads.State.list({ configurable: { thread_id, checkpoint_ns: "" } }, { limit, before });
+    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) => {
+    // Get Thread History Post
+    const { thread_id } = c.req.valid("param");
+    const { limit, before, metadata, checkpoint } = c.req.valid("json");
+    const states = await Threads.State.list({ configurable: { thread_id, checkpoint_ns: "", ...checkpoint } }, { limit, before, metadata });
+    return jsonExtra(c, states.map(stateSnapshotToThreadState));
+});
+api.get("/threads/:thread_id", zValidator("param", z.object({ thread_id: z.string().uuid() })), async (c) => {
+    // Get Thread
+    const { thread_id } = c.req.valid("param");
+    return jsonExtra(c, await Threads.get(thread_id));
+});
+api.delete("/threads/:thread_id", zValidator("param", z.object({ thread_id: z.string().uuid() })), async (c) => {
+    // Delete Thread
+    const { thread_id } = c.req.valid("param");
+    await Threads.delete(thread_id);
+    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) => {
+    // Patch Thread
+    const { thread_id } = c.req.valid("param");
+    const { metadata } = c.req.valid("json");
+    return jsonExtra(c, await Threads.patch(thread_id, { metadata }));
+});
+api.post("/threads/:thread_id/copy", zValidator("param", z.object({ thread_id: z.string().uuid() })), async (c) => {
+    // Copy Thread
+    const { thread_id } = c.req.valid("param");
+    return jsonExtra(c, await Threads.copy(thread_id));
+});
+export default api;

package/dist/cli/build.mjs

@@ -0,0 +1,44 @@
+import { getDockerCapabilities } from "../docker/compose.mjs";
+import { assembleLocalDeps, configToDocker, getBaseImage, } from "../docker/dockerfile.mjs";
+import { getExecaOptions } from "../docker/shell.mjs";
+import { ConfigSchema } from "../utils/config.mjs";
+import { builder } from "./utils/builder.mjs";
+import { getProjectPath } from "./utils/project.mjs";
+import { $ } from "execa";
+import * as path from "node:path";
+import * as fs from "node:fs/promises";
+import { logger } from "../logging.mjs";
+const stream = (proc) => {
+    logger.info(`Running "${proc.spawnargs.join(" ")}"`);
+    return proc;
+};
+builder
+    .command("build")
+    .description("Build LangGraph API server Docker image.")
+    .requiredOption("-t, --tag <tag>", "Tag for the Docker image.")
+    .option("-c, --config <path>", "Path to configuration file", process.cwd())
+    .option("--no-pull", "Running the server with locally-built images. By default LangGraph will pull the latest images from the registry")
+    .argument("[args...]")
+    .passThroughOptions()
+    .action(async (pass, params) => {
+    const configPath = await getProjectPath(params.config);
+    await getDockerCapabilities();
+    const projectDir = path.dirname(configPath);
+    const config = ConfigSchema.parse(JSON.parse(await fs.readFile(configPath, "utf-8")));
+    const opts = await getExecaOptions({
+        cwd: projectDir,
+        stderr: "inherit",
+        stdout: "inherit",
+    });
+    const localDeps = await assembleLocalDeps(configPath, config);
+    const input = await configToDocker(configPath, config, localDeps, {
+        watch: false,
+        dockerCommand: "build",
+    });
+    let exec = $({ ...opts, input });
+    if (params.pull) {
+        await stream(exec `docker pull ${getBaseImage(config)}`);
+    }
+    exec = $({ ...opts, input });
+    await stream(exec `docker build -f - -t ${params.tag} ${projectDir} ${pass}`);
+});