@langchain/langgraph-cli 0.0.0-preview.10

package/dist/api/threads.mjs

@@ -0,0 +1,145 @@
+import { zValidator } from "@hono/zod-validator";
+import { Hono } from "hono";
+import { v4 as uuid4 } from "uuid";
+import * as schemas from "../schemas.mjs";
+import { Threads } from "../storage/ops.mjs";
+import { z } from "zod";
+import { stateSnapshotToThreadState } from "../state.mjs";
+import { jsonExtra } from "../utils/hono.mjs";
+const api = new Hono();
+// Threads Routes
+api.post("/threads", zValidator("json", schemas.ThreadCreate), async (c) => {
+    // Create Thread
+    const payload = c.req.valid("json");
+    const thread = await Threads.put(payload.thread_id || uuid4(), {
+        metadata: payload.metadata,
+        if_exists: payload.if_exists ?? "raise",
+    });
+    return jsonExtra(c, thread);
+});
+api.post("/threads/search", zValidator("json", schemas.ThreadSearchRequest), async (c) => {
+    // Search Threads
+    const payload = c.req.valid("json");
+    const result = [];
+    for await (const item of Threads.search({
+        status: payload.status,
+        values: payload.values,
+        metadata: payload.metadata,
+        limit: payload.limit ?? 10,
+        offset: payload.offset ?? 0,
+    })) {
+        result.push({
+            ...item,
+            created_at: item.created_at.toISOString(),
+            updated_at: item.updated_at.toISOString(),
+        });
+    }
+    return jsonExtra(c, result);
+});
+api.get("/threads/:thread_id/state", zValidator("param", z.object({ thread_id: z.string().uuid() })), zValidator("query", z.object({ subgraphs: schemas.coercedBoolean.optional() })), async (c) => {
+    // Get Latest Thread State
+    const { thread_id } = c.req.valid("param");
+    const { subgraphs } = c.req.valid("query");
+    const state = stateSnapshotToThreadState(await Threads.State.get({ configurable: { thread_id } }, { subgraphs }));
+    return jsonExtra(c, state);
+});
+api.post("/threads/:thread_id/state", zValidator("param", z.object({ thread_id: z.string().uuid() })), zValidator("json", z.object({
+    values: z.union([
+        z.record(z.string(), z.unknown()),
+        z.array(z.record(z.string(), z.unknown())),
+    ]),
+    as_node: z.string().optional(),
+    checkpoint_id: z.string().optional(),
+    checkpoint: z.record(z.string(), z.unknown()).optional(),
+})), async (c) => {
+    // Update Thread State
+    const { thread_id } = c.req.valid("param");
+    const payload = c.req.valid("json");
+    const config = { configurable: { thread_id } };
+    if (payload.checkpoint_id) {
+        config.configurable ??= {};
+        config.configurable.checkpoint_id = payload.checkpoint_id;
+    }
+    if (payload.checkpoint) {
+        config.configurable ??= {};
+        Object.assign(config.configurable, payload.checkpoint);
+    }
+    const inserted = await Threads.State.post(config, payload.values, payload.as_node);
+    return jsonExtra(c, inserted);
+});
+api.get("/threads/:thread_id/state/:checkpoint_id", zValidator("param", z.object({ thread_id: z.string().uuid(), checkpoint_id: z.string().uuid() })), zValidator("query", z.object({ subgraphs: schemas.coercedBoolean.optional() })), async (c) => {
+    // Get Thread State At Checkpoint
+    const { thread_id, checkpoint_id } = c.req.valid("param");
+    const { subgraphs } = c.req.valid("query");
+    const state = stateSnapshotToThreadState(await Threads.State.get({ configurable: { thread_id, checkpoint_id } }, { subgraphs }));
+    return jsonExtra(c, state);
+});
+api.post("/threads/:thread_id/state/checkpoint", zValidator("param", z.object({ thread_id: z.string().uuid() })), zValidator("json", z.object({
+    subgraphs: schemas.coercedBoolean.optional(),
+    checkpoint: z.object({
+        checkpoint_id: z.string().uuid().optional(),
+        checkpoint_ns: z.string().optional(),
+        checkpoint_map: z.record(z.string(), z.unknown()).optional(),
+    }),
+})), async (c) => {
+    // Get Thread State At Checkpoint Post
+    const { thread_id } = c.req.valid("param");
+    const { checkpoint, subgraphs } = c.req.valid("json");
+    const state = stateSnapshotToThreadState(await Threads.State.get({ configurable: { thread_id, ...checkpoint } }, { subgraphs }));
+    return jsonExtra(c, state);
+});
+api.get("/threads/:thread_id/history", zValidator("param", z.object({ thread_id: z.string().uuid() })), zValidator("query", z.object({
+    limit: z
+        .string()
+        .optional()
+        .default("10")
+        .transform((value) => parseInt(value, 10)),
+    before: z.string().optional(),
+})), async (c) => {
+    // Get Thread History
+    const { thread_id } = c.req.valid("param");
+    const { limit, before } = c.req.valid("query");
+    const states = await Threads.State.list({ configurable: { thread_id, checkpoint_ns: "" } }, { limit, before });
+    return jsonExtra(c, states.map(stateSnapshotToThreadState));
+});
+api.post("/threads/:thread_id/history", zValidator("param", z.object({ thread_id: z.string().uuid() })), zValidator("json", z.object({
+    limit: z.number().optional().default(10),
+    before: z.string().optional(),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+    checkpoint: z
+        .object({
+        checkpoint_id: z.string().uuid().optional(),
+        checkpoint_ns: z.string().optional(),
+        checkpoint_map: z.record(z.string(), z.unknown()).optional(),
+    })
+        .optional(),
+})), async (c) => {
+    // Get Thread History Post
+    const { thread_id } = c.req.valid("param");
+    const { limit, before, metadata, checkpoint } = c.req.valid("json");
+    const states = await Threads.State.list({ configurable: { thread_id, checkpoint_ns: "", ...checkpoint } }, { limit, before, metadata });
+    return jsonExtra(c, states.map(stateSnapshotToThreadState));
+});
+api.get("/threads/:thread_id", zValidator("param", z.object({ thread_id: z.string().uuid() })), async (c) => {
+    // Get Thread
+    const { thread_id } = c.req.valid("param");
+    return jsonExtra(c, await Threads.get(thread_id));
+});
+api.delete("/threads/:thread_id", zValidator("param", z.object({ thread_id: z.string().uuid() })), async (c) => {
+    // Delete Thread
+    const { thread_id } = c.req.valid("param");
+    await Threads.delete(thread_id);
+    return new Response(null, { status: 204 });
+});
+api.patch("/threads/:thread_id", zValidator("param", z.object({ thread_id: z.string().uuid() })), zValidator("json", z.object({ metadata: z.record(z.string(), z.unknown()) })), async (c) => {
+    // Patch Thread
+    const { thread_id } = c.req.valid("param");
+    const { metadata } = c.req.valid("json");
+    return jsonExtra(c, await Threads.patch(thread_id, { metadata }));
+});
+api.post("/threads/:thread_id/copy", zValidator("param", z.object({ thread_id: z.string().uuid() })), async (c) => {
+    // Copy Thread
+    const { thread_id } = c.req.valid("param");
+    return jsonExtra(c, await Threads.copy(thread_id));
+});
+export default api;

