@langchain/langgraph-api 1.1.8 → 1.1.10

package/dist/api/store.mjs

@@ -0,0 +1,111 @@
+import { Hono } from "hono";
+import { zValidator } from "@hono/zod-validator";
+import * as schemas from "../schemas.mjs";
+import { HTTPException } from "hono/http-exception";
+import { store as storageStore } from "../storage/store.mjs";
+import { handleAuthEvent } from "../auth/index.mjs";
+const api = new Hono();
+const validateNamespace = (namespace) => {
+    if (!namespace || namespace.length === 0) {
+        throw new HTTPException(400, { message: "Namespace is required" });
+    }
+    for (const label of namespace) {
+        if (!label || label.includes(".")) {
+            throw new HTTPException(422, {
+                message: "Namespace labels cannot be empty or contain periods. Received: " +
+                    namespace.join("."),
+            });
+        }
+    }
+};
+const mapItemsToApi = (item) => {
+    if (item == null)
+        return null;
+    const clonedItem = { ...item };
+    delete clonedItem.createdAt;
+    delete clonedItem.updatedAt;
+    clonedItem.created_at = item.createdAt;
+    clonedItem.updated_at = item.updatedAt;
+    return clonedItem;
+};
+api.post("/store/namespaces", zValidator("json", schemas.StoreListNamespaces), async (c) => {
+    // List Namespaces
+    const payload = c.req.valid("json");
+    if (payload.prefix)
+        validateNamespace(payload.prefix);
+    if (payload.suffix)
+        validateNamespace(payload.suffix);
+    await handleAuthEvent(c.var.auth, "store:list_namespaces", {
+        namespace: payload.prefix,
+        suffix: payload.suffix,
+        max_depth: payload.max_depth,
+        limit: payload.limit,
+        offset: payload.offset,
+    });
+    return c.json({
+        namespaces: await storageStore.listNamespaces({
+            limit: payload.limit ?? 100,
+            offset: payload.offset ?? 0,
+            prefix: payload.prefix,
+            suffix: payload.suffix,
+            maxDepth: payload.max_depth,
+        }),
+    });
+});
+api.post("/store/items/search", zValidator("json", schemas.StoreSearchItems), async (c) => {
+    // Search Items
+    const payload = c.req.valid("json");
+    if (payload.namespace_prefix)
+        validateNamespace(payload.namespace_prefix);
+    await handleAuthEvent(c.var.auth, "store:search", {
+        namespace: payload.namespace_prefix,
+        filter: payload.filter,
+        limit: payload.limit,
+        offset: payload.offset,
+        query: payload.query,
+    });
+    const items = await storageStore.search(payload.namespace_prefix, {
+        filter: payload.filter,
+        limit: payload.limit ?? 10,
+        offset: payload.offset ?? 0,
+        query: payload.query,
+    });
+    return c.json({ items: items.map(mapItemsToApi) });
+});
+api.put("/store/items", zValidator("json", schemas.StorePutItem), async (c) => {
+    // Put Item
+    const payload = c.req.valid("json");
+    if (payload.namespace)
+        validateNamespace(payload.namespace);
+    await handleAuthEvent(c.var.auth, "store:put", {
+        namespace: payload.namespace,
+        key: payload.key,
+        value: payload.value,
+    });
+    await storageStore.put(payload.namespace, payload.key, payload.value);
+    return c.body(null, 204);
+});
+api.delete("/store/items", zValidator("json", schemas.StoreDeleteItem), async (c) => {
+    // Delete Item
+    const payload = c.req.valid("json");
+    if (payload.namespace)
+        validateNamespace(payload.namespace);
+    await handleAuthEvent(c.var.auth, "store:delete", {
+        namespace: payload.namespace,
+        key: payload.key,
+    });
+    await storageStore.delete(payload.namespace ?? [], payload.key);
+    return c.body(null, 204);
+});
+api.get("/store/items", zValidator("query", schemas.StoreGetItem), async (c) => {
+    // Get Item
+    const payload = c.req.valid("query");
+    await handleAuthEvent(c.var.auth, "store:get", {
+        namespace: payload.namespace,
+        key: payload.key,
+    });
+    const key = payload.key;
+    const namespace = payload.namespace;
+    return c.json(mapItemsToApi(await storageStore.get(namespace, key)));
+});
+export default api;

