@langchain/langgraph-api 0.0.18 → 0.0.19

package/dist/api/assistants.mjs

@@ -76,9 +76,10 @@ api.get("/assistants/:assistant_id/graph", zValidator("query", z.object({ xray:
     const assistantId = getAssistantId(c.req.param("assistant_id"));
     const assistant = await Assistants.get(assistantId);
     const { xray } = c.req.valid("query");
-    const graph = getGraph(assistant.graph_id);
+    const config = getRunnableConfig(assistant.config);
+    const graph = await getGraph(assistant.graph_id, config);
     const drawable = await graph.getGraphAsync({
-        ...getRunnableConfig(assistant.config),
+        ...config,
         xray: xray ?? undefined,
     });
     return c.json(drawable.toJSON());
@@ -106,7 +107,8 @@ api.get("/assistants/:assistant_id/subgraphs/:namespace?", zValidator("param", z
     const { recurse } = c.req.valid("query");
     const assistantId = getAssistantId(assistant_id);
     const assistant = await Assistants.get(assistantId);
-    const graph = getGraph(assistant.graph_id);
+    const config = getRunnableConfig(assistant.config);
+    const graph = await getGraph(assistant.graph_id, config);
     const graphSchema = await getGraphSchema(assistant.graph_id);
     const rootGraphId = Object.keys(graphSchema).find((i) => !i.includes("|"));
     if (!rootGraphId) {

package/dist/cli/spawn.d.mts

@@ -6,6 +6,9 @@ export declare function spawnServer(args: {
     config: {
         graphs: Record<string, string>;
         ui?: Record<string, string>;
+        ui_config?: {
+            shared?: string[];
+        };
     };
     env: NodeJS.ProcessEnv;
     hostUrl: string;

package/dist/cli/spawn.mjs

@@ -31,6 +31,7 @@ For production use, please use LangGraph Cloud.
             host: args.host,
             graphs: context.config.graphs,
             ui: context.config.ui,
+            ui_config: context.config.ui_config,
             cwd: options.projectCwd,
         }),
     ], {

package/dist/graph/load.mjs

@@ -41,11 +41,12 @@ export async function registerFromEnv(specs, options) {
         return resolved;
     }));
 }
-export function getGraph(graphId, options) {
+export async function getGraph(graphId, config, options) {
     if (!GRAPHS[graphId])
         throw new HTTPException(404, { message: `Graph "${graphId}" not found` });
-    // TODO: have a check for the type of graph
-    const compiled = GRAPHS[graphId];
+    const compiled = typeof GRAPHS[graphId] === "function"
+        ? await GRAPHS[graphId](config ?? { configurable: {} })
+        : GRAPHS[graphId];
     if (typeof options?.checkpointer !== "undefined") {
         compiled.checkpointer = options?.checkpointer ?? undefined;
     }

package/dist/graph/load.utils.mjs

@@ -23,10 +23,17 @@ export async function resolveGraph(spec, options) {
     const resolved = await (async () => {
         if (!graph)
             throw new Error("Failed to load graph: graph is nullush");
-        const graphLike = typeof graph === "function" ? await graph() : await graph;
-        if (isGraph(graphLike))
-            return graphLike.compile();
-        return graphLike;
+        const afterResolve = (graphLike) => {
+            const graph = isGraph(graphLike) ? graphLike.compile() : graphLike;
+            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 };
 }

package/dist/server.mjs

@@ -50,6 +50,7 @@ export const StartServerSchema = z.object({
     cwd: z.string(),
     graphs: z.record(z.string()),
     ui: z.record(z.string()).optional(),
+    ui_config: z.object({ shared: z.array(z.string()).optional() }).optional(),
 });
 export async function startServer(options) {
     logger.info(`Initializing storage...`);
@@ -69,7 +70,10 @@ export async function startServer(options) {
         const { api, registerGraphUi } = await import("./ui/load.mjs");
         app.route("/", api);
         logger.info(`Registering UI from ${options.cwd}`);
-        await registerGraphUi(options.ui, { cwd: options.cwd });
+        await registerGraphUi(options.ui, {
+            cwd: options.cwd,
+            config: options.ui_config,
+        });
     }
     logger.info(`Starting ${options.nWorkers} workers`);
     for (let i = 0; i < options.nWorkers; i++)

package/dist/storage/ops.mjs

@@ -447,7 +447,10 @@ export class Threads {
                     tasks: [],
                 };
             }
-            const graph = await getGraph(graphId, { checkpointer, store });
+            const graph = await getGraph(graphId, thread.config, {
+                checkpointer,
+                store,
+            });
             const result = await graph.getState(config, { subgraphs });
             if (result.metadata != null &&
                 "checkpoint_ns" in result.metadata &&
@@ -471,7 +474,10 @@ export class Threads {
             }
             config.configurable ??= {};
             config.configurable.graph_id ??= graphId;
-            const graph = await getGraph(graphId, { checkpointer, store });
+            const graph = await getGraph(graphId, thread.config, {
+                checkpointer,
+                store,
+            });
             const updateConfig = structuredClone(config);
             updateConfig.configurable ??= {};
             updateConfig.configurable.checkpoint_ns ??= "";
@@ -501,7 +507,10 @@ export class Threads {
             }
             config.configurable ??= {};
             config.configurable.graph_id ??= graphId;
-            const graph = await getGraph(graphId, { checkpointer, store });
+            const graph = await getGraph(graphId, thread.config, {
+                checkpointer,
+                store,
+            });
             const updateConfig = structuredClone(config);
             updateConfig.configurable ??= {};
             updateConfig.configurable.checkpoint_ns ??= "";
@@ -531,7 +540,10 @@ export class Threads {
             const graphId = thread.metadata?.graph_id;
             if (graphId == null)
                 return [];
-            const graph = await getGraph(graphId, { checkpointer, store });
+            const graph = await getGraph(graphId, thread.config, {
+                checkpointer,
+                store,
+            });
             const before = typeof options?.before === "string"
                 ? { configurable: { checkpoint_id: options.before } }
                 : options?.before;

package/dist/stream.mjs

@@ -57,7 +57,7 @@ export async function* streamState(run, attempt = 1, options) {
     if (!graphId || typeof graphId !== "string") {
         throw new Error("Invalid or missing graph_id");
     }
-    const graph = getGraph(graphId, {
+    const graph = await getGraph(graphId, kwargs.config, {
         checkpointer: kwargs.temporary ? null : undefined,
     });
     const userStreamMode = kwargs.stream_mode ?? [];

package/dist/ui/bundler.d.mts

@@ -2,6 +2,9 @@ import { type BuildOptions } from "esbuild";
 export declare function build(agentName: string, args: {
     cwd: string;
     userPath: string;
+    config?: {
+        shared?: string[];
+    };
 }): Promise<{
     basename: string;
     contents: Uint8Array;
@@ -9,6 +12,9 @@ export declare function build(agentName: string, args: {
 export declare function watch(agentName: string, args: {
     cwd: string;
     userPath: string;
+    config?: {
+        shared?: string[];
+    };
 }, onResult: (result: {
     basename: string;
     contents: Uint8Array;

package/dist/ui/bundler.mjs

@@ -68,6 +68,7 @@ function setup(agentName, args, onResult) {
             "react-dom",
             "@langchain/langgraph-sdk",
             "@langchain/langgraph-sdk/react-ui",
+            ...(args.config?.shared ?? []),
         ],
         plugins: [tailwind(), entrypointPlugin(args), registerPlugin(onResult)],
         globalName: `__LGUI_${agentName}`,

package/dist/ui/load.mjs

@@ -7,7 +7,7 @@ import { watch } from "./bundler.mjs";
 const GRAPH_UI = {};
 export async function registerGraphUi(defs, options) {
     const result = await Promise.all(Object.entries(defs).map(async ([agentName, userPath]) => {
-        const ctx = await watch(agentName, { cwd: options.cwd, userPath }, (result) => {
+        const ctx = await watch(agentName, { cwd: options.cwd, userPath, config: options.config }, (result) => {
             GRAPH_UI[agentName] = result;
         });
         return [agentName, ctx];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/langgraph-api",
-  "version": "0.0.18",
+  "version": "0.0.19",
   "type": "module",
   "engines": {
     "node": "^18.19.0 || >=20.16.0"