@langchain/langgraph-api 1.1.8 → 1.1.10

package/dist/stream.mjs

@@ -0,0 +1,235 @@
+import { isBaseMessage } from "@langchain/core/messages";
+import { LangChainTracer } from "@langchain/core/tracers/tracer_langchain";
+import { Client as LangSmithClient, getDefaultProjectName } from "langsmith";
+import { getLangGraphCommand } from "./command.mjs";
+import { checkLangGraphSemver } from "./semver/index.mjs";
+import { runnableConfigToCheckpoint, taskRunnableConfigToCheckpoint, } from "./utils/runnableConfig.mjs";
+const isRunnableConfig = (config) => {
+    if (typeof config !== "object" || config == null)
+        return false;
+    return ("configurable" in config &&
+        typeof config.configurable === "object" &&
+        config.configurable != null);
+};
+function preprocessDebugCheckpointTask(task) {
+    if (!isRunnableConfig(task.state) ||
+        !taskRunnableConfigToCheckpoint(task.state)) {
+        return task;
+    }
+    const cloneTask = { ...task };
+    cloneTask.checkpoint = taskRunnableConfigToCheckpoint(task.state);
+    delete cloneTask.state;
+    return cloneTask;
+}
+const isConfigurablePresent = (config) => typeof config === "object" &&
+    config != null &&
+    "configurable" in config &&
+    typeof config.configurable === "object" &&
+    config.configurable != null;
+const deleteInternalConfigurableFields = (config) => {
+    if (isConfigurablePresent(config)) {
+        const newConfig = {
+            ...config,
+            configurable: Object.fromEntries(Object.entries(config.configurable).filter(([key]) => !key.startsWith("__"))),
+        };
+        delete newConfig.callbacks;
+        return newConfig;
+    }
+    return config;
+};
+function preprocessDebugCheckpoint(payload) {
+    const result = {
+        ...payload,
+        checkpoint: runnableConfigToCheckpoint(payload["config"]),
+        parent_checkpoint: runnableConfigToCheckpoint(payload["parentConfig"]),
+        tasks: payload["tasks"].map(preprocessDebugCheckpointTask),
+    };
+    // Handle LangGraph JS pascalCase vs snake_case
+    // TODO: use stream to LangGraph.JS
+    result.parent_config = payload["parentConfig"];
+    delete result.parentConfig;
+    result.config = deleteInternalConfigurableFields(result.config);
+    result.parent_config = deleteInternalConfigurableFields(result.parent_config);
+    return result;
+}
+let LANGGRAPH_VERSION;
+export async function* streamState(run, options) {
+    const kwargs = run.kwargs;
+    const graphId = kwargs.config?.configurable?.graph_id;
+    if (!graphId || typeof graphId !== "string") {
+        throw new Error("Invalid or missing graph_id");
+    }
+    const graph = await options.getGraph(graphId, kwargs.config, {
+        checkpointer: kwargs.temporary ? null : undefined,
+    });
+    const userStreamMode = kwargs.stream_mode ?? [];
+    const libStreamMode = new Set(userStreamMode.filter((mode) => mode !== "events" && mode !== "messages-tuple") ?? []);
+    if (userStreamMode.includes("messages-tuple")) {
+        libStreamMode.add("messages");
+    }
+    if (userStreamMode.includes("messages")) {
+        libStreamMode.add("values");
+    }
+    if (!libStreamMode.has("debug"))
+        libStreamMode.add("debug");
+    yield {
+        event: "metadata",
+        data: { run_id: run.run_id, attempt: options.attempt },
+    };
+    if (!LANGGRAPH_VERSION) {
+        const version = await checkLangGraphSemver();
+        LANGGRAPH_VERSION = version.find((v) => v.name === "@langchain/langgraph");
+    }
+    const metadata = {
+        ...kwargs.config?.metadata,
+        run_attempt: options.attempt,
+        langgraph_version: LANGGRAPH_VERSION?.version ?? "0.0.0",
+        langgraph_plan: "developer",
+        langgraph_host: "self-hosted",
+        langgraph_api_url: process.env.LANGGRAPH_API_URL ?? undefined,
+    };
+    const tracer = run.kwargs?.config?.configurable?.langsmith_project
+        ? new LangChainTracer({
+            replicas: [
+                [
+                    run.kwargs?.config?.configurable?.langsmith_project,
+                    {
+                        reference_example_id: run.kwargs?.config?.configurable?.langsmith_example_id,
+                    },
+                ],
+                [getDefaultProjectName(), undefined],
+            ],
+        })
+        : undefined;
+    const events = graph.streamEvents(kwargs.command != null
+        ? getLangGraphCommand(kwargs.command)
+        : kwargs.input ?? null, {
+        version: "v2",
+        interruptAfter: kwargs.interrupt_after,
+        interruptBefore: kwargs.interrupt_before,
+        tags: kwargs.config?.tags,
+        context: kwargs.context,
+        configurable: kwargs.config?.configurable,
+        recursionLimit: kwargs.config?.recursion_limit,
+        subgraphs: kwargs.subgraphs,
+        metadata,
+        runId: run.run_id,
+        streamMode: [...libStreamMode],
+        signal: options?.signal,
+        ...(tracer && { callbacks: [tracer] }),
+    });
+    const messages = {};
+    const completedIds = new Set();
+    for await (const event of events) {
+        if (event.tags?.includes("langsmith:hidden"))
+            continue;
+        if (event.event === "on_chain_stream" && event.run_id === run.run_id) {
+            const [ns, mode, chunk] = (kwargs.subgraphs ? event.data.chunk : [null, ...event.data.chunk]);
+            // Listen for debug events and capture checkpoint
+            let data = chunk;
+            if (mode === "debug") {
+                const debugChunk = chunk;
+                if (debugChunk.type === "checkpoint") {
+                    const debugCheckpoint = preprocessDebugCheckpoint(debugChunk.payload);
+                    options?.onCheckpoint?.(debugCheckpoint);
+                    data = { ...debugChunk, payload: debugCheckpoint };
+                }
+                else if (debugChunk.type === "task_result") {
+                    const debugResult = preprocessDebugCheckpointTask(debugChunk.payload);
+                    options?.onTaskResult?.(debugResult);
+                    data = { ...debugChunk, payload: debugResult };
+                }
+            }
+            else if (mode === "checkpoints") {
+                const debugCheckpoint = preprocessDebugCheckpoint(chunk);
+                options?.onCheckpoint?.(debugCheckpoint);
+                data = debugCheckpoint;
+            }
+            else if (mode === "tasks") {
+                const debugTask = preprocessDebugCheckpointTask(chunk);
+                if ("result" in debugTask || "error" in debugTask) {
+                    options?.onTaskResult?.(debugTask);
+                }
+                data = debugTask;
+            }
+            if (mode === "messages") {
+                if (userStreamMode.includes("messages-tuple")) {
+                    if (kwargs.subgraphs && ns?.length) {
+                        yield { event: `messages|${ns.join("|")}`, data };
+                    }
+                    else {
+                        yield { event: "messages", data };
+                    }
+                }
+            }
+            else if (userStreamMode.includes(mode)) {
+                if (kwargs.subgraphs && ns?.length) {
+                    yield { event: `${mode}|${ns.join("|")}`, data };
+                }
+                else {
+                    yield { event: mode, data };
+                }
+            }
+        }
+        else if (userStreamMode.includes("events")) {
+            yield { event: "events", data: event };
+        }
+        // TODO: we still rely on old messages mode based of streamMode=values
+        // In order to fully switch to library messages mode, we need to do ensure that
+        // `StreamMessagesHandler` sends the final message, which requires the following:
+        // - handleLLMEnd does not send the final message b/c handleLLMNewToken sets the this.emittedChatModelRunIds[runId] flag. Python does not do that
+        // - handleLLMEnd receives the final message as BaseMessageChunk rather than BaseMessage, which from the outside will become indistinguishable.
+        // - handleLLMEnd should not dedupe the message
+        // - Don't think there's an utility that would convert a BaseMessageChunk to a BaseMessage?
+        if (userStreamMode.includes("messages")) {
+            if (event.event === "on_chain_stream" && event.run_id === run.run_id) {
+                const newMessages = [];
+                const [_, chunk] = event.data.chunk;
+                let chunkMessages = [];
+                if (typeof chunk === "object" &&
+                    chunk != null &&
+                    "messages" in chunk &&
+                    !isBaseMessage(chunk)) {
+                    chunkMessages = chunk?.messages;
+                }
+                if (!Array.isArray(chunkMessages)) {
+                    chunkMessages = [chunkMessages];
+                }
+                for (const message of chunkMessages) {
+                    if (!message.id || completedIds.has(message.id))
+                        continue;
+                    completedIds.add(message.id);
+                    newMessages.push(message);
+                }
+                if (newMessages.length > 0) {
+                    yield { event: "messages/complete", data: newMessages };
+                }
+            }
+            else if (event.event === "on_chat_model_stream" &&
+                !event.tags?.includes("nostream")) {
+                const message = event.data.chunk;
+                if (!message.id)
+                    continue;
+                if (messages[message.id] == null) {
+                    messages[message.id] = message;
+                    yield {
+                        event: "messages/metadata",
+                        data: { [message.id]: { metadata: event.metadata } },
+                    };
+                }
+                else {
+                    messages[message.id] = messages[message.id].concat(message);
+                }
+                yield { event: "messages/partial", data: [messages[message.id]] };
+            }
+        }
+    }
+    if (kwargs.feedback_keys) {
+        const client = new LangSmithClient();
+        const data = Object.fromEntries(await Promise.all(kwargs.feedback_keys.map(async (feedback) => {
+            const { url } = await client.createPresignedFeedbackToken(run.run_id, feedback);
+            return [feedback, url];
+        })));
+        yield { event: "feedback", data };
+    }
+}

