@langchain/langgraph-api 1.2.1 → 1.2.2

package/dist/src/api/runs.mjs

@@ -0,0 +1,335 @@
+import { zValidator } from "@hono/zod-validator";
+import { Hono } from "hono";
+import { HTTPException } from "hono/http-exception";
+import { streamSSE } from "hono/streaming";
+import { v7 as uuid7 } from "uuid";
+import { z } from "zod/v3";
+import { getAssistantId } from "../graph/load.mjs";
+import { logError, logger } from "../logging.mjs";
+import * as schemas from "../schemas.mjs";
+import { runs, threads } from "../storage/context.mjs";
+import { getDisconnectAbortSignal, jsonExtra, waitKeepAlive, } from "../utils/hono.mjs";
+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 runId = uuid7();
+    const streamMode = Array.isArray(payload.stream_mode)
+        ? payload.stream_mode
+        : payload.stream_mode != null
+            ? [payload.stream_mode]
+            : [];
+    if (streamMode.length === 0)
+        streamMode.push("values");
+    const multitaskStrategy = payload.multitask_strategy ?? "reject";
+    const preventInsertInInflight = multitaskStrategy === "reject";
+    const config = { ...run.config };
+    if (run.checkpoint_id) {
+        config.configurable ??= {};
+        config.configurable.checkpoint_id = run.checkpoint_id;
+    }
+    if (run.checkpoint) {
+        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();
+            if (key.startsWith("x-")) {
+                if (["x-api-key", "x-tenant-id", "x-service-key"].includes(key)) {
+                    continue;
+                }
+                config.configurable ??= {};
+                config.configurable[key] = value;
+            }
+            else if (key === "user-agent") {
+                config.configurable ??= {};
+                config.configurable[key] = value;
+            }
+        }
+    }
+    let userId;
+    if (auth) {
+        userId = auth.user.identity ?? auth.user.id;
+        config.configurable ??= {};
+        config.configurable["langgraph_auth_user"] = auth.user;
+        config.configurable["langgraph_auth_user_id"] = userId;
+        config.configurable["langgraph_auth_permissions"] = auth.scopes;
+    }
+    let feedbackKeys = run.feedback_keys != null
+        ? Array.isArray(run.feedback_keys)
+            ? run.feedback_keys
+            : [run.feedback_keys]
+        : undefined;
+    if (!feedbackKeys?.length)
+        feedbackKeys = undefined;
+    const [first, ...inflight] = await runs().put(runId, getAssistantId(assistantId), {
+        input: run.input,
+        command: run.command,
+        config,
+        context: run.context,
+        stream_mode: streamMode,
+        interrupt_before: run.interrupt_before,
+        interrupt_after: run.interrupt_after,
+        webhook: run.webhook,
+        feedback_keys: feedbackKeys,
+        temporary: threadId == null && (run.on_completion ?? "delete") === "delete",
+        subgraphs: run.stream_subgraphs ?? false,
+        resumable: run.stream_resumable ?? false,
+    }, {
+        threadId,
+        userId,
+        metadata: run.metadata,
+        status: "pending",
+        multitaskStrategy,
+        preventInsertInInflight,
+        afterSeconds: payload.after_seconds,
+        ifNotExists: payload.if_not_exists,
+    }, auth);
+    if (first?.run_id === runId) {
+        logger.info("Created run", { run_id: runId, thread_id: threadId });
+        if ((multitaskStrategy === "interrupt" || multitaskStrategy === "rollback") &&
+            inflight.length > 0) {
+            try {
+                await runs().cancel(threadId, inflight.map((run) => run.run_id), { action: multitaskStrategy }, auth);
+            }
+            catch (error) {
+                logger.warn("Failed to cancel inflight runs, might be already cancelled", {
+                    error,
+                    run_ids: inflight.map((run) => run.run_id),
+                    thread_id: threadId,
+                });
+            }
+        }
+        return first;
+    }
+    else if (multitaskStrategy === "reject") {
+        throw new HTTPException(422, {
+            message: "Thread is already running a task. Wait for it to finish or choose a different multitask strategy.",
+        });
+    }
+    throw new HTTPException(500, {
+        message: "Unreachable state when creating run",
+    });
+};
+api.post("/runs/crons", zValidator("json", schemas.CronCreate), async () => {
+    // Create Thread Cron
+    throw new HTTPException(500, { message: "Not implemented" });
+});
+api.post("/runs/crons/search", zValidator("json", schemas.CronSearch), async () => {
+    // Search Crons
+    throw new HTTPException(500, { message: "Not implemented" });
+});
+api.delete("/runs/crons/:cron_id", zValidator("param", z.object({ cron_id: z.string().uuid() })), async () => {
+    // Delete Cron
+    throw new HTTPException(500, { message: "Not implemented" });
+});
+api.post("/threads/:thread_id/runs/crons", zValidator("param", z.object({ thread_id: z.string().uuid() })), zValidator("json", schemas.CronCreate), async () => {
+    // Create Thread Cron
+    throw new HTTPException(500, { message: "Not implemented" });
+});
+api.post("/runs/stream", zValidator("json", schemas.RunCreate), async (c) => {
+    // Stream Stateless Run
+    const payload = c.req.valid("json");
+    const run = await createValidRun(undefined, payload, {
+        auth: c.var.auth,
+        headers: c.req.raw.headers,
+    });
+    c.header("Content-Location", `/runs/${run.run_id}`);
+    return streamSSE(c, async (stream) => {
+        const cancelOnDisconnect = payload.on_disconnect === "cancel"
+            ? getDisconnectAbortSignal(c, stream)
+            : undefined;
+        try {
+            for await (const { event, data } of runs().stream.join(run.run_id, undefined, {
+                signal: cancelOnDisconnect,
+                cancelOnDisconnect: cancelOnDisconnect != null,
+                lastEventId: run.kwargs.resumable ? "-1" : undefined,
+                ignore404: true,
+            }, c.var.auth)) {
+                await stream.writeSSE({ data: serialiseAsDict(data), event });
+            }
+        }
+        catch (error) {
+            logError(error, { prefix: "Error streaming run" });
+        }
+    });
+});
+// TODO: port to Python API
+api.get("/runs/:run_id/stream", zValidator("param", z.object({ run_id: z.string().uuid() })), zValidator("query", z.object({ cancel_on_disconnect: schemas.coercedBoolean.optional() })), async (c) => {
+    const { run_id } = c.req.valid("param");
+    const query = c.req.valid("query");
+    const lastEventId = c.req.header("Last-Event-ID") || undefined;
+    c.header("Content-Location", `/runs/${run_id}`);
+    return streamSSE(c, async (stream) => {
+        const cancelOnDisconnect = query.cancel_on_disconnect
+            ? getDisconnectAbortSignal(c, stream)
+            : undefined;
+        try {
+            for await (const { id, event, data } of runs().stream.join(run_id, undefined, {
+                signal: cancelOnDisconnect,
+                cancelOnDisconnect: cancelOnDisconnect != null,
+                lastEventId,
+                ignore404: true,
+            }, c.var.auth)) {
+                await stream.writeSSE({ id, data: serialiseAsDict(data), event });
+            }
+        }
+        catch (error) {
+            logError(error, { prefix: "Error streaming run" });
+        }
+    });
+});
+api.post("/runs/wait", zValidator("json", schemas.RunCreate), async (c) => {
+    // Wait Stateless Run
+    const payload = c.req.valid("json");
+    const run = await createValidRun(undefined, payload, {
+        auth: c.var.auth,
+        headers: c.req.raw.headers,
+    });
+    c.header("Content-Location", `/runs/${run.run_id}`);
+    return waitKeepAlive(c, runs().wait(run.run_id, undefined, c.var.auth));
+});
+api.post("/runs", zValidator("json", schemas.RunCreate), async (c) => {
+    // Create Stateless Run
+    const payload = c.req.valid("json");
+    const run = await createValidRun(undefined, payload, {
+        auth: c.var.auth,
+        headers: c.req.raw.headers,
+    });
+    c.header("Content-Location", `/runs/${run.run_id}`);
+    return jsonExtra(c, run);
+});
+api.post("/runs/batch", zValidator("json", schemas.RunBatchCreate), async (c) => {
+    // Batch Runs
+    const payload = c.req.valid("json");
+    const runs = await Promise.all(payload.map((run) => createValidRun(undefined, run, {
+        auth: c.var.auth,
+        headers: c.req.raw.headers,
+    })));
+    return jsonExtra(c, runs);
+});
+api.get("/threads/:thread_id/runs", zValidator("param", z.object({ thread_id: z.string().uuid() })), zValidator("query", z.object({
+    limit: z.coerce.number().nullish(),
+    offset: z.coerce.number().nullish(),
+    status: z.string().nullish(),
+    metadata: z.record(z.string(), z.unknown()).nullish(),
+})), async (c) => {
+    // List runs
+    const { thread_id } = c.req.valid("param");
+    const { limit, offset, status, metadata } = c.req.valid("query");
+    const [runsResponse] = await Promise.all([
+        runs().search(thread_id, { limit, offset, status, metadata }, c.var.auth),
+        threads().get(thread_id, c.var.auth),
+    ]);
+    return jsonExtra(c, runsResponse);
+});
+api.post("/threads/:thread_id/runs", zValidator("param", z.object({ thread_id: z.string().uuid() })), zValidator("json", schemas.RunCreate), async (c) => {
+    // Create Run
+    const { thread_id } = c.req.valid("param");
+    const payload = c.req.valid("json");
+    const run = await createValidRun(thread_id, payload, {
+        auth: c.var.auth,
+        headers: c.req.raw.headers,
+    });
+    c.header("Content-Location", `/threads/${thread_id}/runs/${run.run_id}`);
+    return jsonExtra(c, run);
+});
+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 run = await createValidRun(thread_id, payload, {
+        auth: c.var.auth,
+        headers: c.req.raw.headers,
+    });
+    c.header("Content-Location", `/threads/${thread_id}/runs/${run.run_id}`);
+    return streamSSE(c, async (stream) => {
+        const cancelOnDisconnect = payload.on_disconnect === "cancel"
+            ? getDisconnectAbortSignal(c, stream)
+            : undefined;
+        try {
+            for await (const { id, event, data } of runs().stream.join(run.run_id, thread_id, {
+                signal: cancelOnDisconnect,
+                cancelOnDisconnect: cancelOnDisconnect != null,
+                lastEventId: run.kwargs.resumable ? "-1" : undefined,
+            }, c.var.auth)) {
+                await stream.writeSSE({ id, data: serialiseAsDict(data), event });
+            }
+        }
+        catch (error) {
+            logError(error, { prefix: "Error streaming run" });
+        }
+    });
+});
+api.post("/threads/:thread_id/runs/wait", zValidator("param", z.object({ thread_id: z.string().uuid() })), zValidator("json", schemas.RunCreate), async (c) => {
+    // Wait Run
+    const { thread_id } = c.req.valid("param");
+    const payload = c.req.valid("json");
+    const run = await createValidRun(thread_id, payload, {
+        auth: c.var.auth,
+        headers: c.req.raw.headers,
+    });
+    c.header("Content-Location", `/threads/${thread_id}/runs/${run.run_id}`);
+    return waitKeepAlive(c, runs().join(run.run_id, thread_id, c.var.auth));
+});
+api.get("/threads/:thread_id/runs/:run_id", zValidator("param", z.object({ thread_id: z.string().uuid(), run_id: z.string().uuid() })), async (c) => {
+    const { thread_id, run_id } = c.req.valid("param");
+    const [run] = await Promise.all([
+        runs().get(run_id, thread_id, c.var.auth),
+        threads().get(thread_id, c.var.auth),
+    ]);
+    if (run == null)
+        throw new HTTPException(404, { message: "Run not found" });
+    return jsonExtra(c, run);
+});
+api.delete("/threads/:thread_id/runs/:run_id", zValidator("param", z.object({ thread_id: z.string().uuid(), run_id: z.string().uuid() })), async (c) => {
+    // Delete Run
+    const { thread_id, run_id } = c.req.valid("param");
+    await runs().delete(run_id, thread_id, c.var.auth);
+    return c.body(null, 204);
+});
+api.get("/threads/:thread_id/runs/:run_id/join", zValidator("param", z.object({ thread_id: z.string().uuid(), run_id: z.string().uuid() })), async (c) => {
+    // Join Run Http
+    const { thread_id, run_id } = c.req.valid("param");
+    return jsonExtra(c, await runs().join(run_id, thread_id, c.var.auth));
+});
+api.get("/threads/:thread_id/runs/:run_id/stream", zValidator("param", z.object({ thread_id: z.string().uuid(), run_id: z.string().uuid() })), zValidator("query", z.object({ cancel_on_disconnect: schemas.coercedBoolean.optional() })), async (c) => {
+    // Stream Run Http
+    const { thread_id, run_id } = c.req.valid("param");
+    const { cancel_on_disconnect } = c.req.valid("query");
+    const lastEventId = c.req.header("Last-Event-ID") || undefined;
+    return streamSSE(c, async (stream) => {
+        const signal = cancel_on_disconnect
+            ? getDisconnectAbortSignal(c, stream)
+            : undefined;
+        for await (const { id, event, data } of runs().stream.join(run_id, thread_id, {
+            signal,
+            cancelOnDisconnect: signal != null,
+            lastEventId,
+        }, c.var.auth)) {
+            await stream.writeSSE({ id, data: serialiseAsDict(data), event });
+        }
+    });
+});
+api.post("/threads/:thread_id/runs/:run_id/cancel", zValidator("param", z.object({ thread_id: z.string().uuid(), run_id: z.string().uuid() })), zValidator("query", z.object({
+    wait: z.coerce.boolean().optional().default(false),
+    action: z.enum(["interrupt", "rollback"]).optional().default("interrupt"),
+})), async (c) => {
+    // Cancel Run Http
+    const { thread_id, run_id } = c.req.valid("param");
+    const { wait, action } = c.req.valid("query");
+    await runs().cancel(thread_id, [run_id], { action }, c.var.auth);
+    if (wait)
+        await runs().join(run_id, thread_id, c.var.auth);
+    return c.body(null, wait ? 204 : 202);
+});
+export default api;