package/dist/cli/build.mjs

@@ -0,0 +1,49 @@
+import { getDockerCapabilities } from "../docker/compose.mjs";
+import { assembleLocalDeps, configToDocker, getBaseImage, } from "../docker/docker.mjs";
+import { getExecaOptions } from "../docker/shell.mjs";
+import { getConfig } from "../utils/config.mjs";
+import { builder } from "./utils/builder.mjs";
+import { getProjectPath } from "./utils/project.mjs";
+import { $ } from "execa";
+import * as path from "node:path";
+import * as fs from "node:fs/promises";
+import { logger } from "../logging.mjs";
+import { withAnalytics } from "./utils/analytics.mjs";
+const stream = (proc) => {
+    logger.info(`Running "${proc.spawnargs.join(" ")}"`);
+    return proc;
+};
+builder
+    .command("build")
+    .description("Build LangGraph API server Docker image.")
+    .requiredOption("-t, --tag <tag>", "Tag for the Docker image.")
+    .option("-c, --config <path>", "Path to configuration file", process.cwd())
+    .option("--no-pull", "Running the server with locally-built images. By default LangGraph will pull the latest images from the registry")
+    .argument("[args...]")
+    .passThroughOptions()
+    .hook("preAction", withAnalytics((command) => ({
+    config: command.opts().config !== process.cwd(),
+    pull: command.opts().pull,
+})))
+    .action(async (pass, params) => {
+    const configPath = await getProjectPath(params.config);
+    await getDockerCapabilities();
+    const projectDir = path.dirname(configPath);
+    const config = getConfig(await fs.readFile(configPath, "utf-8"));
+    const opts = await getExecaOptions({
+        cwd: projectDir,
+        stderr: "inherit",
+        stdout: "inherit",
+    });
+    const localDeps = await assembleLocalDeps(configPath, config);
+    const input = await configToDocker(configPath, config, localDeps, {
+        watch: false,
+        dockerCommand: "build",
+    });
+    let exec = $({ ...opts, input });
+    if (params.pull) {
+        await stream(exec `docker pull ${getBaseImage(config)}`);
+    }
+    exec = $({ ...opts, input });
+    await stream(exec `docker build -f - -t ${params.tag} ${projectDir} ${pass}`);
+});

