@langchain/langgraph-cli 0.0.0-preview.10

package/dist/cli/up.mjs

@@ -0,0 +1,137 @@
+import { builder } from "./utils/builder.mjs";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { getConfig } from "../utils/config.mjs";
+import { getProjectPath } from "./utils/project.mjs";
+import { logger } from "../logging.mjs";
+import { createCompose, getDockerCapabilities } from "../docker/compose.mjs";
+import { configToCompose, getBaseImage } from "../docker/docker.mjs";
+import { getExecaOptions } from "../docker/shell.mjs";
+import { $ } from "execa";
+import { createHash } from "node:crypto";
+import dedent from "dedent";
+import { withAnalytics } from "./utils/analytics.mjs";
+const sha256 = (input) => createHash("sha256").update(input).digest("hex");
+const getProjectName = (configPath) => {
+    const cwd = path.dirname(configPath).toLocaleLowerCase();
+    return `${path.basename(cwd)}-${sha256(cwd)}`;
+};
+const stream = (proc) => {
+    logger.debug(`Running "${proc.spawnargs.join(" ")}"`);
+    return proc;
+};
+const waitForHealthcheck = async (port) => {
+    const now = Date.now();
+    while (Date.now() - now < 10_000) {
+        const ok = await fetch(`http://localhost:${port}/ok`).then((res) => res.ok, () => false);
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        if (ok)
+            return true;
+    }
+    throw new Error("Healthcheck timed out");
+};
+builder
+    .command("up")
+    .description("Launch LangGraph API server.")
+    .option("-c, --config <path>", "Path to configuration file", process.cwd())
+    .option("-d, --docker-compose <path>", "Advanced: Path to docker-compose.yml file with additional services to launch")
+    .option("-p, --port <port>", "Port to run the server on", "8123")
+    .option("--recreate", "Force recreate containers and volumes", false)
+    .option("--no-pull", "Running the server with locally-built images. By default LangGraph will pull the latest images from the registry")
+    .option("--watch", "Restart on file changes", false)
+    .option("--wait", "Wait for services to start before returning. Implies --detach", false)
+    .option("--postgres-uri <uri>", "Postgres URI to use for the database. Defaults to launching a local database")
+    .hook("preAction", withAnalytics((command) => ({
+    config: command.opts().config !== process.cwd(),
+    port: command.opts().port !== "8123",
+    postgres_uri: !!command.opts().postgresUri,
+    docker_compose: !!command.opts().dockerCompose,
+    recreate: command.opts().recreate,
+    pull: command.opts().pull,
+    watch: command.opts().watch,
+    wait: command.opts().wait,
+})))
+    .action(async (params) => {
+    logger.info("Starting LangGraph API server...");
+    logger.warn(dedent `
+        For local dev, requires env var LANGSMITH_API_KEY with access to LangGraph Cloud closed beta.
+        For production use, requires a license key in env var LANGGRAPH_CLOUD_LICENSE_KEY.
+      `);
+    const configPath = await getProjectPath(params.config);
+    const config = getConfig(await fs.readFile(configPath, "utf-8"));
+    const cwd = path.dirname(configPath);
+    const capabilities = await getDockerCapabilities();
+    const fullRestartFiles = [configPath];
+    if (typeof config.env === "string") {
+        fullRestartFiles.push(path.resolve(cwd, config.env));
+    }
+    const { apiDef } = await configToCompose(configPath, config, {
+        watch: capabilities.watchAvailable,
+    });
+    const name = getProjectName(configPath);
+    const execOpts = await getExecaOptions({
+        cwd,
+        stdout: "inherit",
+        stderr: "inherit",
+    });
+    const exec = $(execOpts);
+    if (!config._INTERNAL_docker_tag && params.pull) {
+        // pull the image
+        logger.info(`Pulling image ${getBaseImage(config)}...`);
+        await stream(exec `docker pull ${getBaseImage(config)}`);
+    }
+    // remove dangling images
+    logger.info(`Pruning dangling images...`);
+    await stream(exec `docker image prune -f --filter ${`label=com.docker.compose.project=${name}`}`);
+    // remove stale containers
+    logger.info(`Pruning stale containers...`);
+    await stream(exec `docker container prune -f --filter ${`label=com.docker.compose.project=${name}`}`);
+    const input = createCompose(capabilities, {
+        port: +params.port,
+        postgresUri: params.postgresUri,
+        apiDef,
+    });
+    const args = ["--remove-orphans"];
+    if (params.recreate) {
+        args.push("--force-recreate", "--renew-anon-volumes");
+        try {
+            await stream(exec `docker volume rm langgraph-data`);
+        }
+        catch (e) {
+            // ignore
+        }
+    }
+    if (params.watch) {
+        if (capabilities.watchAvailable) {
+            args.push("--watch");
+        }
+        else {
+            logger.warn("Watch mode is not available. Please upgrade your Docker Engine.");
+        }
+    }
+    else if (params.wait) {
+        args.push("--wait");
+    }
+    else {
+        args.push("--abort-on-container-exit");
+    }
+    logger.info(`Launching docker-compose...`);
+    const cmd = capabilities.composeType === "plugin"
+        ? ["docker", "compose"]
+        : ["docker-compose"];
+    cmd.push("--project-directory", cwd, "--project-name", name);
+    const userCompose = params.dockerCompose || config.docker_compose_file;
+    if (userCompose)
+        cmd.push("-f", userCompose);
+    cmd.push("-f", "-");
+    const up = stream($({ ...execOpts, input }) `${cmd} up ${args}`);
+    waitForHealthcheck(+params.port).then(() => {
+        logger.info(`
+          Ready!
+          - API: http://localhost:${params.port}
+          - Docs: http://localhost:${params.port}/docs
+          - LangGraph Studio: https://smith.langchain.com/studio/?baseUrl=http://127.0.0.1:${params.port}
+        `);
+    }, () => void 0);
+    await up.catch(() => void 0);
+});

