@langchain/langgraph-api 0.0.15 → 0.0.17

package/dist/cli/spawn.mjs

@@ -38,6 +38,7 @@ For production use, please use LangGraph Cloud.
         env: {
             ...context.env,
             NODE_ENV: "development",
+            LANGGRAPH_API_URL: localUrl,
         },
     });
 }

package/dist/graph/load.hooks.mjs

@@ -8,12 +8,45 @@ const OVERRIDE_RESOLVE = [
     new RegExp(`^@langchain\/langgraph-checkpoint(\/.+)?$`),
 ];
 let parentURL;
+let langgraphPackageURL;
 export async function initialize(args) {
     parentURL = args.parentURL;
 }
 export async function resolve(specifier, context, nextResolve) {
+    // HACK: @tailwindcss/node internally uses an ESM loader cache, which does not play nicely with `tsx`.
+    //       Node.js crashes with "TypeError [ERR_INVALID_URL_SCHEME]: The URL must be of scheme file".
+    //       As it already is a valid URI, we can just short-circuit the resolution and avoid `tsx`.
+    if (specifier.includes("@tailwindcss/node/dist/esm-cache.loader") &&
+        specifier.startsWith("file://")) {
+        return {
+            shortCircuit: true,
+            // Node 18.x will for some reason attempt to load `.mts` instead of `.mjs`
+            url: specifier.replace(".mts", ".mjs"),
+            format: "module",
+        };
+    }
+    if (specifier === "@langchain/langgraph-checkpoint") {
+        // resolve relative to @langchain/langgraph package instead
+        // This is done to avoid adding a direct dependency on @langchain/langgraph-checkpoint
+        // in project, which if not present will cause `pnpm` to not find the package.
+        if (!langgraphPackageURL) {
+            const main = await nextResolve("@langchain/langgraph", {
+                ...context,
+                parentURL,
+            });
+            langgraphPackageURL = main.url.toString();
+        }
+        return await nextResolve(specifier, {
+            ...context,
+            parentURL: langgraphPackageURL,
+        });
+    }
     if (OVERRIDE_RESOLVE.some((regex) => regex.test(specifier))) {
-        return await nextResolve(specifier, { ...context, parentURL });
+        const resolved = await nextResolve(specifier, { ...context, parentURL });
+        // If @langchain/langgraph is resolved first, cache it!
+        if (specifier === "@langchain/langgraph" && !langgraphPackageURL) {
+            langgraphPackageURL = resolved.url.toString();
+        }
     }
     return nextResolve(specifier, context);
 }

package/dist/server.mjs

