@langchain/langgraph-api 0.0.21 → 0.0.22

package/dist/api/meta.mjs

@@ -0,0 +1,5 @@
+import { Hono } from "hono";
+const api = new Hono();
+api.get("/info", (c) => c.json({ flags: { assistants: true, crons: false } }));
+api.get("/ok", (c) => c.json({ ok: true }));
+export default api;

package/dist/cli/spawn.d.mts

@@ -13,6 +13,23 @@ export declare function spawnServer(args: {
             path?: string;
             disable_studio_auth?: boolean;
         };
+        http?: {
+            app?: string;
+            disable_assistants?: boolean;
+            disable_threads?: boolean;
+            disable_runs?: boolean;
+            disable_store?: boolean;
+            disable_meta?: boolean;
+            cors?: {
+                allow_origins?: string[];
+                allow_methods?: string[];
+                allow_headers?: string[];
+                allow_credentials?: boolean;
+                allow_origin_regex?: string;
+                expose_headers?: string[];
+                max_age?: number;
+            };
+        };
     };
     env: NodeJS.ProcessEnv;
     hostUrl: string;

package/dist/cli/spawn.mjs

@@ -34,6 +34,7 @@ For production use, please use LangGraph Cloud.
             ui: context.config.ui,
             ui_config: context.config.ui_config,
             cwd: options.projectCwd,
+            http: context.config.http,
         }),
     ], {
         stdio: ["inherit", "inherit", "inherit", "ipc"],

package/dist/http/custom.mjs

@@ -0,0 +1,10 @@
+import * as path from "node:path";
+import * as url from "node:url";
+export async function registerHttp(appPath, options) {
+    const [userFile, exportSymbol] = appPath.split(":", 2);
+    const sourceFile = path.resolve(options.cwd, userFile);
+    const user = (await import(url.pathToFileURL(sourceFile).toString()).then((module) => module[exportSymbol || "default"]));
+    if (!user)
+        throw new Error(`Failed to load HTTP app: ${appPath}`);
+    return { api: user };
+}

package/dist/http/middleware.mjs

@@ -0,0 +1,38 @@
+import { cors as honoCors } from "hono/cors";
+export const cors = (cors) => {
+    if (cors == null)
+        return honoCors();
+    const originRegex = cors.allow_origin_regex
+        ? new RegExp(cors.allow_origin_regex)
+        : undefined;
+    const origin = originRegex
+        ? (origin) => {
+            originRegex.lastIndex = 0; // reset regex in case it's a global regex
+            if (originRegex.test(origin))
+                return origin;
+            return undefined;
+        }
+        : (cors.allow_origins ?? []);
+    // TODO: handle `cors.allow_credentials`
+    return honoCors({
+        origin,
+        maxAge: cors.max_age,
+        allowMethods: cors.allow_methods,
+        allowHeaders: cors.allow_headers,
+        credentials: cors.allow_credentials,
+        exposeHeaders: cors.expose_headers,
+    });
+};
+// 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.
+export const ensureContentType = () => {
+    return 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();
+    };
+};

package/dist/queue.mjs

@@ -2,6 +2,7 @@ import { Runs, Threads } from "./storage/ops.mjs";
 import { streamState, } from "./stream.mjs";
 import { logError, logger } from "./logging.mjs";
 import { serializeError } from "./utils/serde.mjs";
