@langchain/langgraph-api 1.1.8 → 1.1.9

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/utils/get-pipe-path.d.mts

@@ -0,0 +1 @@
+export declare const getPipePath: (processId: number) => string;

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.d.mts

@@ -0,0 +1,5 @@
+/**
+ * This ensures that the cache directory is unique per user
+ * and has the appropriate permissions
+ */
+export declare const tmpdir: string;

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/command.d.mts

@@ -0,0 +1,11 @@
+import { Command } from "@langchain/langgraph";
+export interface RunSend {
+    node: string;
+    input?: unknown;
+}
+export interface RunCommand {
+    goto?: string | RunSend | Array<RunSend | string>;
+    update?: Record<string, unknown> | [string, unknown][];
+    resume?: unknown;
+}
+export declare const getLangGraphCommand: (command: RunCommand) => Command<unknown, Record<string, unknown>, string>;

package/dist/command.mjs

@@ -0,0 +1,15 @@
+import { Command, Send } from "@langchain/langgraph";
+export const getLangGraphCommand = (command) => {
+    let goto = command.goto != null && !Array.isArray(command.goto)
+        ? [command.goto]
+        : command.goto;
+    return new Command({
+        goto: goto?.map((item) => {
+            if (typeof item !== "string")
+                return new Send(item.node, item.input);
+            return item;
+        }),
+        update: command.update,
+        resume: command.resume,
+    });
+};

package/dist/experimental/embed.d.mts

@@ -0,0 +1,42 @@
+import type { BaseCheckpointSaver, BaseStore, Pregel } from "@langchain/langgraph";
+import { Hono } from "hono";
+import type { Metadata } from "../storage/types.mjs";
+type AnyPregel = Pregel<any, any, any, any, any>;
+interface Thread {
+    thread_id: string;
+    metadata: Metadata;
+}
+/**
+ * Interface for storing and retrieving threads used by `createEmbedServer`.
+ * @experimental Does not follow semver.
+ */
+export interface ThreadSaver {
+    get: (id: string) => Promise<Thread>;
+    set: (id: string, options: {
+        kind: "put" | "patch";
+        metadata?: Metadata;
+    }) => Promise<Thread>;
+    delete: (id: string) => Promise<void>;
+    search?: (options: {
+        metadata?: Metadata;
+        limit: number;
+        offset: number;
+        sortBy: "created_at" | "updated_at";
+        sortOrder: "asc" | "desc";
+    }) => AsyncGenerator<{
+        thread: Thread;
+        total: number;
+    }>;
+}
+/**
+ * Create a Hono server with a subset of LangGraph Platform routes.
+ *
+ * @experimental Does not follow semver.
+ */
+export declare function createEmbedServer(options: {
+    graph: Record<string, AnyPregel>;
+    threads: ThreadSaver;
+    checkpointer: BaseCheckpointSaver;
+    store?: BaseStore;
+}): Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+export {};

package/dist/experimental/embed.mjs