package/dist/api/threads.d.mts

@@ -0,0 +1,3 @@
+import { Hono } from "hono";
+declare const api: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+export default api;

package/dist/api/threads.mjs

@@ -0,0 +1,143 @@
+import { zValidator } from "@hono/zod-validator";
+import { Hono } from "hono";
+import { v4 as uuid4 } from "uuid";
+import { z } from "zod/v3";
+import * as schemas from "../schemas.mjs";
+import { stateSnapshotToThreadState } from "../state.mjs";
+import { threads } from "../storage/context.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" }, c.var.auth);
+    if (payload.supersteps?.length) {
+        await threads().state.bulk({ configurable: { thread_id: thread.thread_id } }, payload.supersteps, c.var.auth);
+    }
+    return jsonExtra(c, thread);
+});
+api.post("/threads/search", zValidator("json", schemas.ThreadSearchRequest), async (c) => {
+    // Search Threads
+    const payload = c.req.valid("json");
+    const result = [];
+    let total = 0;
+    for await (const item of threads().search({
+        status: payload.status,
+        values: payload.values,
+        metadata: payload.metadata,
+        ids: payload.ids,
+        limit: payload.limit ?? 10,
+        offset: payload.offset ?? 0,
+        sort_by: payload.sort_by ?? "created_at",
+        sort_order: payload.sort_order ?? "desc",
+        select: payload.select,
+    }, c.var.auth)) {
+        result.push(Object.fromEntries(Object.entries(item.thread).filter(([k]) => !payload.select || payload.select.includes(k))));
+        // Only set total if it's the first item
+        if (total === 0) {
+            total = item.total;
+        }
+    }
+    const nextOffset = (payload.offset ?? 0) + total;
+    if (total === payload.limit) {
+        c.res.headers.set("X-Pagination-Next", nextOffset.toString());
+        c.res.headers.set("X-Pagination-Total", (nextOffset + 1).toString());
+    }
+    else {
+        c.res.headers.set("X-Pagination-Total", nextOffset.toString());
+    }
+    return jsonExtra(c, result);
+});
+api.post("/threads/count", zValidator("json", schemas.ThreadCountRequest), async (c) => {
+    const payload = c.req.valid("json");
+    const total = await threads().count(payload, c.var.auth);
+    return c.json(total);
+});
+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 }, c.var.auth));
+    return jsonExtra(c, state);
+});
+api.post("/threads/:thread_id/state", zValidator("param", z.object({ thread_id: z.string().uuid() })), zValidator("json", schemas.ThreadStateUpdate), 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, c.var.auth);
+    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 }, c.var.auth));
+    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: schemas.CheckpointSchema.nullish(),
+})), 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 }, c.var.auth));
+    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 }, c.var.auth);
+    return jsonExtra(c, states.map(stateSnapshotToThreadState));
+});
+api.post("/threads/:thread_id/history", zValidator("param", z.object({ thread_id: z.string().uuid() })), zValidator("json", schemas.ThreadHistoryRequest), 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 }, c.var.auth);
+    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, c.var.auth));
+});
+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, c.var.auth);
+    return new Response(null, { status: 204 });
+});
+api.patch("/threads/:thread_id", zValidator("param", z.object({ thread_id: z.string().uuid() })), zValidator("json", schemas.ThreadPatchRequest), 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 }, c.var.auth));
+});
+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, c.var.auth));
+});
+export default api;

package/dist/auth/custom.d.mts