package/dist/src/api/store.d.mts

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

package/dist/src/api/store.mjs

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

package/dist/src/api/threads.d.mts

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

package/dist/src/api/threads.mjs

@@ -0,0 +1,143 @@
+import { zValidator } from "@hono/zod-validator";
+import { Hono } from "hono";
+import { v7 as uuid7 } from "uuid";
+import { z } from "zod/v3";
+import * as schemas from "../schemas.mjs";
+import { stateSnapshotToThreadState } from "../state.mjs";
+import { threads } from "../storage/context.mjs";
+import { jsonExtra } from "../utils/hono.mjs";
+const api = new Hono();
+// Threads Routes
+api.post("/threads", zValidator("json", schemas.ThreadCreate), async (c) => {
+    // Create Thread
+    const payload = c.req.valid("json");
+    const thread = await threads().put(payload.thread_id || uuid7(), { metadata: payload.metadata, if_exists: payload.if_exists ?? "raise" }, c.var.auth);
+    if (payload.supersteps?.length) {
+        await threads().state.bulk({ configurable: { thread_id: thread.thread_id } }, payload.supersteps, c.var.auth);
+    }
+    return jsonExtra(c, thread);
+});
+api.post("/threads/search", zValidator("json", schemas.ThreadSearchRequest), async (c) => {
+    // Search Threads
+    const payload = c.req.valid("json");
+    const result = [];
+    let total = 0;
+    for await (const item of threads().search({
+        status: payload.status,
+        values: payload.values,
+        metadata: payload.metadata,
+        ids: payload.ids,
+        limit: payload.limit ?? 10,
+        offset: payload.offset ?? 0,
+        sort_by: payload.sort_by ?? "created_at",
+        sort_order: payload.sort_order ?? "desc",
+        select: payload.select,
+    }, c.var.auth)) {
+        result.push(Object.fromEntries(Object.entries(item.thread).filter(([k]) => !payload.select || payload.select.includes(k))));
+        // Only set total if it's the first item
+        if (total === 0) {
+            total = item.total;
+        }
+    }
+    const nextOffset = (payload.offset ?? 0) + total;
+    if (total === payload.limit) {
+        c.res.headers.set("X-Pagination-Next", nextOffset.toString());
+        c.res.headers.set("X-Pagination-Total", (nextOffset + 1).toString());
+    }
+    else {
+        c.res.headers.set("X-Pagination-Total", nextOffset.toString());
+    }
+    return jsonExtra(c, result);
+});
+api.post("/threads/count", zValidator("json", schemas.ThreadCountRequest), async (c) => {
+    const payload = c.req.valid("json");
+    const total = await threads().count(payload, c.var.auth);
+    return c.json(total);
+});
+api.get("/threads/:thread_id/state", zValidator("param", z.object({ thread_id: z.string().uuid() })), zValidator("query", z.object({ subgraphs: schemas.coercedBoolean.optional() })), async (c) => {
+    // Get Latest Thread State
+    const { thread_id } = c.req.valid("param");
+    const { subgraphs } = c.req.valid("query");
+    const state = stateSnapshotToThreadState(await threads().state.get({ configurable: { thread_id } }, { subgraphs }, c.var.auth));
+    return jsonExtra(c, state);
+});
+api.post("/threads/:thread_id/state", zValidator("param", z.object({ thread_id: z.string().uuid() })), zValidator("json", schemas.ThreadStateUpdate), async (c) => {
+    // Update Thread State
+    const { thread_id } = c.req.valid("param");
+    const payload = c.req.valid("json");
+    const config = { configurable: { thread_id } };
+    if (payload.checkpoint_id) {
+        config.configurable ??= {};
+        config.configurable.checkpoint_id = payload.checkpoint_id;
+    }
+    if (payload.checkpoint) {
+        config.configurable ??= {};
+        Object.assign(config.configurable, payload.checkpoint);
+    }
+    const inserted = await threads().state.post(config, payload.values, payload.as_node, c.var.auth);
+    return jsonExtra(c, inserted);
+});
+api.get("/threads/:thread_id/state/:checkpoint_id", zValidator("param", z.object({
+    thread_id: z.string().uuid(),
+    checkpoint_id: z.string().uuid(),
+})), zValidator("query", z.object({ subgraphs: schemas.coercedBoolean.optional() })), async (c) => {
+    // Get Thread State At Checkpoint
+    const { thread_id, checkpoint_id } = c.req.valid("param");
+    const { subgraphs } = c.req.valid("query");
+    const state = stateSnapshotToThreadState(await threads().state.get({ configurable: { thread_id, checkpoint_id } }, { subgraphs }, c.var.auth));
+    return jsonExtra(c, state);
+});
+api.post("/threads/:thread_id/state/checkpoint", zValidator("param", z.object({ thread_id: z.string().uuid() })), zValidator("json", z.object({
+    subgraphs: schemas.coercedBoolean.optional(),
+    checkpoint: schemas.CheckpointSchema.nullish(),
+})), async (c) => {
+    // Get Thread State At Checkpoint Post
+    const { thread_id } = c.req.valid("param");
+    const { checkpoint, subgraphs } = c.req.valid("json");
+    const state = stateSnapshotToThreadState(await threads().state.get({ configurable: { thread_id, ...checkpoint } }, { subgraphs }, c.var.auth));
+    return jsonExtra(c, state);
+});
+api.get("/threads/:thread_id/history", zValidator("param", z.object({ thread_id: z.string().uuid() })), zValidator("query", z.object({
+    limit: z
+        .string()
+        .optional()
+        .default("10")
+        .transform((value) => parseInt(value, 10)),
+    before: z.string().optional(),
+})), async (c) => {
+    // Get Thread History
+    const { thread_id } = c.req.valid("param");
+    const { limit, before } = c.req.valid("query");
+    const states = await threads().state.list({ configurable: { thread_id, checkpoint_ns: "" } }, { limit, before }, c.var.auth);
+    return jsonExtra(c, states.map(stateSnapshotToThreadState));
+});
+api.post("/threads/:thread_id/history", zValidator("param", z.object({ thread_id: z.string().uuid() })), zValidator("json", schemas.ThreadHistoryRequest), async (c) => {
+    // Get Thread History Post
+    const { thread_id } = c.req.valid("param");
+    const { limit, before, metadata, checkpoint } = c.req.valid("json");
+    const states = await threads().state.list({ configurable: { thread_id, checkpoint_ns: "", ...checkpoint } }, { limit, before, metadata }, c.var.auth);
+    return jsonExtra(c, states.map(stateSnapshotToThreadState));
+});
+api.get("/threads/:thread_id", zValidator("param", z.object({ thread_id: z.string().uuid() })), async (c) => {
+    // Get Thread
+    const { thread_id } = c.req.valid("param");
+    return jsonExtra(c, await threads().get(thread_id, c.var.auth));
+});
+api.delete("/threads/:thread_id", zValidator("param", z.object({ thread_id: z.string().uuid() })), async (c) => {
+    // Delete Thread
+    const { thread_id } = c.req.valid("param");
+    await threads().delete(thread_id, c.var.auth);
+    return new Response(null, { status: 204 });
+});
+api.patch("/threads/:thread_id", zValidator("param", z.object({ thread_id: z.string().uuid() })), zValidator("json", schemas.ThreadPatchRequest), async (c) => {
+    // Patch Thread
+    const { thread_id } = c.req.valid("param");
+    const { metadata } = c.req.valid("json");
+    return jsonExtra(c, await threads().patch(thread_id, { metadata }, c.var.auth));
+});
+api.post("/threads/:thread_id/copy", zValidator("param", z.object({ thread_id: z.string().uuid() })), async (c) => {
+    // Copy Thread
+    const { thread_id } = c.req.valid("param");
+    return jsonExtra(c, await threads().copy(thread_id, c.var.auth));
+});
+export default api;