+import { callWebhook } from "./webhook.mjs";
 const MAX_RETRY_ATTEMPTS = 3;
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 export const queue = async () => {
@@ -15,9 +16,12 @@ export const queue = async () => {
 };
 const worker = async (run, attempt, abortSignal) => {
     const startedAt = new Date();
+    let endedAt = undefined;
     let checkpoint = undefined;
     let exception = undefined;
+    let status = undefined;
     const temporary = run.kwargs.temporary;
+    const webhook = run.kwargs.webhook;
     logger.info("Starting background run", {
         run_id: run.run_id,
         run_attempt: attempt,
@@ -54,7 +58,7 @@ const worker = async (run, attempt, abortSignal) => {
             await Runs.Stream.publish(run.run_id, "error", serializeError(error));
             throw error;
         }
-        const endedAt = new Date();
+        endedAt = new Date();
         logger.info("Background run succeeded", {
             run_id: run.run_id,
             run_attempt: attempt,
@@ -63,10 +67,11 @@ const worker = async (run, attempt, abortSignal) => {
             run_ended_at: endedAt,
             run_exec_ms: endedAt.valueOf() - startedAt.valueOf(),
         });
-        await Runs.setStatus(run.run_id, "success");
+        status = "success";
+        await Runs.setStatus(run.run_id, status);
     }
     catch (error) {
-        const endedAt = new Date();
+        endedAt = new Date();
         if (error instanceof Error)
             exception = error;
         logError(error, {
@@ -80,6 +85,7 @@ const worker = async (run, attempt, abortSignal) => {
                 run_exec_ms: endedAt.valueOf() - startedAt.valueOf(),
             },
         });
+        status = "error";
         await Runs.setStatus(run.run_id, "error");
     }
     finally {
@@ -89,5 +95,16 @@ const worker = async (run, attempt, abortSignal) => {
         else {
             await Threads.setStatus(run.thread_id, { checkpoint, exception });
         }
+        if (webhook) {
+            await callWebhook({
+                checkpoint,
+                status,
+                exception,
+                run,
+                webhook,
+                run_started_at: startedAt,
+                run_ended_at: endedAt,
+            });
+        }
     }
 };

package/dist/schemas.mjs

@@ -89,7 +89,7 @@ export const CronCreate = z
         .describe("Metadata for the run.")
         .optional(),
     config: AssistantConfig.optional(),
-    webhook: z.string().url().optional(),
+    webhook: z.string().optional(),
     interrupt_before: z.union([z.enum(["*"]), z.array(z.string())]).optional(),
     interrupt_after: z.union([z.enum(["*"]), z.array(z.string())]).optional(),
     multitask_strategy: z
@@ -172,7 +172,7 @@ export const RunCreate = z
         .describe("Metadata for the run.")
         .optional(),
     config: AssistantConfig.optional(),
-    webhook: z.string().url().optional(),
+    webhook: z.string().optional(),
     interrupt_before: z.union([z.enum(["*"]), z.array(z.string())]).optional(),
     interrupt_after: z.union([z.enum(["*"]), z.array(z.string())]).optional(),
     on_disconnect: z

package/dist/server.mjs

@@ -1,11 +1,11 @@
 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 meta from "./api/meta.mjs";
 import { truncate, conn as opsConn } from "./storage/ops.mjs";
 import { zValidator } from "@hono/zod-validator";
 import { z } from "zod";
@@ -15,37 +15,9 @@ import { checkpointer } from "./storage/checkpoint.mjs";
 import { store as graphStore } from "./storage/store.mjs";
 import { auth } from "./auth/custom.mjs";
 import { registerAuth } from "./auth/index.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.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 });
-});
-app.use(auth());
-app.route("/", assistants);
-app.route("/", runs);
-app.route("/", threads);
-app.route("/", store);
+import { registerHttp } from "./http/custom.mjs";
+import { cors, ensureContentType } from "./http/middleware.mjs";
+import { bindLoopbackFetch } from "./webhook.mjs";
 export const StartServerSchema = z.object({
     port: z.number(),
     nWorkers: z.number(),
@@ -60,6 +32,27 @@ export const StartServerSchema = z.object({
         .optional(),
     ui: z.record(z.string()).optional(),
     ui_config: z.object({ shared: z.array(z.string()).optional() }).optional(),
+    http: z
+        .object({
+        app: z.string().optional(),
+        disable_assistants: z.boolean().default(false),
+        disable_threads: z.boolean().default(false),
+        disable_runs: z.boolean().default(false),
+        disable_store: z.boolean().default(false),
+        disable_meta: z.boolean().default(false),
+        cors: z
+            .object({
+            allow_origins: z.array(z.string()).optional(),
+            allow_methods: z.array(z.string()).optional(),
+            allow_headers: z.array(z.string()).optional(),
+            allow_credentials: z.boolean().optional(),
+            allow_origin_regex: z.string().optional(),
+            expose_headers: z.array(z.string()).optional(),
+            max_age: z.number().optional(),
+        })
+            .optional(),
+    })
+        .optional(),
 });
 export async function startServer(options) {
     logger.info(`Initializing storage...`);
@@ -74,20 +67,52 @@ export async function startServer(options) {
     };
     logger.info(`Registering graphs from ${options.cwd}`);
     await registerFromEnv(options.graphs, { cwd: options.cwd });
+    const app = new Hono();
     if (options.auth?.path) {
         logger.info(`Loading auth from ${options.auth.path}`);
         await registerAuth(options.auth, { cwd: options.cwd });
+        app.use(auth());
     }
-    if (options.ui) {
-        logger.info(`Loading UI`);
-        const { api, registerGraphUi } = await import("./ui/load.mjs");
+    if (options.http?.app) {
+        logger.info(`Loading HTTP app from ${options.http.app}`);
+        const { api } = await registerHttp(options.http.app, { cwd: options.cwd });
         app.route("/", api);
+    }
+    app.use(cors(options.http?.cors));
+    app.use(requestLogger());
+    app.use(ensureContentType());
+    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 });
+    });
+    if (!options.http?.disable_meta)
+        app.route("/", meta);
+    if (!options.http?.disable_assistants)
+        app.route("/", assistants);
+    if (!options.http?.disable_runs)
+        app.route("/", runs);
+    if (!options.http?.disable_threads)
+        app.route("/", threads);
+    if (!options.http?.disable_store)
+        app.route("/", store);
+    if (options.ui) {
         logger.info(`Registering UI from ${options.cwd}`);
+        const { api, registerGraphUi } = await import("./ui/load.mjs");
         await registerGraphUi(options.ui, {
             cwd: options.cwd,
             config: options.ui_config,
         });
+        app.route("/", api);
     }
+    // Loopback fetch used by webhooks
+    bindLoopbackFetch(app);
     logger.info(`Starting ${options.nWorkers} workers`);
     for (let i = 0; i < options.nWorkers; i++)
         queue();

package/dist/webhook.mjs

@@ -0,0 +1,30 @@
+import { serializeError } from "./utils/serde.mjs";
+let LOOPBACK_FETCH;
+export const bindLoopbackFetch = (app) => {
+    LOOPBACK_FETCH = async (url, init) => app.request(url, init);
+};
+export async function callWebhook(result) {
+    const payload = {
+        ...result.run,
+        status: result.status,
+        run_started_at: result.run_started_at.toISOString(),
+        run_ended_at: result.run_ended_at?.toISOString(),
+        webhook_sent_at: new Date().toISOString(),
+        values: result.checkpoint?.values,
+        ...(result.exception
+            ? { error: serializeError(result.exception).message }
+            : undefined),
+    };
+    if (result.webhook.startsWith("/")) {
+        await LOOPBACK_FETCH?.(result.webhook, {
+            method: "POST",
+            body: JSON.stringify(payload),
+        });
+    }
+    else {
+        await fetch(result.webhook, {
+            method: "POST",
+            body: JSON.stringify(payload),
+        });
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/langgraph-api",
-  "version": "0.0.21",
+  "version": "0.0.22",
   "type": "module",
   "engines": {
     "node": "^18.19.0 || >=20.16.0"
@@ -43,7 +43,7 @@
     "winston": "^3.17.0",
     "winston-console-format": "^1.0.8",
     "zod": "^3.23.8",
-    "@langchain/langgraph-ui": "0.0.21"
+    "@langchain/langgraph-ui": "0.0.22"
   },
   "peerDependencies": {
     "@langchain/core": "^0.3.42",