@langchain/langgraph-api 0.0.59 → 0.0.61

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @langchain/langgraph-api
 
+## 0.0.61
+
+### Patch Changes
+
+- a334897: feat(api): add /count endpoints for threads and assistants
+- 9357bb7: chore(api): abstract internal operations away from createServer
+- 9f13d74: fix(api): prevent overriding default CORS config when applying a single override
+  - @langchain/langgraph-ui@0.0.61
+
+## 0.0.60
+
+### Patch Changes
+
+- 9c57526: fix(api): serialization of "checkpoints" and "tasks" stream modes
+  - @langchain/langgraph-ui@0.0.60
+
 ## 0.0.59
 
 ### Patch Changes

package/dist/api/assistants.mjs

@@ -6,7 +6,7 @@ import { getAssistantId, getCachedStaticGraphSchema, getGraph, } from "../graph/
 import { getRuntimeGraphSchema } from "../graph/parser/index.mjs";
 import { HTTPException } from "hono/http-exception";
 import * as schemas from "../schemas.mjs";
-import { Assistants } from "../storage/ops.mjs";
+import { assistants } from "../storage/context.mjs";
 const api = new Hono();
 const RunnableConfigSchema = z.object({
     tags: z.array(z.string()).optional(),
@@ -33,7 +33,7 @@ const getRunnableConfig = (userConfig) => {
 api.post("/assistants", zValidator("json", schemas.AssistantCreate), async (c) => {
     // Create Assistant
     const payload = c.req.valid("json");
-    const assistant = await Assistants.put(payload.assistant_id ?? uuid(), {
+    const assistant = await assistants().put(payload.assistant_id ?? uuid(), {
         config: payload.config ?? {},
         context: payload.context ?? {},
         graph_id: payload.graph_id,
@@ -48,7 +48,7 @@ api.post("/assistants/search", zValidator("json", schemas.AssistantSearchRequest
     const payload = c.req.valid("json");
     const result = [];
     let total = 0;
-    for await (const item of Assistants.search({
+    for await (const item of assistants().search({
         graph_id: payload.graph_id,
         metadata: payload.metadata,
         limit: payload.limit ?? 10,
@@ -62,26 +62,31 @@ api.post("/assistants/search", zValidator("json", schemas.AssistantSearchRequest
     c.res.headers.set("X-Pagination-Total", total.toString());
     return c.json(result);
 });
+api.post("/assistants/count", zValidator("json", schemas.AssistantCountRequest), async (c) => {
+    const payload = c.req.valid("json");
+    const total = await assistants().count(payload, c.var.auth);
+    return c.json(total);
+});
 api.get("/assistants/:assistant_id", async (c) => {
     // Get Assistant
     const assistantId = getAssistantId(c.req.param("assistant_id"));
-    return c.json(await Assistants.get(assistantId, c.var.auth));
+    return c.json(await assistants().get(assistantId, c.var.auth));
 });
 api.delete("/assistants/:assistant_id", async (c) => {
     // Delete Assistant
     const assistantId = getAssistantId(c.req.param("assistant_id"));
-    return c.json(await Assistants.delete(assistantId, c.var.auth));
+    return c.json(await assistants().delete(assistantId, c.var.auth));
 });
 api.patch("/assistants/:assistant_id", zValidator("json", schemas.AssistantPatch), async (c) => {
     // Patch Assistant
     const assistantId = getAssistantId(c.req.param("assistant_id"));
     const payload = c.req.valid("json");
-    return c.json(await Assistants.patch(assistantId, payload, c.var.auth));
+    return c.json(await assistants().patch(assistantId, payload, c.var.auth));
 });
 api.get("/assistants/:assistant_id/graph", zValidator("query", z.object({ xray: schemas.coercedBoolean.optional() })), async (c) => {
     // Get Assistant Graph
     const assistantId = getAssistantId(c.req.param("assistant_id"));
-    const assistant = await Assistants.get(assistantId, c.var.auth);
+    const assistant = await assistants().get(assistantId, c.var.auth);
     const { xray } = c.req.valid("query");
     const config = getRunnableConfig(assistant.config);
     const graph = await getGraph(assistant.graph_id, config);
@@ -95,7 +100,7 @@ api.get("/assistants/:assistant_id/schemas", zValidator("json", z.object({ confi
     // Get Assistant Schemas
     const json = c.req.valid("json");
     const assistantId = getAssistantId(c.req.param("assistant_id"));
-    const assistant = await Assistants.get(assistantId, c.var.auth);
+    const assistant = await assistants().get(assistantId, c.var.auth);
     const config = getRunnableConfig(json.config);
     const graph = await getGraph(assistant.graph_id, config);
     const schema = await (async () => {
@@ -124,7 +129,7 @@ api.get("/assistants/:assistant_id/subgraphs/:namespace?", zValidator("param", z
     const { assistant_id, namespace } = c.req.valid("param");
     const { recurse } = c.req.valid("query");
     const assistantId = getAssistantId(assistant_id);
-    const assistant = await Assistants.get(assistantId, c.var.auth);
+    const assistant = await assistants().get(assistantId, c.var.auth);
     const config = getRunnableConfig(assistant.config);
     const graph = await getGraph(assistant.graph_id, config);
     const result = [];
@@ -156,7 +161,7 @@ api.post("/assistants/:assistant_id/latest", zValidator("json", schemas.Assistan
     // Set Latest Assistant Version
     const assistantId = getAssistantId(c.req.param("assistant_id"));
     const { version } = c.req.valid("json");
-    return c.json(await Assistants.setLatest(assistantId, version, c.var.auth));
+    return c.json(await assistants().setLatest(assistantId, version, c.var.auth));
 });
 api.post("/assistants/:assistant_id/versions", zValidator("json", z.object({
     limit: z.number().min(1).max(1000).optional().default(10),
@@ -166,7 +171,7 @@ api.post("/assistants/:assistant_id/versions", zValidator("json", z.object({
     // Get Assistant Versions
     const assistantId = getAssistantId(c.req.param("assistant_id"));
     const { limit, offset, metadata } = c.req.valid("json");
-    const versions = await Assistants.getVersions(assistantId, { limit, offset, metadata }, c.var.auth);
+    const versions = await assistants().getVersions(assistantId, { limit, offset, metadata }, c.var.auth);
     if (!versions?.length) {
         throw new HTTPException(404, {
             message: `Assistant "${assistantId}" not found.`,

package/dist/api/meta.mjs

@@ -7,26 +7,33 @@ const api = new Hono();
 const packageJsonPath = path.resolve(url.fileURLToPath(import.meta.url), "../../../package.json");
 let version;
 let langgraph_js_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");
-}
-// Get the installed version of @langchain/langgraph
-try {
-    const langgraphPkg = await import("@langchain/langgraph/package.json");
-    if (langgraphPkg?.default?.version) {
-        langgraph_js_version = langgraphPkg.default.version;
+let versionInfoLoaded = false;
+const loadVersionInfo = async () => {
+    try {
+        const packageJson = JSON.parse(await fs.readFile(packageJsonPath, "utf-8"));
+        version = packageJson.version;
     }
-}
-catch {
-    console.warn("Could not determine version of @langchain/langgraph");
-}
+    catch {
+        console.warn("Could not determine version of langgraph-api");
+    }
+    // Get the installed version of @langchain/langgraph
+    try {
+        const langgraphPkg = await import("@langchain/langgraph/package.json");
+        if (langgraphPkg?.default?.version) {
+            langgraph_js_version = langgraphPkg.default.version;
+        }
+    }
+    catch {
+        console.warn("Could not determine version of @langchain/langgraph");
+    }
+};
 // read env variable
 const env = process.env;
-api.get("/info", (c) => {
+api.get("/info", async (c) => {
+    if (!versionInfoLoaded) {
+        await loadVersionInfo();
+        versionInfoLoaded = true;
+    }
     const langsmithApiKey = env["LANGSMITH_API_KEY"] || env["LANGCHAIN_API_KEY"];
     const langsmithTracing = (() => {
         if (langsmithApiKey) {

package/dist/api/runs.mjs

@@ -7,7 +7,7 @@ import { z } from "zod";
 import { getAssistantId } from "../graph/load.mjs";
 import { logError, logger } from "../logging.mjs";
 import * as schemas from "../schemas.mjs";
-import { Runs, Threads } from "../storage/ops.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();
@@ -71,7 +71,7 @@ const createValidRun = async (threadId, payload, kwargs) => {
         : undefined;
     if (!feedbackKeys?.length)
         feedbackKeys = undefined;
-    const [first, ...inflight] = await Runs.put(runId, getAssistantId(assistantId), {
+    const [first, ...inflight] = await runs().put(runId, getAssistantId(assistantId), {
         input: run.input,
         command: run.command,
         config,
@@ -99,7 +99,7 @@ const createValidRun = async (threadId, payload, kwargs) => {
         if ((multitaskStrategy === "interrupt" || multitaskStrategy === "rollback") &&
             inflight.length > 0) {
             try {
-                await Runs.cancel(threadId, inflight.map((run) => run.run_id), { action: multitaskStrategy }, auth);
+                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", {
@@ -149,7 +149,7 @@ api.post("/runs/stream", zValidator("json", schemas.RunCreate), async (c) => {
             ? getDisconnectAbortSignal(c, stream)
             : undefined;
         try {
-            for await (const { event, data } of Runs.Stream.join(run.run_id, undefined, {
+            for await (const { event, data } of runs().stream.join(run.run_id, undefined, {
                 cancelOnDisconnect,
                 lastEventId: run.kwargs.resumable ? "-1" : undefined,
                 ignore404: true,
@@ -173,7 +173,7 @@ api.get("/runs/:run_id/stream", zValidator("param", z.object({ run_id: z.string(
             ? getDisconnectAbortSignal(c, stream)
             : undefined;
         try {
-            for await (const { id, event, data } of Runs.Stream.join(run_id, undefined, { cancelOnDisconnect, lastEventId, ignore404: true }, c.var.auth)) {
+            for await (const { id, event, data } of runs().stream.join(run_id, undefined, { cancelOnDisconnect, lastEventId, ignore404: true }, c.var.auth)) {
                 await stream.writeSSE({ id, data: serialiseAsDict(data), event });
             }
         }
@@ -190,7 +190,7 @@ api.post("/runs/wait", zValidator("json", schemas.RunCreate), async (c) => {
         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));
+    return waitKeepAlive(c, runs().wait(run.run_id, undefined, c.var.auth));
 });
 api.post("/runs", zValidator("json", schemas.RunCreate), async (c) => {
     // Create Stateless Run
@@ -220,11 +220,11 @@ api.get("/threads/:thread_id/runs", zValidator("param", z.object({ thread_id: z.
     // List runs
     const { thread_id } = c.req.valid("param");
     const { limit, offset, status, metadata } = c.req.valid("query");
-    const [runs] = await Promise.all([
-        Runs.search(thread_id, { limit, offset, status, metadata }, c.var.auth),
-        Threads.get(thread_id, c.var.auth),
+    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, runs);
+    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
@@ -251,7 +251,7 @@ api.post("/threads/:thread_id/runs/stream", zValidator("param", z.object({ threa
             ? getDisconnectAbortSignal(c, stream)
             : undefined;
         try {
-            for await (const { id, event, data } of Runs.Stream.join(run.run_id, thread_id, {
+            for await (const { id, event, data } of runs().stream.join(run.run_id, thread_id, {
                 cancelOnDisconnect,
                 lastEventId: run.kwargs.resumable ? "-1" : undefined,
             }, c.var.auth)) {
@@ -272,13 +272,13 @@ api.post("/threads/:thread_id/runs/wait", zValidator("param", z.object({ thread_
         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));
+    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),
+        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" });
@@ -287,13 +287,13 @@ api.get("/threads/:thread_id/runs/:run_id", zValidator("param", z.object({ threa
 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);
+    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));
+    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
@@ -304,7 +304,7 @@ api.get("/threads/:thread_id/runs/:run_id/stream", zValidator("param", z.object(
         const signal = cancel_on_disconnect
             ? getDisconnectAbortSignal(c, stream)
             : undefined;
-        for await (const { id, event, data } of Runs.Stream.join(run_id, thread_id, { cancelOnDisconnect: signal, lastEventId }, c.var.auth)) {
+        for await (const { id, event, data } of runs().stream.join(run_id, thread_id, { cancelOnDisconnect: signal, lastEventId }, c.var.auth)) {
             await stream.writeSSE({ id, data: serialiseAsDict(data), event });
         }
     });
@@ -316,9 +316,9 @@ api.post("/threads/:thread_id/runs/:run_id/cancel", zValidator("param", z.object
     // 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);
+    await runs().cancel(thread_id, [run_id], { action }, c.var.auth);
     if (wait)
-        await Runs.join(run_id, thread_id, c.var.auth);
+        await runs().join(run_id, thread_id, c.var.auth);
     return c.body(null, wait ? 204 : 202);
 });
 export default api;

package/dist/api/store.mjs

@@ -3,7 +3,7 @@ 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/custom.mjs";
+import { handleAuthEvent } from "../auth/index.mjs";
 const api = new Hono();
 const validateNamespace = (namespace) => {
     if (!namespace || namespace.length === 0) {

package/dist/api/threads.mjs

@@ -4,16 +4,16 @@ import { v4 as uuid4 } from "uuid";
 import { z } from "zod";
 import * as schemas from "../schemas.mjs";
 import { stateSnapshotToThreadState } from "../state.mjs";
-import { Threads } from "../storage/ops.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 || uuid4(), { metadata: payload.metadata, if_exists: payload.if_exists ?? "raise" }, c.var.auth);
+    const thread = await threads().put(payload.thread_id || uuid4(), { 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);
+        await threads().state.bulk({ configurable: { thread_id: thread.thread_id } }, payload.supersteps, c.var.auth);
     }
     return jsonExtra(c, thread);
 });
@@ -22,7 +22,7 @@ api.post("/threads/search", zValidator("json", schemas.ThreadSearchRequest), asy
     const payload = c.req.valid("json");
     const result = [];
     let total = 0;
-    for await (const item of Threads.search({
+    for await (const item of threads().search({
         status: payload.status,
         values: payload.values,
         metadata: payload.metadata,
@@ -44,11 +44,16 @@ api.post("/threads/search", zValidator("json", schemas.ThreadSearchRequest), asy
     c.res.headers.set("X-Pagination-Total", total.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));
+    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) => {
@@ -64,7 +69,7 @@ api.post("/threads/:thread_id/state", zValidator("param", z.object({ thread_id:
         config.configurable ??= {};
         Object.assign(config.configurable, payload.checkpoint);
     }
-    const inserted = await Threads.State.post(config, payload.values, payload.as_node, c.var.auth);
+    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({
@@ -74,7 +79,7 @@ api.get("/threads/:thread_id/state/:checkpoint_id", zValidator("param", z.object
     // 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));
+    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({
@@ -84,7 +89,7 @@ api.post("/threads/:thread_id/state/checkpoint", zValidator("param", z.object({
     // 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));
+    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({
@@ -98,36 +103,36 @@ api.get("/threads/:thread_id/history", zValidator("param", z.object({ thread_id:
     // 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);
+    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);
+    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));
+    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);
+    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));
+    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));
+    return jsonExtra(c, await threads().copy(thread_id, c.var.auth));
 });
 export default api;

package/dist/auth/custom.d.mts

@@ -1,12 +1,9 @@
-import type { AuthEventValueMap } from "@langchain/langgraph-sdk/auth";
 import type { MiddlewareHandler } from "hono";
-import { type AuthContext, type AuthFilters } from "./index.mjs";
+import { type AuthContext } from "./index.mjs";
 declare module "hono" {
     interface ContextVariableMap {
         auth?: AuthContext | undefined;
     }
 }
-export declare function isAuthMatching(metadata: Record<string, unknown> | undefined, filters: AuthFilters): boolean;
-export declare const handleAuthEvent: <T extends keyof AuthEventValueMap>(context: AuthContext | undefined, event: T, value: AuthEventValueMap[T]) => Promise<[AuthFilters | undefined, value: AuthEventValueMap[T]]>;
 export declare const auth: () => MiddlewareHandler;
 export { registerAuth } from "./index.mjs";

package/dist/auth/custom.mjs

@@ -1,37 +1,4 @@
-import { authorize, authenticate, isAuthRegistered, isStudioAuthDisabled, } from "./index.mjs";
-export function isAuthMatching(metadata, filters) {
-    if (filters == null)
-        return true;
-    for (const [key, value] of Object.entries(filters)) {
-        if (typeof value === "object" && value != null) {
-            if (value.$eq) {
-                if (metadata?.[key] !== value.$eq)
-                    return false;
-            }
-            else if (value.$contains) {
-                if (!Array.isArray(metadata?.[key]) ||
-                    !metadata?.[key].includes(value.$contains)) {
-                    return false;
-                }
-            }
-        }
-        else {
-            if (metadata?.[key] !== value)
-                return false;
-        }
-    }
-    return true;
-}
-export const handleAuthEvent = async (context, event, value) => {
-    const [resource, action] = event.split(":");
-    const result = await authorize({
-        resource,
-        action,
-        context,
-        value,
-    });
-    return [result.filters, result.value];
-};
+import { authenticate, isAuthRegistered, isStudioAuthDisabled, } from "./index.mjs";
 const STUDIO_USER = {
     kind: "StudioUser",
     display_name: "langgraph-studio-user",

package/dist/auth/index.d.mts

@@ -1,3 +1,4 @@
+import type { AuthEventValueMap } from "@langchain/langgraph-sdk/auth";
 export declare const isAuthRegistered: () => boolean;
 export declare const isStudioAuthDisabled: () => boolean;
 export type AuthFilters = Record<string, string | {
@@ -38,3 +39,5 @@ export declare function registerAuth(auth: {
 }, options: {
     cwd: string;
 }): Promise<void>;
+export declare const handleAuthEvent: <T extends keyof AuthEventValueMap>(context: AuthContext | undefined, event: T, value: AuthEventValueMap[T]) => Promise<[AuthFilters | undefined, value: AuthEventValueMap[T]]>;
+export declare function isAuthMatching(metadata: Record<string, unknown> | undefined, filters: AuthFilters): boolean;

package/dist/auth/index.mjs

@@ -118,3 +118,36 @@ export async function registerAuth(auth, options) {
     CUSTOM_AUTH = module;
     DISABLE_STUDIO_AUTH = auth.disable_studio_auth ?? false;
 }
+export const handleAuthEvent = async (context, event, value) => {
+    const [resource, action] = event.split(":");
+    const result = await authorize({
+        resource,
+        action,
+        context,
+        value,
+    });
+    return [result.filters, result.value];
+};
+export function isAuthMatching(metadata, filters) {
+    if (filters == null)
+        return true;
+    for (const [key, value] of Object.entries(filters)) {
+        if (typeof value === "object" && value != null) {
+            if (value.$eq) {
+                if (metadata?.[key] !== value.$eq)
+                    return false;
+            }
+            else if (value.$contains) {
+                if (!Array.isArray(metadata?.[key]) ||
+                    !metadata?.[key].includes(value.$contains)) {
+                    return false;
+                }
+            }
+        }
+        else {
+            if (metadata?.[key] !== value)
+                return false;
+        }
+    }
+    return true;
+}

package/dist/experimental/embed.d.mts

@@ -1,6 +1,6 @@
 import type { BaseCheckpointSaver, BaseStore, Pregel } from "@langchain/langgraph";
 import { Hono } from "hono";
-import type { Metadata } from "../storage/ops.mjs";
+import type { Metadata } from "../storage/types.mjs";
 type AnyPregel = Pregel<any, any, any, any, any>;
 interface Thread {
     thread_id: string;

package/dist/graph/api.d.mts

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

package/dist/graph/api.mjs

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

package/dist/graph/load.d.mts

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

package/dist/graph/load.mjs

@@ -1,6 +1,5 @@
 import { z } from "zod";
 import * as uuid from "uuid";
-import { Assistants } from "../storage/ops.mjs";
 import { HTTPException } from "hono/http-exception";
 import { resolveGraph } from "./load.utils.mjs";
 import { getStaticGraphSchema } from "./parser/index.mjs";
@@ -17,7 +16,7 @@ export const getAssistantId = (graphId) => {
         return uuid.v5(graphId, NAMESPACE_GRAPH);
     return graphId;
 };
-export async function registerFromEnv(specs, options) {
+export async function registerFromEnv(assistants, specs, options) {
     const envConfig = process.env.LANGGRAPH_CONFIG
         ? ConfigSchema.parse(JSON.parse(process.env.LANGGRAPH_CONFIG))
         : undefined;
@@ -32,7 +31,7 @@ export async function registerFromEnv(specs, options) {
         // registering the graph runtime
         GRAPHS[graphId] = resolved;
         GRAPH_SPEC[graphId] = spec;
-        await Assistants.put(uuid.v5(graphId, NAMESPACE_GRAPH), {
+        await assistants.put(uuid.v5(graphId, NAMESPACE_GRAPH), {
             graph_id: graphId,
             metadata: { created_by: "system" },
             config,
@@ -44,8 +43,7 @@ export async function registerFromEnv(specs, options) {
     }));
 }
 export async function getGraph(graphId, config, options) {
-    if (!GRAPHS[graphId])
-        throw new HTTPException(404, { message: `Graph "${graphId}" not found` });
+    assertGraphExists(graphId);
     const compiled = typeof GRAPHS[graphId] === "function"
         ? await GRAPHS[graphId](config ?? { configurable: {} })
         : GRAPHS[graphId];
@@ -58,6 +56,12 @@ export async function getGraph(graphId, config, options) {
     compiled.store = options?.store ?? store;
     return compiled;
 }
+export function assertGraphExists(graphId) {
+    if (!GRAPHS[graphId])
+        throw new HTTPException(404, {
+            message: `Graph "${graphId}" not found`,
+        });
+}
 export async function getCachedStaticGraphSchema(graphId) {
     if (!GRAPH_SPEC[graphId])
         throw new HTTPException(404, {