package/dist/src/graph/load.utils.d.mts

@@ -0,0 +1,22 @@
+import type { CompiledGraph } from "@langchain/langgraph";
+export declare const GRAPHS: Record<string, CompiledGraph<string>>;
+export declare const NAMESPACE_GRAPH: Uint8Array<ArrayBufferLike>;
+export type CompiledGraphFactory<T extends string> = (config: {
+    configurable?: Record<string, unknown>;
+}) => Promise<CompiledGraph<T>>;
+export declare function resolveGraph(spec: string, options: {
+    cwd: string;
+    onlyFilePresence?: false;
+}): Promise<{
+    sourceFile: string;
+    exportSymbol: string;
+    resolved: CompiledGraph<string> | CompiledGraphFactory<string>;
+}>;
+export declare function resolveGraph(spec: string, options: {
+    cwd: string;
+    onlyFilePresence: true;
+}): Promise<{
+    sourceFile: string;
+    exportSymbol: string;
+    resolved: undefined;
+}>;

package/dist/src/graph/load.utils.mjs

@@ -0,0 +1,59 @@
+import * as uuid from "uuid";
+import * as path from "node:path";
+import * as fs from "node:fs/promises";
+import { pathToFileURL } from "node:url";
+export const GRAPHS = {};
+export const NAMESPACE_GRAPH = uuid.parse("6ba7b821-9dad-11d1-80b4-00c04fd430c8");
+export async function resolveGraph(spec, options) {
+    const [userFile, exportSymbol] = spec.split(":", 2);
+    const sourceFile = path.resolve(options.cwd, userFile);
+    // validate file exists
+    await fs.stat(sourceFile);
+    if (options?.onlyFilePresence) {
+        return { sourceFile, exportSymbol, resolved: undefined };
+    }
+    const isGraph = (graph) => {
+        if (typeof graph !== "object" || graph == null)
+            return false;
+        return "compile" in graph && typeof graph.compile === "function";
+    };
+    const isCompiledGraph = (graph) => {
+        if (typeof graph !== "object" || graph == null)
+            return false;
+        return ("builder" in graph &&
+            typeof graph.builder === "object" &&
+            graph.builder != null);
+    };
+    const graph = await import(pathToFileURL(sourceFile).toString()).then((module) => module[exportSymbol || "default"]);
+    // obtain the graph, and if not compiled, compile it
+    const resolved = await (async () => {
+        if (!graph)
+            throw new Error("Failed to load graph: graph is nullush");
+        const afterResolve = (graphLike) => {
+            const graph = isGraph(graphLike) ? graphLike.compile() : graphLike;
+            // TODO: hack, remove once LangChain 1.x createAgent is fixed.
+            // `createAgent` returns a ReactAgent wrapper that itself looks
+            // like a CompiledGraph (it has a `builder` — the outer
+            // StateGraph) *and* exposes the real compiled pregel under
+            // `.graph`. Unwrap to the inner graph whenever both are
+            // present so downstream code (e.g. the v2 streaming path that
+            // keys off `graph.streamTransformers`) sees the actual pregel
+            // rather than the wrapper.
+            const inner = graph.graph;
+            if (inner != null &&
+                typeof inner === "object" &&
+                isCompiledGraph(inner)) {
+                return inner;
+            }
+            return graph;
+        };
+        if (typeof graph === "function") {
+            return async (config) => {
+                const graphLike = await graph(config);
+                return afterResolve(graphLike);
+            };
+        }
+        return afterResolve(await graph);
+    })();
+    return { sourceFile, exportSymbol, resolved };
+}