@@ -0,0 +1,9 @@
+import type { MiddlewareHandler } from "hono";
+import { type AuthContext } from "./index.mjs";
+declare module "hono" {
+    interface ContextVariableMap {
+        auth?: AuthContext | undefined;
+    }
+}
+export declare const auth: () => MiddlewareHandler;
+export { registerAuth } from "./index.mjs";

package/dist/auth/custom.mjs

@@ -0,0 +1,32 @@
+import { authenticate, isAuthRegistered, isStudioAuthDisabled, } from "./index.mjs";
+const STUDIO_USER = {
+    kind: "StudioUser",
+    display_name: "langgraph-studio-user",
+    identity: "langgraph-studio-user",
+    permissions: [],
+    is_authenticated: true,
+};
+export const auth = () => {
+    return async (c, next) => {
+        if (!isAuthRegistered())
+            return next();
+        // skip for /info
+        if (c.req.path === "/info")
+            return next();
+        // skip for UI asset requests
+        if (c.req.path.startsWith("/ui") && c.req.method === "GET")
+            return next();
+        if (!isStudioAuthDisabled() &&
+            c.req.header("x-auth-scheme") === "langsmith") {
+            c.set("auth", {
+                user: STUDIO_USER,
+                scopes: STUDIO_USER.permissions.slice(),
+            });
+            return next();
+        }
+        const auth = await authenticate(c.req.raw);
+        c.set("auth", auth);
+        return next();
+    };
+};
+export { registerAuth } from "./index.mjs";

package/dist/auth/index.d.mts

@@ -0,0 +1,43 @@
+import type { AuthEventValueMap } from "@langchain/langgraph-sdk/auth";
+export declare const isAuthRegistered: () => boolean;
+export declare const isStudioAuthDisabled: () => boolean;
+export type AuthFilters = Record<string, string | {
+    $eq?: string;
+    $contains?: string | string[];
+}> | undefined;
+export interface AuthContext {
+    user: {
+        identity: string;
+        permissions: string[];
+        display_name: string;
+        is_authenticated: boolean;
+        [key: string]: unknown;
+    };
+    scopes: string[];
+}
+export declare function authorize(payload: {
+    resource: string;
+    action: string;
+    value: unknown;
+    context: AuthContext | undefined | null;
+}): Promise<{
+    filters: AuthFilters;
+    value: unknown;
+}>;
+export declare function authenticate(request: Request): Promise<{
+    scopes: string[];
+    user: {
+        permissions: string[];
+        is_authenticated: boolean;
+        display_name: string;
+        identity: string;
+    };
+} | undefined>;
+export declare function registerAuth(auth: {
+    path?: string;
+    disable_studio_auth?: boolean;
+}, options: {
+    cwd: string;
+}): Promise<void>;
+export declare const handleAuthEvent: <T extends keyof AuthEventValueMap>(context: AuthContext | undefined, event: T, value: AuthEventValueMap[T]) => Promise<[AuthFilters | undefined, value: AuthEventValueMap[T]]>;
+export declare function isAuthMatching(metadata: Record<string, unknown> | undefined, filters: AuthFilters): boolean;

package/dist/auth/index.mjs