@@ -65,10 +65,6 @@ export async function startServer(options) {
     logger.info(`Registering graphs from ${options.cwd}`);
     await registerFromEnv(options.graphs, { cwd: options.cwd });
     if (options.ui) {
-        if (process.versions.node.startsWith("18")) {
-            // Not supported due to weird interop issues with `@tailwindcss/postcss` and `tsx`
-            throw new Error("Built-in UI is not supported in Node.js 18.x. Please upgrade to Node.js 20.16 or later.");
-        }
         logger.info(`Loading UI`);
         const { api, registerGraphUi } = await import("./ui/load.mjs");
         app.route("/", api);

package/dist/stream.mjs

@@ -2,7 +2,7 @@ import { getGraph } from "./graph/load.mjs";
 import { Client as LangSmithClient } from "langsmith";
 import { Command, Send, } from "@langchain/langgraph";
 import { runnableConfigToCheckpoint, taskRunnableConfigToCheckpoint, } from "./utils/runnableConfig.mjs";
-import { BaseMessageChunk, isBaseMessage } from "@langchain/core/messages";
+import { isBaseMessage } from "@langchain/core/messages";
 const getLangGraphCommand = (command) => {
     let goto = command.goto != null && !Array.isArray(command.goto)
         ? [command.goto]
@@ -95,6 +95,7 @@ export async function* streamState(run, attempt = 1, options) {
         langgraph_version: "0.2.35",
         langgraph_plan: "developer",
         langgraph_host: "self-hosted",
+        langgraph_api_url: process.env.LANGGRAPH_API_URL ?? undefined,
     };
     const events = graph.streamEvents(kwargs.command != null
         ? getLangGraphCommand(kwargs.command)

package/dist/ui/bundler.d.mts

@@ -1,9 +1,15 @@
 import { type BuildOptions } from "esbuild";
-export declare function build(agentName: string, uiUserPath: string): Promise<{
+export declare function build(agentName: string, args: {
+    cwd: string;
+    userPath: string;
+}): Promise<{
     basename: string;
     contents: Uint8Array;
 }[]>;
-export declare function watch(agentName: string, uiUserPath: string, onResult: (result: {
+export declare function watch(agentName: string, args: {
+    cwd: string;
+    userPath: string;
+}, onResult: (result: {
     basename: string;
     contents: Uint8Array;
 }[]) => void): Promise<import("esbuild").BuildContext<BuildOptions>>;

package/dist/ui/bundler.mjs

@@ -4,19 +4,27 @@ import * as fs from "node:fs";
 import { build as runBuild, context as runContext, } from "esbuild";
 import tailwind from "esbuild-plugin-tailwindcss";
 const renderTemplate = await fs.promises.readFile(url.fileURLToPath(new URL("./render.template.mts", import.meta.url)), "utf-8");
-function entrypointPlugin(uiUserPath) {
-    const projectDir = path.dirname(uiUserPath);
+function entrypointPlugin(paths) {
+    const fullPath = path.resolve(paths.cwd, paths.userPath);
+    let relativeUiPath = path
+        .relative(paths.cwd, fullPath)
+        .replaceAll(path.sep, "/");
+    if (relativeUiPath.startsWith("../")) {
+        throw new Error(`UI path must be relative to the project root. Received: "${relativeUiPath}"`);
+    }
+    if (!relativeUiPath.startsWith("./"))
+        relativeUiPath = `./${relativeUiPath}`;
     return {
         name: "entrypoint",
         setup(build) {
-            build.onResolve({ filter: /^entrypoint$/ }, (args) => ({
-                path: path.resolve(projectDir, "ui.entrypoint.tsx"),
+            build.onResolve({ filter: /^entrypoint$/ }, () => ({
+                path: path.resolve(path.dirname(fullPath), "ui.entrypoint.tsx"),
                 namespace: "entrypoint-ns",
             }));
             build.onLoad({ filter: /.*/, namespace: "entrypoint-ns" }, () => ({
-                resolveDir: projectDir,
+                resolveDir: paths.cwd,
                 contents: [
-                    `import ui from "${uiUserPath}"`,
+                    `import ui from "${relativeUiPath}"`,
                     renderTemplate,
                     `export const render = createRenderer(ui)`,
                 ].join("\n"),
@@ -46,10 +54,10 @@ function registerPlugin(onEnd) {
         },
     };
 }
-function setup(agentName, uiUserPath, onResult) {
+function setup(agentName, args, onResult) {
     return {
         write: false,
-        outdir: path.resolve(path.dirname(uiUserPath), "dist"),
+        outdir: path.resolve(args.cwd, "dist"),
         entryPoints: ["entrypoint"],
         bundle: true,
         platform: "browser",
@@ -61,21 +69,17 @@ function setup(agentName, uiUserPath, onResult) {
             "@langchain/langgraph-sdk",
             "@langchain/langgraph-sdk/react-ui",
         ],
-        plugins: [
-            tailwind(),
-            entrypointPlugin(uiUserPath),
-            registerPlugin(onResult),
-        ],
+        plugins: [tailwind(), entrypointPlugin(args), registerPlugin(onResult)],
         globalName: `__LGUI_${agentName}`,
     };
 }
-export async function build(agentName, uiUserPath) {
+export async function build(agentName, args) {
     let results = [];
-    await runBuild(setup(agentName, uiUserPath, (result) => (results = result)));
+    await runBuild(setup(agentName, args, (result) => (results = result)));
     return results;
 }
-export async function watch(agentName, uiUserPath, onResult) {
-    const ctx = await runContext(setup(agentName, uiUserPath, onResult));
+export async function watch(agentName, args, onResult) {
+    const ctx = await runContext(setup(agentName, args, onResult));
     await ctx.watch();
     return ctx;
 }

package/dist/ui/load.mjs

@@ -6,9 +6,8 @@ import * as path from "node:path";
 import { watch } from "./bundler.mjs";
 const GRAPH_UI = {};
 export async function registerGraphUi(defs, options) {
-    const result = await Promise.all(Object.entries(defs).map(async ([agentName, uiUserPath]) => {
-        const userPath = path.resolve(options.cwd, uiUserPath);
-        const ctx = await watch(agentName, userPath, (result) => {
+    const result = await Promise.all(Object.entries(defs).map(async ([agentName, userPath]) => {
+        const ctx = await watch(agentName, { cwd: options.cwd, userPath }, (result) => {
             GRAPH_UI[agentName] = result;
         });
         return [agentName, ctx];
@@ -26,11 +25,11 @@ api.post("/ui/:agent", zValidator("json", z.object({ name: z.string() })), async
     const messageName = JSON.stringify(message.name);
     const result = [];
     for (const css of files.filter((i) => path.extname(i.basename) === ".css")) {
-        result.push(`<link rel="stylesheet" href="//${host}/ui/${agent}/${css.basename}" />`);
+        result.push(`<link rel="stylesheet" href="http://${host}/ui/${agent}/${css.basename}" />`);
     }
     const js = files.find((i) => path.extname(i.basename) === ".js");
     if (js) {
-        result.push(`<script src="//${host}/ui/${agent}/${js.basename}" onload='__LGUI_${agent}.render(${messageName}, "{{shadowRootId}}")'></script>`);
+        result.push(`<script src="http://${host}/ui/${agent}/${js.basename}" onload='__LGUI_${agent}.render(${messageName}, "{{shadowRootId}}")'></script>`);
     }
     return c.text(result.join("\n"), {
         headers: { "Content-Type": "text/html" },

package/dist/utils/hono.mjs

@@ -1,6 +1,5 @@
 import { serialiseAsDict } from "./serde.mjs";
 import { stream } from "hono/streaming";
-import { StreamingApi } from "hono/utils/stream";
 export function jsonExtra(c, object) {
     return new Response(serialiseAsDict(object), {
         ...c.res,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/langgraph-api",
-  "version": "0.0.15",
+  "version": "0.0.17",
   "type": "module",
   "engines": {
     "node": "^18.19.0 || >=20.16.0"