@langchain/langgraph-api 0.0.39 → 0.0.41

package/dist/api/meta.mjs

@@ -1,5 +1,17 @@
 import { Hono } from "hono";
+import * as fs from "node:fs/promises";
+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));
+let version;
+try {
+    const packageJson = JSON.parse(await fs.readFile(packageJsonPath, "utf-8"));
+    version = packageJson.version;
+}
+catch {
+    console.warn("Could not determine version of langgraph-api");
+}
 // read env variable
 const env = process.env;
 api.get("/info", (c) => {
@@ -19,7 +31,14 @@ api.get("/info", (c) => {
         return undefined;
     })();
     return c.json({
-        flags: { assistants: true, crons: false, langsmith: !!langsmithTracing },
+        version,
+        context: "js",
+        flags: {
+            assistants: true,
+            crons: false,
+            langsmith: !!langsmithTracing,
+            langsmith_tracing_replicas: true,
+        },
     });
 });
 api.get("/ok", (c) => c.json({ ok: true }));

package/dist/api/runs.mjs

@@ -1,19 +1,19 @@
+import { zValidator } from "@hono/zod-validator";
 import { Hono } from "hono";
 import { HTTPException } from "hono/http-exception";
 import { streamSSE } from "hono/streaming";
+import { v4 as uuid4 } from "uuid";
+import { z } from "zod";
 import { getAssistantId } from "../graph/load.mjs";
-import { zValidator } from "@hono/zod-validator";
+import { logError, logger } from "../logging.mjs";
 import * as schemas from "../schemas.mjs";
-import { z } from "zod";
 import { Runs, Threads } from "../storage/ops.mjs";
-import { serialiseAsDict } from "../utils/serde.mjs";
 import { getDisconnectAbortSignal, jsonExtra, waitKeepAlive, } from "../utils/hono.mjs";
-import { logError, logger } from "../logging.mjs";
-import { v4 as uuid4 } from "uuid";
+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
@@ -33,6 +33,13 @@ const createValidRun = async (threadId, payload, kwargs) => {
         config.configurable ??= {};
         Object.assign(config.configurable, run.checkpoint);
     }
+    if (run.langsmith_tracer) {
+        config.configurable ??= {};
+        Object.assign(config.configurable, {
+            langsmith_project: run.langsmith_tracer.project_name,
+            langsmith_example_id: run.langsmith_tracer.example_id,
+        });
+    }
     if (headers) {
         for (const [rawKey, value] of headers.entries()) {
             const key = rawKey.toLowerCase();

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/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/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

@@ -579,6 +579,16 @@ export declare const CommandSchema: z.ZodObject<{
     })[] | undefined;
     resume?: unknown;
 }>;