package/dist/ui/load.d.mts

@@ -0,0 +1,8 @@
+import { Hono } from "hono";
+export declare function registerGraphUi(defs: Record<string, string>, options: {
+    cwd: string;
+    config?: {
+        shared?: string[];
+    };
+}): Promise<void>;
+export declare const api: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;

package/dist/ui/load.mjs

@@ -0,0 +1,53 @@
+import { z } from "zod/v3";
+import { Hono } from "hono";
+import { getMimeType } from "hono/utils/mime";
+import { zValidator } from "@hono/zod-validator";
+import { watch } from "@langchain/langgraph-ui";
+import * as path from "node:path";
+const GRAPH_UI = {};
+export async function registerGraphUi(defs, options) {
+    await watch({
+        defs,
+        cwd: options.cwd,
+        config: options.config,
+        onOutput: (graphId, files) => (GRAPH_UI[graphId] = files),
+    });
+}
+export const api = new Hono();
+api.post("/ui/:agent", zValidator("json", z.object({ name: z.string() })), async (c) => {
+    const agent = c.req.param("agent");
+    const host = c.req.header("host");
+    const message = await c.req.valid("json");
+    const isHost = (needle) => {
+        if (!host)
+            return false;
+        return host.startsWith(needle + ":") || host === needle;
+    };
+    const protocol = isHost("localhost") || isHost("127.0.0.1") ? "http:" : "";
+    const files = GRAPH_UI[agent];
+    if (!files?.length)
+        return c.text(`UI not found for agent "${agent}"`, 404);
+    const messageName = JSON.stringify(message.name);
+    const result = [];
+    for (const css of files.filter((i) => path.extname(i.basename) === ".css")) {
+        result.push(`<link rel="stylesheet" href="${protocol}//${host}/ui/${agent}/${css.basename}" />`);
+    }
+    const stableName = agent.replace(/[^a-zA-Z0-9]/g, "_");
+    const js = files.find((i) => path.extname(i.basename) === ".js");
+    if (js) {
+        result.push(`<script src="${protocol}//${host}/ui/${agent}/${js.basename}" onload='__LGUI_${stableName}.render(${messageName}, "{{shadowRootId}}")'></script>`);
+    }
+    return c.text(result.join("\n"), {
+        headers: { "Content-Type": "text/html" },
+    });
+});
+api.get("/ui/:agent/:basename", async (c) => {
+    const agent = c.req.param("agent");
+    const basename = c.req.param("basename");
+    const file = GRAPH_UI[agent]?.find((item) => item.basename === basename);
+    if (!file)
+        return c.text("File not found", 404);
+    return c.body(file.contents, {
+        headers: { "Content-Type": getMimeType(file.basename) ?? "text/plain" },
+    });
+});

