@langchain/langgraph-api 0.0.33 → 0.0.35

package/dist/graph/parser/index.d.mts

@@ -10,8 +10,14 @@ export interface GraphSpec {
     sourceFile: string;
     exportSymbol: string;
 }
+type GraphSchemaWithSubgraphs = Record<string, GraphSchema>;
 export declare function getStaticGraphSchema(spec: GraphSpec, options?: {
     mainThread?: boolean;
     timeoutMs?: number;
-}): Promise<Record<string, GraphSchema>>;
+}): Promise<GraphSchemaWithSubgraphs>;
+export declare function getStaticGraphSchema(specMap: Record<string, GraphSpec>, options?: {
+    mainThread?: boolean;
+    timeoutMs?: number;
+}): Promise<Record<string, GraphSchemaWithSubgraphs>>;
 export declare function getRuntimeGraphSchema(graph: Pregel<any, any, any, any, any>): Promise<GraphSchema | undefined>;
+export {};

package/dist/graph/parser/index.mjs

@@ -1,25 +1,42 @@
 import { fileURLToPath } from "node:url";
 import { Worker } from "node:worker_threads";
-export async function getStaticGraphSchema(spec, options) {
-    if (options?.mainThread) {
-        const { SubgraphExtractor } = await import("./parser.mjs");
-        return SubgraphExtractor.extractSchemas(spec.sourceFile, spec.exportSymbol, { strict: false });
-    }
-    return await new Promise((resolve, reject) => {
-        const worker = new Worker(fileURLToPath(new URL("./parser.worker.mjs", import.meta.url)), { argv: process.argv.slice(-1) });
-        // Set a timeout to reject if the worker takes too long
-        const timeoutId = setTimeout(() => {
-            worker.terminate();
-            reject(new Error("Schema extract worker timed out"));
-        }, options?.timeoutMs ?? 30000);
-        worker.on("message", (result) => {
-            worker.terminate();
-            clearTimeout(timeoutId);
-            resolve(result);
+const isGraphSpec = (spec) => {
+    if (typeof spec !== "object" || spec == null)
+        return false;
+    if (!("sourceFile" in spec) || typeof spec.sourceFile !== "string")
+        return false;
+    if (!("exportSymbol" in spec) || typeof spec.exportSymbol !== "string")
+        return false;
+    return true;
+};
+export async function getStaticGraphSchema(input, options) {
+    async function execute(specs) {
+        if (options?.mainThread) {
+            const { SubgraphExtractor } = await import("./parser.mjs");
+            return SubgraphExtractor.extractSchemas(specs, { strict: false });
+        }
+        return await new Promise((resolve, reject) => {
+            const worker = new Worker(fileURLToPath(new URL("./parser.worker.mjs", import.meta.url)), { argv: process.argv.slice(-1) });
+            // Set a timeout to reject if the worker takes too long
+            const timeoutId = setTimeout(() => {
+                worker.terminate();
+                reject(new Error("Schema extract worker timed out"));
+            }, options?.timeoutMs ?? 30000);
+            worker.on("message", (result) => {
+                worker.terminate();
+                clearTimeout(timeoutId);
+                resolve(result);
+            });
+            worker.on("error", reject);
+            worker.postMessage(specs);
         });
-        worker.on("error", reject);
-        worker.postMessage(spec);
-    });
+    }
+    const specs = isGraphSpec(input) ? [input] : Object.values(input);
+    const results = await execute(specs);
+    if (isGraphSpec(input)) {
+        return results[0];
+    }
+    return Object.fromEntries(Object.keys(input).map((graphId, idx) => [graphId, results[idx]]));
 }
 export async function getRuntimeGraphSchema(graph) {
     try {

package/dist/graph/parser/parser.d.mts

@@ -35,8 +35,15 @@ export declare class SubgraphExtractor {
             node: ts.Node;
         };
     }[];
-    getAugmentedSourceFile: (name: string) => {
-        files: [filePath: string, contents: string][];
+    getAugmentedSourceFile: (suffix: string, name: string) => {
+        inferFile: {
+            fileName: string;
+            contents: string;
+        };
+        sourceFile: {
+            fileName: string;
+            contents: string;
+        };
         exports: {
             typeName: string;
             valueName: string;
@@ -53,11 +60,15 @@ export declare class SubgraphExtractor {
     protected isGraphOrPregelType: (type: ts.Type) => boolean;
     protected getText(node: ts.Node): string;
     protected reduceChildren<Acc>(node: ts.Node, fn: (acc: Acc, node: ts.Node) => Acc, initial: Acc): Acc;
-    static extractSchemas(target: string | {
-        contents: string;
-        files?: [fileName: string, contents: string][];
-    }, name: string, options?: {
+    static extractSchemas(target: {
+        sourceFile: string | {
+            name: string;
+            contents: string;
+            main?: boolean;
+        }[];
+        exportSymbol: string;
+    }[], options?: {
         strict?: boolean;
-    }): Record<string, GraphSchema>;
+    }): Record<string, GraphSchema>[];
 }
 export {};

package/dist/graph/parser/parser.mjs

@@ -11,6 +11,7 @@ const OVERRIDE_RESOLVE = [
     new RegExp(`^@langchain\/langgraph(\/.+)?$`),
     new RegExp(`^@langchain\/langgraph-checkpoint(\/.+)?$`),
 ];
+const INFER_TEMPLATE_PATH = path.resolve(__dirname, "./schema/types.template.mts");
 const compilerOptions = {
     noEmit: true,
     strict: true,
@@ -144,7 +145,7 @@ export class SubgraphExtractor {
             return this.findSubgraphs(varDecl.initializer, [name]);
         });
     };
-    getAugmentedSourceFile = (name) => {
+    getAugmentedSourceFile = (suffix, name) => {
         const vars = this.getSubgraphsVariables(name);
         const typeExports = [
             { typeName: `__langgraph__${name}`, valueName: name, graphName: name },
@@ -156,14 +157,14 @@ export class SubgraphExtractor {
                 graphName: [...namespace, node].join("|"),
             });
         }
-        const sourceFilePath = "__langgraph__source.mts";
+        const sourceFilePath = `__langgraph__source_${suffix}.mts`;
         const sourceContents = [
             this.getText(this.sourceFile),
             ...typeExports.map(({ typeName, valueName }) => `export type ${typeName} = typeof ${valueName}`),
         ].join("\n\n");
-        const inferFilePath = "__langgraph__infer.mts";
+        const inferFilePath = `__langgraph__infer_${suffix}.mts`;
         const inferContents = [
-            ...typeExports.map(({ typeName }) => `import type { ${typeName}} from "./__langgraph__source.mts"`),
+            ...typeExports.map(({ typeName }) => `import type { ${typeName}} from "./__langgraph__source_${suffix}.mts"`),
             this.inferFile.getText(this.inferFile),
             ...typeExports.flatMap(({ typeName }) => {
                 return [
@@ -181,10 +182,8 @@ export class SubgraphExtractor {
             }),
         ].join("\n\n");
         return {
-            files: [
-                [sourceFilePath, sourceContents],
-                [inferFilePath, inferContents],
-            ],
+            inferFile: { fileName: inferFilePath, contents: inferContents },
+            sourceFile: { fileName: sourceFilePath, contents: sourceContents },
             exports: typeExports,
         };
     };
@@ -228,11 +227,34 @@ export class SubgraphExtractor {
         ts.forEachChild(node, it.bind(this));
         return acc;
     }
-    static extractSchemas(target, name, options) {
-        const dirname = typeof target === "string" ? path.dirname(target) : __dirname;
+    static extractSchemas(target, options) {
+        if (!target.length)
+            throw new Error("No graphs found");
+        function getCommonPath(a, b) {
+            const aSeg = path.normalize(a).split(path.sep);
+            const bSeg = path.normalize(b).split(path.sep);
+            const maxIter = Math.min(aSeg.length, bSeg.length);
+            const result = [];
+            for (let i = 0; i < maxIter; ++i) {
+                if (aSeg[i] !== bSeg[i])
+                    break;
+                result.push(aSeg[i]);
+            }
+            return result.join(path.sep);
+        }
+        const isTestTarget = (check) => {
+            return check.every((x) => typeof x.sourceFile === "string");
+        };
+        const projectDirname = isTestTarget(target)
+            ? target.reduce((acc, item) => {
+                if (!acc)
+                    return path.dirname(item.sourceFile);
+                return getCommonPath(acc, path.dirname(item.sourceFile));
+            }, "")
+            : __dirname;
         // This API is not well made for Windows, ensure that the paths are UNIX slashes
         const fsMap = new Map();
-        const system = vfs.createFSBackedSystem(fsMap, dirname, ts);
+        const system = vfs.createFSBackedSystem(fsMap, projectDirname, ts);
         // TODO: investigate if we should create a PR in @typescript/vfs
         const oldReadFile = system.readFile.bind(system);
         system.readFile = (fileName) => oldReadFile(fileName) ?? "// Non-existent file";
@@ -243,17 +265,24 @@ export class SubgraphExtractor {
         };
         const vfsHost = vfs.createVirtualCompilerHost(system, compilerOptions, ts);
         const host = vfsHost.compilerHost;
-        const targetPath = typeof target === "string"
-            ? target
-            : path.resolve(dirname, "./__langgraph__target.mts");
-        const inferTemplatePath = path.resolve(__dirname, "./schema/types.template.mts");
-        if (typeof target !== "string") {
-            fsMap.set(vfsPath(targetPath), target.contents);
-            for (const [name, contents] of target.files ?? []) {
-                fsMap.set(vfsPath(path.resolve(dirname, name)), contents);
+        const targetPaths = [];
+        for (const item of target) {
+            if (typeof item.sourceFile === "string") {
+                targetPaths.push({ ...item, sourceFile: item.sourceFile });
+            }
+            else {
+                for (const { name, contents, main } of item.sourceFile ?? []) {
+                    fsMap.set(vfsPath(path.resolve(projectDirname, name)), contents);
+                    if (main) {
+                        targetPaths.push({
+                            ...item,
+                            sourceFile: path.resolve(projectDirname, name),
+                        });
+                    }
+                }
             }
         }
-        const moduleCache = ts.createModuleResolutionCache(dirname, (x) => x);
+        const moduleCache = ts.createModuleResolutionCache(projectDirname, (x) => x);
         host.resolveModuleNameLiterals = (entries, containingFile, redirectedReference, options) => entries.flatMap((entry) => {
             const specifier = entry.text;
             // Force module resolution to use @langchain/langgraph from the local project
@@ -263,7 +292,7 @@ export class SubgraphExtractor {
                 // check if we're not already importing from node_modules
                 if (!containingFile.split(path.sep).includes("node_modules")) {
                     // Doesn't matter if the file exists, only used to nudge `ts.resolveModuleName`
-                    targetFile = path.resolve(dirname, "__langgraph__resolve.mts");
+                    targetFile = path.resolve(projectDirname, "__langgraph__resolve.mts");
                 }
             }
             return [
@@ -271,17 +300,24 @@ export class SubgraphExtractor {
             ];
         });
         const research = ts.createProgram({
-            rootNames: [inferTemplatePath, targetPath],
+            rootNames: [INFER_TEMPLATE_PATH, ...targetPaths.map((i) => i.sourceFile)],
             options: compilerOptions,
             host,
         });
-        const extractor = new SubgraphExtractor(research, research.getSourceFile(targetPath), research.getSourceFile(inferTemplatePath), options);
-        const { files, exports } = extractor.getAugmentedSourceFile(name);
-        for (const [name, source] of files) {
-            system.writeFile(vfsPath(path.resolve(dirname, name)), source);
+        const researchTargets = [];
+        for (const targetPath of targetPaths) {
+            const extractor = new SubgraphExtractor(research, research.getSourceFile(targetPath.sourceFile), research.getSourceFile(INFER_TEMPLATE_PATH), options);
+            const { sourceFile, inferFile, exports } = extractor.getAugmentedSourceFile(path.basename(targetPath.sourceFile), targetPath.exportSymbol);
+            for (const { fileName, contents } of [sourceFile, inferFile]) {
+                system.writeFile(vfsPath(path.resolve(projectDirname, fileName)), contents);
+            }
+            researchTargets.push({
+                rootName: path.resolve(projectDirname, inferFile.fileName),
+                exports,
+            });
         }
         const extract = ts.createProgram({
-            rootNames: [path.resolve(dirname, "./__langgraph__infer.mts")],
+            rootNames: researchTargets.map((i) => i.rootName),
             options: compilerOptions,
             host,
         });
@@ -295,7 +331,7 @@ export class SubgraphExtractor {
             }
             return undefined;
         };
-        return Object.fromEntries(exports.map(({ typeName, graphName }) => [
+        return researchTargets.map(({ exports }) => Object.fromEntries(exports.map(({ typeName, graphName }) => [
             graphName,
             {
                 state: trySymbol(schemaGenerator, `${typeName}__update`),
@@ -303,6 +339,6 @@ export class SubgraphExtractor {
                 output: trySymbol(schemaGenerator, `${typeName}__output`),
                 config: trySymbol(schemaGenerator, `${typeName}__config`),
             },
-        ]));
+        ])));
     }
 }

package/dist/graph/parser/parser.worker.mjs

@@ -2,6 +2,6 @@ import { tsImport } from "tsx/esm/api";
 import { parentPort } from "node:worker_threads";
 parentPort?.on("message", async (payload) => {
     const { SubgraphExtractor } = await tsImport("./parser.mjs", import.meta.url);
-    const result = SubgraphExtractor.extractSchemas(payload.sourceFile, payload.exportSymbol, { strict: false });
+    const result = SubgraphExtractor.extractSchemas(payload, { strict: false });
     parentPort?.postMessage(result);
 });

package/dist/storage/ops.d.mts

@@ -256,7 +256,7 @@ export declare class Runs {
     static get(runId: string, thread_id: string | undefined, auth: AuthContext | undefined): Promise<Run | null>;
     static delete(run_id: string, thread_id: string | undefined, auth: AuthContext | undefined): Promise<string | null>;
     static wait(runId: string, threadId: string | undefined, auth: AuthContext | undefined): Promise<unknown>;
-    static join(runId: string, threadId: string, auth: AuthContext | undefined): Promise<{} | undefined>;
+    static join(runId: string, threadId: string, auth: AuthContext | undefined): Promise<{} | null>;
     static cancel(threadId: string | undefined, runIds: string[], options: {
         action?: "interrupt" | "rollback";
     }, auth: AuthContext | undefined): Promise<void>;

package/dist/storage/ops.mjs

@@ -596,6 +596,13 @@ export class Threads {
             if (!isAuthMatching(thread["metadata"], filters)) {
                 throw new HTTPException(403);
             }
+            // do a check if there are no pending runs
+            await conn.with(async (STORE) => {
+                if (Object.values(STORE.runs).some((run) => run.thread_id === threadId &&
+                    (run.status === "pending" || run.status === "running"))) {
+                    throw new HTTPException(409, { message: "Thread is busy" });
+                }
+            });
             const graphId = thread.metadata?.graph_id;
             if (graphId == null) {
                 throw new HTTPException(400, {
@@ -903,7 +910,7 @@ export class Runs {
         if (lastChunk != null)
             return lastChunk;
         const thread = await Threads.get(threadId, auth);
-        return thread.values;
+        return thread.values ?? null;
     }
     static async cancel(threadId, runIds, options, auth) {
         return conn.with(async (STORE) => {
@@ -932,6 +939,11 @@ export class Runs {
                     if (control || action !== "rollback") {
                         run.status = "interrupted";
                         run.updated_at = new Date();
+                        const thread = STORE.threads[run.thread_id];
+                        if (thread) {
+                            thread.status = "idle";
+                            thread.updated_at = new Date();
+                        }
                     }
                     else {
                         logger.info("Eagerly deleting unscheduled run with rollback action", {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/langgraph-api",
-  "version": "0.0.33",
+  "version": "0.0.35",
   "type": "module",
   "engines": {
     "node": "^18.19.0 || >=20.16.0"
@@ -53,7 +53,7 @@
     "winston": "^3.17.0",
     "winston-console-format": "^1.0.8",
     "zod": "^3.23.8",
-    "@langchain/langgraph-ui": "0.0.33"
+    "@langchain/langgraph-ui": "0.0.35"
   },
   "peerDependencies": {
     "@langchain/core": "^0.3.42",