@langchain/langgraph-api 0.0.10

package/dist/cli/spawn.d.mts

@@ -0,0 +1,14 @@
+export declare function spawnServer(args: {
+    host: string;
+    port: string;
+    nJobsPerWorker: string;
+}, context: {
+    config: {
+        graphs: Record<string, string>;
+    };
+    env: NodeJS.ProcessEnv;
+    hostUrl: string;
+}, options: {
+    pid: number;
+    projectCwd: string;
+}): Promise<import("child_process").ChildProcess>;

package/dist/cli/spawn.mjs

@@ -0,0 +1,34 @@
+import { fileURLToPath } from "node:url";
+import { spawn } from "node:child_process";
+export async function spawnServer(args, context, options) {
+    const localUrl = `http://${args.host}:${args.port}`;
+    const studioUrl = `${context.hostUrl}/studio?baseUrl=${localUrl}`;
+    console.log(`
+          Welcome to
+
+╦  ┌─┐┌┐┌┌─┐╔═╗┬─┐┌─┐┌─┐┬ ┬
+║  ├─┤││││ ┬║ ╦├┬┘├─┤├─┘├─┤
+╩═╝┴ ┴┘└┘└─┘╚═╝┴└─┴ ┴┴  ┴ ┴.js
+
+- 🚀 API: \x1b[36m${localUrl}\x1b[0m
+- 🎨 Studio UI: \x1b[36m${studioUrl}\x1b[0m
+
+This in-memory server is designed for development and testing.
+For production use, please use LangGraph Cloud.
+
+`);
+    return spawn(process.execPath, [
+        fileURLToPath(new URL("../../cli.mjs", import.meta.resolve("tsx/esm/api"))),
+        "watch",
+        "--clear-screen=false",
+        fileURLToPath(new URL(import.meta.resolve("./entrypoint.mjs"))),
+        options.pid.toString(),
+        JSON.stringify({
+            port: Number.parseInt(args.port, 10),
+            nWorkers: Number.parseInt(args.nJobsPerWorker, 10),
+            host: args.host,
+            graphs: context.config.graphs,
+            cwd: options.projectCwd,
+        }),
+    ], { stdio: ["inherit", "inherit", "inherit", "ipc"], env: context.env });
+}

package/dist/cli/utils/ipc/client.mjs

@@ -0,0 +1,47 @@
+// MIT License
+// 
+// Copyright (c) Hiroki Osame <hiroki.osame@gmail.com>
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+// 
+// https://github.com/privatenumber/tsx/tree/28a3e7d2b8fd72b683aab8a98dd1fcee4624e4cb
+import net from "node:net";
+import { getPipePath } from "./utils/get-pipe-path.mjs";
+export const connectToServer = (processId = process.ppid) => new Promise((resolve) => {
+    const pipePath = getPipePath(processId);
+    const socket = net.createConnection(pipePath, () => {
+        const sendToParent = (data) => {
+            const messageBuffer = Buffer.from(JSON.stringify(data));
+            const lengthBuffer = Buffer.alloc(4);
+            lengthBuffer.writeInt32BE(messageBuffer.length, 0);
+            socket.write(Buffer.concat([lengthBuffer, messageBuffer]));
+        };
+        resolve(sendToParent);
+    });
+    /**
+     * Ignore error when:
+     * - Called as a loader and there is no server
+     * - Nested process when using --test and the ppid is incorrect
+     */
+    socket.on("error", () => {
+        resolve(undefined);
+    });
+    // Prevent Node from waiting for this socket to close before exiting
+    socket.unref();
+});

package/dist/cli/utils/ipc/utils/get-pipe-path.mjs

@@ -0,0 +1,29 @@
+// MIT License
+//
+// Copyright (c) Hiroki Osame <hiroki.osame@gmail.com>
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//
+// https://github.com/privatenumber/tsx/tree/28a3e7d2b8fd72b683aab8a98dd1fcee4624e4cb
+import path from "node:path";
+import { tmpdir } from "./temporary-directory.mjs";
+export const getPipePath = (processId) => {
+    const pipePath = path.join(tmpdir, `${processId}.pipe`);
+    return process.platform === "win32" ? `\\\\?\\pipe\\${pipePath}` : pipePath;
+};

package/dist/cli/utils/ipc/utils/temporary-directory.mjs

