@langchain/langgraph-cli 1.1.2 → 1.1.8

package/dist/docker/docker.mjs

@@ -1,390 +0,0 @@
-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) {
-    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;
-    const dependencies = "dependencies" in config ? config.dependencies : [];
-    for (const localDep of 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)
-                        .split(path.sep)
-                        .join("/"),
-                    `${containerPath}/requirements.txt`,
-                ]);
-            }
-        }
-    }
-    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)
-                .split(path.sep)
-                .join("/");
-            rebuildFiles.push(jsFile);
-        }
-        workingDir ??= `/deps/${path.basename(path.dirname(configPath))}`;
-    }
-    return { pipReqs, realPkgs, fauxPkgs, workingDir, reloadDir, rebuildFiles };
-}
-async function updateGraphPaths(configPath, config, localDeps) {
-    for (const [graphId, graphDef] of Object.entries(config.graphs)) {
-        const importStr = typeof graphDef === "string" ? graphDef : graphDef.path;
-        const description = typeof graphDef === "string" ? undefined : graphDef.description;
-        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 = path
-                                .join("/deps", path.basename(realPath), path.relative(realPath, resolved))
-                                .split(path.sep)
-                                .join("/");
-                            break find;
-                        }
-                    }
-                    for (const [fauxPkg, [_, destPath]] of Object.entries(localDeps.fauxPkgs)) {
-                        if (resolved.startsWith(fauxPkg)) {
-                            moduleStr = path
-                                .join(destPath, path.relative(fauxPkg, resolved))
-                                .split(path.sep)
-                                .join("/");
-                            break find;
-                        }
-                        throw new Error(`Module '${importStr}' not found in 'dependencies' list. Add its containing package to 'dependencies' list.`);
-                    }
-                }
-                const resolvedPath = `${moduleStr}:${attrStr}`;
-                config["graphs"][graphId] = description
-                    ? {
-                        path: resolvedPath,
-                        description,
-                    }
-                    : resolvedPath;
-            }
-        }
-    }
-}
-export function getBaseImage(config) {
-    if ("node_version" in config) {
-        return `langchain/langgraphjs-api:${config._INTERNAL_docker_tag || config.node_version}`;
-    }
-    if ("python_version" in config) {
-        return `langchain/langgraph-api:${config._INTERNAL_docker_tag || config.python_version}`;
-    }
-    throw new Error("Invalid config type");
-}
-export async function configToDocker(configPath, config, localDeps, options) {
-    // figure out the package manager used here
-    const testFile = async (file) => fs
-        .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"),
-        testFile("pnpm-lock.yaml"),
-        testFile("bun.lockb"),
-    ]);
-    let installCmd = "npm i";
-    if (yarn) {
-        installCmd = "yarn install";
-    }
-    else if (pnpm) {
-        installCmd = "pnpm i --frozen-lockfile";
-    }
-    else if (npm) {
-        installCmd = "npm ci";
-    }
-    else if (bun) {
-        installCmd = "bun i";
-    }
-    const lines = [
-        `FROM ${getBaseImage(config)}`,
-        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.ui && `ENV LANGGRAPH_UI='${JSON.stringify(config.ui)}'`,
-        !!config.ui_config &&
-            `ENV LANGGRAPH_UI_CONFIG='${JSON.stringify(config.ui_config)}'`,
-        !!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.flat().filter(Boolean).join("\n");
-}
-export async function configToWatch(configPath, config, localDeps) {
-    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.map((item) => ({
-            ...item,
-            path: item.path.split(path.sep).join("/"),
-            target: item.target?.split(path.sep).join("/"),
-            ignore: item.ignore?.map((i) => i.split(path.sep).join("/")),
-        }));
-    }
-    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, localDeps);
-        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

@@ -1,62 +0,0 @@
-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/utils/config.mjs