@@ -0,0 +1,299 @@
+import { Hono } from "hono";
+import { zValidator } from "@hono/zod-validator";
+import { streamSSE } from "hono/streaming";
+import { v4 as uuidv4 } from "uuid";
+import * as schemas from "../schemas.mjs";
+import { z } from "zod/v3";
+import { streamState } from "../stream.mjs";
+import { serialiseAsDict, serializeError } from "../utils/serde.mjs";
+import { getDisconnectAbortSignal, jsonExtra } from "../utils/hono.mjs";
+import { stateSnapshotToThreadState } from "../state.mjs";
+import { ensureContentType } from "../http/middleware.mjs";
+function createStubRun(threadId, payload) {
+    const now = new Date();
+    const runId = uuidv4();
+    let streamMode = Array.isArray(payload.stream_mode)
+        ? payload.stream_mode
+        : payload.stream_mode
+            ? [payload.stream_mode]
+            : undefined;
+    if (streamMode == null || streamMode.length === 0)
+        streamMode = ["values"];
+    const config = Object.assign({}, payload.config ?? {}, {
+        configurable: {
+            run_id: runId,
+            thread_id: threadId,
+            graph_id: payload.assistant_id,
+            ...(payload.checkpoint_id
+                ? { checkpoint_id: payload.checkpoint_id }
+                : null),
+            ...payload.checkpoint,
+            ...(payload.langsmith_tracer
+                ? {
+                    langsmith_project: payload.langsmith_tracer.project_name,
+                    langsmith_example_id: payload.langsmith_tracer.example_id,
+                }
+                : null),
+        },
+    }, { metadata: payload.metadata ?? {} });
+    return {
+        run_id: runId,
+        thread_id: threadId,
+        assistant_id: payload.assistant_id,
+        metadata: payload.metadata ?? {},
+        status: "running",
+        kwargs: {
+            input: payload.input,
+            command: payload.command,
+            config,
+            context: payload.context,
+            stream_mode: streamMode,
+            interrupt_before: payload.interrupt_before,
+            interrupt_after: payload.interrupt_after,
+            feedback_keys: payload.feedback_keys,
+            subgraphs: payload.stream_subgraphs,
+            temporary: false,
+        },
+        multitask_strategy: "reject",
+        created_at: now,
+        updated_at: now,
+    };
+}
+/**
+ * Create a Hono server with a subset of LangGraph Platform routes.
+ *
+ * @experimental Does not follow semver.
+ */
+export function createEmbedServer(options) {
+    async function getGraph(graphId) {
+        const targetGraph = options.graph[graphId];
+        targetGraph.store = options.store;
+        targetGraph.checkpointer = options.checkpointer;
+        return targetGraph;
+    }
+    const api = new Hono();
+    api.use(ensureContentType());
+    api.post("/threads", zValidator("json", schemas.ThreadCreate), async (c) => {
+        // create a new thread
+        const payload = c.req.valid("json");
+        const threadId = payload.thread_id || uuidv4();
+        return jsonExtra(c, await options.threads.set(threadId, {
+            kind: "put",
+            metadata: payload.metadata,
+        }));
+    });
+    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 options.threads.get(thread_id));
+    });
+    api.patch("/threads/:thread_id", zValidator("param", z.object({ thread_id: z.string().uuid() })), zValidator("json", schemas.ThreadCreate), async (c) => {
+        // Update Thread
+        const { thread_id } = c.req.valid("param");
+        const payload = c.req.valid("json");
+        return jsonExtra(c, await options.threads.set(thread_id, {
+            kind: "patch",
+            metadata: payload.metadata,
+        }));
+    });
+    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 options.threads.delete(thread_id);
+        return new Response(null, { status: 204 });
+    });
+    api.post("/threads/search", zValidator("json", schemas.ThreadSearchRequest), async (c) => {
+        const payload = c.req.valid("json");
+        const result = [];
+        if (!options.threads.search)
+            return c.json({ error: "Threads search not implemented" }, 422);
+        const sortBy = payload.sort_by === "created_at" || payload.sort_by === "updated_at"
+            ? payload.sort_by
+            : "created_at";
+        let total = 0;
+        for await (const item of options.threads.search({
+            metadata: payload.metadata,
+            limit: payload.limit ?? 10,
+            offset: payload.offset ?? 0,
+            sortBy,
+            sortOrder: payload.sort_order ?? "desc",
+        })) {
+            result.push(item.thread);
+            // Only set total if it's the first item
+            if (total === 0)
+                total = item.total;
+        }
+        c.res.headers.set("X-Pagination-Total", total.toString());
+        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 thread = await options.threads.get(thread_id);
+        const graphId = thread.metadata?.graph_id;
+        const graph = graphId ? await getGraph(graphId) : undefined;
+        if (graph == null) {
+            return jsonExtra(c, stateSnapshotToThreadState({
+                values: {},
+                next: [],
+                config: {},
+                metadata: undefined,
+                createdAt: undefined,
+                parentConfig: undefined,
+                tasks: [],
+            }));
+        }
+        const config = { configurable: { thread_id } };
+        const result = await graph.getState(config, { subgraphs });
+        return jsonExtra(c, stateSnapshotToThreadState(result));
+    });
+    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 } };
+        config.configurable ??= {};
+        if (payload.checkpoint_id) {
+            config.configurable.checkpoint_id = payload.checkpoint_id;
+        }
+        if (payload.checkpoint) {
+            Object.assign(config.configurable, payload.checkpoint);
+        }
+        const thread = await options.threads.get(thread_id);
+        const graphId = thread.metadata?.graph_id;
+        const graph = graphId ? await getGraph(graphId) : undefined;
+        if (graph == null)
+            return c.json({ error: "Graph not found" }, 404);
+        const result = await graph.updateState(config, payload.values, payload.as_node);
+        return jsonExtra(c, { checkpoint: result.configurable });
+    });
+    // get thread state at checkpoint
+    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 thread = await options.threads.get(thread_id);
+        const graphId = thread.metadata?.graph_id;
+        const graph = graphId ? await getGraph(graphId) : undefined;
+        if (graph == null)
+            return c.json({ error: "Graph not found" }, 404);
+        const result = await graph.getState({ configurable: { thread_id, checkpoint_id } }, { subgraphs });
+        return jsonExtra(c, stateSnapshotToThreadState(result));
+    });
+    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 thread = await options.threads.get(thread_id);
+        const graphId = thread.metadata?.graph_id;
+        const graph = graphId ? await getGraph(graphId) : undefined;
+        if (graph == null)
+            return c.json({ error: "Graph not found" }, 404);
+        const result = await graph.getState({ configurable: { thread_id, ...checkpoint } }, { subgraphs });
+        return jsonExtra(c, stateSnapshotToThreadState(result));
+    });
+    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 thread = await options.threads.get(thread_id);
+        const graphId = thread.metadata?.graph_id;
+        const graph = graphId ? await getGraph(graphId) : undefined;
+        if (graph == null)
+            return jsonExtra(c, []);
+        const config = { configurable: { thread_id, ...checkpoint } };
+        const result = [];
+        const beforeConfig = typeof before === "string"
+            ? { configurable: { checkpoint_id: before } }
+            : before;
+        for await (const state of graph.getStateHistory(config, {
+            limit,
+            before: beforeConfig,
+            filter: metadata,
+        })) {
+            result.push(stateSnapshotToThreadState(state));
+        }
+        return jsonExtra(c, result);
+    });
+    api.post("/threads/:thread_id/runs/stream", zValidator("param", z.object({ thread_id: z.string().uuid() })), zValidator("json", schemas.RunCreate), async (c) => {
+        // Stream Run
+        const { thread_id } = c.req.valid("param");
+        const payload = c.req.valid("json");
+        const thread = await options.threads.get(thread_id);
+        if (thread == null)
+            return c.json({ error: "Thread not found" }, 404);
+        return streamSSE(c, async (stream) => {
+            const signal = getDisconnectAbortSignal(c, stream);
+            const run = createStubRun(thread_id, payload);
+            await options.threads.set(thread_id, {
+                kind: "patch",
+                metadata: {
+                    graph_id: payload.assistant_id,
+                    assistant_id: payload.assistant_id,
+                },
+            });
+            try {
+                for await (const { event, data } of streamState(run, {
+                    attempt: 1,
+                    getGraph,
+                    signal,
+                })) {
+                    await stream.writeSSE({ data: serialiseAsDict(data), event });
+                }
+            }
+            catch (error) {
+                await stream.writeSSE({
+                    data: serialiseAsDict(serializeError(error)),
+                    event: "error",
+                });
+            }
+        });
+    });
+    api.post("/runs/stream", zValidator("json", schemas.RunCreate), async (c) => {
+        // Stream Stateless Run
+        return streamSSE(c, async (stream) => {
+            const payload = c.req.valid("json");
+            const signal = getDisconnectAbortSignal(c, stream);
+            const threadId = uuidv4();
+            await options.threads.set(threadId, {
+                kind: "put",
+                metadata: {
+                    graph_id: payload.assistant_id,
+                    assistant_id: payload.assistant_id,
+                },
+            });
+            try {
+                const run = createStubRun(threadId, payload);
+                try {
+                    for await (const { event, data } of streamState(run, {
+                        attempt: 1,
+                        getGraph,
+                        signal,
+                    })) {
+                        await stream.writeSSE({ data: serialiseAsDict(data), event });
+                    }
+                }
+                catch (error) {
+                    await stream.writeSSE({
+                        data: serialiseAsDict(serializeError(error)),
+                        event: "error",
+                    });
+                }
+            }
+            finally {
+                await options.threads.delete(threadId);
+            }
+        });
+    });
+    api.notFound((c) => {
+        return c.json({ error: `${c.req.method} ${c.req.path} not implemented` }, 404);
+    });
+    return api;
+}

