langgraph-api 0.0.26__py3-none-any.whl → 0.0.28rc1__py3-none-any.whl

langgraph_api/js/build.mts

@@ -9,6 +9,7 @@ import {
   resolveGraph,
   runGraphSchemaWorker,
 } from "./src/graph.mts";
+import { build } from "@langchain/langgraph-api/ui/bundler";
 
 const __dirname = new URL(".", import.meta.url).pathname;
 
@@ -17,7 +18,7 @@ async function main() {
     z.record(z.string()).parse(JSON.parse(process.env.LANGSERVE_GRAPHS))
   );
 
-  const GRAPH_SCHEMAS: Record<string, Record<string, GraphSchema>> = {};
+  const GRAPH_SCHEMAS: Record<string, Record<string, GraphSchema> | false> = {};
 
   try {
     await Promise.all(
@@ -29,9 +30,12 @@ async function main() {
 
         try {
           console.info(`[${graphId}]: Extracting schema`);
-          GRAPH_SCHEMAS[graphId] = await runGraphSchemaWorker(spec);
+          GRAPH_SCHEMAS[graphId] = await runGraphSchemaWorker(spec, {
+            timeoutMs: 120_000,
+          });
         } catch (error) {
           console.error(`[${graphId}]: Error extracting schema: ${error}`);
+          GRAPH_SCHEMAS[graphId] = false;
         }
       })
     );
@@ -46,7 +50,49 @@ async function main() {
     process.exit(1);
   }
 
-  console.info("All graphs resolved");
+  const uiSpecs = z
+    .record(z.string())
+    .parse(JSON.parse(process.env.LANGGRAPH_UI || "{}"));
+
+  if (Object.keys(uiSpecs).length > 0) {
+    try {
+      const schemas: Record<string, { assets: string[]; name: string }> = {};
+      await Promise.all(
+        Object.entries(uiSpecs).map(async ([graphId, uiUserPath]) => {
+          console.info(`[${graphId}]: Building UI`);
+          const userPath = path.resolve(process.cwd(), uiUserPath);
+          const files = await build(graphId, userPath);
+          await Promise.all([
+            ...files.map(async (item) => {
+              const folder = path.resolve(__dirname, "ui", graphId);
+              const source = path.resolve(folder, item.basename);
+
+              await fs.mkdir(path.dirname(source), { recursive: true });
+              await fs.writeFile(source, item.contents);
+
+              schemas[graphId] ??= { assets: [], name: graphId };
+
+              const relative = path.relative(
+                path.resolve(__dirname, "ui", graphId),
+                source
+              );
+
+              schemas[graphId].assets.push(relative);
+            }),
+          ]);
+        })
+      );
+
+      await fs.writeFile(
+        path.resolve(__dirname, "client.ui.schemas.json"),
+        JSON.stringify(schemas),
+        { encoding: "utf-8" }
+      );
+    } catch (error) {
+      console.error(`Error building UI: ${error}`);
+      process.exit(1);
+    }
+  }
 }
 
 main();

langgraph_api/js/client.mts

@@ -4,9 +4,9 @@ import { z } from "zod";
 import { Context, Hono } from "hono";
 import { serve } from "@hono/node-server";
 import { zValidator } from "@hono/zod-validator";
-import { streamSSE } from "hono/streaming";
+import { streamSSE, stream } from "hono/streaming";
 import { HTTPException } from "hono/http-exception";