package/dist/cli/cli.mjs

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+import { builder } from "./utils/builder.mjs";
+import { flushAnalytics } from "./utils/analytics.mjs";
+import { asyncExitHook, gracefulExit } from "exit-hook";
+import "./dev.mjs";
+import "./docker.mjs";
+import "./build.mjs";
+import "./up.mjs";
+builder.exitOverride((error) => gracefulExit(error.exitCode));
+asyncExitHook(() => flushAnalytics(), { wait: 2000 });
+builder.parse();

package/dist/cli/dev.mjs

@@ -0,0 +1,113 @@
+import * as path from "node:path";
+import * as fs from "node:fs/promises";
+import { parse, populate } from "dotenv";
+import { watch } from "chokidar";
+import { z } from "zod";
+import open from "open";
+import { createIpcServer } from "./utils/ipc/server.mjs";
+import { getProjectPath } from "./utils/project.mjs";
+import { getConfig } from "../utils/config.mjs";
+import { builder } from "./utils/builder.mjs";
+import { logError, logger } from "../logging.mjs";
+import { withAnalytics } from "./utils/analytics.mjs";
+builder
+    .command("dev")
+    .description("Run LangGraph API server in development mode with hot reloading.")
+    .option("-p, --port <number>", "port to run the server on", "2024")
+    .option("-h, --host <string>", "host to bind to", "localhost")
+    .option("--no-browser", "disable auto-opening the browser")
+    .option("-n, --n-jobs-per-worker <number>", "number of workers to run", "10")
+    .option("-c, --config <path>", "path to configuration file", process.cwd())
+    .allowExcessArguments()
+    .allowUnknownOption()
+    .hook("preAction", withAnalytics((command) => ({
+    config: command.opts().config !== process.cwd(),
+    port: command.opts().port !== "2024",
+    host: command.opts().host !== "localhost",
+    n_jobs_per_worker: command.opts().nJobsPerWorker !== "10",
+})))
+    .action(async (options, { args }) => {
+    try {
+        const configPath = await getProjectPath(options.config);
+        const projectCwd = path.dirname(configPath);
+        const [pid, server] = await createIpcServer();
+        const watcher = watch([configPath], {
+            ignoreInitial: true,
+            cwd: projectCwd,
+        });
+        let hasOpenedFlag = false;
+        let child = undefined;
+        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}`);
+            }
+        });
+        // check if .gitignore already contains .langgraph-api
+        const gitignorePath = path.resolve(projectCwd, ".gitignore");
+        const gitignoreContent = await fs
+            .readFile(gitignorePath, "utf-8")
+            .catch(() => "");
+        if (!gitignoreContent.includes(".langgraph_api")) {
+            logger.info("Updating .gitignore to prevent `.langgraph_api` from being committed.");
+            await fs.appendFile(gitignorePath, "\n# LangGraph API\n.langgraph_api\n");
+        }
+        const prepareContext = async () => {
+            const config = getConfig(await fs.readFile(configPath, "utf-8"));
+            const newWatch = [configPath];
+            const env = { ...process.env };
+            const configEnv = config?.env;
+            if (configEnv) {
+                if (typeof configEnv === "string") {
+                    const envPath = path.resolve(projectCwd, configEnv);
+                    newWatch.push(envPath);
+                    const envData = await fs.readFile(envPath, "utf-8");
+                    populate(env, parse(envData));
+                }
+                else if (Array.isArray(configEnv)) {
+                    throw new Error("Env storage is not supported by CLI.");
+                }
+                else if (typeof configEnv === "object") {
+                    if (!process.env)
+                        throw new Error("process.env is not defined");
+                    populate(env, configEnv);
+                }
+            }
+            const oldWatch = Object.entries(watcher.getWatched()).flatMap(([dir, files]) => files.map((file) => path.resolve(projectCwd, dir, file)));
+            const addedTarget = newWatch.filter((target) => !oldWatch.includes(target));
+            const removedTarget = oldWatch.filter((target) => !newWatch.includes(target));
+            watcher.unwatch(removedTarget).add(addedTarget);
+            return { config, env };
+        };
+        const launchServer = async () => {
+            const { config, env } = 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 });
+            }
+            else {
+                const { spawnNodeServer } = await import("./dev.node.mjs");
+                child = await spawnNodeServer({ ...options, rest: args }, { configPath, config, env }, { pid, projectCwd });
+            }
+        };
+        watcher.on("all", async (_name, path) => {
+            logger.warn(`Detected changes in ${path}, restarting server`);
+            launchServer();
+        });
+        // TODO: sometimes the server keeps sending stuff
+        // while gracefully exiting
+        launchServer();
+        process.on("exit", () => {
+            watcher.close();
+            server.close();
+            child?.kill();
+        });
+    }
+    catch (error) {
+        logError(error, { prefix: "Failed to launch server" });
+    }
+});

package/dist/cli/dev.node.entrypoint.mjs

@@ -0,0 +1,40 @@
+import "../preload.mjs";
+import { asyncExitHook } from "exit-hook";
+import * as process from "node:process";
+import { startServer, StartServerSchema } from "../server.mjs";
+import { connectToServer } from "./utils/ipc/client.mjs";
+import { Client as LangSmithClient } from "langsmith";
+import { logger } from "../logging.mjs";
+logger.info(`Starting server...`);
+const [ppid, payload] = process.argv.slice(-2);
+const sendToParent = await connectToServer(+ppid);
+// TODO: re-export langsmith/isTracingEnabled
+const isTracingEnabled = () => {
+    const value = process.env?.LANGSMITH_TRACING_V2 ||
+        process.env?.LANGCHAIN_TRACING_V2 ||
+        process.env?.LANGSMITH_TRACING ||
+        process.env?.LANGCHAIN_TRACING;
+    return value === "true";
+};
+const options = StartServerSchema.parse(JSON.parse(payload));
+const [{ host, cleanup }, organizationId] = await Promise.all([
+    startServer(options),
+    (async () => {
+        if (isTracingEnabled()) {
+            try {
+                // @ts-expect-error Private method
+                return new LangSmithClient()._getTenantId();
+            }
+            catch (error) {
+                logger.warn("Failed to get organization ID", { error });
+            }
+        }
+        return null;
+    })(),
+]);
+logger.info(`Server running at ${host}`);
+let queryParams = `?baseUrl=http://${options.host}:${options.port}`;
+if (organizationId)
+    queryParams += `&organizationId=${organizationId}`;
+asyncExitHook(cleanup, { wait: 1000 });
+sendToParent?.({ queryParams });

package/dist/cli/dev.node.mjs

@@ -0,0 +1,35 @@
+import { fileURLToPath } from "node:url";
+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}`;
+    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("./dev.node.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/dev.python.mjs

@@ -0,0 +1,128 @@
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { Readable } from "node:stream";
+import fs from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+import { extract as tarExtract } from "tar";
+import zipExtract from "extract-zip";
+import { logger } from "../logging.mjs";
+import { assembleLocalDeps } from "../docker/docker.mjs";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const UV_VERSION = "0.5.20";
+const UV_BINARY_CACHE = path.join(__dirname, ".uv", UV_VERSION);
+function getPlatformInfo() {
+    const platform = os.platform();
+    const arch = os.arch();
+    let binaryName = "uv";
+    let extension = "";
+    if (platform === "win32") {
+        extension = ".exe";
+    }
+    return {
+        platform,
+        arch,
+        extension,
+        binaryName: binaryName + extension,
+    };
+}
+function getDownloadUrl(info) {
+    let platformStr;
+    switch (info.platform) {
+        case "darwin":
+            platformStr = "apple-darwin";
+            break;
+        case "win32":
+            platformStr = "pc-windows-msvc";
+            break;
+        case "linux":
+            platformStr = "unknown-linux-gnu";
+            break;
+        default:
+            throw new Error(`Unsupported platform: ${info.platform}`);
+    }
+    let archStr;
+    switch (info.arch) {
+        case "x64":
+            archStr = "x86_64";
+            break;
+        case "arm64":
+            archStr = "aarch64";
+            break;
+        default:
+            throw new Error(`Unsupported architecture: ${info.arch}`);
+    }
+    const fileName = `uv-${archStr}-${platformStr}${info.platform === "win32" ? ".zip" : ".tar.gz"}`;
+    return `https://github.com/astral-sh/uv/releases/download/${UV_VERSION}/${fileName}`;
+}
+async function downloadAndExtract(url, destPath, info) {
+    const response = await fetch(url);
+    if (!response.ok)
+        throw new Error(`Failed to download uv: ${response.statusText}`);
+    if (!response.body)
+        throw new Error("No response body");
+    const tempDirPath = await fs.mkdtemp(path.join(os.tmpdir(), "uv-"));
+    const tempFilePath = path.join(tempDirPath, path.basename(url));
+    try {
+        // @ts-expect-error invalid types for response.body
+        await fs.writeFile(tempFilePath, Readable.fromWeb(response.body));
+        let sourceBinaryPath = tempDirPath;
+        if (url.endsWith(".zip")) {
+            await zipExtract(tempFilePath, { dir: tempDirPath });
+        }
+        else {
+            await tarExtract({ file: tempFilePath, cwd: tempDirPath });
+            sourceBinaryPath = path.resolve(sourceBinaryPath, path.basename(tempFilePath).slice(0, ".tar.gz".length * -1));
+        }
+        sourceBinaryPath = path.resolve(sourceBinaryPath, info.binaryName);
+        // Move binary to cache directory
+        const targetBinaryPath = path.join(destPath, info.binaryName);
+        await fs.rename(sourceBinaryPath, targetBinaryPath);
+        await fs.chmod(targetBinaryPath, 0o755);
+        return targetBinaryPath;
+    }
+    finally {
+        await fs.rm(tempDirPath, { recursive: true, force: true });
+    }
+}
+export async function getUvBinary() {
+    await fs.mkdir(UV_BINARY_CACHE, { recursive: true });
+    const info = getPlatformInfo();
+    const cachedBinaryPath = path.join(UV_BINARY_CACHE, info.binaryName);
+    try {
+        await fs.access(cachedBinaryPath);
+        return cachedBinaryPath;
+    }
+    catch {
+        // Binary not found in cache, download it
+        logger.info(`Downloading uv ${UV_VERSION} for ${info.platform}...`);
+        const url = getDownloadUrl(info);
+        return await downloadAndExtract(url, UV_BINARY_CACHE, info);
+    }
+}
+export async function spawnPythonServer(args, context, options) {
+    const deps = await assembleLocalDeps(context.configPath, context.config);
+    const requirements = deps.rebuildFiles.filter((i) => i.endsWith(".txt"));
+    return spawn(await getUvBinary(), [
+        "run",
+        "--with",
+        "langgraph-cli[inmem]",
+        ...requirements?.flatMap((i) => ["--with-requirements", i]),
+        "langgraph",
+        "dev",
+        "--port",
+        args.port,
+        "--host",
+        args.host,
+        "--n-jobs-per-worker",
+        args.nJobsPerWorker,
+        "--config",
+        context.configPath,
+        ...(args.browser ? [] : ["--no-browser"]),
+        ...args.rest,
+    ], {
+        stdio: ["inherit", "inherit", "inherit"],
+        env: context.env,
+        cwd: options.projectCwd,
+    });
+}