@@ -1,104 +0,0 @@
-import { z } from "zod/v3";
-import { extname } from "node:path";
-const GraphPathSchema = z.string().refine((i) => i.includes(":"), {
-    message: "Import string must be in format '<file>:<export>'",
-});
-const BaseConfigSchema = z.object({
-    docker_compose_file: z.string().optional(),
-    dockerfile_lines: z.array(z.string()).default([]),
-    graphs: z.record(z.union([
-        GraphPathSchema,
-        z.object({
-            path: GraphPathSchema,
-            description: z.string().optional(),
-        }),
-    ])),
-    ui: z.record(z.string()).optional(),
-    ui_config: z.object({ shared: z.array(z.string()).optional() }).optional(),
-    _INTERNAL_docker_tag: z.string().optional(),
-    env: z
-        .union([z.array(z.string()), z.record(z.string()), z.string()])
-        .default({}),
-    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(),
-    http: z
-        .object({
-        app: z.string().optional(),
-        disable_assistants: z.boolean().default(false),
-        disable_threads: z.boolean().default(false),
-        disable_runs: z.boolean().default(false),
-        disable_store: z.boolean().default(false),
-        disable_meta: z.boolean().default(false),
-        cors: z
-            .object({
-            allow_origins: z.array(z.string()).optional(),
-            allow_methods: z.array(z.string()).optional(),
-            allow_headers: z.array(z.string()).optional(),
-            allow_credentials: z.boolean().optional(),
-            allow_origin_regex: z.string().optional(),
-            expose_headers: z.array(z.string()).optional(),
-            max_age: z.number().optional(),
-        })
-            .optional(),
-    })
-        .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.union([z.literal("20"), z.literal("22")]);
-const PythonConfigSchema = BaseConfigSchema.merge(z.object({
-    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: NodeVersionSchema.default(DEFAULT_NODE_VERSION) }));
-const ConfigSchema = z.union([NodeConfigSchema, PythonConfigSchema]);
-// TODO: implement this in Python CLI
-export const getConfig = (config) => {
-    let input = typeof config === "string" ? JSON.parse(config) : config;
-    const { graphs } = BaseConfigSchema.parse(input);
-    const isPython = Object.values(graphs).map((graphDef) => {
-        const importStr = typeof graphDef === "string" ? graphDef : graphDef.path;
-        return PYTHON_EXTENSIONS.includes(extname(importStr.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");
-    }
-    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/dist/utils/logging.mjs

@@ -1,96 +0,0 @@
-import { createLogger, format, transports } from "winston";
-import { consoleFormat } from "winston-console-format";
-import { parse as stacktraceParser } from "stacktrace-parser";
-import { readFileSync } from "fs";
-import { codeFrameColumns } from "@babel/code-frame";
-import path from "node:path";
-const LOG_JSON = process.env.LOG_JSON === "true";
-const LOG_LEVEL = process.env.LOG_LEVEL || "debug";
-export const logger = createLogger({
-    level: LOG_LEVEL,
-    format: format.combine(format.errors({ stack: true }), format.timestamp(), format.json(), ...(!LOG_JSON
-        ? [
-            format.colorize({ all: true }),
-            format.padLevels(),
-            consoleFormat({
-                showMeta: true,
-                metaStrip: ["timestamp"],
-                inspectOptions: {
-                    depth: Infinity,
-                    colors: true,
-                    maxArrayLength: Infinity,
-                    breakLength: 120,
-                    compact: Infinity,
-                },
-            }),
-        ]
-        : [
-            format.printf((info) => {
-                const { timestamp, level, message, ...rest } = info;
-                let event;
-                if (typeof message === "string") {
-                    event = message;
-                }
-                else {
-                    event = JSON.stringify(message);
-                }
-                if (rest.stack) {
-                    rest.message = event;
-                    event = rest.stack;
-                }
-                return JSON.stringify({ timestamp, level, event, ...rest });
-            }),
-        ])),
-    transports: [new transports.Console()],
-});
-const formatStack = (stack) => {
-    if (!stack)
-        return stack;
-    const [firstFile] = stacktraceParser(stack).filter((item) => !item.file?.split(path.sep).includes("node_modules") &&
-        !item.file?.startsWith("node:"));
-    if (firstFile?.file && firstFile?.lineNumber) {
-        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
-        }
-    }
-    return stack;
-};
-export const logError = (error, options) => {
-    let message;
-    let context = options?.context;
-    if (error instanceof Error) {
-        message = formatStack(error.stack) || error.message;
-    }
-    else {
-        message = String(error);
-        context = { ...context, error };
-    }
-    if (options?.prefix != null)
-        message = `${options.prefix}:\n${message}`;
-    logger.error(message, ...(context != null ? [context] : []));
-};
-process.on("uncaughtException", (error) => logError(error));
-process.on("unhandledRejection", (error) => logError(error));