package/dist/cli/utils/analytics.mjs

@@ -0,0 +1,39 @@
+import os from "node:os";
+import { version } from "./version.mjs";
+const SUPABASE_PUBLIC_API_KEY = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6Imt6cmxwcG9qaW5wY3l5YWlweG5iIiwicm9sZSI6ImFub24iLCJpYXQiOjE3MTkyNTc1NzksImV4cCI6MjAzNDgzMzU3OX0.kkVOlLz3BxemA5nP-vat3K4qRtrDuO4SwZSR_htcX9c";
+const SUPABASE_URL = "https://kzrlppojinpcyyaipxnb.supabase.co";
+async function logData(data) {
+    try {
+        await fetch(`${SUPABASE_URL}/rest/v1/js_logs`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                apikey: SUPABASE_PUBLIC_API_KEY,
+                "User-Agent": "Mozilla/5.0",
+            },
+            body: JSON.stringify(data),
+        });
+    }
+    catch (error) {
+        // pass
+    }
+}
+let analyticsPromise = Promise.resolve();
+export function withAnalytics(fn) {
+    if (process.env.LANGGRAPH_CLI_NO_ANALYTICS === "1") {
+        return () => void 0;
+    }
+    return function (actionCommand) {
+        analyticsPromise = analyticsPromise.then(() => logData({
+            os: os.platform(),
+            os_version: os.release(),
+            node_version: process.version,
+            cli_version: version,
+            cli_command: actionCommand.name(),
+            params: fn?.(actionCommand) ?? {},
+        }).catch(() => { }));
+    };
+}
+export async function flushAnalytics() {
+    await analyticsPromise;
+}

package/dist/cli/utils/builder.mjs

@@ -0,0 +1,7 @@
+import { Command } from "@commander-js/extra-typings";
+import { version } from "./version.mjs";
+export const builder = new Command()
+    .name("langgraphjs")
+    .description("LangGraph.js CLI")
+    .version(version)
+    .enablePositionalOptions();

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/server.mjs