package/dist/utils/abort.d.mts

@@ -0,0 +1 @@
+export declare const combineAbortSignals: (...input: (AbortSignal | undefined | null)[]) => AbortSignal;

package/dist/utils/abort.mjs

@@ -0,0 +1,8 @@
+export const combineAbortSignals = (...input) => {
+    const signals = input.filter((item) => item != null);
+    if ("any" in AbortSignal)
+        return AbortSignal.any(signals);
+    const abortController = new AbortController();
+    signals.forEach((signal) => signal.addEventListener("abort", () => abortController.abort()));
+    return abortController.signal;
+};

package/dist/utils/hono.d.mts

@@ -0,0 +1,5 @@
+import type { Context } from "hono";
+import { StreamingApi } from "hono/utils/stream";
+export declare function jsonExtra<T>(c: Context, object: T): Response & import("hono").TypedResponse<string, import("hono/utils/http-status").ContentfulStatusCode, "body">;
+export declare function waitKeepAlive(c: Context, promise: Promise<unknown>): Response;
+export declare const getDisconnectAbortSignal: (c: Context, stream: StreamingApi) => AbortSignal;

package/dist/utils/hono.mjs

@@ -0,0 +1,24 @@
+import { serialiseAsDict } from "./serde.mjs";
+import { stream } from "hono/streaming";
+export function jsonExtra(c, object) {
+    c.header("Content-Type", "application/json");
+    return c.body(serialiseAsDict(object));
+}
+export function waitKeepAlive(c, promise) {
+    return stream(c, async (stream) => {
+        // keep sending newlines until we resolved the chunk
+        let keepAlive = Promise.resolve();
+        const timer = setInterval(() => {
+            keepAlive = keepAlive.then(() => stream.write("\n"));
+        }, 1000);
+        const result = await promise;
+        clearInterval(timer);
+        await keepAlive;
+        await stream.write(serialiseAsDict(result));
+    });
+}
+export const getDisconnectAbortSignal = (c, stream) => {
+    // https://github.com/honojs/hono/issues/1770
+    stream.onAbort(() => { });
+    return c.req.raw.signal;
+};

