@langchain/langgraph-api 0.0.10

package/dist/server.mjs

@@ -0,0 +1,74 @@
+import { serve } from "@hono/node-server";
+import { Hono } from "hono";
+import { cors } from "hono/cors";
+import { registerFromEnv } from "./graph/load.mjs";
+import runs from "./api/runs.mjs";
+import threads from "./api/threads.mjs";
+import assistants from "./api/assistants.mjs";
+import store from "./api/store.mjs";
+import { truncate, conn as opsConn } from "./storage/ops.mjs";
+import { zValidator } from "@hono/zod-validator";
+import { z } from "zod";
+import { queue } from "./queue.mjs";
+import { logger, requestLogger } from "./logging.mjs";
+import { checkpointer } from "./storage/checkpoint.mjs";
+import { store as graphStore } from "./storage/store.mjs";
+const app = new Hono();
+// This is used to match the behavior of the original LangGraph API
+// where the content-type is not being validated. Might be nice
+// to warn about this in the future and throw an error instead.
+app.use(async (c, next) => {
+    if (c.req.header("content-type")?.startsWith("text/plain") &&
+        c.req.method !== "GET" &&
+        c.req.method !== "OPTIONS") {
+        c.req.raw.headers.set("content-type", "application/json");
+    }
+    await next();
+});
+app.use(cors());
+app.use(requestLogger());
+app.route("/", assistants);
+app.route("/", runs);
+app.route("/", threads);
+app.route("/", store);
+app.get("/info", (c) => c.json({ flags: { assistants: true, crons: false } }));
+app.post("/internal/truncate", zValidator("json", z.object({
+    runs: z.boolean().optional(),
+    threads: z.boolean().optional(),
+    assistants: z.boolean().optional(),
+    checkpointer: z.boolean().optional(),
+    store: z.boolean().optional(),
+})), (c) => {
+    const { runs, threads, assistants, checkpointer, store } = c.req.valid("json");
+    truncate({ runs, threads, assistants, checkpointer, store });
+    return c.json({ ok: true });
+});
+export const StartServerSchema = z.object({
+    port: z.number(),
+    nWorkers: z.number(),
+    host: z.string(),
+    cwd: z.string(),
+    graphs: z.record(z.string()),
+});
+export async function startServer(options) {
+    logger.info(`Initializing storage...`);
+    const callbacks = await Promise.all([
+        opsConn.initialize(options.cwd),
+        checkpointer.initialize(options.cwd),
+        graphStore.initialize(options.cwd),
+    ]);
+    const cleanup = async () => {
+        logger.info(`Flushing to persistent storage, exiting...`);
+        await Promise.all(callbacks.map((c) => c.flush()));
+    };
+    logger.info(`Registering graphs from ${options.cwd}`);
+    await registerFromEnv(options.graphs, { cwd: options.cwd });
+    logger.info(`Starting ${options.nWorkers} workers`);
+    for (let i = 0; i < options.nWorkers; i++)
+        queue();
+    return new Promise((resolve) => {
+        serve({ fetch: app.fetch, port: options.port, hostname: options.host }, (c) => {
+            resolve({ host: `${c.address}:${c.port}`, cleanup });
+        });
+    });
+}

package/dist/state.mjs

@@ -0,0 +1,32 @@
+import { runnableConfigToCheckpoint } from "./utils/runnableConfig.mjs";
+import { serializeError } from "./utils/serde.mjs";
+const isStateSnapshot = (state) => {
+    return "values" in state && "next" in state;
+};
+export const stateSnapshotToThreadState = (state) => {
+    return {
+        values: state.values,
+        next: state.next,
+        tasks: state.tasks.map((task) => ({
+            id: task.id,
+            name: task.name,
+            error: task.error != null ? serializeError(task.error).message : null,
+            interrupts: task.interrupts,
+            path: task.path,
+            // TODO: too many type assertions, check if this is actually correct
+            checkpoint: task.state != null && "configurable" in task.state
+                ? (task.state.configurable ?? null)
+                : null,
+            state: task.state != null && isStateSnapshot(task.state)
+                ? stateSnapshotToThreadState(task.state)
+                : null,
+            // TODO: add missing result to the library
+            // @ts-expect-error
+            result: task.result ?? null,
+        })),
+        metadata: state.metadata,
+        created_at: state.createdAt ? new Date(state.createdAt) : null,
+        checkpoint: runnableConfigToCheckpoint(state.config),
+        parent_checkpoint: runnableConfigToCheckpoint(state.parentConfig),
+    };
+};