package/dist/cli/docker.mjs

@@ -0,0 +1,112 @@
+import { assembleLocalDeps, configToCompose, configToDocker, } from "../docker/docker.mjs";
+import { createCompose, getDockerCapabilities } from "../docker/compose.mjs";
+import { getConfig } from "../utils/config.mjs";
+import { getProjectPath } from "./utils/project.mjs";
+import { builder } from "./utils/builder.mjs";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import dedent from "dedent";
+import { logger } from "../logging.mjs";
+import { withAnalytics } from "./utils/analytics.mjs";
+const fileExists = async (path) => {
+    try {
+        await fs.access(path);
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+};
+builder
+    .command("dockerfile")
+    .description("Generate a Dockerfile for the LangGraph API server, with Docker Compose options.")
+    .argument("<save-path>", "Path to save the Dockerfile")
+    .option("--add-docker-compose", "Add additional files for running the LangGraph API server with docker-compose. These files include a docker-compose.yml, .env file, and a .dockerignore file.")
+    .option("-c, --config <path>", "Path to configuration file", process.cwd())
+    .hook("preAction", withAnalytics((command) => ({
+    config: command.opts().config !== process.cwd(),
+    add_docker_compose: !!command.opts().addDockerCompose,
+})))
+    .action(async (savePath, options) => {
+    const configPath = await getProjectPath(options.config);
+    const config = getConfig(await fs.readFile(configPath, "utf-8"));
+    const localDeps = await assembleLocalDeps(configPath, config);
+    const dockerfile = await configToDocker(configPath, config, localDeps);
+    if (savePath === "-") {
+        process.stdout.write(dockerfile);
+        process.stdout.write("\n");
+        return;
+    }
+    const targetPath = path.resolve(process.cwd(), savePath);
+    await fs.writeFile(targetPath, dockerfile);
+    logger.info(`✅ Created: ${path.basename(targetPath)}`);
+    if (options.addDockerCompose) {
+        const { apiDef } = await configToCompose(configPath, config, {
+            watch: false,
+        });
+        const capabilities = await getDockerCapabilities();
+        const compose = createCompose(capabilities, { apiDef });
+        const composePath = path.resolve(path.dirname(targetPath), "docker-compose.yml");
+        await fs.writeFile(composePath, compose);
+        logger.info("✅ Created: .docker-compose.yml");
+        const dockerignorePath = path.resolve(path.dirname(targetPath), ".dockerignore");
+        if (!fileExists(dockerignorePath)) {
+            await fs.writeFile(dockerignorePath, dedent `
+            # Ignore node_modules and other dependency directories
+            node_modules
+            bower_components
+            vendor
+  
+            # Ignore logs and temporary files
+            *.log
+            *.tmp
+            *.swp
+  
+            # Ignore .env files and other environment files
+            .env
+            .env.*
+            *.local
+  
+            # Ignore git-related files
+            .git
+            .gitignore
+  
+            # Ignore Docker-related files and configs
+            .dockerignore
+            docker-compose.yml
+  
+            # Ignore build and cache directories
+            dist
+            build
+            .cache
+            __pycache__
+  
+            # Ignore IDE and editor configurations
+            .vscode
+            .idea
+            *.sublime-project
+            *.sublime-workspace
+            .DS_Store  # macOS-specific
+  
+            # Ignore test and coverage files
+            coverage
+            *.coverage
+            *.test.js
+            *.spec.js
+            tests
+          `);
+            logger.info(`✅ Created: ${path.basename(dockerignorePath)}`);
+        }
+        const envPath = path.resolve(path.dirname(targetPath), ".env");
+        if (!fileExists(envPath)) {
+            await fs.writeFile(envPath, dedent `
+            # Uncomment the following line to add your LangSmith API key
+            # LANGSMITH_API_KEY=your-api-key
+            # Or if you have a LangGraph Cloud license key, then uncomment the following line:
+            # LANGGRAPH_CLOUD_LICENSE_KEY=your-license-key
+            # Add any other environment variables go below...
+          `);
+            logger.info(`✅ Created: ${path.basename(envPath)}`);
+        }
+    }
+});