package/dist/utils/importMap.d.mts

@@ -0,0 +1,55 @@
+import { PromptTemplate, AIMessagePromptTemplate, ChatMessagePromptTemplate, ChatPromptTemplate, HumanMessagePromptTemplate, MessagesPlaceholder, SystemMessagePromptTemplate, ImagePromptTemplate, PipelinePromptTemplate } from "@langchain/core/prompts";
+import { AIMessage, AIMessageChunk, BaseMessage, BaseMessageChunk, ChatMessage, ChatMessageChunk, FunctionMessage, FunctionMessageChunk, HumanMessage, HumanMessageChunk, SystemMessage, SystemMessageChunk, ToolMessage, ToolMessageChunk } from "@langchain/core/messages";
+import { StringPromptValue } from "@langchain/core/prompt_values";
+export declare const prompts__prompt: {
+    PromptTemplate: typeof PromptTemplate;
+};
+export declare const schema__messages: {
+    AIMessage: typeof AIMessage;
+    AIMessageChunk: typeof AIMessageChunk;
+    BaseMessage: typeof BaseMessage;
+    BaseMessageChunk: typeof BaseMessageChunk;
+    ChatMessage: typeof ChatMessage;
+    ChatMessageChunk: typeof ChatMessageChunk;
+    FunctionMessage: typeof FunctionMessage;
+    FunctionMessageChunk: typeof FunctionMessageChunk;
+    HumanMessage: typeof HumanMessage;
+    HumanMessageChunk: typeof HumanMessageChunk;
+    SystemMessage: typeof SystemMessage;
+    SystemMessageChunk: typeof SystemMessageChunk;
+    ToolMessage: typeof ToolMessage;
+    ToolMessageChunk: typeof ToolMessageChunk;
+};
+export declare const schema: {
+    AIMessage: typeof AIMessage;
+    AIMessageChunk: typeof AIMessageChunk;
+    BaseMessage: typeof BaseMessage;
+    BaseMessageChunk: typeof BaseMessageChunk;
+    ChatMessage: typeof ChatMessage;
+    ChatMessageChunk: typeof ChatMessageChunk;
+    FunctionMessage: typeof FunctionMessage;
+    FunctionMessageChunk: typeof FunctionMessageChunk;
+    HumanMessage: typeof HumanMessage;
+    HumanMessageChunk: typeof HumanMessageChunk;
+    SystemMessage: typeof SystemMessage;
+    SystemMessageChunk: typeof SystemMessageChunk;
+    ToolMessage: typeof ToolMessage;
+    ToolMessageChunk: typeof ToolMessageChunk;
+};
+export declare const prompts__chat: {
+    AIMessagePromptTemplate: typeof AIMessagePromptTemplate;
+    ChatMessagePromptTemplate: typeof ChatMessagePromptTemplate;
+    ChatPromptTemplate: typeof ChatPromptTemplate;
+    HumanMessagePromptTemplate: typeof HumanMessagePromptTemplate;
+    MessagesPlaceholder: typeof MessagesPlaceholder;
+    SystemMessagePromptTemplate: typeof SystemMessagePromptTemplate;
+};
+export declare const prompts__image: {
+    ImagePromptTemplate: typeof ImagePromptTemplate;
+};
+export declare const prompts__pipeline: {
+    PipelinePromptTemplate: typeof PipelinePromptTemplate;
+};
+export declare const prompts__base: {
+    StringPromptValue: typeof StringPromptValue;
+};