package/dist/storage/checkpoint.mjs

@@ -0,0 +1,127 @@
+import { MemorySaver, } from "@langchain/langgraph";
+import { FileSystemPersistence } from "./persist.mjs";
+const EXCLUDED_KEYS = ["checkpoint_ns", "checkpoint_id", "run_id", "thread_id"];
+const textDecoder = new TextDecoder();
+const textEncoder = new TextEncoder();
+const WriteKey = {
+    serialize: (key) => {
+        return JSON.stringify(key);
+    },
+    deserialize: (key) => {
+        const [threadId, checkpointNamespace, checkpointId] = JSON.parse(key);
+        return [threadId, checkpointNamespace, checkpointId];
+    },
+};
+const conn = new FileSystemPersistence(".langgraphjs_api.checkpointer.json", () => ({
+    storage: {},
+    writes: {},
+}));
+class InMemorySaver extends MemorySaver {
+    async initialize(cwd) {
+        await conn.initialize(cwd);
+        await conn.with(({ storage, writes }) => {
+            this.storage = storage;
+            this.writes = writes;
+        });
+        return conn;
+    }
+    clear() {
+        // { [threadId: string]: { [checkpointNs: string]: { [checkpointId]: [checkpoint, metadata, parentId] } }}
+        this.storage = {};
+        // { [WriteKey]: CheckpointPendingWrite[] }
+        this.writes = {};
+    }
+    // Patch every method that has access to this.storage or this.writes
+    // to also persist the changes to the filesystem in a non-blocking manner
+    async getTuple(...args) {
+        return await conn.with(() => super.getTuple(...args));
+    }
+    async *list(...args) {
+        yield* conn.withGenerator(super.list(...args));
+    }
+    async putWrites(...args) {
+        return await conn.with(() => super.putWrites(...args));
+    }
+    async put(config, checkpoint, metadata) {
+        return await conn.with(() => super.put(config, checkpoint, {
+            ...Object.fromEntries(Object.entries(config.configurable ?? {}).filter(([key]) => !key.startsWith("__") && !EXCLUDED_KEYS.includes(key))),
+            ...config.metadata,
+            ...metadata,
+        }));
+    }
+    async delete(threadId, runId) {
+        if (this.storage[threadId] == null)
+            return;
+        return await conn.with(() => {
+            if (runId != null) {
+                const writeKeysToDelete = [];
+                for (const ns of Object.keys(this.storage[threadId])) {
+                    for (const id of Object.keys(this.storage[threadId][ns])) {
+                        const [_checkpoint, metadata, _parentId] = this.storage[threadId][ns][id];
+                        const jsonMetadata = JSON.parse(textDecoder.decode(metadata));
+                        if (jsonMetadata.run_id === runId) {
+                            delete this.storage[threadId][ns][id];
+                            writeKeysToDelete.push(WriteKey.serialize([threadId, ns, id]));
+                            if (Object.keys(this.storage[threadId][ns]).length === 0) {
+                                delete this.storage[threadId][ns];
+                            }
+                        }
+                    }
+                }
+                for (const key of writeKeysToDelete) {
+                    delete this.writes[key];
+                }
+            }
+            else {
+                delete this.storage[threadId];
+                // delete all writes for this thread
+                const writeKeys = Object.keys(this.writes);
+                for (const key of writeKeys) {
+                    const [writeThreadId] = WriteKey.deserialize(key);
+                    if (writeThreadId === threadId)
+                        delete this.writes[key];
+                }
+            }
+        });
+    }
+    async copy(threadId, newThreadId) {
+        return await conn.with(() => {
+            // copy storage over
+            const newThreadCheckpoints = {};
+            for (const oldNs of Object.keys(this.storage[threadId] ?? {})) {
+                const newNs = oldNs.replace(threadId, newThreadId);
+                for (const oldId of Object.keys(this.storage[threadId][oldNs])) {
+                    const newId = oldId.replace(threadId, newThreadId);
+                    const [checkpoint, metadata, oldParentId] = this.storage[threadId][oldNs][oldId];
+                    const newParentId = oldParentId?.replace(threadId, newThreadId);
+                    const rawMetadata = textDecoder
+                        .decode(metadata)
+                        .replaceAll(threadId, newThreadId);
+                    newThreadCheckpoints[newNs] ??= {};
+                    newThreadCheckpoints[newNs][newId] = [
+                        checkpoint,
+                        textEncoder.encode(rawMetadata),
+                        newParentId,
+                    ];
+                }
+            }
+            this.storage[newThreadId] = newThreadCheckpoints;
+            // copy writes over (if any)
+            const outerKeys = [];
+            for (const keyJson of Object.keys(this.writes)) {
+                const key = WriteKey.deserialize(keyJson);
+                if (key[0] === threadId)
+                    outerKeys.push(keyJson);
+            }
+            for (const keyJson of outerKeys) {
+                const [_threadId, checkpointNamespace, checkpointId] = WriteKey.deserialize(keyJson);
+                this.writes[WriteKey.serialize([newThreadId, checkpointNamespace, checkpointId])] = structuredClone(this.writes[keyJson]);
+            }
+        });
+    }
+    toJSON() {
+        // Prevent serialization of internal state
+        return "[InMemorySaver]";
+    }
+}
+export const checkpointer = new InMemorySaver();