@@ -0,0 +1,93 @@
+// 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 fs from "node:fs";
+import { tmpdir } from "./utils/temporary-directory.mjs";
+import { getPipePath } from "./utils/get-pipe-path.mjs";
+const bufferData = (onMessage) => {
+    let buffer = Buffer.alloc(0);
+    return (data) => {
+        buffer = Buffer.concat([buffer, data]);
+        while (buffer.length > 4) {
+            const messageLength = buffer.readInt32BE(0);
+            if (buffer.length >= 4 + messageLength) {
+                const message = buffer.slice(4, 4 + messageLength);
+                onMessage(message);
+                buffer = buffer.slice(4 + messageLength);
+            }
+            else {
+                break;
+            }
+        }
+    };
+};
+export const createIpcServer = async () => {
+    const server = net.createServer((socket) => {
+        socket.on("data", bufferData((message) => {
+            const data = JSON.parse(message.toString());
+            server.emit("data", data);
+        }));
+    });
+    const pipePath = getPipePath(process.pid);
+    await fs.promises.mkdir(tmpdir, { recursive: true });
+    /**
+     * Fix #457 (https://github.com/privatenumber/tsx/issues/457)
+     *
+     * Avoid the error "EADDRINUSE: address already in use"
+     *
+     * If the pipe file already exists, it means that the previous process has been closed abnormally.
+     *
+     * We can safely delete the pipe file, the previous process must has been closed,
+     * as pid is unique at the same.
+     */
+    await fs.promises.rm(pipePath, { force: true });
+    await new Promise((resolve, reject) => {
+        server.listen(pipePath, resolve);
+        server.on("error", reject);
+    });
+    // Prevent Node from waiting for this socket to close before exiting
+    server.unref();
+    process.on("exit", () => {
+        server.close();
+        /**
+         * Only clean on Unix
+         *
+         * https://nodejs.org/api/net.html#ipc-support:
+         * On Windows, the local domain is implemented using a named pipe.
+         * The path must refer to an entry in \\?\pipe\ or \\.\pipe\.
+         * Any characters are permitted, but the latter may do some processing
+         * of pipe names, such as resolving .. sequences. Despite how it might
+         * look, the pipe namespace is flat. Pipes will not persist. They are
+         * removed when the last reference to them is closed. Unlike Unix domain
+         * sockets, Windows will close and remove the pipe when the owning process exits.
+         */
+        if (process.platform !== "win32") {
+            try {
+                fs.rmSync(pipePath);
+            }
+            catch { }
+        }
+    });
+    return [process.pid, server];
+};

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/cli/utils/project.mjs

@@ -0,0 +1,18 @@
+import * as url from "node:url";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+export async function getProjectPath(key) {
+    const configPathOrFile = key.startsWith("file://")
+        ? url.fileURLToPath(key)
+        : path.resolve(process.cwd(), key);
+    let configPath = undefined;
+    if ((await fs.stat(configPathOrFile)).isDirectory()) {
+        configPath = path.join(configPathOrFile, "langgraph.json");
+    }
+    else if (path.basename(configPathOrFile) === "langgraph.json") {
+        configPath = configPathOrFile;
+    }
+    if (!configPath)
+        throw new Error("Invalid path");
+    return configPath;
+}

package/dist/cli/utils/version.mjs

@@ -0,0 +1,13 @@
+import * as fs from "node:fs/promises";
+import * as url from "node:url";
+async function getVersion() {
+    try {
+        const packageJson = url.fileURLToPath(new URL("../../../package.json", import.meta.url));
+        const { version } = JSON.parse(await fs.readFile(packageJson, "utf-8"));
+        return version + "+js";
+    }
+    catch {
+        return "0.0.0-unknown";
+    }
+}
+export const version = await getVersion();

package/dist/docker/compose.mjs