package/dist/utils/importMap.mjs

@@ -0,0 +1,55 @@
+import { PromptTemplate, AIMessagePromptTemplate, ChatMessagePromptTemplate, ChatPromptTemplate, HumanMessagePromptTemplate, MessagesPlaceholder, SystemMessagePromptTemplate, ImagePromptTemplate, PipelinePromptTemplate, } from "@langchain/core/prompts";
+import { AIMessage, AIMessageChunk, BaseMessage, BaseMessageChunk, ChatMessage, ChatMessageChunk, FunctionMessage, FunctionMessageChunk, HumanMessage, HumanMessageChunk, SystemMessage, SystemMessageChunk, ToolMessage, ToolMessageChunk, } from "@langchain/core/messages";
+import { StringPromptValue } from "@langchain/core/prompt_values";
+export const prompts__prompt = {
+    PromptTemplate,
+};
+export const schema__messages = {
+    AIMessage,
+    AIMessageChunk,
+    BaseMessage,
+    BaseMessageChunk,
+    ChatMessage,
+    ChatMessageChunk,
+    FunctionMessage,
+    FunctionMessageChunk,
+    HumanMessage,
+    HumanMessageChunk,
+    SystemMessage,
+    SystemMessageChunk,
+    ToolMessage,
+    ToolMessageChunk,
+};
+export const schema = {
+    AIMessage,
+    AIMessageChunk,
+    BaseMessage,
+    BaseMessageChunk,
+    ChatMessage,
+    ChatMessageChunk,
+    FunctionMessage,
+    FunctionMessageChunk,
+    HumanMessage,
+    HumanMessageChunk,
+    SystemMessage,
+    SystemMessageChunk,
+    ToolMessage,
+    ToolMessageChunk,
+};
+export const prompts__chat = {
+    AIMessagePromptTemplate,
+    ChatMessagePromptTemplate,
+    ChatPromptTemplate,
+    HumanMessagePromptTemplate,
+    MessagesPlaceholder,
+    SystemMessagePromptTemplate,
+};
+export const prompts__image = {
+    ImagePromptTemplate,
+};
+export const prompts__pipeline = {
+    PipelinePromptTemplate,
+};
+export const prompts__base = {
+    StringPromptValue,
+};

package/dist/utils/runnableConfig.d.mts

