@langchain/langgraph-api 0.0.40 → 0.0.42

package/dist/api/meta.mjs

@@ -1,9 +1,10 @@
 import { Hono } from "hono";
 import * as fs from "node:fs/promises";
+import * as path from "node:path";
 import * as url from "node:url";
 const api = new Hono();
 // Get the version using the same pattern as semver/index.mts
-const packageJsonPath = url.fileURLToPath(new URL("../../package.json", import.meta.url));
+const packageJsonPath = path.resolve(url.fileURLToPath(import.meta.url), "../../../package.json");
 let version;
 try {
     const packageJson = JSON.parse(await fs.readFile(packageJsonPath, "utf-8"));

package/dist/api/runs.mjs

@@ -13,7 +13,7 @@ import { serialiseAsDict } from "../utils/serde.mjs";
 const api = new Hono();
 const createValidRun = async (threadId, payload, kwargs) => {
     const { assistant_id: assistantId, ...run } = payload;
-    const { auth, headers } = kwargs;
+    const { auth, headers } = kwargs ?? {};
     const runId = uuid4();
     const streamMode = Array.isArray(payload.stream_mode)
         ? payload.stream_mode

package/dist/api/threads.mjs

@@ -111,18 +111,7 @@ api.get("/threads/:thread_id/history", zValidator("param", z.object({ thread_id:
     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", z.object({
-    limit: z.number().optional().default(10),
-    before: z.string().optional(),
-    metadata: z.record(z.string(), z.unknown()).optional(),
-    checkpoint: z
-        .object({
-        checkpoint_id: z.string().uuid().optional(),
-        checkpoint_ns: z.string().optional(),
-        checkpoint_map: z.record(z.string(), z.unknown()).optional(),
-    })
-        .optional(),
-})), async (c) => {
+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");
@@ -140,7 +129,7 @@ api.delete("/threads/:thread_id", zValidator("param", z.object({ thread_id: z.st
     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", z.object({ metadata: z.record(z.string(), z.unknown()) })), async (c) => {
+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");

package/dist/command.d.mts

@@ -8,4 +8,4 @@ export interface RunCommand {
     update?: Record<string, unknown> | [string, unknown][];
     resume?: unknown;
 }
-export declare const getLangGraphCommand: (command: RunCommand) => Command<unknown>;
+export declare const getLangGraphCommand: (command: RunCommand) => Command<unknown, Record<string, unknown>, string>;

package/dist/experimental/embed.d.mts

@@ -0,0 +1,26 @@
+import type { BaseCheckpointSaver, BaseStore, Pregel } from "@langchain/langgraph";
+import { Hono } from "hono";
+import type { Metadata } from "../storage/ops.mjs";
+type AnyPregel = Pregel<any, any, any, any, any>;
+interface Thread {
+    thread_id: string;
+    metadata: Metadata;
+}
+interface ThreadSaver {
+    get: (id: string) => Promise<Thread>;
+    put: (id: string, options: {
+        metadata?: Metadata;
+    }) => Promise<void>;
+    delete: (id: string) => Promise<void>;
+}
+/**
+ * Attach LangGraph Platform-esque routes to a given Hono instance.
+ * @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,167 @@
+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";
+import { streamState } from "../stream.mjs";
+import { serialiseAsDict } 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();
+    const streamMode = Array.isArray(payload.stream_mode)
+        ? payload.stream_mode
+        : payload.stream_mode
+            ? [payload.stream_mode]
+            : undefined;
+    const config = Object.assign({}, payload.config ?? {}, {
+        configurable: {
+            run_id: runId,
+            thread_id: threadId,
+            graph_id: payload.assistant_id,
+        },
+    }, { 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,
+            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,
+    };
+}
+/**
+ * Attach LangGraph Platform-esque routes to a given Hono instance.
+ * @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 threaad
+        const payload = c.req.valid("json");
+        const threadId = payload.thread_id || uuidv4();
+        await options.threads.put(threadId, payload);
+        return jsonExtra(c, { thread_id: threadId });
+    });
+    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 ? options.graph[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/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 ? options.graph[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
+        return streamSSE(c, async (stream) => {
+            const { thread_id } = c.req.valid("param");
+            const payload = c.req.valid("json");
+            const signal = getDisconnectAbortSignal(c, stream);
+            const run = createStubRun(thread_id, payload);
+            // update thread with new graph_id
+            const thread = await options.threads.get(thread_id);
+            await options.threads.put(thread_id, {
+                metadata: {
+                    ...thread.metadata,
+                    graph_id: payload.assistant_id,
+                    assistant_id: payload.assistant_id,
+                },
+            });
+            for await (const { event, data } of streamState(run, {
+                attempt: 1,
+                getGraph,
+                signal,
+            })) {
+                await stream.writeSSE({ data: serialiseAsDict(data), event });
+            }
+        });
+    });
+    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.put(threadId, {
+                metadata: {
+                    graph_id: payload.assistant_id,
+                    assistant_id: payload.assistant_id,
+                },
+            });
+            try {
+                const run = createStubRun(threadId, payload);
+                for await (const { event, data } of streamState(run, {
+                    attempt: 1,
+                    getGraph,
+                    signal,
+                })) {
+                    await stream.writeSSE({ data: serialiseAsDict(data), event });
+                }
+            }
+            finally {
+                await options.threads.delete(threadId);
+            }
+        });
+    });
+    return api;
+}

package/dist/graph/parser/schema/types.template.mts

@@ -20,12 +20,11 @@ type AnyGraph = {
 
 type Wrap<T> = (a: T) => void;
 type MatchBaseMessage<T> = T extends BaseMessage ? BaseMessage : never;
-type MatchBaseMessageArray<T> =
-  T extends Array<infer C>
-    ? Wrap<MatchBaseMessage<C>> extends Wrap<BaseMessage>
-      ? BaseMessage[]
-      : never
-    : never;
+type MatchBaseMessageArray<T> = T extends Array<infer C>
+  ? Wrap<MatchBaseMessage<C>> extends Wrap<BaseMessage>
+    ? BaseMessage[]
+    : never
+  : never;
 
 type Defactorify<T> = T extends (...args: any[]) => infer R
   ? Awaited<R>
@@ -35,32 +34,31 @@ type Defactorify<T> = T extends (...args: any[]) => infer R
 type Inspect<T, TDepth extends Array<0> = []> = TDepth extends [0, 0, 0]
   ? any
   : T extends unknown
-    ? {
-        [K in keyof T]: 0 extends 1 & T[K]
-          ? T[K]
-          : Wrap<MatchBaseMessageArray<T[K]>> extends Wrap<BaseMessage[]>
-            ? BaseMessage[]
-            : Wrap<MatchBaseMessage<T[K]>> extends Wrap<BaseMessage>
-              ? BaseMessage
-              : Inspect<T[K], [0, ...TDepth]>;
-      }
-    : never;
+  ? {
+      [K in keyof T]: 0 extends 1 & T[K]
+        ? T[K]
+        : Wrap<MatchBaseMessageArray<T[K]>> extends Wrap<BaseMessage[]>
+        ? BaseMessage[]
+        : Wrap<MatchBaseMessage<T[K]>> extends Wrap<BaseMessage>
+        ? BaseMessage
+        : Inspect<T[K], [0, ...TDepth]>;
+    }
+  : never;
 
 type ReflectCompiled<T> = T extends { RunInput: infer S; RunOutput: infer U }
   ? { state: S; update: U }
   : T extends { "~InputType": infer InputType; "~OutputType": infer OutputType }
-    ? { state: OutputType; update: InputType }
-    : never;
+  ? { state: OutputType; update: InputType }
+  : never;
 
 // @ts-expect-error
-type Reflect<T> =
-  Defactorify<T> extends infer DT
-    ? DT extends {
-        compile(...args: any[]): infer Compiled;
-      }
-      ? ReflectCompiled<Compiled>
-      : ReflectCompiled<DT>
-    : never;
+type Reflect<T> = Defactorify<T> extends infer DT
+  ? DT extends {
+      compile(...args: any[]): infer Compiled;
+    }
+    ? ReflectCompiled<Compiled>
+    : ReflectCompiled<DT>
+  : never;
 
 type BuilderReflectCompiled<T> = T extends {
   builder: {
@@ -77,14 +75,13 @@ type BuilderReflectCompiled<T> = T extends {
   : never;
 
 // @ts-expect-error
-type BuilderReflect<T> =
-  Defactorify<T> extends infer DT
-    ? DT extends {
-        compile(...args: any[]): infer Compiled;
-      }
-      ? BuilderReflectCompiled<Compiled>
-      : BuilderReflectCompiled<DT>
-    : never;
+type BuilderReflect<T> = Defactorify<T> extends infer DT
+  ? DT extends {
+      compile(...args: any[]): infer Compiled;
+    }
+    ? BuilderReflectCompiled<Compiled>
+    : BuilderReflectCompiled<DT>
+  : never;
 
 // @ts-expect-error
 type FilterAny<T> = 0 extends 1 & T ? never : T;

package/dist/http/middleware.mjs

@@ -16,7 +16,7 @@ export const cors = (cors) => {
                 return origin;
             return undefined;
         }
-        : (cors.allow_origins ?? []);
+        : cors.allow_origins ?? [];
     if (cors.expose_headers?.length) {
         const headersSet = new Set(cors.expose_headers.map((h) => h.toLowerCase()));
         if (!headersSet.has("content-location")) {

package/dist/queue.mjs

@@ -3,6 +3,7 @@ import { streamState, } from "./stream.mjs";
 import { logError, logger } from "./logging.mjs";
 import { serializeError } from "./utils/serde.mjs";
 import { callWebhook } from "./webhook.mjs";
+import { getGraph } from "./graph/load.mjs";
 const MAX_RETRY_ATTEMPTS = 3;
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 export const queue = async () => {
@@ -14,7 +15,7 @@ export const queue = async () => {
         await sleep(1000 * Math.random());
     }
 };
-const worker = async (run, attempt, abortSignal) => {
+const worker = async (run, attempt, signal) => {
     const startedAt = new Date();
     let endedAt = undefined;
     let checkpoint = undefined;
@@ -48,8 +49,10 @@ const worker = async (run, attempt, abortSignal) => {
         const runId = run.run_id;
         const resumable = run.kwargs?.resumable ?? false;
         try {
-            const stream = streamState(run, attempt, {
-                signal: abortSignal,
+            const stream = streamState(run, {
+                getGraph,
+                attempt,
+                signal,
                 ...(!temporary ? { onCheckpoint, onTaskResult } : undefined),
             });
             for await (const { event, data } of stream) {

package/dist/schemas.d.mts

@@ -1340,6 +1340,49 @@ export declare const ThreadStateUpdate: z.ZodObject<{
     checkpoint_id?: string | undefined;
     as_node?: string | undefined;
 }>;
+export declare const ThreadHistoryRequest: z.ZodObject<{
+    limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    before: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    checkpoint: z.ZodOptional<z.ZodObject<{
+        checkpoint_id: z.ZodOptional<z.ZodString>;
+        checkpoint_ns: z.ZodOptional<z.ZodString>;
+        checkpoint_map: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        checkpoint_ns?: string | undefined;
+        checkpoint_id?: string | undefined;
+        checkpoint_map?: Record<string, unknown> | undefined;
+    }, {
+        checkpoint_ns?: string | undefined;
+        checkpoint_id?: string | undefined;
+        checkpoint_map?: Record<string, unknown> | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    limit: number;
+    metadata?: Record<string, unknown> | undefined;
+    checkpoint?: {
+        checkpoint_ns?: string | undefined;
+        checkpoint_id?: string | undefined;
+        checkpoint_map?: Record<string, unknown> | undefined;
+    } | undefined;
+    before?: string | undefined;
+}, {
+    metadata?: Record<string, unknown> | undefined;
+    checkpoint?: {
+        checkpoint_ns?: string | undefined;
+        checkpoint_id?: string | undefined;
+        checkpoint_map?: Record<string, unknown> | undefined;
+    } | undefined;
+    limit?: number | undefined;
+    before?: string | undefined;
+}>;
+export declare const ThreadPatchRequest: z.ZodObject<{
+    metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    metadata: Record<string, unknown>;
+}, {
+    metadata: Record<string, unknown>;
+}>;
 export declare const AssistantLatestVersion: z.ZodObject<{
     version: z.ZodNumber;
 }, "strip", z.ZodTypeAny, {

package/dist/schemas.mjs

@@ -388,6 +388,21 @@ export const ThreadStateUpdate = z
     as_node: z.string().optional(),
 })
     .describe("Payload for adding state to a thread.");
+export const ThreadHistoryRequest = z.object({
+    limit: z.number().optional().default(10),
+    before: z.string().optional(),
+    metadata: z.record(z.string(), z.unknown()).optional(),
+    checkpoint: z
+        .object({
+        checkpoint_id: z.string().uuid().optional(),
+        checkpoint_ns: z.string().optional(),
+        checkpoint_map: z.record(z.string(), z.unknown()).optional(),
+    })
+        .optional(),
+});
+export const ThreadPatchRequest = z.object({
+    metadata: z.record(z.string(), z.unknown()),
+});
 export const AssistantLatestVersion = z.object({
     version: z.number(),
 });

package/dist/semver/index.mjs

@@ -1,7 +1,8 @@
 import * as url from "node:url";
 import * as fs from "node:fs/promises";
+import * as path from "node:path";
 import * as semver from "semver";
-const packageJsonPath = url.fileURLToPath(new URL("../../package.json", import.meta.url));
+const packageJsonPath = path.resolve(url.fileURLToPath(import.meta.url), "../../../package.json");
 export async function checkSemver(packages) {
     const packageJson = JSON.parse(await fs.readFile(packageJsonPath, "utf-8"));
     const peerDependencies = packageJson.peerDependencies ?? {};

package/dist/state.mjs

@@ -15,13 +15,11 @@ export const stateSnapshotToThreadState = (state) => {
             path: task.path,
             // TODO: too many type assertions, check if this is actually correct
             checkpoint: task.state != null && "configurable" in task.state
-                ? (task.state.configurable ?? null)
+                ? task.state.configurable ?? null
                 : null,
             state: task.state != null && isStateSnapshot(task.state)
                 ? stateSnapshotToThreadState(task.state)
                 : null,
-            // TODO: add missing result to the library
-            // @ts-expect-error
             result: task.result ?? null,
         })),
         metadata: state.metadata,

package/dist/storage/ops.d.mts

@@ -5,7 +5,7 @@ import { FileSystemPersistence } from "./persist.mjs";
 export type Metadata = Record<string, unknown>;
 export type ThreadStatus = "idle" | "busy" | "interrupted" | "error";
 export type RunStatus = "pending" | "running" | "error" | "success" | "timeout" | "interrupted";
-export type StreamMode = "values" | "messages" | "messages-tuple" | "custom" | "updates" | "events" | "debug";
+export type StreamMode = "values" | "messages" | "messages-tuple" | "custom" | "updates" | "events" | "debug" | "tasks" | "checkpoints";
 export type MultitaskStrategy = "reject" | "rollback" | "interrupt" | "enqueue";
 export type OnConflictBehavior = "raise" | "do_nothing";
 export type IfNotExists = "create" | "reject";
@@ -183,7 +183,7 @@ interface ThreadTask {
     interrupts: Record<string, unknown>[];
     checkpoint: Checkpoint | null;
     state: ThreadState | null;
-    result: Record<string, unknown> | null;
+    result: unknown | null;
 }
 export interface ThreadState {
     values: Record<string, unknown>;

package/dist/storage/ops.mjs

@@ -744,27 +744,37 @@ export class Runs {
     static async *next() {
         yield* conn.withGenerator(async function* (STORE, options) {
             const now = new Date();
-            const pendingRuns = Object.values(STORE.runs)
+            const pendingRunIds = Object.values(STORE.runs)
                 .filter((run) => run.status === "pending" && run.created_at < now)
-                .sort((a, b) => a.created_at.getTime() - b.created_at.getTime());
-            if (!pendingRuns.length) {
+                .sort((a, b) => a.created_at.getTime() - b.created_at.getTime())
+                .map((run) => run.run_id);
+            if (!pendingRunIds.length) {
                 return;
             }
-            for (const run of pendingRuns) {
-                const runId = run.run_id;
-                const threadId = run.thread_id;
-                const thread = STORE.threads[threadId];
-                if (!thread) {
-                    await console.warn(`Unexpected missing thread in Runs.next: ${threadId}`);
-                    continue;
-                }
+            for (const runId of pendingRunIds) {
                 if (StreamManager.isLocked(runId))
                     continue;
                 try {
                     const signal = StreamManager.lock(runId);
+                    const run = STORE.runs[runId];
+                    if (!run)
+                        continue;
+                    const threadId = run.thread_id;
+                    const thread = STORE.threads[threadId];
+                    if (!thread) {
+                        logger.warn(`Unexpected missing thread in Runs.next: ${threadId}`);
+                        continue;
+                    }
+                    // is the run still valid?
+                    if (run.status !== "pending")
+                        continue;
+                    if (Object.values(STORE.runs).some((run) => run.thread_id === threadId && run.status === "running")) {
+                        continue;
+                    }
                     options.schedulePersist();
                     STORE.retry_counter[runId] ??= 0;
                     STORE.retry_counter[runId] += 1;
+                    STORE.runs[runId].status = "running";
                     yield { run, attempt: STORE.retry_counter[runId], signal };
                 }
                 finally {
@@ -842,7 +852,8 @@ export class Runs {
             }
             // if multitask_mode = reject, check for inflight runs
             // and if there are any, return them to reject putting a new run
-            const inflightRuns = Object.values(STORE.runs).filter((run) => run.thread_id === threadId && run.status === "pending");
+            const inflightRuns = Object.values(STORE.runs).filter((run) => run.thread_id === threadId &&
+                (run.status === "pending" || run.status === "running"));
             if (options?.preventInsertInInflight) {
                 if (inflightRuns.length > 0)
                     return inflightRuns;
@@ -1090,7 +1101,7 @@ export class Runs {
                                 yield { event: "error", data: "Run not found" };
                             break;
                         }
-                        else if (run.status !== "pending") {
+                        else if (run.status !== "pending" && run.status !== "running") {
                             break;
                         }
                     }

package/dist/stream.d.mts

@@ -1,4 +1,5 @@
-import { type CheckpointMetadata, type Interrupt, type StateSnapshot } from "@langchain/langgraph";
+import type { BaseCheckpointSaver, LangGraphRunnableConfig, CheckpointMetadata, Interrupt, StateSnapshot } from "@langchain/langgraph";
+import type { Pregel } from "@langchain/langgraph/pregel";
 import type { Checkpoint, Run, RunnableConfig } from "./storage/ops.mjs";
 interface DebugTask {
     id: string;
@@ -27,7 +28,11 @@ export type StreamTaskResult = Prettify<Omit<DebugTask, "state"> & {
     state?: StateSnapshot;
     checkpoint?: Checkpoint;
 }>;
-export declare function streamState(run: Run, attempt?: number, options?: {
+export declare function streamState(run: Run, options: {
+    attempt: number;
+    getGraph: (graphId: string, config: LangGraphRunnableConfig | undefined, options?: {
+        checkpointer?: BaseCheckpointSaver | null;
+    }) => Promise<Pregel<any, any, any, any, any>>;
     onCheckpoint?: (checkpoint: StreamCheckpoint) => void;
     onTaskResult?: (taskResult: StreamTaskResult) => void;
     signal?: AbortSignal;

package/dist/stream.mjs

@@ -2,7 +2,6 @@ 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 { getGraph } from "./graph/load.mjs";
 import { checkLangGraphSemver } from "./semver/index.mjs";
 import { runnableConfigToCheckpoint, taskRunnableConfigToCheckpoint, } from "./utils/runnableConfig.mjs";
 const isRunnableConfig = (config) => {
@@ -54,13 +53,13 @@ function preprocessDebugCheckpoint(payload) {
     return result;
 }
 let LANGGRAPH_VERSION;
-export async function* streamState(run, attempt = 1, options) {
+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 getGraph(graphId, kwargs.config, {
+    const graph = await options.getGraph(graphId, kwargs.config, {
         checkpointer: kwargs.temporary ? null : undefined,
     });
     const userStreamMode = kwargs.stream_mode ?? [];
@@ -75,7 +74,7 @@ export async function* streamState(run, attempt = 1, options) {
         libStreamMode.add("debug");
     yield {
         event: "metadata",
-        data: { run_id: run.run_id, attempt },
+        data: { run_id: run.run_id, attempt: options.attempt },
     };
     if (!LANGGRAPH_VERSION) {
         const version = await checkLangGraphSemver();
@@ -83,7 +82,7 @@ export async function* streamState(run, attempt = 1, options) {
     }
     const metadata = {
         ...kwargs.config?.metadata,
-        run_attempt: attempt,
+        run_attempt: options.attempt,
         langgraph_version: LANGGRAPH_VERSION?.version ?? "0.0.0",
         langgraph_plan: "developer",
         langgraph_host: "self-hosted",
@@ -104,7 +103,7 @@ export async function* streamState(run, attempt = 1, options) {
         : undefined;
     const events = graph.streamEvents(kwargs.command != null
         ? getLangGraphCommand(kwargs.command)
-        : (kwargs.input ?? null), {
+        : kwargs.input ?? null, {
         version: "v2",
         interruptAfter: kwargs.interrupt_after,
         interruptBefore: kwargs.interrupt_before,

package/dist/ui/load.mjs

@@ -26,9 +26,10 @@ api.post("/ui/:agent", zValidator("json", z.object({ name: z.string() })), async
     for (const css of files.filter((i) => path.extname(i.basename) === ".css")) {
         result.push(`<link rel="stylesheet" href="http://${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="http://${host}/ui/${agent}/${js.basename}" onload='__LGUI_${agent}.render(${messageName}, "{{shadowRootId}}")'></script>`);
+        result.push(`<script src="http://${host}/ui/${agent}/${js.basename}" onload='__LGUI_${stableName}.render(${messageName}, "{{shadowRootId}}")'></script>`);
     }
     return c.text(result.join("\n"), {
         headers: { "Content-Type": "text/html" },

package/dist/vitest.config.d.ts

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

package/dist/vitest.config.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/langgraph-api",
-  "version": "0.0.40",
+  "version": "0.0.42",
   "type": "module",
   "engines": {
     "node": "^18.19.0 || >=20.16.0"
@@ -27,6 +27,10 @@
       "types": "./dist/graph/parser/index.d.mts",
       "default": "./dist/graph/parser/index.mjs"
     },
+    "./experimental/embed": {
+      "types": "./dist/experimental/embed.d.mts",
+      "default": "./dist/experimental/embed.mjs"
+    },
     "./package.json": "./package.json"
   },
   "repository": {
@@ -34,14 +38,13 @@
     "url": "git@github.com:langchain-ai/langgraphjs-api.git"
   },
   "scripts": {
-    "clean": "npx -y bun scripts/clean.mjs",
-    "build": "npx -y bun scripts/build.mjs",
+    "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",
     "prepack": "yarn run build",
     "typecheck": "tsc --noEmit",
-    "test": "vitest",
-    "test:parser": "vitest run ./tests/parser.test.mts --testTimeout 15000",
-    "test:api": "npx -y bun scripts/test.mjs",
+    "test": "vitest run",
     "format": "prettier --write .",
     "format:check": "prettier --check ."
   },
@@ -49,7 +52,7 @@
     "@babel/code-frame": "^7.26.2",
     "@hono/node-server": "^1.12.0",
     "@hono/zod-validator": "^0.2.2",
-    "@langchain/langgraph-ui": "0.0.40",
+    "@langchain/langgraph-ui": "workspace:*",
     "@types/json-schema": "^7.0.15",
     "@typescript/vfs": "^1.6.0",
     "dedent": "^1.5.3",
@@ -81,19 +84,20 @@
   },
   "devDependencies": {
     "@langchain/core": "^0.3.59",
-    "@langchain/langgraph": "^0.2.57",
-    "@langchain/langgraph-checkpoint": "~0.0.16",
-    "@langchain/langgraph-sdk": "^0.0.77",
+    "@langchain/langgraph": "workspace:*",
+    "@langchain/langgraph-checkpoint": "workspace:*",
+    "@langchain/langgraph-sdk": "workspace:*",
     "@types/babel__code-frame": "^7.0.6",
-    "@types/node": "^22.2.0",
+    "@types/node": "^18.15.11",
     "@types/react": "^19.0.8",
     "@types/react-dom": "^19.0.3",
     "@types/semver": "^7.7.0",
     "@types/uuid": "^10.0.0",
     "jose": "^6.0.10",
     "postgres": "^3.4.5",
-    "prettier": "^3.3.3",
-    "typescript": "^5.5.4",
-    "vitest": "^3.0.5"
+    "prettier": "^2.8.3",
+    "typescript": "^4.9.5 || ^5.4.5",
+    "vitest": "^3.1.2",
+    "wait-port": "^1.1.0"
   }
-}
+}