@@ -0,0 +1,163 @@
+import { HTTPException } from "hono/http-exception";
+import * as url from "node:url";
+import * as path from "node:path";
+let CUSTOM_AUTH;
+let DISABLE_STUDIO_AUTH = false;
+export const isAuthRegistered = () => CUSTOM_AUTH != null;
+export const isStudioAuthDisabled = () => DISABLE_STUDIO_AUTH;
+function convertError(error) {
+    const isHTTPAuthException = (error) => {
+        return (typeof error === "object" &&
+            error != null &&
+            "status" in error &&
+            "headers" in error);
+    };
+    if (isHTTPAuthException(error)) {
+        throw new HTTPException(error.status, {
+            message: error.message,
+            res: new Response(error.message || "Unauthorized", {
+                status: error.status,
+                headers: error.headers,
+            }),
+        });
+    }
+    throw error;
+}
+export async function authorize(payload) {
+    // find filters and execute them
+    const handlers = CUSTOM_AUTH?.["~handlerCache"];
+    if (!handlers)
+        return { filters: undefined, value: payload.value };
+    const cbKey = [
+        `${payload.resource}:${payload.action}`,
+        `${payload.resource}`,
+        `*:${payload.action}`,
+        `*`,
+    ].find((priority) => handlers.callbacks?.[priority]);
+    const handler = cbKey ? handlers.callbacks?.[cbKey] : undefined;
+    if (!handler || !payload.context) {
+        return { filters: undefined, value: payload.value };
+    }
+    try {
+        const result = await handler({
+            event: `${payload.resource}:${payload.action}`,
+            resource: payload.resource,
+            action: payload.action,
+            value: payload.value,
+            permissions: payload.context?.scopes,
+            user: payload.context?.user,
+        });
+        if (result == null || result == true) {
+            return { filters: undefined, value: payload.value };
+        }
+        if (result === false)
+            throw new HTTPException(403);
+        if (typeof result !== "object") {
+            throw new HTTPException(500, {
+                message: `Auth handler returned invalid result. Expected filter object, null, undefined or boolean. Got "${typeof result}" instead.`,
+            });
+        }
+        return { filters: result, value: payload.value };
+    }
+    catch (error) {
+        throw convertError(error);
+    }
+}
+export async function authenticate(request) {
+    const handlers = CUSTOM_AUTH?.["~handlerCache"];
+    if (!handlers?.authenticate)
+        return undefined;
+    try {
+        const response = await handlers.authenticate(request);
+        // normalize auth response
+        const { scopes, user } = (() => {
+            if (typeof response === "string") {
+                return {
+                    scopes: [],
+                    user: {
+                        permissions: [],
+                        identity: response,
+                        display_name: response,
+                        is_authenticated: true,
+                    },
+                };
+            }
+            if ("identity" in response && typeof response.identity === "string") {
+                const scopes = "permissions" in response && Array.isArray(response.permissions)
+                    ? response.permissions
+                    : [];
+                return {
+                    scopes,
+                    user: {
+                        ...response,
+                        permissions: scopes,
+                        is_authenticated: response.is_authenticated ?? true,
+                        display_name: response.display_name ?? response.identity,
+                    },
+                };
+            }
+            throw new Error("Invalid auth response received. Make sure to either return a `string` or an object with `identity` property.");
+        })();
+        return { scopes, user };
+    }
+    catch (error) {
+        throw convertError(error);
+    }
+}
+export async function registerAuth(auth, options) {
+    if (!auth.path)
+        return;
+    // TODO: handle options.auth.disable_studio_auth
+    const [userFile, exportSymbol] = auth.path.split(":", 2);
+    const sourceFile = path.resolve(options.cwd, userFile);
+    const module = (await import(url.pathToFileURL(sourceFile).toString()).then((module) => module[exportSymbol || "default"]));
+    if (!module)
+        throw new Error(`Failed to load auth: ${auth.path}`);
+    if (!("~handlerCache" in module))
+        throw new Error(`Auth must be an instance of Auth: ${auth.path}`);
+    CUSTOM_AUTH = module;
+    DISABLE_STUDIO_AUTH = auth.disable_studio_auth ?? false;
+}
+export const handleAuthEvent = async (context, event, value) => {
+    const [resource, action] = event.split(":");
+    const result = await authorize({
+        resource,
+        action,
+        context,
+        value,
+    });
+    return [result.filters, result.value];
+};
+export function isAuthMatching(metadata, filters) {
+    if (filters == null)
+        return true;
+    for (const [key, value] of Object.entries(filters)) {
+        if (typeof value === "object" && value != null) {
+            if (value.$eq) {
+                if (metadata?.[key] !== value.$eq)
+                    return false;
+            }
+            else if (value.$contains) {
+                if (!Array.isArray(metadata?.[key])) {
+                    return false;
+                }
+                if (Array.isArray(value.$contains)) {
+                    // Match Postgres list containment semantics (at the top level).
+                    if (!value.$contains.every((v) => (metadata?.[key]).includes(v))) {
+                        return false;
+                    }
+                }
+                else {
+                    if (!metadata?.[key].includes(value.$contains)) {
+                        return false;
+                    }
+                }
+            }
+        }
+        else {
+            if (metadata?.[key] !== value)
+                return false;
+        }
+    }
+    return true;
+}