@@ -0,0 +1,3 @@
+import type { Checkpoint, RunnableConfig } from "../storage/types.mjs";
+export declare const runnableConfigToCheckpoint: (config: RunnableConfig | null | undefined) => Checkpoint | null;
+export declare const taskRunnableConfigToCheckpoint: (config: RunnableConfig | null | undefined) => Partial<Checkpoint> | null;

package/dist/utils/runnableConfig.mjs

@@ -0,0 +1,45 @@
+import { z } from "zod/v3";
+const ConfigSchema = z.object({
+    configurable: z.object({
+        thread_id: z.string(),
+        checkpoint_id: z.string(),
+        checkpoint_ns: z.string().nullish(),
+        checkpoint_map: z.record(z.string(), z.unknown()).nullish(),
+    }),
+});
+export const runnableConfigToCheckpoint = (config) => {
+    if (!config || !config.configurable || !config.configurable.thread_id) {
+        return null;
+    }
+    const parsed = ConfigSchema.safeParse(config);
+    if (!parsed.success)
+        return null;
+    return {
+        thread_id: parsed.data.configurable.thread_id,
+        checkpoint_id: parsed.data.configurable.checkpoint_id,
+        checkpoint_ns: parsed.data.configurable.checkpoint_ns || "",
+        checkpoint_map: parsed.data.configurable.checkpoint_map || null,
+    };
+};
+const TaskConfigSchema = z.object({
+    configurable: z.object({
+        thread_id: z.string(),
+        checkpoint_id: z.string().nullish(),
+        checkpoint_ns: z.string().nullish(),
+        checkpoint_map: z.record(z.string(), z.unknown()).nullish(),
+    }),
+});
+export const taskRunnableConfigToCheckpoint = (config) => {
+    if (!config || !config.configurable || !config.configurable.thread_id) {
+        return null;
+    }
+    const parsed = TaskConfigSchema.safeParse(config);
+    if (!parsed.success)
+        return null;
+    return {
+        thread_id: parsed.data.configurable.thread_id,
+        checkpoint_id: parsed.data.configurable.checkpoint_id || null,
+        checkpoint_ns: parsed.data.configurable.checkpoint_ns || "",
+        checkpoint_map: parsed.data.configurable.checkpoint_map || null,
+    };
+};

package/dist/utils/serde.d.mts

@@ -0,0 +1,5 @@
+export declare const serialiseAsDict: (obj: unknown) => string;
+export declare const serializeError: (error: unknown) => {
+    error: string;
+    message: string;
+};

package/dist/utils/serde.mjs

@@ -0,0 +1,20 @@
+export const serialiseAsDict = (obj) => {
+    return JSON.stringify(obj, function (key, value) {
+        const rawValue = this[key];
+        if (rawValue != null &&
+            typeof rawValue === "object" &&
+            "toDict" in rawValue &&
+            typeof rawValue.toDict === "function") {
+            // TODO: we need to upstream this to LangChainJS
+            const { type, data } = rawValue.toDict();
+            return { ...data, type };
+        }
+        return value;
+    }, 2);
+};
+export const serializeError = (error) => {
+    if (error instanceof Error) {
+        return { error: error.name, message: error.message };
+    }
+    return { error: "Error", message: JSON.stringify(error) };
+};

package/dist/vitest.config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vitest/config.js").UserConfigFnObject;
+export default _default;

package/dist/vitest.config.js

@@ -0,0 +1,11 @@
+import { defineConfig } from "vitest/config";
+export default defineConfig(() => {
+    /** @type {import("vitest/config").UserConfigExport} */
+    return {
+        test: {
+            hideSkippedTests: true,
+            testTimeout: 30_000,
+            fileParallelism: false,
+        },
+    };
+});

package/dist/webhook.d.mts

@@ -0,0 +1,11 @@
+import type { Run } from "./storage/types.mjs";
+import type { StreamCheckpoint } from "./stream.mjs";
+export declare function callWebhook(result: {
+    checkpoint: StreamCheckpoint | undefined;
+    status: string | undefined;
+    exception: Error | undefined;
+    run: Run;
+    webhook: string;
+    run_started_at: Date;
+    run_ended_at: Date | undefined;
+}): Promise<void>;

