@langchain/langgraph-cli 0.0.6 → 0.0.8-dev.0

package/dist/cli/dev.mjs

@@ -37,11 +37,12 @@ builder
         });
         let hasOpenedFlag = false;
         let child = undefined;
+        let hostUrl = "https://smith.langchain.com";
         server.on("data", (data) => {
             const response = z.object({ queryParams: z.string() }).parse(data);
             if (options.browser && !hasOpenedFlag) {
                 hasOpenedFlag = true;
-                open(`https://smith.langchain.com/studio${response.queryParams}`);
+                open(`${hostUrl}/studio${response.queryParams}`);
             }
         });
         // check if .gitignore already contains .langgraph-api
@@ -78,20 +79,30 @@ builder
             const addedTarget = newWatch.filter((target) => !oldWatch.includes(target));
             const removedTarget = oldWatch.filter((target) => !newWatch.includes(target));
             watcher.unwatch(removedTarget).add(addedTarget);
-            return { config, env };
+            try {
+                const { Client } = await import("langsmith");
+                const apiUrl = env?.["LANGSMITH_ENDPOINT"] ||
+                    env?.["LANGCHAIN_ENDPOINT"] ||
+                    undefined;
+                hostUrl = new Client({ apiUrl }).getHostUrl() || hostUrl;
+            }
+            catch {
+                // pass
+            }
+            return { config, env, hostUrl };
         };
         const launchServer = async () => {
-            const { config, env } = await prepareContext();
+            const { config, env, hostUrl } = await prepareContext();
             if (child != null)
                 child.kill();
             if ("python_version" in config) {
                 logger.warn("Launching Python server from @langchain/langgraph-cli is experimental. Please use the `langgraph-cli` package from PyPi instead.");
                 const { spawnPythonServer } = await import("./dev.python.mjs");
-                child = await spawnPythonServer({ ...options, rest: args }, { configPath, config, env }, { pid, projectCwd });
+                child = await spawnPythonServer({ ...options, rest: args }, { configPath, config, env, hostUrl }, { pid, projectCwd });
             }
             else {
                 const { spawnNodeServer } = await import("./dev.node.mjs");
-                child = await spawnNodeServer({ ...options, rest: args }, { configPath, config, env }, { pid, projectCwd });
+                child = await spawnNodeServer({ ...options, rest: args }, { configPath, config, env, hostUrl }, { pid, projectCwd });
             }
         };
         watcher.on("all", async (_name, path) => {

package/dist/cli/dev.node.mjs

@@ -3,7 +3,7 @@ import { spawn } from "node:child_process";
 import {} from "../utils/config.mjs";
 export async function spawnNodeServer(args, context, options) {
     const localUrl = `http://${args.host}:${args.port}`;
-    const studioUrl = `https://smith.langchain.com/studio?baseUrl=${localUrl}`;
+    const studioUrl = `${context.hostUrl}/studio?baseUrl=${localUrl}`;
     console.log(`
           Welcome to
 

package/dist/docker/docker.mjs

@@ -12,21 +12,6 @@ async function exists(path) {
     }
 }
 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",
@@ -54,7 +39,8 @@ export async function assembleLocalDeps(configPath, config) {
     const rebuildFiles = [];
     let workingDir;
     let reloadDir;
-    for (const localDep of config.dependencies) {
+    const dependencies = "dependencies" in config ? config.dependencies : [];
+    for (const localDep of dependencies) {
         if (!localDep.startsWith("."))
             continue;
         const resolved = path.resolve(path.dirname(configPath), localDep);
@@ -130,6 +116,19 @@ export async function assembleLocalDeps(configPath, config) {
             }
         }
     }
+    if ("node_version" in config) {
+        for (const name of [
+            "package.json",
+            "package-lock.json",
+            "yarn.lock",
+            "pnpm-lock.yaml",
+            "bun.lockb",
+        ]) {
+            const jsFile = path.resolve(path.dirname(configPath), name);
+            rebuildFiles.push(jsFile);
+        }
+        workingDir ??= `/deps/${path.basename(path.dirname(configPath))}`;
+    }
     return { pipReqs, realPkgs, fauxPkgs, workingDir, reloadDir, rebuildFiles };
 }
 async function updateGraphPaths(configPath, config, localDeps) {
@@ -168,30 +167,59 @@ async function updateGraphPaths(configPath, config, localDeps) {
     }
 }
 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);
+        return `langchain/langgraph-api:${config._INTERNAL_docker_tag || config.python_version}`;
     }
     throw new Error("Invalid config type");
 }
-export async function nodeConfigToDocker(configPath, config, localDeps, options) {
+export async function configToDocker(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))
+        .stat(path.resolve(path.dirname(configPath), file))
         .then((a) => a.isFile())
         .catch(() => false);
+    let pipInstall = `PYTHONDONTWRITEBYTECODE=1 pip install -c /api/constraints.txt`;
+    if ("python_version" in config && config.pip_config_file) {
+        pipInstall = `PIP_CONFIG_FILE=/pipconfig.txt ${pipInstall}`;
+    }
+    pipInstall = `--mount=type=cache,target=/root/.cache/pip ${pipInstall}`;
+    const pipConfigFile = "python_version" in config && config.pip_config_file
+        ? `ADD ${config.pip_config_file} /pipconfig.txt`
+        : undefined;
+    const _pypiDeps = "python_version" in config
+        ? config.dependencies.filter((dep) => !dep.startsWith("."))
+        : [];
+    await updateGraphPaths(configPath, config, localDeps);
+    const pipPkgs = _pypiDeps.length
+        ? `RUN ${pipInstall} ${_pypiDeps.join(" ")}`
+        : undefined;
+    const pipReqs = localDeps.pipReqs.map(([reqpath, destpath]) => `ADD ${reqpath} ${destpath}`);
+    if (pipReqs.length) {
+        pipReqs.push(`RUN ${pipInstall} ${localDeps.pipReqs.map(([, r]) => `-r ${r}`).join(" ")}`);
+    }
+    const localPkg = Object.entries(localDeps.realPkgs).map(([fullpath, relpath]) => `ADD ${relpath} /deps/${path.basename(fullpath)}`);
+    const fauxPkgs = Object.entries(localDeps.fauxPkgs).flatMap(([fullpath, [relpath, destpath]]) => [
+        `ADD ${relpath} ${destpath}`,
+        dedenter `
+        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
+      `,
+    ]);
+    if (!pipReqs.length &&
+        !localPkg.length &&
+        !fauxPkgs.length &&
+        "node_version" in config) {
+        pipReqs.push(`ADD . ${localDeps.workingDir}`);
+    }
     const [npm, yarn, pnpm, bun] = await Promise.all([
         testFile("package-lock.json"),
         testFile("yarn.lock"),
@@ -213,94 +241,31 @@ export async function nodeConfigToDocker(configPath, config, localDeps, options)
     }
     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/*`,
+        config.dockerfile_lines,
+        pipConfigFile,
+        pipPkgs,
+        pipReqs,
+        localPkg,
+        fauxPkgs,
+        "python_version" in config ? `RUN ${pipInstall} -e /deps/*` : undefined,
         `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,
+        !!config.store && `ENV LANGGRAPH_STORE='${JSON.stringify(config.store)}'`,
+        !!config.auth && `ENV LANGGRAPH_AUTH='${JSON.stringify(config.auth)}'`,
+        !!localDeps.workingDir && `WORKDIR ${localDeps.workingDir}`,
+        "node_version" in config
+            ? [
+                `RUN ${installCmd}`,
+                `RUN (test ! -f /api/langgraph_api/js/build.mts && echo "Prebuild script not found, skipping") || tsx /api/langgraph_api/js/build.mts`,
+            ]
+            : undefined,
     ];
     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");
+    return lines.flat().filter(Boolean).join("\n");
 }
-export async function configToWatch(configPath, config) {
-    const localDeps = await assembleLocalDeps(configPath, config);
+export async function configToWatch(configPath, config, localDeps) {
     const projectDir = path.dirname(configPath);
     const watch = [];
     const watchSources = "python_version" in config
@@ -367,7 +332,7 @@ export async function configToCompose(configPath, config, options) {
         });
     }
     if (options?.watch) {
-        const watch = await configToWatch(configPath, config);
+        const watch = await configToWatch(configPath, config, localDeps);
         if (watch)
             result.develop = { watch };
     }

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

@@ -41,7 +41,9 @@ type Inspect<T> = T extends unknown
 
 type ReflectCompiled<T> = T extends { RunInput: infer S; RunOutput: infer U }
   ? { state: S; update: U }
-  : never;
+  : T extends { "~InputType": infer InputType; "~OutputType": infer OutputType }
+    ? { state: OutputType; update: InputType }
+    : never;
 
 // @ts-expect-error
 type Reflect<T> =

package/dist/logging.mjs

@@ -50,27 +50,32 @@ const formatStack = (stack) => {
     const [firstFile] = stacktraceParser(stack).filter((item) => !item.file?.split(path.sep).includes("node_modules") &&
         !item.file?.startsWith("node:"));
     if (firstFile?.file && firstFile?.lineNumber) {
-        const filePath = firstFile.file;
-        const line = firstFile.lineNumber;
-        const column = firstFile.column ?? 0;
-        const messageLines = stack.split("\n");
-        const spliceIndex = messageLines.findIndex((i) => i.includes(filePath));
-        const padding = " ".repeat(Math.max(0, messageLines[spliceIndex].indexOf("at")));
-        const highlightCode = process.stdout.isTTY;
-        let codeFrame = codeFrameColumns(readFileSync(filePath, "utf-8"), { start: { line, column } }, { highlightCode });
-        codeFrame = codeFrame
-            .split("\n")
-            .map((i) => padding + i + "\x1b[0m")
-            .join("\n");
-        if (highlightCode) {
-            codeFrame = "\x1b[36m" + codeFrame + "\x1b[31m";
+        try {
+            const filePath = firstFile.file;
+            const line = firstFile.lineNumber;
+            const column = firstFile.column ?? 0;
+            const messageLines = stack.split("\n");
+            const spliceIndex = messageLines.findIndex((i) => i.includes(filePath));
+            const padding = " ".repeat(Math.max(0, messageLines[spliceIndex].indexOf("at")));
+            const highlightCode = process.stdout.isTTY;
+            let codeFrame = codeFrameColumns(readFileSync(filePath, "utf-8"), { start: { line, column } }, { highlightCode });
+            codeFrame = codeFrame
+                .split("\n")
+                .map((i) => padding + i + "\x1b[0m")
+                .join("\n");
+            if (highlightCode) {
+                codeFrame = "\x1b[36m" + codeFrame + "\x1b[31m";
+            }
+            // insert codeframe after the line but dont lose the stack
+            return [
+                ...messageLines.slice(0, spliceIndex + 1),
+                codeFrame,
+                ...messageLines.slice(spliceIndex + 1),
+            ].join("\n");
+        }
+        catch {
+            // pass
         }
-        // insert codeframe after the line but dont lose the stack
-        return [
-            ...messageLines.slice(0, spliceIndex + 1),
-            codeFrame,
-            ...messageLines.slice(spliceIndex + 1),
-        ].join("\n");
     }
     return stack;
 };

package/dist/utils/config.mjs

@@ -1,47 +1,71 @@
 import { z } from "zod";
-const AuthConfigSchema = z.object({
-    path: z.string().optional(),
-    disable_studio_auth: z.boolean().default(false),
-});
-const IndexConfigSchema = z.object({
-    dims: z.number().optional(),
-    embed: z.string().optional(),
-    fields: z.array(z.string()).optional(),
-});
-const StoreConfigSchema = z.object({
-    index: IndexConfigSchema.optional(),
-});
+import { extname } from "node:path";
 const BaseConfigSchema = z.object({
     docker_compose_file: z.string().optional(),
     dockerfile_lines: z.array(z.string()).default([]),
-    graphs: z.record(z.string()),
+    graphs: z.record(z.string().refine((i) => i.includes(":"), {
+        message: "Import string must be in format '<file>:<export>'",
+    })),
+    _INTERNAL_docker_tag: z.string().optional(),
     env: z
         .union([z.array(z.string()), z.record(z.string()), z.string()])
         .default({}),
-    store: StoreConfigSchema.optional(),
-    _INTERNAL_docker_tag: z.string().optional(),
-    auth: AuthConfigSchema.optional(),
+    store: z
+        .object({
+        index: z
+            .object({
+            dims: z.number().optional(),
+            embed: z.string().optional(),
+            fields: z.array(z.string()).optional(),
+        })
+            .optional(),
+    })
+        .optional(),
+    auth: z
+        .object({
+        path: z.string().optional(),
+        disable_studio_auth: z.boolean().default(false),
+    })
+        .optional(),
 });
+const DEFAULT_PYTHON_VERSION = "3.11";
+const DEFAULT_NODE_VERSION = "20";
+const PYTHON_EXTENSIONS = [".py", ".pyx", ".pyd", ".pyi"];
+const PythonVersionSchema = z.union([z.literal("3.11"), z.literal("3.12")]);
+const NodeVersionSchema = z.literal("20");
 const PythonConfigSchema = BaseConfigSchema.merge(z.object({
-    python_version: z
-        .union([z.literal("3.11"), z.literal("3.12")])
-        .default("3.11"),
     pip_config_file: z.string().optional(),
     dependencies: z
         .array(z.string())
         .nonempty("You need to specify at least one dependency"),
+})).merge(z.object({
+    python_version: PythonVersionSchema.default(DEFAULT_PYTHON_VERSION),
+    node_version: NodeVersionSchema.optional(),
 }));
-const NodeConfigSchema = BaseConfigSchema.merge(z.object({ node_version: z.literal("20").default("20") }));
+const NodeConfigSchema = BaseConfigSchema.merge(z.object({ node_version: NodeVersionSchema.default(DEFAULT_NODE_VERSION) }));
 const ConfigSchema = z.union([NodeConfigSchema, PythonConfigSchema]);
-import * as path from "node:path";
-const PYTHON_EXTENSIONS = [".py", ".pyx", ".pyd", ".pyi"];
 // TODO: implement this in Python CLI
 export const getConfig = (config) => {
-    const rawConfig = typeof config === "string" ? JSON.parse(config) : config;
-    const { graphs } = BaseConfigSchema.parse(rawConfig);
-    const preferPython = Object.values(graphs).every((i) => PYTHON_EXTENSIONS.includes(path.extname(i.split(":")[0])));
-    if (preferPython) {
-        return z.union([PythonConfigSchema, NodeConfigSchema]).parse(rawConfig);
+    let input = typeof config === "string" ? JSON.parse(config) : config;
+    const { graphs } = BaseConfigSchema.parse(input);
+    const isPython = Object.values(graphs).map((i) => PYTHON_EXTENSIONS.includes(extname(i.split(":")[0])));
+    const somePython = isPython.some((i) => i);
+    const someNode = !isPython.every((i) => i);
+    const node_version = someNode
+        ? input.node_version || DEFAULT_NODE_VERSION
+        : undefined;
+    const python_version = somePython
+        ? input.python_version || (someNode ? "3.12" : DEFAULT_PYTHON_VERSION)
+        : undefined;
+    if (node_version && python_version && python_version !== "3.12") {
+        throw new Error("Only Python 3.12 is supported with Node.js");
     }
-    return z.union([NodeConfigSchema, PythonConfigSchema]).parse(rawConfig);
+    input = { ...input, node_version, python_version };
+    if (!input.node_version)
+        delete input.node_version;
+    if (!input.python_version)
+        delete input.python_version;
+    if (python_version)
+        return PythonConfigSchema.parse(input);
+    return NodeConfigSchema.parse(input);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/langgraph-cli",
-  "version": "0.0.6",
+  "version": "0.0.8-dev.0",
   "type": "module",
   "engines": {
     "node": ">=18"
@@ -51,9 +51,9 @@
     "@babel/code-frame": "^7.26.2"
   },
   "peerDependencies": {
-    "@langchain/core": "^0.3.27",
-    "@langchain/langgraph": "^0.2.39",
-    "@langchain/langgraph-checkpoint": "^0.0.13",
+    "@langchain/core": "^0.3.36",
+    "@langchain/langgraph": "^0.2.42",
+    "@langchain/langgraph-checkpoint": "^0.0.14",
     "typescript": "^5.5.4"
   },
   "devDependencies": {