@@ -0,0 +1,185 @@
+import { $ } from "execa";
+import * as yaml from "yaml";
+import { z } from "zod";
+import { getExecaOptions } from "./shell.mjs";
+export const DEFAULT_POSTGRES_URI = "postgres://postgres:postgres@langgraph-postgres:5432/postgres?sslmode=disable";
+const REDIS = {
+    image: "redis:6",
+    healthcheck: {
+        test: "redis-cli ping",
+        start_period: "10s",
+        timeout: "1s",
+        retries: 5,
+    },
+};
+const DB = {
+    image: "pgvector/pgvector:pg16",
+    // TODO: make exposing postgres optional
+    // ports: ['5433:5432'],
+    expose: ["5432"],
+    command: ["postgres", "-c", "shared_preload_libraries=vector"],
+    environment: {
+        POSTGRES_DB: "postgres",
+        POSTGRES_USER: "postgres",
+        POSTGRES_PASSWORD: "postgres",
+    },
+    volumes: ["langgraph-data:/var/lib/postgresql/data"],
+    healthcheck: {
+        test: "pg_isready -U postgres",
+        start_period: "10s",
+        timeout: "1s",
+        retries: 5,
+    },
+};
+function parseVersion(input) {
+    const parts = input.trim().split(".", 3);
+    const majorStr = parts[0] ?? "0";
+    const minorStr = parts[1] ?? "0";
+    const patchStr = parts[2] ?? "0";
+    const major = Number.parseInt(majorStr.startsWith("v") ? majorStr.slice(1) : majorStr);
+    const minor = Number.parseInt(minorStr);
+    const patch = Number.parseInt(patchStr.split("-").at(0) ?? "0");
+    return { major, minor, patch };
+}
+function compareVersion(a, b) {
+    if (a.major !== b.major) {
+        return Math.sign(a.major - b.major);
+    }
+    if (a.minor !== b.minor) {
+        return Math.sign(a.minor - b.minor);
+    }
+    return Math.sign(a.patch - b.patch);
+}
+export async function getDockerCapabilities() {
+    let rawInfo = null;
+    try {
+        const { stdout } = await $(await getExecaOptions()) `docker info -f json`;
+        rawInfo = JSON.parse(stdout);
+    }
+    catch (error) {
+        throw new Error("Docker not installed or not running: " + error);
+    }
+    const info = z
+        .object({
+        ServerVersion: z.string(),
+        ClientInfo: z.object({
+            Plugins: z.array(z.object({
+                Name: z.string(),
+                Version: z.string().optional(),
+            })),
+        }),
+    })
+        .safeParse(rawInfo);
+    if (!info.success || !info.data.ServerVersion) {
+        throw new Error("Docker not running");
+    }
+    const composePlugin = info.data.ClientInfo.Plugins.find((i) => i.Name === "compose" && i.Version != null);
+    const buildxPlugin = info.data.ClientInfo.Plugins.find((i) => i.Name === "buildx" && i.Version != null);
+    let composeRes;
+    if (composePlugin != null) {
+        composeRes = {
+            composeType: "plugin",
+            versionCompose: parseVersion(composePlugin.Version),
+        };
+    }
+    else {
+        try {
+            const standalone = await $(await getExecaOptions()) `docker-compose --version --short`;
+            composeRes = {
+                composeType: "standalone",
+                versionCompose: parseVersion(standalone.stdout),
+            };
+        }
+        catch (error) {
+            console.error(error);
+            throw new Error("Docker Compose not installed");
+        }
+    }
+    const versionDocker = parseVersion(info.data.ServerVersion);
+    if (compareVersion(versionDocker, parseVersion("23.0.5")) < 0) {
+        throw new Error("Please upgrade Docker to at least 23.0.5");
+    }
+    return {
+        ...composeRes,
+        healthcheckStartInterval: compareVersion(versionDocker, parseVersion("25.0.0")) >= 0,
+        watchAvailable: compareVersion(composeRes.versionCompose, parseVersion("2.25.0")) >= 0,
+        buildAvailable: buildxPlugin != null,
+        versionDocker,
+    };
+}
+function isPlainObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+export function createCompose(capabilities, options) {
+    let includeDb = false;
+    let postgresUri = options.postgresUri;
+    if (!options.postgresUri) {
+        includeDb = true;
+        postgresUri = DEFAULT_POSTGRES_URI;
+    }
+    else {
+        includeDb = false;
+    }
+    const compose = {
+        services: {},
+    };
+    compose.services["langgraph-redis"] = { ...REDIS };
+    if (includeDb) {
+        compose.volumes = {
+            "langgraph-data": { driver: "local" },
+        };
+        compose.services["langgraph-postgres"] = { ...DB };
+        if (capabilities.healthcheckStartInterval) {
+            compose.services["langgraph-postgres"].healthcheck.interval = "60s";
+            compose.services["langgraph-postgres"].healthcheck.start_interval = "1s";
+        }
+        else {
+            compose.services["langgraph-postgres"].healthcheck.interval = "5s";
+        }
+    }
+    compose.services["langgraph-api"] = {
+        ports: [options.port ? `${options.port}:8000` : "8000"],
+        environment: {
+            REDIS_URI: "redis://langgraph-redis:6379",
+            POSTGRES_URI: postgresUri,
+        },
+        depends_on: {
+            "langgraph-redis": { condition: "service_healthy" },
+        },
+    };
+    if (includeDb) {
+        compose.services["langgraph-api"].depends_on["langgraph-postgres"] = {
+            condition: "service_healthy",
+        };
+    }
+    if (capabilities.healthcheckStartInterval) {
+        compose.services["langgraph-api"].healthcheck = {
+            test: "python /api/healthcheck.py",
+            interval: "60s",
+            start_interval: "1s",
+            start_period: "10s",
+        };
+        compose.services["langgraph-redis"].healthcheck.interval = "60s";
+        compose.services["langgraph-redis"].healthcheck.start_interval = "1s";
+    }
+    else {
+        compose.services["langgraph-redis"].healthcheck.interval = "5s";
+    }
+    // merge in with rest of the payload
+    if (options.apiDef) {
+        for (const key in options.apiDef) {
+            const prevValue = compose.services["langgraph-api"][key];
+            const newValue = options.apiDef[key];
+            if (isPlainObject(prevValue) && isPlainObject(newValue)) {
+                compose.services["langgraph-api"][key] = {
+                    ...prevValue,
+                    ...newValue,
+                };
+            }
+            else {
+                compose.services["langgraph-api"][key] = newValue;
+            }
+        }
+    }
+    return yaml.stringify(compose, { blockQuote: "literal" });
+}