package/dist/webhook.mjs

@@ -0,0 +1,30 @@
+import { serializeError } from "./utils/serde.mjs";
+import { getLoopbackFetch } from "./loopback.mjs";
+export async function callWebhook(result) {
+    const payload = {
+        ...result.run,
+        status: result.status,
+        run_started_at: result.run_started_at.toISOString(),
+        run_ended_at: result.run_ended_at?.toISOString(),
+        webhook_sent_at: new Date().toISOString(),
+        values: result.checkpoint?.values,
+        ...(result.exception
+            ? { error: serializeError(result.exception).message }
+            : undefined),
+    };
+    if (result.webhook.startsWith("/")) {
+        const fetch = getLoopbackFetch();
+        if (!fetch)
+            throw new Error("Loopback fetch is not bound");
+        await fetch(result.webhook, {
+            method: "POST",
+            body: JSON.stringify(payload),
+        });
+    }
+    else {
+        await fetch(result.webhook, {
+            method: "POST",
+            body: JSON.stringify(payload),
+        });
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/langgraph-api",
-  "version": "1.1.8",
+  "version": "1.1.10",
   "type": "module",
   "engines": {
     "node": "^18.19.0 || >=20.16.0"
@@ -50,22 +50,10 @@
     "url": "git+ssh://git@github.com/langchain-ai/langgraphjs.git",
     "directory": "libs/langgraph-api"
   },
-  "scripts": {
-    "clean": "rm -rf dist/ .turbo/ ./tests/graphs/.langgraph_api/",
-    "build": "yarn turbo:command build:internal --filter=@langchain/langgraph-api",
-    "build:internal": "yarn clean && node scripts/build.mjs",
-    "dev": "tsx ./tests/utils.server.mts --dev",
-    "prepublish": "yarn build",
-    "typecheck": "tsc --noEmit",
-    "test": "vitest run",
-    "format": "prettier --write .",
-    "format:check": "prettier --check ."
-  },
   "dependencies": {
     "@babel/code-frame": "^7.26.2",
     "@hono/node-server": "^1.12.0",
     "@hono/zod-validator": "^0.7.6",
-    "@langchain/langgraph-ui": "workspace:*",
     "@types/json-schema": "^7.0.15",
     "@typescript/vfs": "^1.6.0",
     "dedent": "^1.5.3",
@@ -81,7 +69,8 @@
     "uuid": "^10.0.0",
     "winston": "^3.17.0",
     "winston-console-format": "^1.0.8",
-    "zod": "^3.25.76 || ^4"
+    "zod": "^3.25.76 || ^4",
+    "@langchain/langgraph-ui": "1.1.10"
   },
   "peerDependencies": {
     "@langchain/core": "^0.3.59 || ^1.0.1",
@@ -97,9 +86,6 @@
   },
   "devDependencies": {
     "@langchain/core": "^1.0.0",
-    "@langchain/langgraph": "workspace:*",
-    "@langchain/langgraph-checkpoint": "workspace:*",
-    "@langchain/langgraph-sdk": "workspace:*",
     "@types/babel__code-frame": "^7.0.6",
     "@types/node": "^18.15.11",
     "@types/react": "^19.0.8",
@@ -111,6 +97,20 @@
     "prettier": "^2.8.3",
     "typescript": "^4.9.5 || ^5.4.5",
     "vitest": "^3.2.4",
-    "wait-port": "^1.1.0"
+    "wait-port": "^1.1.0",
+    "@langchain/langgraph": "1.0.14",
+    "@langchain/langgraph-checkpoint": "1.0.0",
+    "@langchain/langgraph-sdk": "1.4.6"
+  },
+  "scripts": {
+    "clean": "rm -rf dist/ .turbo/ ./tests/graphs/.langgraph_api/",
+    "build": "pnpm turbo build:internal --filter=@langchain/langgraph-api",
+    "build:internal": "pnpm clean && node scripts/build.mjs",
+    "dev": "tsx ./tests/utils.server.mts --dev",
+    "prepublish": "pnpm build",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "format": "prettier --write .",
+    "format:check": "prettier --check ."
   }
-}
+}