@@ -0,0 +1,40 @@
+// MIT License
+// 
+// Copyright (c) Hiroki Osame <hiroki.osame@gmail.com>
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+// 
+// https://github.com/privatenumber/tsx/tree/28a3e7d2b8fd72b683aab8a98dd1fcee4624e4cb
+import path from "node:path";
+import os from "node:os";
+/**
+ * Cache directory is based on the user's identifier
+ * to avoid permission issues when accessed by a different user
+ */
+const { geteuid } = process;
+const userId = geteuid
+    ? // For Linux users with virtual users on CI (e.g. Docker)
+        geteuid()
+    : // Use username on Windows because it doesn't have id
+        os.userInfo().username;
+/**
+ * This ensures that the cache directory is unique per user
+ * and has the appropriate permissions
+ */
+export const tmpdir = path.join(os.tmpdir(), `tsx-${userId}`);

package/dist/graph/load.hooks.mjs

@@ -0,0 +1,17 @@
+// 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.
+const OVERRIDE_RESOLVE = [
+    "@langchain/langgraph",
+    "@langchain/langgraph-checkpoint",
+];
+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,
+        });
+    }
+    return nextResolve(specifier, context);
+}

package/dist/graph/load.mjs

@@ -0,0 +1,72 @@
+import { z } from "zod";
+import * as uuid from "uuid";
+import { Assistants } from "../storage/ops.mjs";
+import { HTTPException } from "hono/http-exception";
+import { resolveGraph, runGraphSchemaWorker, } from "./load.utils.mjs";
+import { checkpointer } from "../storage/checkpoint.mjs";
+import { store } from "../storage/store.mjs";
+import { logger } from "../logging.mjs";
+export const GRAPHS = {};
+export const GRAPH_SPEC = {};
+export const GRAPH_SCHEMA = {};
+export const NAMESPACE_GRAPH = uuid.parse("6ba7b821-9dad-11d1-80b4-00c04fd430c8");
+const ConfigSchema = z.record(z.unknown());
+export const getAssistantId = (graphId) => {
+    if (graphId in GRAPHS)
+        return uuid.v5(graphId, NAMESPACE_GRAPH);
+    return graphId;
+};
+export async function registerFromEnv(specs, options) {
+    const envConfig = process.env.LANGGRAPH_CONFIG
+        ? ConfigSchema.parse(JSON.parse(process.env.LANGGRAPH_CONFIG))
+        : undefined;
+    return await Promise.all(Object.entries(specs).map(async ([graphId, rawSpec]) => {
+        logger.info(`Registering graph with id '${graphId}'`, {
+            graph_id: graphId,
+        });
+        const config = envConfig?.[graphId];
+        const { resolved, ...spec } = await resolveGraph(rawSpec, {
+            cwd: options.cwd,
+        });
+        // registering the graph runtime
+        GRAPHS[graphId] = resolved;
+        GRAPH_SPEC[graphId] = spec;
+        await Assistants.put(uuid.v5(graphId, NAMESPACE_GRAPH), {
+            graph_id: graphId,
+            metadata: { created_by: "system" },
+            config: config ?? {},
+            if_exists: "do_nothing",
+            name: graphId,
+        });
+        return resolved;
+    }));
+}
+export function getGraph(graphId, options) {
+    if (!GRAPHS[graphId])
+        throw new HTTPException(404, { message: `Graph "${graphId}" not found` });
+    // TODO: have a check for the type of graph
+    const compiled = GRAPHS[graphId];
+    if (typeof options?.checkpointer !== "undefined") {
+        compiled.checkpointer = options?.checkpointer ?? undefined;
+    }
+    else {
+        compiled.checkpointer = checkpointer;
+    }
+    compiled.store = options?.store ?? store;
+    return compiled;
+}
+export async function getGraphSchema(graphId) {
+    if (!GRAPH_SPEC[graphId])
+        throw new HTTPException(404, {
+            message: `Spec for "${graphId}" not found`,
+        });
+    if (!GRAPH_SCHEMA[graphId] || true) {
+        try {
+            GRAPH_SCHEMA[graphId] = await runGraphSchemaWorker(GRAPH_SPEC[graphId]);
+        }
+        catch (error) {
+            throw new Error(`Failed to extract schema for "${graphId}": ${error}`);
+        }
+    }
+    return GRAPH_SCHEMA[graphId];
+}

package/dist/graph/load.utils.mjs