package/dist/graph/api.d.mts

@@ -0,0 +1 @@
+export { assertGraphExists, getAssistantId, getGraph, getGraphKeys, } from "./load.mjs";

package/dist/graph/api.mjs

@@ -0,0 +1,2 @@
+// Public API for graph operations (useful for writing custom operation backends).
+export { assertGraphExists, getAssistantId, getGraph, getGraphKeys, } from "./load.mjs";

package/dist/graph/load.d.mts

@@ -0,0 +1,19 @@
+import type { AssistantsRepo } from "../storage/types.mjs";
+import type { BaseCheckpointSaver, BaseStore, CompiledGraph, LangGraphRunnableConfig } from "@langchain/langgraph";
+import { type CompiledGraphFactory } from "./load.utils.mjs";
+import type { GraphSchema, GraphSpec } from "./parser/index.mjs";
+export declare const GRAPHS: Record<string, CompiledGraph<string> | CompiledGraphFactory<string>>;
+export declare const GRAPH_SPEC: Record<string, GraphSpec>;
+export declare const GRAPH_SCHEMA: Record<string, Record<string, GraphSchema>>;
+export declare const NAMESPACE_GRAPH: Uint8Array<ArrayBufferLike>;
+export declare const getAssistantId: (graphId: string) => string;
+export declare function registerFromEnv(assistants: AssistantsRepo, specs: Record<string, string>, options: {
+    cwd: string;
+}): Promise<(CompiledGraph<string, any, any, Record<string, any>, any, any, unknown, unknown, any> | CompiledGraphFactory<string>)[]>;
+export declare function getGraph(graphId: string, config: LangGraphRunnableConfig | undefined, options?: {
+    checkpointer?: BaseCheckpointSaver | null;
+    store?: BaseStore;
+}): Promise<CompiledGraph<string, any, any, Record<string, any>, any, any, unknown, unknown, any>>;
+export declare function assertGraphExists(graphId: string): void;
+export declare function getGraphKeys(): string[];
+export declare function getCachedStaticGraphSchema(graphId: string): Promise<Record<string, GraphSchema>>;

