@langchain/langgraph-cli 0.0.0-preview.4

package/dist/docker/dockerfile.mjs

@@ -0,0 +1,390 @@
+import dedent from "dedent";
+import * as path from "node:path";
+import { promises as fs } from "node:fs";
+const dedenter = dedent.withOptions({ escapeSpecialCharacters: false });
+async function exists(path) {
+    try {
+        await fs.stat(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function assembleLocalDeps(configPath, config) {
+    if ("node_version" in config) {
+        const rebuildFiles = [];
+        const workingDir = `/deps/${path.basename(path.dirname(configPath))}`;
+        rebuildFiles.push(path.resolve(path.dirname(configPath), "package.json"));
+        rebuildFiles.push(path.resolve(path.dirname(configPath), "package-lock.json"));
+        rebuildFiles.push(path.resolve(path.dirname(configPath), "yarn.lock"));
+        rebuildFiles.push(path.resolve(path.dirname(configPath), "pnpm-lock.yaml"));
+        return {
+            pipReqs: [],
+            realPkgs: {},
+            fauxPkgs: {},
+            rebuildFiles,
+            workingDir,
+        };
+    }
+    const reserved = new Set([
+        "src",
+        "langgraph-api",
+        "langgraph_api",
+        "langgraph",
+        "langchain-core",
+        "langchain_core",
+        "pydantic",
+        "orjson",
+        "fastapi",
+        "uvicorn",
+        "psycopg",
+        "httpx",
+        "langsmith",
+    ]);
+    function checkReserved(name, ref) {
+        if (reserved.has(name)) {
+            throw new Error(`Package name '${name}' used in local dep '${ref}' is reserved. Rename the directory.`);
+        }
+        reserved.add(name);
+    }
+    const pipReqs = [];
+    const realPkgs = {};
+    const fauxPkgs = {};
+    const rebuildFiles = [];
+    let workingDir;
+    let reloadDir;
+    for (const localDep of config.dependencies) {
+        if (!localDep.startsWith("."))
+            continue;
+        const resolved = path.resolve(path.dirname(configPath), localDep);
+        if (!(await exists(resolved))) {
+            throw new Error(`Could not find local dependency: ${resolved}`);
+        }
+        else if (!(await fs.stat(resolved)).isDirectory()) {
+            throw new Error(`Local dependency must be a directory: ${resolved}`);
+        }
+        else if (!resolved.startsWith(path.dirname(configPath))) {
+            throw new Error(`Local dependency must be a subdirectory of the config file: ${resolved}`);
+        }
+        // if it's installable, add it to local_pkgs
+        // otherwise, add it to faux_pkgs, and create a pyproject.toml
+        const files = await fs.readdir(resolved);
+        if (files.includes("pyproject.toml") || files.includes("setup.py")) {
+            realPkgs[resolved] = localDep;
+            if (localDep === ".") {
+                workingDir = `/deps/${path.basename(resolved)}`;
+            }
+            if (files.includes("pyproject.toml")) {
+                rebuildFiles.push(path.resolve(resolved, "pyproject.toml"));
+            }
+            if (files.includes("setup.py")) {
+                rebuildFiles.push(path.resolve(resolved, "setup.py"));
+            }
+        }
+        else {
+            let containerPath;
+            if (files.includes("__init__.py")) {
+                // flat layout
+                if (path.basename(resolved).includes("-")) {
+                    throw new Error(`Package name '${path.basename(resolved)}' contains a hyphen. Rename the directory to use it as flat-layout package.`);
+                }
+                checkReserved(path.basename(resolved), localDep);
+                containerPath = `/deps/__outer_${path.basename(resolved)}/${path.basename(resolved)}`;
+            }
+            else {
+                containerPath = `/deps/__outer_${path.basename(resolved)}/src`;
+                for (const file of files) {
+                    const rfile = path.resolve(resolved, file);
+                    if (file !== "__pycache__" &&
+                        !file.startsWith(".") &&
+                        (await fs.stat(rfile)).isDirectory()) {
+                        try {
+                            for (const subfile of await fs.readdir(rfile)) {
+                                if (subfile.endsWith(".py")) {
+                                    checkReserved(file, localDep);
+                                    break;
+                                }
+                            }
+                        }
+                        catch {
+                            // pass
+                        }
+                    }
+                }
+            }
+            fauxPkgs[resolved] = [localDep, containerPath];
+            if (localDep === ".") {
+                workingDir = containerPath;
+            }
+            else {
+                reloadDir = containerPath;
+            }
+            if (files.includes("requirements.txt")) {
+                const rfile = path.resolve(resolved, "requirements.txt");
+                rebuildFiles.push(rfile);
+                pipReqs.push([
+                    path.relative(path.dirname(configPath), rfile),
+                    `${containerPath}/requirements.txt`,
+                ]);
+            }
+        }
+    }
+    return { pipReqs, realPkgs, fauxPkgs, workingDir, reloadDir, rebuildFiles };
+}
+async function updateGraphPaths(configPath, config, localDeps) {
+    for (const [graphId, importStr] of Object.entries(config.graphs)) {
+        let [moduleStr, attrStr] = importStr.split(":", 2);
+        if (!moduleStr || !attrStr) {
+            throw new Error(`Import string "${importStr}" must be in format "<module>:<attribute>".`);
+        }
+        if (moduleStr.includes("/")) {
+            const resolved = path.resolve(path.dirname(configPath), moduleStr);
+            if (!(await exists(resolved))) {
+                throw new Error(`Could not find local module: ${resolved}`);
+            }
+            else if (!(await fs.stat(resolved)).isFile()) {
+                throw new Error(`Local module must be a file: ${resolved}`);
+            }
+            else {
+                find: {
+                    for (const realPath of Object.keys(localDeps.realPkgs)) {
+                        if (resolved.startsWith(realPath)) {
+                            moduleStr = `/deps/${path.basename(realPath)}/${path.relative(realPath, resolved)}`;
+                            break find;
+                        }
+                    }
+                    for (const [fauxPkg, [_, destPath]] of Object.entries(localDeps.fauxPkgs)) {
+                        if (resolved.startsWith(fauxPkg)) {
+                            moduleStr = `${destPath}/${path.relative(fauxPkg, resolved)}`;
+                            break find;
+                        }
+                        throw new Error(`Module '${importStr}' not found in 'dependencies' list. Add its containing package to 'dependencies' list.`);
+                    }
+                }
+                config["graphs"][graphId] = `${moduleStr}:${attrStr}`;
+            }
+        }
+    }
+}
+export function getBaseImage(config) {
+    if ("python_version" in config) {
+        return `langchain/langgraph-api:${config._INTERNAL_docker_tag || config.python_version}`;
+    }
+    if ("node_version" in config) {
+        return `langchain/langgraphjs-api:${config._INTERNAL_docker_tag || config.node_version}`;
+    }
+    throw new Error("Invalid config type");
+}
+export async function configToDocker(configPath, config, localDeps, options) {
+    if ("python_version" in config) {
+        return pythonConfigToDocker(configPath, config, localDeps, options);
+    }
+    if ("node_version" in config) {
+        return nodeConfigToDocker(configPath, config, localDeps, options);
+    }
+    throw new Error("Invalid config type");
+}
+export async function nodeConfigToDocker(configPath, config, localDeps, options) {
+    // figure out the package manager used here
+    const projectFolder = path.dirname(configPath);
+    const testFile = async (file) => fs
+        .stat(path.resolve(projectFolder, file))
+        .then((a) => a.isFile())
+        .catch(() => false);
+    const [npm, yarn, pnpm] = await Promise.all([
+        testFile("package-lock.json"),
+        testFile("yarn.lock"),
+        testFile("pnpm-lock.yaml"),
+    ]);
+    let installCmd = "npm i";
+    if (yarn) {
+        installCmd = "yarn install";
+    }
+    else if (pnpm) {
+        installCmd = "pnpm i --frozen-lockfile";
+    }
+    else if (npm) {
+        installCmd = "npm ci";
+    }
+    const lines = [
+        `FROM ${getBaseImage(config)}`,
+        ...config.dockerfile_lines,
+        `ADD . ${localDeps.workingDir}`,
+        `RUN cd ${localDeps.workingDir} && ${installCmd}`,
+        `ENV LANGSERVE_GRAPHS='${JSON.stringify(config.graphs)}'`,
+        ...(config.store
+            ? [`ENV LANGGRAPH_STORE='${JSON.stringify(config.store)}'`]
+            : []),
+        ...(config.auth
+            ? [`ENV LANGGRAPH_AUTH='${JSON.stringify(config.auth)}'`]
+            : []),
+        `WORKDIR ${localDeps.workingDir}`,
+        `RUN (test ! -f /api/langgraph_api/js/build.mts && echo "Prebuild script not found, skipping") || tsx /api/langgraph_api/js/build.mts`,
+    ];
+    if (options?.watch) {
+        // TODO: hacky, should add as entrypoint to the langgraph-api base image
+        lines.push(`CMD exec uvicorn langgraph_api.server:app --log-config /api/logging.json --no-access-log --host 0.0.0.0 --port 8000 --reload --reload-dir ${localDeps.workingDir}`);
+    }
+    return lines.filter(Boolean).join("\n");
+}
+export async function pythonConfigToDocker(configPath, config, localDeps, options) {
+    let pipInstall = `PYTHONDONTWRITEBYTECODE=1 pip install -c /api/constraints.txt`;
+    if (config.pip_config_file) {
+        pipInstall = `PIP_CONFIG_FILE=/pipconfig.txt ${pipInstall}`;
+    }
+    pipInstall = `--mount=type=cache,target=/root/.cache/pip ${pipInstall}`;
+    const pipConfigFileStr = config.pip_config_file
+        ? [`ADD ${config.pip_config_file} /pipconfig.txt`].join("\n")
+        : "";
+    const pypiDeps = config.dependencies.filter((dep) => !dep.startsWith("."));
+    await updateGraphPaths(configPath, config, localDeps);
+    const pipPkgsStr = pypiDeps.length
+        ? `RUN ${pipInstall} ${pypiDeps.join(" ")}`
+        : "";
+    let pipReqStr;
+    if (localDeps.pipReqs.length) {
+        const pipReqsStr = localDeps.pipReqs
+            .map(([reqpath, destpath]) => `ADD ${reqpath} ${destpath}`)
+            .join("\n");
+        pipReqStr = `${pipReqsStr}\nRUN ${pipInstall} ${localDeps.pipReqs.map(([, r]) => `-r ${r}`)}`;
+    }
+    else {
+        pipReqStr = "";
+    }
+    const localPkgStr = Object.entries(localDeps.realPkgs)
+        .map(([fullpath, relpath]) => `ADD ${relpath} /deps/${path.basename(fullpath)}`)
+        .join("\n");
+    const fauxPkgsStr = Object.entries(localDeps.fauxPkgs)
+        .map(([fullpath, [relpath, destpath]]) => {
+        const x = dedenter `
+        ADD ${relpath} ${destpath}
+        RUN set -ex && \
+            for line in '[project]' \
+                        'name = "${path.basename(fullpath)}"' \
+                        'version = "0.1"' \
+                        '[tool.setuptools.package-data]' \
+                        '"*" = ["**/*"]'; do \
+                echo "${options?.dockerCommand === "build" ? "$line" : "$$line"}" >> /deps/__outer_${path.basename(fullpath)}/pyproject.toml; \
+            done
+      `;
+        return x;
+    })
+        .join("\n");
+    const lines = [
+        `FROM ${getBaseImage(config)}`,
+        ...config.dockerfile_lines,
+        pipConfigFileStr,
+        pipPkgsStr,
+        pipReqStr,
+        localPkgStr,
+        fauxPkgsStr,
+        `RUN ${pipInstall} -e /deps/*`,
+        `ENV LANGSERVE_GRAPHS='${JSON.stringify(config.graphs)}'`,
+        ...(config.store
+            ? [`ENV LANGGRAPH_STORE='${JSON.stringify(config.store)}'`]
+            : []),
+        ...(config.auth
+            ? [`ENV LANGGRAPH_AUTH='${JSON.stringify(config.auth)}'`]
+            : []),
+        localDeps.workingDir ? `WORKDIR ${localDeps.workingDir}` : null,
+    ];
+    if (options?.watch && (localDeps.workingDir || localDeps.reloadDir)) {
+        // TODO: hacky, should add as entrypoint to the langgraph-api base image
+        lines.push(`CMD exec uvicorn langgraph_api.server:app --log-config /api/logging.json --no-access-log --host 0.0.0.0 --port 8000 --reload --reload-dir ${localDeps.workingDir || localDeps.reloadDir}`);
+    }
+    return lines.filter(Boolean).join("\n");
+}
+export async function configToWatch(configPath, config) {
+    const localDeps = await assembleLocalDeps(configPath, config);
+    const projectDir = path.dirname(configPath);
+    const watch = [];
+    const watchSources = "python_version" in config
+        ? config.dependencies.filter((dep) => dep.startsWith("."))
+        : ["."];
+    const watchIgnore = "node_version" in config
+        ? ["node_modules", "langgraph.json"]
+        : ["langgraph.json"];
+    if (typeof config.env === "string") {
+        watchIgnore.push(config.env);
+    }
+    for (const absPath of localDeps.rebuildFiles) {
+        const relative = path.relative(projectDir, absPath);
+        if (watch.find((i) => i.path === relative))
+            continue;
+        watch.push({ path: relative, action: "rebuild" });
+        watchIgnore.push(relative);
+    }
+    for (const source of watchSources) {
+        const target = localDeps.workingDir || localDeps.reloadDir;
+        watch.push({
+            path: source,
+            action: target ? "sync" : "rebuild",
+            target: target,
+            ignore: watchIgnore,
+        });
+    }
+    if (watch.length > 0)
+        return watch;
+    return undefined;
+}
+export async function configToCompose(configPath, config, options) {
+    const result = {};
+    const localDeps = await assembleLocalDeps(configPath, config);
+    const inline = await configToDocker(configPath, config, localDeps, options);
+    result.pull_policy = "build";
+    result.build = {
+        context: ".",
+        dockerfile_inline: inline + "\n",
+    };
+    const extendEnvIgnore = new Set();
+    if (typeof config.env === "string") {
+        // try to parse out the env file
+        const envPath = path.resolve(path.dirname(configPath), config.env);
+        try {
+            const envFileKeys = (await fs.readFile(envPath, "utf-8"))
+                .split("\n")
+                .map((lines) => lines.trim().split("=").at(0));
+            for (const key of envFileKeys) {
+                if (key)
+                    extendEnvIgnore.add(key);
+            }
+        }
+        catch {
+            throw new Error(`Could not read env file: ${envPath}`);
+        }
+        result.env_file = config.env;
+    }
+    else if (!Array.isArray(config.env)) {
+        Object.entries(config.env).forEach(([k, v]) => {
+            result.environment ??= {};
+            result.environment[k] = v;
+            extendEnvIgnore.add(k);
+        });
+    }
+    if (options?.watch) {
+        const watch = await configToWatch(configPath, config);
+        if (watch)
+            result.develop = { watch };
+    }
+    if (options?.extendEnv) {
+        Object.entries(options.extendEnv).forEach(([k, v]) => {
+            if (extendEnvIgnore.has(k))
+                return;
+            result.environment ??= {};
+            result.environment[k] = v;
+        });
+    }
+    if (Array.isArray(config.env)) {
+        // check if all the environment variables are present or not
+        const missing = config.env.filter((k) => !result.environment?.[k]);
+        if (missing.length)
+            throw new Error(`Missing environment variables: ${missing.join(", ")}`);
+    }
+    return {
+        apiDef: result,
+        rewrite: localDeps.workingDir
+            ? { source: path.dirname(configPath), target: localDeps.workingDir }
+            : undefined,
+    };
+}

package/dist/docker/shell.mjs

@@ -0,0 +1,62 @@
+import { $ } from "execa";
+import { homedir } from "node:os";
+let PATH = undefined;
+// TODO: macOS related only
+async function getUserShell() {
+    const dscl = await $({
+        shell: true,
+    }) `dscl . -read ~/ UserShell | sed 's/UserShell: //'`;
+    return dscl.stdout.trim();
+}
+async function verifyDockerPath(PATH) {
+    await $({ env: { PATH } }) `which docker`;
+    return PATH;
+}
+// TODO: macOS related only
+async function extractPathFromShell() {
+    const pathToShell = await getUserShell().catch(() => "/bin/zsh");
+    const args = pathToShell.includes("csh")
+        ? ["-c", "echo $PATH"]
+        : ["-lc", "echo $PATH"];
+    const shell = await $(pathToShell, args);
+    return shell.stdout.trim();
+}
+// TODO: macOS related only
+async function guessUserPath() {
+    return [
+        "/bin",
+        "/usr/bin",
+        "/sbin",
+        "/usr/sbin",
+        "/opt/homebrew/bin",
+        "/opt/homebrew/sbin",
+        `${homedir()}/.local/bin`,
+        "/Applications/Docker.app/Contents/Resources/bin",
+        `${homedir()}/.docker/bin`,
+        // support for Rancher Desktop
+        // https://github.com/langchain-ai/langgraph-studio/issues/24#issuecomment-2274046328
+        // https://github.com/langchain-ai/langgraph-studio/issues/122
+        `${homedir()}/.rd/bin`,
+        `/Applications/Rancher Desktop.app/Contents/Resources/resources/darwin/bin`,
+    ].join(":");
+}
+async function getLoginPath() {
+    if (PATH)
+        return { PATH };
+    const [fromShell, fromBackup] = await Promise.allSettled([extractPathFromShell(), guessUserPath()].map((promise) => promise.then(verifyDockerPath)));
+    if (fromShell.status === "fulfilled") {
+        PATH = fromShell.value;
+    }
+    else if (fromBackup.status === "fulfilled") {
+        PATH = fromBackup.value;
+    }
+    else {
+        console.error("Failed to get PATH from shell or backup", fromShell.reason, fromBackup.reason);
+        throw fromShell.reason || fromBackup.reason;
+    }
+    return { PATH };
+}
+export async function getExecaOptions(options) {
+    const env = await getLoginPath();
+    return { ...options, env };
+}

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,71 @@
+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",
+        });
+        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);
+    });
+}