@@ -0,0 +1,50 @@
+import { Worker } from "node:worker_threads";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import * as uuid from "uuid";
+export const GRAPHS = {};
+export const NAMESPACE_GRAPH = uuid.parse("6ba7b821-9dad-11d1-80b4-00c04fd430c8");
+export async function resolveGraph(spec, options) {
+    const [userFile, exportSymbol] = spec.split(":", 2);
+    const sourceFile = path.resolve(options.cwd, userFile);
+    // validate file exists
+    await fs.stat(sourceFile);
+    if (options?.onlyFilePresence) {
+        return { sourceFile: userFile, exportSymbol, resolved: undefined };
+    }
+    const isGraph = (graph) => {
+        if (typeof graph !== "object" || graph == null)
+            return false;
+        return "compile" in graph && typeof graph.compile === "function";
+    };
+    const graph = await import(pathToFileURL(sourceFile).toString()).then((module) => module[exportSymbol || "default"]);
+    // obtain the graph, and if not compiled, compile it
+    const resolved = await (async () => {
+        if (!graph)
+            throw new Error("Failed to load graph: graph is nullush");
+        const graphLike = typeof graph === "function" ? await graph() : await graph;
+        if (isGraph(graphLike))
+            return graphLike.compile();
+        return graphLike;
+    })();
+    return { sourceFile, exportSymbol, resolved };
+}
+export async function runGraphSchemaWorker(spec) {
+    const SCHEMA_RESOLVE_TIMEOUT_MS = 30_000;
+    return await new Promise((resolve, reject) => {
+        const worker = new Worker(fileURLToPath(new URL("./parser/parser.worker.mjs", import.meta.url)));
+        // Set a timeout to reject if the worker takes too long
+        const timeoutId = setTimeout(() => {
+            worker.terminate();
+            reject(new Error("Schema extract worker timed out"));
+        }, SCHEMA_RESOLVE_TIMEOUT_MS);
+        worker.on("message", (result) => {
+            worker.terminate();
+            clearTimeout(timeoutId);
+            resolve(result);
+        });
+        worker.on("error", reject);
+        worker.postMessage(spec);
+    });
+}

package/dist/graph/parser/parser.mjs