+export declare const LangsmithTracer: z.ZodObject<{
+    project_name: z.ZodOptional<z.ZodString>;
+    example_id: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    project_name?: string | undefined;
+    example_id?: string | undefined;
+}, {
+    project_name?: string | undefined;
+    example_id?: string | undefined;
+}>;
 export declare const RunCreate: z.ZodObject<{
     assistant_id: z.ZodUnion<[z.ZodString, z.ZodString]>;
     checkpoint_id: z.ZodOptional<z.ZodString>;
@@ -692,6 +702,16 @@ export declare const RunCreate: z.ZodObject<{
     if_not_exists: z.ZodOptional<z.ZodEnum<["reject", "create"]>>;
     on_completion: z.ZodOptional<z.ZodEnum<["delete", "keep"]>>;
     feedback_keys: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    langsmith_tracer: z.ZodOptional<z.ZodObject<{
+        project_name: z.ZodOptional<z.ZodString>;
+        example_id: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        project_name?: string | undefined;
+        example_id?: string | undefined;
+    }, {
+        project_name?: string | undefined;
+        example_id?: string | undefined;
+    }>>;
 }, "strip", z.ZodTypeAny, {
     assistant_id: string;
     on_disconnect: "cancel" | "continue";
@@ -739,6 +759,10 @@ export declare const RunCreate: z.ZodObject<{
     stream_subgraphs?: boolean | undefined;
     stream_resumable?: boolean | undefined;
     on_completion?: "delete" | "keep" | undefined;
+    langsmith_tracer?: {
+        project_name?: string | undefined;
+        example_id?: string | undefined;
+    } | undefined;
 }, {
     assistant_id: string;
     metadata?: z.objectInputType<{}, z.ZodAny, "strip"> | undefined;
@@ -786,6 +810,10 @@ export declare const RunCreate: z.ZodObject<{
     stream_subgraphs?: boolean | undefined;
     stream_resumable?: boolean | undefined;
     on_completion?: "delete" | "keep" | undefined;
+    langsmith_tracer?: {
+        project_name?: string | undefined;
+        example_id?: string | undefined;
+    } | undefined;
 }>;
 export declare const RunBatchCreate: z.ZodArray<z.ZodObject<{
     assistant_id: z.ZodUnion<[z.ZodString, z.ZodString]>;
@@ -900,6 +928,16 @@ export declare const RunBatchCreate: z.ZodArray<z.ZodObject<{
     if_not_exists: z.ZodOptional<z.ZodEnum<["reject", "create"]>>;
     on_completion: z.ZodOptional<z.ZodEnum<["delete", "keep"]>>;
     feedback_keys: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    langsmith_tracer: z.ZodOptional<z.ZodObject<{
+        project_name: z.ZodOptional<z.ZodString>;
+        example_id: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        project_name?: string | undefined;
+        example_id?: string | undefined;
+    }, {
+        project_name?: string | undefined;
+        example_id?: string | undefined;
+    }>>;
 }, "strip", z.ZodTypeAny, {
     assistant_id: string;
     on_disconnect: "cancel" | "continue";
@@ -947,6 +985,10 @@ export declare const RunBatchCreate: z.ZodArray<z.ZodObject<{
     stream_subgraphs?: boolean | undefined;
     stream_resumable?: boolean | undefined;
     on_completion?: "delete" | "keep" | undefined;
+    langsmith_tracer?: {
+        project_name?: string | undefined;
+        example_id?: string | undefined;
+    } | undefined;
 }, {
     assistant_id: string;
     metadata?: z.objectInputType<{}, z.ZodAny, "strip"> | undefined;
@@ -994,6 +1036,10 @@ export declare const RunBatchCreate: z.ZodArray<z.ZodObject<{
     stream_subgraphs?: boolean | undefined;
     stream_resumable?: boolean | undefined;
     on_completion?: "delete" | "keep" | undefined;
+    langsmith_tracer?: {
+        project_name?: string | undefined;
+        example_id?: string | undefined;
+    } | undefined;
 }>, "many">;
 export declare const SearchResult: z.ZodObject<{
     metadata: z.ZodOptional<z.ZodObject<{}, "strip", z.ZodAny, z.objectOutputType<{}, z.ZodAny, "strip">, z.objectInputType<{}, z.ZodAny, "strip">>>;
@@ -1294,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

@@ -159,6 +159,10 @@ export const CommandSchema = z.object({
         .optional(),
     resume: z.unknown().optional(),
 });
+export const LangsmithTracer = z.object({
+    project_name: z.string().optional(),
+    example_id: z.string().optional(),
+});
 export const RunCreate = z
     .object({
     assistant_id: z.union([z.string().uuid(), z.string()]),
@@ -210,6 +214,7 @@ export const RunCreate = z
     if_not_exists: z.enum(["reject", "create"]).optional(),
     on_completion: z.enum(["delete", "keep"]).optional(),
     feedback_keys: z.array(z.string()).optional(),
+    langsmith_tracer: LangsmithTracer.optional(),
 })
     .describe("Payload for creating a stateful run.");
 export const RunBatchCreate = z
@@ -383,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/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,5 +1,6 @@
-import type { Run, RunnableConfig, Checkpoint } from "./storage/ops.mjs";
-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;
     name: 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

@@ -1,9 +1,9 @@
-import { getGraph } from "./graph/load.mjs";
-import { Client as LangSmithClient } from "langsmith";
-import { runnableConfigToCheckpoint, taskRunnableConfigToCheckpoint, } from "./utils/runnableConfig.mjs";
 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;
@@ -53,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 ?? [];
@@ -74,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();
@@ -82,12 +82,25 @@ 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",
         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), {
@@ -102,6 +115,7 @@ export async function* streamState(run, attempt = 1, options) {
         runId: run.run_id,
         streamMode: [...libStreamMode],
         signal: options?.signal,
+        ...(tracer && { callbacks: [tracer] }),
     });
     const messages = {};
     const completedIds = new Set();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/langgraph-api",
-  "version": "0.0.39",
+  "version": "0.0.41",
   "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": {
@@ -49,14 +53,14 @@
     "@babel/code-frame": "^7.26.2",
     "@hono/node-server": "^1.12.0",
     "@hono/zod-validator": "^0.2.2",
-    "@langchain/langgraph-ui": "0.0.39",
+    "@langchain/langgraph-ui": "0.0.41",
     "@types/json-schema": "^7.0.15",
     "@typescript/vfs": "^1.6.0",
     "dedent": "^1.5.3",
     "dotenv": "^16.4.7",
     "exit-hook": "^4.0.0",
     "hono": "^4.5.4",
-    "langsmith": "^0.2.15",
+    "langsmith": "^0.3.33",
     "open": "^10.1.0",
     "semver": "^7.7.1",
     "stacktrace-parser": "^0.1.10",
@@ -68,7 +72,7 @@
     "zod": "^3.23.8"
   },
   "peerDependencies": {
-    "@langchain/core": "^0.3.42",
+    "@langchain/core": "^0.3.59",
     "@langchain/langgraph": "^0.2.57 || ^0.3.0",
     "@langchain/langgraph-checkpoint": "~0.0.16",
     "@langchain/langgraph-sdk": "~0.0.70",
@@ -80,7 +84,7 @@
     }
   },
   "devDependencies": {
-    "@langchain/core": "^0.3.42",
+    "@langchain/core": "^0.3.59",
     "@langchain/langgraph": "^0.2.57",
     "@langchain/langgraph-checkpoint": "~0.0.16",
     "@langchain/langgraph-sdk": "^0.0.77",