-import { Agent, fetch } from "undici";
+import { fetch } from "undici";
 import pRetry from "p-retry";
 import {
   BaseStore,
@@ -43,6 +43,8 @@ import {
   GraphSpec,
   filterValidGraphSpecs,
 } from "./src/graph.mts";
+import { asyncExitHook, gracefulExit } from "exit-hook";
+import { awaitAllCallbacks } from "@langchain/core/callbacks/promises";
 
 const logger = createLogger({
   level: "debug",
@@ -76,7 +78,7 @@ const logger = createLogger({
   ],
 });
 
-let GRAPH_SCHEMA: Record<string, Record<string, GraphSchema>> = {};
+let GRAPH_SCHEMA: Record<string, Record<string, GraphSchema> | false> = {};
 const GRAPH_RESOLVED: Record<string, CompiledGraph<string>> = {};
 const GRAPH_SPEC: Record<string, GraphSpec> = {};
 
@@ -92,9 +94,28 @@ async function getOrExtractSchema(graphId: string) {
   }
 
   if (!GRAPH_SCHEMA[graphId]) {
+    // This is only set during build phase
+    if (GRAPH_SCHEMA[graphId] === false) {
+      throw new Error(`Failed to locate schema for "${graphId}"`);
+    }
+
     try {
       const timer = logger.startTimer();
-      GRAPH_SCHEMA[graphId] = await runGraphSchemaWorker(GRAPH_SPEC[graphId]);
+
+      let timeoutMs: number | undefined = undefined;
+      try {
+        timeoutMs = Number.parseInt(
+          process.env.LANGGRAPH_SCHEMA_RESOLVE_TIMEOUT_MS || "30000",
+          10
+        );
+        if (Number.isNaN(timeoutMs) || timeoutMs <= 0) timeoutMs = undefined;
+      } catch {
+        // ignore
+      }
+
+      GRAPH_SCHEMA[graphId] = await runGraphSchemaWorker(GRAPH_SPEC[graphId], {
+        timeoutMs,
+      });
       timer.done({ message: `Extracting schema for ${graphId} finished` });
     } catch (error) {
       throw new Error(`Failed to extract schema for "${graphId}": ${error}`);
@@ -104,11 +125,8 @@ async function getOrExtractSchema(graphId: string) {
   return GRAPH_SCHEMA[graphId];
 }
 
-const GRAPH_SOCKET = "./graph.sock";
-const REMOTE_SOCKET = "./checkpointer.sock";
-const remoteDispatcher = new Agent({
-  connect: { socketPath: REMOTE_SOCKET },
-});
+const GRAPH_PORT = 5556;
+const REMOTE_PORT = 5555;
 
 const RunnableConfigSchema = z.object({
   tags: z.array(z.string()).optional(),
@@ -165,8 +183,7 @@ async function sendRecv<T = any>(
   method: `${"checkpointer" | "store"}_${string}`,
   data: unknown
 ): Promise<T> {
-  const res = await tryFetch(`http://remote/${method}`, {
-    dispatcher: remoteDispatcher,
+  const res = await tryFetch(`http://localhost:${REMOTE_PORT}/${method}`, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify(data),
@@ -180,6 +197,7 @@ async function sendRecv<T = any>(
   })) as T;
 }
 
+const HEARTBEAT_MS = 5_000;
 const handleInvoke = <T extends z.ZodType<any>>(
   name: string,
   _schema: T,
@@ -188,8 +206,29 @@ const handleInvoke = <T extends z.ZodType<any>>(
   return async (c: Context<any, any, { in: z.infer<T>; out: any }>) => {
     const graphId = c.req.param("graphId");
     const body = c.req.valid("json") as any;
-    const response = await handler({ graph_id: graphId, ...body });
-    return c.json(response);
+
+    // send heartbeat every HEARTBEAT_INTERVAL_MS
+    // to prevent connection from timing out
+    c.header("Content-Type", "application/json");
+    return stream(c, async (stream) => {
+      let resolved: Promise<any> = Promise.resolve();
+      const enqueueWrite = (payload: Uint8Array | string) => {
+        resolved = stream.write(payload);
+        return resolved;
+      };
+
+      // orjson.loads(...) does ignore the
+      // whitespace prefix, so we can use that
+      // as a heartbeat
+      let interval = setInterval(() => enqueueWrite(" "), HEARTBEAT_MS);
+
+      const response = JSON.stringify(
+        await handler({ graph_id: graphId, ...body })
+      );
+
+      clearInterval(interval);
+      await enqueueWrite(response);
+    });
   };
 };
 
@@ -202,25 +241,35 @@ const handleStream = <T extends z.ZodType<any>>(
     const graphId = c.req.param("graphId");
     const body = c.req.valid("json") as any;
     return streamSSE(c, async (stream) => {
+      let resolve: Promise<any> = Promise.resolve();
+      let timer: NodeJS.Timeout | undefined;
+      const sendHeartbeat = () => {
+        clearTimeout(timer);
+        resolve = stream.writeln(": heartbeat");
+        timer = setTimeout(sendHeartbeat, HEARTBEAT_MS);
+        return resolve;
+      };
+
+      const sendSSE = (event: string, data: unknown) => {
+        clearTimeout(timer);
+        resolve = stream.writeSSE({ data: serialiseAsDict(data), event });
+        timer = setTimeout(sendHeartbeat, HEARTBEAT_MS);
+        return resolve;
+      };
+
       try {
         for await (const data of handler({ graph_id: graphId, ...body })) {
-          await stream.writeSSE({
-            data: Buffer.from(serialiseAsDict(data)).toString("base64"),
-            event: name,
-          });
+          await sendSSE(name, data);
         }
       } catch (error) {
         // Still print out the error, as the stack
         // trace is not carried over in Python
         logger.error(error);
-
-        await stream.writeSSE({
-          event: "error",
-          data: Buffer.from(serialiseAsDict(serializeError(error))).toString(
-            "base64"
-          ),
-        });
+        await sendSSE("error", serializeError(error));
       }
+
+      clearTimeout(timer);
+      await resolve;
     });
   };
 };
@@ -604,12 +653,12 @@ const GetGraphPayload = z.object({
 async function getGraphRequest(rawPayload: z.infer<typeof GetGraphPayload>) {
   const { graph_id: graphId, ...payload } = rawPayload;
   const graph = getGraph(graphId);
-  return graph
-    .getGraph({
-      ...getRunnableConfig(payload.config),
-      xray: payload.xray ?? undefined,
-    })
-    .toJSON();
+
+  const drawable = await graph.getGraphAsync({
+    ...getRunnableConfig(payload.config),
+    xray: payload.xray ?? undefined,
+  });
+  return drawable.toJSON();
 }
 
 const GetSubgraphsPayload = z.object({
@@ -630,7 +679,7 @@ async function getSubgraphsRequest(
 
   if (!rootGraphId) throw new Error("Failed to find root graph");
 
-  for (const [name] of graph.getSubgraphs(
+  for await (const [name] of graph.getSubgraphsAsync(
     payload.namespace ?? undefined,
     payload.recurse ?? undefined
   )) {
@@ -818,20 +867,15 @@ async function main() {
     return c.text(message || "Internal server error", 500);
   });
 
-  await fs.unlink(GRAPH_SOCKET).catch(() => void 0);
-  serve(
-    {
-      fetch: app.fetch,
-      hostname: "localhost",
-      port: GRAPH_SOCKET as any,
-    },
-    (c) => logger.info(`Listening to ${c}`)
+  serve({ fetch: app.fetch, hostname: "localhost", port: GRAPH_PORT }, (c) =>
+    logger.info(`Listening to ${c.address}:${c.port}`)
   );
 }
 
 process.on("uncaughtExceptionMonitor", (error) => {
   logger.error(error);
-  process.exit(1);
+  gracefulExit();
 });
 
+asyncExitHook(() => awaitAllCallbacks(), { wait: 3_000 });
 main();

langgraph_api/js/global.d.ts

@@ -1,6 +1,7 @@
 declare namespace NodeJS {
   interface ProcessEnv {
     LANGSERVE_GRAPHS: string;
+    LANGGRAPH_UI?: string;
     PORT: string;
   }
 }

langgraph_api/js/package.json

@@ -9,27 +9,35 @@
   "dependencies": {
     "@hono/node-server": "^1.12.0",
     "@hono/zod-validator": "^0.2.2",
-    "@langchain/core": "^0.3.36",
-    "@langchain/langgraph": "^0.2.43",
+    "@langchain/core": "^0.3.40",
+    "@langchain/langgraph": "^0.2.49",
+    "@langchain/langgraph-checkpoint": "^0.0.15",
     "@types/json-schema": "^7.0.15",
     "@typescript/vfs": "^1.6.0",
     "dedent": "^1.5.3",
+    "exit-hook": "^4.0.0",
     "hono": "^4.5.4",
     "p-queue": "^8.0.1",
     "p-retry": "^6.2.0",
-    "tsx": "^4.19.1",
+    "tsx": "^4.19.3",
     "typescript": "^5.5.4",
     "undici": "^6.21.1",
     "uuid": "^10.0.0",
-    "winston": "^3.15.0",
-    "zeromq": "^6.3.0",
+    "winston": "^3.17.0",
+    "@langchain/langgraph-api": "~0.0.14",
     "zod": "^3.23.8"
   },
+  "resolutions": {
+    "esbuild": "^0.25.0"
+  },
   "devDependencies": {
     "@langchain/langgraph-sdk": "^0.0.31",
+    "@types/react": "^19.0.8",
+    "@types/react-dom": "^19.0.3",
     "@types/node": "^22.2.0",
     "postgres": "^3.4.4",
     "prettier": "^3.3.3",
     "vitest": "^3.0.4"
-  }
-}
+  },
+  "packageManager": "yarn@1.22.22+sha512.a6b2f7906b721bba3d67d4aff083df04dad64c399707841b7acf00f6b133b7ac24255f2652fa22ae3534329dc6180534e98d17432037ff6fd140556e2bb3137e"
+}