@@ -0,0 +1,309 @@
+import * as ts from "typescript";
+import * as vfs from "@typescript/vfs";
+import * as path from "node:path";
+import dedent from "dedent";
+import { buildGenerator } from "./schema/types.mjs";
+import { fileURLToPath } from "node:url";
+const __dirname = fileURLToPath(new URL(".", import.meta.url));
+const compilerOptions = {
+    noEmit: true,
+    strict: true,
+    allowUnusedLabels: true,
+};
+export class SubgraphExtractor {
+    program;
+    checker;
+    sourceFile;
+    inferFile;
+    anyPregelType;
+    anyGraphType;
+    strict;
+    constructor(program, sourceFile, inferFile, options) {
+        this.program = program;
+        this.sourceFile = sourceFile;
+        this.inferFile = inferFile;
+        this.checker = program.getTypeChecker();
+        this.strict = options?.strict ?? false;
+        this.anyPregelType = this.findTypeByName("AnyPregel");
+        this.anyGraphType = this.findTypeByName("AnyGraph");
+    }
+    findTypeByName = (needle) => {
+        let result = undefined;
+        const visit = (node) => {
+            if (ts.isTypeAliasDeclaration(node)) {
+                const symbol = node.symbol;
+                if (symbol != null) {
+                    const name = this.checker
+                        .getFullyQualifiedName(symbol)
+                        .replace(/".*"\./, "");
+                    if (name === needle)
+                        result = this.checker.getTypeAtLocation(node);
+                }
+            }
+            if (result == null)
+                ts.forEachChild(node, visit);
+        };
+        ts.forEachChild(this.inferFile, visit);
+        if (!result)
+            throw new Error(`Failed to find "${needle}" type`);
+        return result;
+    };
+    find = (root, predicate) => {
+        let result = undefined;
+        const visit = (node) => {
+            if (predicate(node)) {
+                result = node;
+            }
+            else {
+                ts.forEachChild(node, visit);
+            }
+        };
+        if (predicate(root))
+            return root;
+        ts.forEachChild(root, visit);
+        return result;
+    };
+    findSubgraphs = (node, namespace = []) => {
+        const findAllAddNodeCalls = (acc, node) => {
+            if (ts.isCallExpression(node)) {
+                const firstChild = node.getChildAt(0);
+                if (ts.isPropertyAccessExpression(firstChild) &&
+                    this.getText(firstChild.name) === "addNode") {
+                    let nodeName = "unknown";
+                    let variables = [];
+                    const [subgraphNode, callArg] = node.arguments;
+                    if (subgraphNode && ts.isStringLiteralLike(subgraphNode)) {
+                        nodeName = this.getText(subgraphNode);
+                        if ((nodeName.startsWith(`"`) && nodeName.endsWith(`"`)) ||
+                            (nodeName.startsWith(`'`) && nodeName.endsWith(`'`))) {
+                            nodeName = nodeName.slice(1, -1);
+                        }
+                    }
+                    if (callArg) {
+                        if (ts.isFunctionLike(callArg) ||
+                            ts.isCallLikeExpression(callArg)) {
+                            variables = this.reduceChildren(callArg, this.findSubgraphIdentifiers, []);
+                        }
+                        else if (ts.isIdentifier(callArg)) {
+                            variables = this.findSubgraphIdentifiers([], callArg);
+                        }
+                    }
+                    if (variables.length > 0) {
+                        if (variables.length > 1) {
+                            const targetName = [...namespace, nodeName].join("|");
+                            const errMsg = `Multiple unique subgraph invocations found for "${targetName}"`;
+                            if (this.strict)
+                                throw new Error(errMsg);
+                            console.warn(errMsg);
+                        }
+                        acc.push({
+                            namespace: namespace,
+                            node: nodeName,
+                            subgraph: variables[0],
+                        });
+                    }
+                }
+            }
+            return acc;
+        };
+        let subgraphs = this.reduceChildren(node, findAllAddNodeCalls, []);
+        // TODO: make this more strict, only traverse the flow graph only
+        // if no `addNode` calls were found
+        if (!subgraphs.length) {
+            const candidate = this.find(node, (node) => node && "flowNode" in node && node.flowNode);
+            if (candidate?.flowNode &&
+                this.isGraphOrPregelType(this.checker.getTypeAtLocation(candidate.flowNode.node))) {
+                subgraphs = this.findSubgraphs(candidate.flowNode.node, namespace);
+            }
+        }
+        // handle recursive behaviour
+        if (subgraphs.length > 0) {
+            return [
+                ...subgraphs,
+                ...subgraphs.map(({ subgraph, node }) => this.findSubgraphs(subgraph.node, [...namespace, node])),
+            ].flat();
+        }
+        return subgraphs;
+    };
+    getSubgraphsVariables = (name) => {
+        const sourceSymbol = this.checker.getSymbolAtLocation(this.sourceFile);
+        const exports = this.checker.getExportsOfModule(sourceSymbol);
+        const targetExport = exports.find((item) => item.name === name);
+        if (!targetExport)
+            throw new Error(`Failed to find export "${name}"`);
+        const varDecls = (targetExport.declarations ?? []).filter(ts.isVariableDeclaration);
+        return varDecls.flatMap((varDecl) => {
+            if (!varDecl.initializer)
+                return [];
+            return this.findSubgraphs(varDecl.initializer, [name]);
+        });
+    };
+    getAugmentedSourceFile = (name) => {
+        const vars = this.getSubgraphsVariables(name);
+        const typeExports = [
+            { typeName: `__langgraph__${name}`, valueName: name, graphName: name },
+        ];
+        for (const { subgraph, node, namespace } of vars) {
+            typeExports.push({
+                typeName: `__langgraph__${namespace.join("_")}_${node}`,
+                valueName: subgraph.name,
+                graphName: [...namespace, node].join("|"),
+            });
+        }
+        const sourceFilePath = "__langgraph__source.mts";
+        const sourceContents = [
+            this.getText(this.sourceFile),
+            ...typeExports.map(({ typeName, valueName }) => `export type ${typeName} = typeof ${valueName}`),
+        ].join("\n\n");
+        const inferFilePath = "__langraph__infer.mts";
+        const inferContents = [
+            ...typeExports.map(({ typeName }) => `import type { ${typeName}} from "./__langgraph__source.mts"`),
+            this.inferFile.getText(this.inferFile),
+            ...typeExports.flatMap(({ typeName }) => {
+                return [
+                    dedent `
+            type ${typeName}__reflect = Reflect<${typeName}>;
+            export type ${typeName}__state = Inspect<${typeName}__reflect["state"]>;
+            export type ${typeName}__update = Inspect<${typeName}__reflect["update"]>;
+
+            type ${typeName}__builder = BuilderReflect<${typeName}>;
+            export type ${typeName}__input = Inspect<FilterAny<${typeName}__builder["input"]>>;
+            export type ${typeName}__output = Inspect<FilterAny<${typeName}__builder["output"]>>;
+            export type ${typeName}__config = Inspect<FilterAny<${typeName}__builder["config"]>>;
+          `,
+                ];
+            }),
+        ].join("\n\n");
+        return {
+            files: [
+                [sourceFilePath, sourceContents],
+                [inferFilePath, inferContents],
+            ],
+            exports: typeExports,
+        };
+    };
+    findSubgraphIdentifiers = (acc, node) => {
+        if (ts.isIdentifier(node)) {
+            const smb = this.checker.getSymbolAtLocation(node);
+            if (smb?.valueDeclaration &&
+                ts.isVariableDeclaration(smb.valueDeclaration)) {
+                const target = smb.valueDeclaration;
+                const targetType = this.checker.getTypeAtLocation(target);
+                if (this.isGraphOrPregelType(targetType)) {
+                    acc.push({ name: this.getText(target.name), node: target });
+                }
+            }
+            if (smb?.declarations) {
+                const target = smb.declarations.find(ts.isImportSpecifier);
+                if (target) {
+                    const targetType = this.checker.getTypeAtLocation(target);
+                    if (this.isGraphOrPregelType(targetType)) {
+                        acc.push({ name: this.getText(target.name), node: target });
+                    }
+                }
+            }
+        }
+        return acc;
+    };
+    isGraphOrPregelType = (type) => {
+        return (this.checker.isTypeAssignableTo(type, this.anyPregelType) ||
+            this.checker.isTypeAssignableTo(type, this.anyGraphType));
+    };
+    getText(node) {
+        return node.getText(this.sourceFile);
+    }
+    reduceChildren(node, fn, initial) {
+        let acc = initial;
+        function it(node) {
+            acc = fn(acc, node);
+            // @ts-expect-error
+            ts.forEachChild(node, it.bind(this));
+        }
+        ts.forEachChild(node, it.bind(this));
+        return acc;
+    }
+    static extractSchemas(target, name, options) {
+        const dirname = typeof target === "string" ? path.dirname(target) : __dirname;
+        // 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);
+        const vfsPath = (inputPath) => {
+            if (process.platform === "win32")
+                return inputPath.replace(/\\/g, "/");
+            return inputPath;
+        };
+        const host = vfs.createVirtualCompilerHost(system, compilerOptions, ts);
+        const targetPath = typeof target === "string"
+            ? target
+            : path.resolve(dirname, "./__langgraph__target.mts");
+        const inferTemplatePath = path.resolve(__dirname, "./schema/types.template.mts");
+        if (typeof target !== "string") {
+            fsMap.set(vfsPath(targetPath), target.contents);
+            for (const [name, contents] of target.files ?? []) {
+                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 research = ts.createProgram({
+            rootNames: [inferTemplatePath, targetPath],
+            options: compilerOptions,
+            host: host.compilerHost,
+        });
+        const extractor = new SubgraphExtractor(research, research.getSourceFile(targetPath), research.getSourceFile(inferTemplatePath), options);
+        const { files, exports } = extractor.getAugmentedSourceFile(name);
+        for (const [name, source] of files) {
+            system.writeFile(vfsPath(path.resolve(dirname, name)), source);
+        }
+        const extract = ts.createProgram({
+            rootNames: [path.resolve(dirname, "./__langraph__infer.mts")],
+            options: compilerOptions,
+            host: host.compilerHost,
+        });
+        const schemaGenerator = buildGenerator(extract);
+        const trySymbol = (schema, symbol) => {
+            try {
+                return schema?.getSchemaForSymbol(symbol) ?? undefined;
+            }
+            catch (e) {
+                console.warn(`Failed to obtain symbol "${symbol}":`, e?.message);
+            }
+            return undefined;
+        };
+        return Object.fromEntries(exports.map(({ typeName, graphName }) => [
+            graphName,
+            {
+                input: trySymbol(schemaGenerator, `${typeName}__input`),
+                output: trySymbol(schemaGenerator, `${typeName}__output`),
+                state: trySymbol(schemaGenerator, `${typeName}__update`),
+                config: trySymbol(schemaGenerator, `${typeName}__config`),
+            },
+        ]));
+    }
+}

package/dist/graph/parser/parser.worker.mjs

@@ -0,0 +1,7 @@
+import { tsImport } from "tsx/esm/api";
+import { parentPort } from "node:worker_threads";
+parentPort?.on("message", async (payload) => {
+    const { SubgraphExtractor } = await tsImport("./parser.mjs", import.meta.url);
+    const result = SubgraphExtractor.extractSchemas(payload.sourceFile, payload.exportSymbol, { strict: false });
+    parentPort?.postMessage(result);
+});