package/dist/graph/load.hooks.d.mts

@@ -0,0 +1,2 @@
+export function initialize(args: any): Promise<void>;
+export function resolve(specifier: any, context: any, nextResolve: any): Promise<any>;

package/dist/graph/load.hooks.mjs

@@ -0,0 +1,52 @@
+// This module hook is used to ensure that @langchain/langgraph package
+// is imported from a consistent location.
+// Accepts `{ parentURL: string }` as argument when registering the hook.
+const OVERRIDE_RESOLVE = [
+    // Override `@langchain/langgraph` or `@langchain/langgraph/prebuilt`,
+    // but not `@langchain/langgraph-sdk`
+    new RegExp(`^@langchain\/langgraph(\/.+)?$`),
+    new RegExp(`^@langchain\/langgraph-checkpoint(\/.+)?$`),
+];
+let parentURL;
+let langgraphPackageURL;
+export async function initialize(args) {
+    parentURL = args.parentURL;
+}
+export async function resolve(specifier, context, nextResolve) {
+    // HACK: @tailwindcss/node internally uses an ESM loader cache, which does not play nicely with `tsx`.
+    //       Node.js crashes with "TypeError [ERR_INVALID_URL_SCHEME]: The URL must be of scheme file".
+    //       As it already is a valid URI, we can just short-circuit the resolution and avoid `tsx`.
+    if (specifier.includes("@tailwindcss/node/dist/esm-cache.loader") &&
+        specifier.startsWith("file://")) {
+        return {
+            shortCircuit: true,
+            // Node 18.x will for some reason attempt to load `.mts` instead of `.mjs`
+            url: specifier.replace(".mts", ".mjs"),
+            format: "module",
+        };
+    }
+    if (specifier === "@langchain/langgraph-checkpoint") {
+        // resolve relative to @langchain/langgraph package instead
+        // This is done to avoid adding a direct dependency on @langchain/langgraph-checkpoint
+        // in project, which if not present will cause `pnpm` to not find the package.
+        if (!langgraphPackageURL) {
+            const main = await nextResolve("@langchain/langgraph", {
+                ...context,
+                parentURL,
+            });
+            langgraphPackageURL = main.url.toString();
+        }
+        return await nextResolve(specifier, {
+            ...context,
+            parentURL: langgraphPackageURL,
+        });
+    }
+    if (OVERRIDE_RESOLVE.some((regex) => regex.test(specifier))) {
+        const resolved = await nextResolve(specifier, { ...context, parentURL });
+        // If @langchain/langgraph is resolved first, cache it!
+        if (specifier === "@langchain/langgraph" && !langgraphPackageURL) {
+            langgraphPackageURL = resolved.url.toString();
+        }
+    }
+    return nextResolve(specifier, context);
+}