@langchain/langgraph-api 0.0.14 → 0.0.15

package/dist/cli/entrypoint.mjs

@@ -1,4 +1,3 @@
-import "../preload.mjs";
 import { asyncExitHook } from "exit-hook";
 import * as process from "node:process";
 import { startServer, StartServerSchema } from "../server.mjs";

package/dist/cli/spawn.mjs

@@ -21,6 +21,8 @@ For production use, please use LangGraph Cloud.
         fileURLToPath(new URL("../../cli.mjs", import.meta.resolve("tsx/esm/api"))),
         "watch",
         "--clear-screen=false",
+        "--import",
+        new URL(import.meta.resolve("../preload.mjs")).toString(),
         fileURLToPath(new URL(import.meta.resolve("./entrypoint.mjs"))),
         options.pid.toString(),
         JSON.stringify({

package/dist/graph/load.hooks.mjs

@@ -1,17 +1,19 @@
-// This hook is to ensure that @langchain/langgraph package
-// found in /api folder has precendence compared to user-provided package
-// found in /deps. Does not attempt to semver check for too old packages.
+// This module hook is used to ensure that @langchain/langgraph package
+// is imported from a consistent location.
+// Accepts `{ parentURL: string }` as argument when registering the hook.
 const OVERRIDE_RESOLVE = [
-    "@langchain/langgraph",
-    "@langchain/langgraph-checkpoint",
+    // Override `@langchain/langgraph` or `@langchain/langgraph/prebuilt`,
+    // but not `@langchain/langgraph-sdk`
+    new RegExp(`^@langchain\/langgraph(\/.+)?$`),
+    new RegExp(`^@langchain\/langgraph-checkpoint(\/.+)?$`),
 ];
+let parentURL;
+export async function initialize(args) {
+    parentURL = args.parentURL;
+}
 export async function resolve(specifier, context, nextResolve) {
-    if (OVERRIDE_RESOLVE.includes(specifier)) {
-        const parentURL = new URL("./load.mts", import.meta.url).toString();
-        return await nextResolve(specifier, {
-            ...context,
-            parentURL,
-        });
+    if (OVERRIDE_RESOLVE.some((regex) => regex.test(specifier))) {
+        return await nextResolve(specifier, { ...context, parentURL });
     }
     return nextResolve(specifier, context);
 }

package/dist/graph/load.utils.mjs

@@ -30,7 +30,7 @@ export async function resolveGraph(spec, options) {
     })();
     return { sourceFile, exportSymbol, resolved };
 }
-export async function runGraphSchemaWorker(spec) {
+export async function runGraphSchemaWorker(spec, options) {
     let SCHEMA_RESOLVE_TIMEOUT_MS = 30_000;
     try {
         const envTimeout = Number.parseInt(process.env.LANGGRAPH_SCHEMA_RESOLVE_TIMEOUT_MS ?? "0", 10);
@@ -41,8 +41,12 @@ export async function runGraphSchemaWorker(spec) {
     catch {
         // ignore
     }
+    if (options?.mainThread) {
+        const { SubgraphExtractor } = await import("./parser/parser.mjs");
+        return SubgraphExtractor.extractSchemas(spec.sourceFile, spec.exportSymbol, { strict: false });
+    }
     return await new Promise((resolve, reject) => {
-        const worker = new Worker(fileURLToPath(new URL("./parser/parser.worker.mjs", import.meta.url)));
+        const worker = new Worker(fileURLToPath(new URL("./parser/parser.worker.mjs", import.meta.url)), { argv: process.argv.slice(-1) });
         // Set a timeout to reject if the worker takes too long
         const timeoutId = setTimeout(() => {
             worker.terminate();

package/dist/graph/parser/parser.mjs

@@ -5,6 +5,12 @@ import dedent from "dedent";
 import { buildGenerator } from "./schema/types.mjs";
 import { fileURLToPath } from "node:url";
 const __dirname = fileURLToPath(new URL(".", import.meta.url));
+const OVERRIDE_RESOLVE = [
+    // Override `@langchain/langgraph` or `@langchain/langgraph/prebuilt`,
+    // but not `@langchain/langgraph-sdk`
+    new RegExp(`^@langchain\/langgraph(\/.+)?$`),
+    new RegExp(`^@langchain\/langgraph-checkpoint(\/.+)?$`),
+];
 const compilerOptions = {
     noEmit: true,
     strict: true,
@@ -227,12 +233,16 @@ export class SubgraphExtractor {
         // This API is not well made for Windows, ensure that the paths are UNIX slashes
         const fsMap = new Map();
         const system = vfs.createFSBackedSystem(fsMap, dirname, ts);
+        // TODO: investigate if we should create a PR in @typescript/vfs
+        const oldReadFile = system.readFile.bind(system);
+        system.readFile = (fileName) => oldReadFile(fileName) ?? "// Non-existent file";
         const vfsPath = (inputPath) => {
             if (process.platform === "win32")
                 return inputPath.replace(/\\/g, "/");
             return inputPath;
         };
-        const host = vfs.createVirtualCompilerHost(system, compilerOptions, ts);
+        const vfsHost = vfs.createVirtualCompilerHost(system, compilerOptions, ts);
+        const host = vfsHost.compilerHost;
         const targetPath = typeof target === "string"
             ? target
             : path.resolve(dirname, "./__langgraph__target.mts");
@@ -243,38 +253,27 @@ export class SubgraphExtractor {
                 fsMap.set(vfsPath(path.resolve(dirname, name)), contents);
             }
         }
-        // TODO: this is in all instances broken, will need to address in a way
-        // that allows loading fs-backed modules from different vfs
-        // host.compilerHost.resolveModuleNames = (moduleNames, containingFile) => {
-        //   const resolvedModules: (ts.ResolvedModule | undefined)[] = [];
-        //   for (const moduleName of moduleNames) {
-        //     let target = containingFile;
-        //     const relative = path.relative(dirname, containingFile);
-        //     logger.debug(`${moduleName} ${containingFile}`);
-        //     if (
-        //       moduleName.startsWith("@langchain/langgraph") &&
-        //       relative &&
-        //       !relative.startsWith("..") &&
-        //       !path.isAbsolute(relative)
-        //     ) {
-        //       target = path.resolve(__dirname, "../", relative);
-        //       process.stderr.write(`${moduleName} ${relative} -> ${target}\n`);
-        //     }
-        //     resolvedModules.push(
-        //       ts.resolveModuleName(
-        //         moduleName,
-        //         target,
-        //         compilerOptions,
-        //         host.compilerHost
-        //       ).resolvedModule
-        //     );
-        //   }
-        //   return resolvedModules;
-        // };
+        const moduleCache = ts.createModuleResolutionCache(dirname, (x) => x);
+        host.resolveModuleNameLiterals = (entries, containingFile, redirectedReference, options) => entries.flatMap((entry) => {
+            const specifier = entry.text;
+            // Force module resolution to use @langchain/langgraph from the local project
+            // rather than from API/CLI.
+            let targetFile = containingFile;
+            if (OVERRIDE_RESOLVE.some((regex) => regex.test(specifier))) {
+                // check if we're not already importing from node_modules
+                if (!containingFile.split(path.sep).includes("node_modules")) {
+                    // Doesn't matter if the file exists, only used to nudge `ts.resolveModuleName`
+                    targetFile = path.resolve(dirname, "__langgraph__resolve.mts");
+                }
+            }
+            return [
+                ts.resolveModuleName(specifier, targetFile, options, host, moduleCache, redirectedReference),
+            ];
+        });
         const research = ts.createProgram({
             rootNames: [inferTemplatePath, targetPath],
             options: compilerOptions,
-            host: host.compilerHost,
+            host,
         });
         const extractor = new SubgraphExtractor(research, research.getSourceFile(targetPath), research.getSourceFile(inferTemplatePath), options);
         const { files, exports } = extractor.getAugmentedSourceFile(name);
@@ -284,7 +283,7 @@ export class SubgraphExtractor {
         const extract = ts.createProgram({
             rootNames: [path.resolve(dirname, "./__langraph__infer.mts")],
             options: compilerOptions,
-            host: host.compilerHost,
+            host,
         });
         const schemaGenerator = buildGenerator(extract);
         const trySymbol = (schema, symbol) => {

package/dist/graph/parser/schema/types.template.mts

@@ -27,17 +27,19 @@ type Defactorify<T> = T extends (...args: any[]) => infer R
   : Awaited<T>;
 
 // @ts-expect-error
-type Inspect<T> = T extends unknown
-  ? {
-      [K in keyof T]: 0 extends 1 & T[K]
-        ? T[K]
-        : Wrap<MatchBaseMessageArray<T[K]>> extends Wrap<BaseMessage[]>
-          ? BaseMessage[]
-          : Wrap<MatchBaseMessage<T[K]>> extends Wrap<BaseMessage>
-            ? BaseMessage
-            : Inspect<T[K]>;
-    }
-  : never;
+type Inspect<T, TDepth extends Array<0> = []> = TDepth extends [0, 0, 0]
+  ? any
+  : T extends unknown
+    ? {
+        [K in keyof T]: 0 extends 1 & T[K]
+          ? T[K]
+          : Wrap<MatchBaseMessageArray<T[K]>> extends Wrap<BaseMessage[]>
+            ? BaseMessage[]
+            : Wrap<MatchBaseMessage<T[K]>> extends Wrap<BaseMessage>
+              ? BaseMessage
+              : Inspect<T[K], [0, ...TDepth]>;
+      }
+    : never;
 
 type ReflectCompiled<T> = T extends { RunInput: infer S; RunOutput: infer U }
   ? { state: S; update: U }

package/dist/preload.mjs

@@ -1,3 +1,20 @@
 import { register } from "node:module";
-// enforce API @langchain/langgraph precedence
-register("./graph/load.hooks.mjs", import.meta.url);
+import { pathToFileURL } from "node:url";
+import { join } from "node:path";
+// arguments passed to the entrypoint: [ppid, payload]
+// we only care about the payload, which contains the server definition
+const lastArg = process.argv.at(-1);
+const options = JSON.parse(lastArg || "{}");
+// find the first file, as `parentURL` needs to be a valid file URL
+// if no graph found, just assume a dummy default file, which should
+// be working fine as well.
+const firstGraphFile = Object.values(options.graphs)
+    .flatMap((i) => i.split(":").at(0))
+    .at(0) || "index.mts";
+// enforce API @langchain/langgraph resolution
+register("./graph/load.hooks.mjs", import.meta.url, {
+    parentURL: "data:",
+    data: {
+        parentURL: pathToFileURL(join(options.cwd, firstGraphFile)).toString(),
+    },
+});

package/dist/ui/load.mjs

@@ -26,11 +26,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="http://${host}/ui/${agent}/${css.basename}" />`);
+        result.push(`<link rel="stylesheet" href="//${host}/ui/${agent}/${css.basename}" />`);
     }
     const js = files.find((i) => path.extname(i.basename) === ".js");
     if (js) {
-        result.push(`<script src="http://${host}/ui/${agent}/${js.basename}" onload='__LGUI_${agent}.render(${messageName}, "{{shadowRootId}}")'></script>`);
+        result.push(`<script src="//${host}/ui/${agent}/${js.basename}" onload='__LGUI_${agent}.render(${messageName}, "{{shadowRootId}}")'></script>`);
     }
     return c.text(result.join("\n"), {
         headers: { "Content-Type": "text/html" },

package/package.json

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