package/dist/cli/entrypoint.d.mts

@@ -0,0 +1 @@
+export {};

package/dist/cli/entrypoint.mjs

@@ -0,0 +1,41 @@
+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));
+// Export PORT to the environment
+process.env.PORT = options.port.toString();
+const [{ host, cleanup }, organizationId] = await Promise.all([
+    startServer(options),
+    (async () => {
+        if (isTracingEnabled()) {
+            try {
+                // @ts-expect-error Private method
+                return await new LangSmithClient()._getTenantId();
+            }
+            catch (error) {
+                logger.warn("Failed to get organization ID. Tracing to LangSmith will not work.", { 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: 3_000 });
+sendToParent?.({ queryParams });

package/dist/cli/spawn.d.mts

@@ -0,0 +1,42 @@
+export declare function spawnServer(args: {
+    host: string;
+    port: string;
+    nJobsPerWorker: string;
+}, context: {
+    config: {
+        graphs: Record<string, string | {
+            path: string;
+            description?: string;
+        }>;
+        ui?: Record<string, string>;
+        ui_config?: {
+            shared?: string[];
+        };
+        auth?: {
+            path?: string;
+            disable_studio_auth?: boolean;
+        };
+        http?: {
+            app?: string;
+            disable_assistants?: boolean;
+            disable_threads?: boolean;
+            disable_runs?: boolean;
+            disable_store?: boolean;
+            disable_meta?: boolean;
+            cors?: {
+                allow_origins?: string[];
+                allow_methods?: string[];
+                allow_headers?: string[];
+                allow_credentials?: boolean;
+                allow_origin_regex?: string;
+                expose_headers?: string[];
+                max_age?: number;
+            };
+        };
+    };
+    env: NodeJS.ProcessEnv;
+    hostUrl: string;
+}, options: {
+    pid: number;
+    projectCwd: string;
+}): Promise<import("child_process").ChildProcess>;

package/dist/cli/spawn.mjs

@@ -0,0 +1,47 @@
+import { fileURLToPath } from "node:url";
+import { spawn } from "node:child_process";
+export async function spawnServer(args, context, options) {
+    const localUrl = `http://${args.host}:${args.port}`;
+    const studioUrl = `${context.hostUrl}/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 LangSmith Deployment.
+
+`);
+    return spawn(process.execPath, [
+        fileURLToPath(new URL("../../cli.mjs", import.meta.resolve("tsx/esm/api"))),
+        "watch",
+        "--clear-screen=false",
+        "--import",
+        new URL(import.meta.resolve("../preload.mjs")).toString(),
+        fileURLToPath(new URL(import.meta.resolve("./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,
+            auth: context.config.auth,
+            ui: context.config.ui,
+            ui_config: context.config.ui_config,
+            cwd: options.projectCwd,
+            http: context.config.http,
+        }),
+    ], {
+        stdio: ["inherit", "inherit", "inherit", "ipc"],
+        env: {
+            ...context.env,
+            NODE_ENV: "development",
+            LANGGRAPH_API_URL: localUrl,
+        },
+    });
+}

package/dist/cli/utils/ipc/client.d.mts

@@ -0,0 +1,5 @@
+export type SendToParent = (data: Record<string, unknown>) => void;
+export type Parent = {
+    send: SendToParent | undefined;
+};
+export declare const connectToServer: (processId?: number) => Promise<SendToParent | undefined>;