package/dist/storage/importMap.mjs

@@ -0,0 +1,55 @@
+import { PromptTemplate, AIMessagePromptTemplate, ChatMessagePromptTemplate, ChatPromptTemplate, HumanMessagePromptTemplate, MessagesPlaceholder, SystemMessagePromptTemplate, ImagePromptTemplate, PipelinePromptTemplate, } from "@langchain/core/prompts";
+import { AIMessage, AIMessageChunk, BaseMessage, BaseMessageChunk, ChatMessage, ChatMessageChunk, FunctionMessage, FunctionMessageChunk, HumanMessage, HumanMessageChunk, SystemMessage, SystemMessageChunk, ToolMessage, ToolMessageChunk, } from "@langchain/core/messages";
+import { StringPromptValue } from "@langchain/core/prompt_values";
+export const prompts__prompt = {
+    PromptTemplate,
+};
+export const schema__messages = {
+    AIMessage,
+    AIMessageChunk,
+    BaseMessage,
+    BaseMessageChunk,
+    ChatMessage,
+    ChatMessageChunk,
+    FunctionMessage,
+    FunctionMessageChunk,
+    HumanMessage,
+    HumanMessageChunk,
+    SystemMessage,
+    SystemMessageChunk,
+    ToolMessage,
+    ToolMessageChunk,
+};
+export const schema = {
+    AIMessage,
+    AIMessageChunk,
+    BaseMessage,
+    BaseMessageChunk,
+    ChatMessage,
+    ChatMessageChunk,
+    FunctionMessage,
+    FunctionMessageChunk,
+    HumanMessage,
+    HumanMessageChunk,
+    SystemMessage,
+    SystemMessageChunk,
+    ToolMessage,
+    ToolMessageChunk,
+};
+export const prompts__chat = {
+    AIMessagePromptTemplate,
+    ChatMessagePromptTemplate,
+    ChatPromptTemplate,
+    HumanMessagePromptTemplate,
+    MessagesPlaceholder,
+    SystemMessagePromptTemplate,
+};
+export const prompts__image = {
+    ImagePromptTemplate,
+};
+export const prompts__pipeline = {
+    PipelinePromptTemplate,
+};
+export const prompts__base = {
+    StringPromptValue,
+};