@langchain/langgraph-api 0.0.54 → 0.0.56

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @langchain/langgraph-api
 
+## 0.0.56
+
+### Patch Changes
+
+- 3c390c9: fix(api): parser: sanitise generated symbol names, honor typescript extension
+  - @langchain/langgraph-ui@0.0.56
+
+## 0.0.55
+
+### Patch Changes
+
+- ef84039: fix(api): place the schema inference template next to the graph code, use whole path for symbol name
+- 7edf347: exlcude meta routes from auth
+- 77b21d5: add installed langgraph version to info endpoint for js server
+  - @langchain/langgraph-ui@0.0.55
+
 ## 0.0.54
 
 ### Patch Changes

package/dist/api/meta.mjs

@@ -6,6 +6,7 @@ const api = new Hono();
 // Get the version using the same pattern as semver/index.mts
 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;
@@ -13,6 +14,16 @@ try {
 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) => {
@@ -33,6 +44,7 @@ api.get("/info", (c) => {
     })();
     return c.json({
         version,
+        langgraph_js_version,
         context: "js",
         flags: {
             assistants: true,

package/dist/auth/custom.mjs

@@ -43,6 +43,9 @@ export const auth = () => {
     return async (c, next) => {
         if (!isAuthRegistered())
             return next();
+        // skip for /info
+        if (c.req.path === "/info")
+            return next();
         if (!isStudioAuthDisabled() &&
             c.req.header("x-auth-scheme") === "langsmith") {
             c.set("auth", {

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

@@ -35,7 +35,9 @@ export declare class SubgraphExtractor {
             node: ts.Node;
         };
     }[];
-    getAugmentedSourceFile: (suffix: string, name: string) => {
+    getAugmentedSourceFile: (sourcePath: string, name: string, options: {
+        allowImportingTsExtensions: boolean;
+    }) => {
         inferFile: {
             fileName: string;
             contents: string;
@@ -62,7 +64,7 @@ export declare class SubgraphExtractor {
     protected reduceChildren<Acc>(node: ts.Node, fn: (acc: Acc, node: ts.Node) => Acc, initial: Acc): Acc;
     static extractSchemas(target: {
         sourceFile: string | {
-            name: string;
+            path: string;
             contents: string;
             main?: boolean;
         }[];

package/dist/graph/parser/parser.mjs

@@ -12,11 +12,6 @@ const OVERRIDE_RESOLVE = [
     new RegExp(`^@langchain\/langgraph-checkpoint(\/.+)?$`),
 ];
 const INFER_TEMPLATE_PATH = path.resolve(__dirname, "./schema/types.template.mts");
-const compilerOptions = {
-    noEmit: true,
-    strict: true,
-    allowUnusedLabels: true,
-};
 export class SubgraphExtractor {
     program;
     checker;
@@ -145,50 +140,67 @@ export class SubgraphExtractor {
             return this.findSubgraphs(varDecl.initializer, [name]);
         });
     };
-    getAugmentedSourceFile = (suffix, name) => {
+    getAugmentedSourceFile = (sourcePath, name, options) => {
+        function sanitize(input) {
+            return input.replace(/[^a-zA-Z0-9]/g, "_");
+        }
         const vars = this.getSubgraphsVariables(name);
-        const typeSuffix = suffix.replace(/[^a-zA-Z0-9]/g, "_");
-        const typeExports = [
+        const ext = path.extname(sourcePath);
+        const suffix = sourcePath.slice(0, -ext.length);
+        let typeExports = [
             {
-                typeName: `__langgraph__${name}_${typeSuffix}`,
+                typeName: sanitize(`__langgraph__${name}_${suffix}`),
                 valueName: name,
                 graphName: name,
             },
         ];
+        const seenTypeName = new Set();
         for (const { subgraph, node, namespace } of vars) {
+            if (seenTypeName.has(subgraph.name))
+                continue;
+            seenTypeName.add(subgraph.name);
             typeExports.push({
-                typeName: `__langgraph__${namespace.join("_")}_${node}_${typeSuffix}`,
+                typeName: sanitize(`__langgraph__${namespace.join("_")}_${node}_${suffix}`),
                 valueName: subgraph.name,
                 graphName: [...namespace, node].join("|"),
             });
         }
-        const sourceFilePath = `__langgraph__source_${suffix}.mts`;
+        typeExports = typeExports.map(({ typeName, ...rest }) => ({
+            ...rest,
+            typeName: sanitize(typeName),
+        }));
+        const sourceFilePath = `__langgraph__source_${sanitize(suffix)}${ext}`;
         const sourceContents = [
             this.getText(this.sourceFile),
-            ...typeExports.map(({ typeName, valueName }) => `export type ${typeName} = typeof ${valueName}`),
-        ].join("\n\n");
-        const inferFilePath = `__langgraph__infer_${suffix}.mts`;
+            typeExports.map((type) => `export type ${type.typeName} = typeof ${type.valueName}`),
+        ];
+        const inferFilePath = `__langgraph__infer_${sanitize(suffix)}${ext}`;
+        const sourceFileImportPath = options.allowImportingTsExtensions
+            ? sourceFilePath
+            : sourceFilePath.slice(0, -ext.length) + ext.replace("ts", "js");
         const inferContents = [
-            ...typeExports.map(({ typeName }) => `import type { ${typeName}} from "./__langgraph__source_${suffix}.mts"`),
+            typeExports.map((type) => `import type { ${type.typeName} } from "./${sourceFileImportPath}"`),
             this.inferFile.getText(this.inferFile),
-            ...typeExports.flatMap(({ typeName }) => {
-                return [
-                    dedent `
-            type ${typeName}__reflect = Reflect<${typeName}>;
-            export type ${typeName}__state = Inspect<${typeName}__reflect["state"]>;
-            export type ${typeName}__update = Inspect<${typeName}__reflect["update"]>;
+            typeExports.map((type) => dedent `
+          type ${type.typeName}__reflect = Reflect<${type.typeName}>;
+          export type ${type.typeName}__state = Inspect<${type.typeName}__reflect["state"]>;
+          export type ${type.typeName}__update = Inspect<${type.typeName}__reflect["update"]>;
 
-            type ${typeName}__builder = BuilderReflect<${typeName}>;
-            export type ${typeName}__input = Inspect<FilterAny<${typeName}__builder["input"]>>;
-            export type ${typeName}__output = Inspect<FilterAny<${typeName}__builder["output"]>>;
-            export type ${typeName}__config = Inspect<FilterAny<${typeName}__builder["config"]>>;
-          `,
-                ];
-            }),
-        ].join("\n\n");
+          type ${type.typeName}__builder = BuilderReflect<${type.typeName}>;
+          export type ${type.typeName}__input = Inspect<FilterAny<${type.typeName}__builder["input"]>>;
+          export type ${type.typeName}__output = Inspect<FilterAny<${type.typeName}__builder["output"]>>;
+          export type ${type.typeName}__config = Inspect<FilterAny<${type.typeName}__builder["config"]>>;
+        `),
+        ];
         return {
-            inferFile: { fileName: inferFilePath, contents: inferContents },
-            sourceFile: { fileName: sourceFilePath, contents: sourceContents },
+            inferFile: {
+                fileName: inferFilePath,
+                contents: inferContents.flat(1).join("\n\n"),
+            },
+            sourceFile: {
+                fileName: sourceFilePath,
+                contents: sourceContents.flat(1).join("\n\n"),
+            },
             exports: typeExports,
         };
     };
@@ -268,6 +280,19 @@ export class SubgraphExtractor {
                 return inputPath.replace(/\\/g, "/");
             return inputPath;
         };
+        let compilerOptions = {
+            noEmit: true,
+            strict: true,
+            allowUnusedLabels: true,
+        };
+        // Find tsconfig.json file
+        const tsconfigPath = ts.findConfigFile(projectDirname, ts.sys.fileExists, "tsconfig.json");
+        // Read tsconfig.json file
+        if (tsconfigPath != null) {
+            const tsconfigFile = ts.readConfigFile(tsconfigPath, ts.sys.readFile);
+            const parsedTsconfig = ts.parseJsonConfigFileContent(tsconfigFile.config, ts.sys, path.dirname(tsconfigPath));
+            compilerOptions = { ...parsedTsconfig.options, ...compilerOptions };
+        }
         const vfsHost = vfs.createVirtualCompilerHost(system, compilerOptions, ts);
         const host = vfsHost.compilerHost;
         const targetPaths = [];
@@ -276,12 +301,13 @@ export class SubgraphExtractor {
                 targetPaths.push({ ...item, sourceFile: item.sourceFile });
             }
             else {
-                for (const { name, contents, main } of item.sourceFile ?? []) {
-                    fsMap.set(vfsPath(path.resolve(projectDirname, name)), contents);
+                for (const { path: sourcePath, contents, main } of item.sourceFile ??
+                    []) {
+                    fsMap.set(vfsPath(path.resolve(projectDirname, sourcePath)), contents);
                     if (main) {
                         targetPaths.push({
                             ...item,
-                            sourceFile: path.resolve(projectDirname, name),
+                            sourceFile: path.resolve(projectDirname, sourcePath),
                         });
                     }
                 }
@@ -312,12 +338,15 @@ export class SubgraphExtractor {
         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);
+            const graphDirname = path.dirname(targetPath.sourceFile);
+            const { sourceFile, inferFile, exports } = extractor.getAugmentedSourceFile(path.relative(projectDirname, targetPath.sourceFile), targetPath.exportSymbol, {
+                allowImportingTsExtensions: compilerOptions.allowImportingTsExtensions ?? false,
+            });
             for (const { fileName, contents } of [sourceFile, inferFile]) {
-                system.writeFile(vfsPath(path.resolve(projectDirname, fileName)), contents);
+                system.writeFile(vfsPath(path.resolve(graphDirname, fileName)), contents);
             }
             researchTargets.push({
-                rootName: path.resolve(projectDirname, inferFile.fileName),
+                rootName: path.resolve(graphDirname, inferFile.fileName),
                 exports,
             });
         }
@@ -326,23 +355,70 @@ export class SubgraphExtractor {
             options: compilerOptions,
             host,
         });
+        // Print out any diagnostics file that were detected before emitting
+        // This may explain why sometimes the schema is invalid.
+        const allDiagnostics = ts.getPreEmitDiagnostics(extract);
+        for (const diagnostic of allDiagnostics) {
+            let message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n") + "\n";
+            if (diagnostic.file) {
+                const fileName = diagnostic.file.fileName;
+                const { line, character } = ts.getLineAndCharacterOfPosition(diagnostic.file, diagnostic.start);
+                const fileLoc = `(${line + 1},${character + 1})`;
+                message = `${fileName} ${fileLoc}: ${message}`;
+            }
+            console.log(message);
+        }
         const schemaGenerator = buildGenerator(extract);
-        const trySymbol = (schema, symbol) => {
+        const trySymbol = (symbol) => {
+            let schema = undefined;
             try {
-                return schema?.getSchemaForSymbol(symbol) ?? undefined;
+                schema = schemaGenerator?.getSchemaForSymbol(symbol) ?? undefined;
             }
             catch (e) {
                 console.warn(`Failed to obtain symbol "${symbol}":`, e?.message);
             }
-            return undefined;
+            if (schema == null)
+                return undefined;
+            const definitions = schema.definitions;
+            if (definitions == null)
+                return schema;
+            const toReplace = Object.keys(definitions).flatMap((key) => {
+                const replacedKey = key.includes("import(")
+                    ? key.replace(/import\(.+@langchain[\\/]core.+\)\./, "")
+                    : key;
+                if (key !== replacedKey && definitions[replacedKey] == null) {
+                    return [
+                        {
+                            source: key,
+                            target: replacedKey,
+                            sourceRef: `#/definitions/${key}`,
+                            targetRef: `#/definitions/${replacedKey}`,
+                        },
+                    ];
+                }
+                return [];
+            });
+            for (const { source, target } of toReplace) {
+                definitions[target] = definitions[source];
+                delete definitions[source];
+            }
+            const refMap = toReplace.reduce((acc, item) => {
+                acc[item.sourceRef] = item.targetRef;
+                return acc;
+            }, {});
+            return JSON.parse(JSON.stringify(schema, (_, value) => {
+                if (typeof value === "string" && refMap[value])
+                    return refMap[value];
+                return value;
+            }));
         };
         return researchTargets.map(({ exports }) => Object.fromEntries(exports.map(({ typeName, graphName }) => [
             graphName,
             {
-                state: trySymbol(schemaGenerator, `${typeName}__update`),
-                input: trySymbol(schemaGenerator, `${typeName}__input`),
-                output: trySymbol(schemaGenerator, `${typeName}__output`),
-                config: trySymbol(schemaGenerator, `${typeName}__config`),
+                state: trySymbol(`${typeName}__update`),
+                input: trySymbol(`${typeName}__input`),
+                output: trySymbol(`${typeName}__output`),
+                config: trySymbol(`${typeName}__config`),
             },
         ])));
     }

package/dist/graph/parser/schema/types.template.mts

@@ -5,14 +5,14 @@ import type {
   StateDefinition,
 } from "@langchain/langgraph";
 
-// @ts-expect-error
+// @ts-ignore
 type AnyPregel = {
   lg_is_pregel: boolean;
   stream: (...args: any[]) => any;
   invoke: (...args: any[]) => any;
 };
 
-// @ts-expect-error
+// @ts-ignore
 type AnyGraph = {
   compiled: boolean;
   compile: (...args: any[]) => any;
@@ -30,7 +30,7 @@ type Defactorify<T> = T extends (...args: any[]) => infer R
   ? Awaited<R>
   : Awaited<T>;
 
-// @ts-expect-error
+// @ts-ignore
 type Inspect<T, TDepth extends Array<0> = []> = TDepth extends [0, 0, 0]
   ? any
   : T extends unknown
@@ -51,7 +51,7 @@ type ReflectCompiled<T> = T extends { RunInput: infer S; RunOutput: infer U }
   ? { state: OutputType; update: InputType }
   : never;
 
-// @ts-expect-error
+// @ts-ignore
 type Reflect<T> = Defactorify<T> extends infer DT
   ? DT extends {
       compile(...args: any[]): infer Compiled;
@@ -74,7 +74,7 @@ type BuilderReflectCompiled<T> = T extends {
     }
   : never;
 
-// @ts-expect-error
+// @ts-ignore
 type BuilderReflect<T> = Defactorify<T> extends infer DT
   ? DT extends {
       compile(...args: any[]): infer Compiled;
@@ -83,5 +83,5 @@ type BuilderReflect<T> = Defactorify<T> extends infer DT
     : BuilderReflectCompiled<DT>
   : never;
 
-// @ts-expect-error
+// @ts-ignore
 type FilterAny<T> = 0 extends 1 & T ? never : T;

package/dist/schemas.d.mts

@@ -183,7 +183,6 @@ export declare const AssistantCreate: z.ZodObject<{
     graph_id: string;
     context?: unknown;
     metadata?: z.objectOutputType<{}, z.ZodUnknown, "strip"> | undefined;
-    name?: string | undefined;
     config?: z.objectOutputType<{
         tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         recursion_limit: z.ZodOptional<z.ZodNumber>;
@@ -198,13 +197,13 @@ export declare const AssistantCreate: z.ZodObject<{
             thread_ts: z.ZodOptional<z.ZodString>;
         }, z.ZodUnknown, "strip">>>;
     }, z.ZodUnknown, "strip"> | undefined;
+    name?: string | undefined;
     if_exists?: "do_nothing" | "raise" | undefined;
     assistant_id?: string | undefined;
 }, {
     graph_id: string;
     context?: unknown;
     metadata?: z.objectInputType<{}, z.ZodUnknown, "strip"> | undefined;
-    name?: string | undefined;
     config?: z.objectInputType<{
         tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         recursion_limit: z.ZodOptional<z.ZodNumber>;
@@ -219,6 +218,7 @@ export declare const AssistantCreate: z.ZodObject<{
             thread_ts: z.ZodOptional<z.ZodString>;
         }, z.ZodUnknown, "strip">>>;
     }, z.ZodUnknown, "strip"> | undefined;
+    name?: string | undefined;
     if_exists?: "do_nothing" | "raise" | undefined;
     assistant_id?: string | undefined;
 }>;
@@ -270,7 +270,6 @@ export declare const AssistantPatch: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     context?: unknown;
     metadata?: z.objectOutputType<{}, z.ZodAny, "strip"> | undefined;
-    name?: string | undefined;
     config?: z.objectOutputType<{
         tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         recursion_limit: z.ZodOptional<z.ZodNumber>;
@@ -285,11 +284,11 @@ export declare const AssistantPatch: z.ZodObject<{
             thread_ts: z.ZodOptional<z.ZodString>;
         }, z.ZodUnknown, "strip">>>;
     }, z.ZodUnknown, "strip"> | undefined;
+    name?: string | undefined;
     graph_id?: string | undefined;
 }, {
     context?: unknown;
     metadata?: z.objectInputType<{}, z.ZodAny, "strip"> | undefined;
-    name?: string | undefined;
     config?: z.objectInputType<{
         tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
         recursion_limit: z.ZodOptional<z.ZodNumber>;
@@ -304,6 +303,7 @@ export declare const AssistantPatch: z.ZodObject<{
             thread_ts: z.ZodOptional<z.ZodString>;
         }, z.ZodUnknown, "strip">>>;
     }, z.ZodUnknown, "strip"> | undefined;
+    name?: string | undefined;
     graph_id?: string | undefined;
 }>;
 export declare const Config: z.ZodObject<{

package/dist/server.mjs

@@ -19,6 +19,7 @@ import { registerHttp } from "./http/custom.mjs";
 import { cors, ensureContentType } from "./http/middleware.mjs";
 import { bindLoopbackFetch } from "./loopback.mjs";
 import { checkLangGraphSemver } from "./semver/index.mjs";
+import { getConfig } from "@langchain/langgraph";
 export const StartServerSchema = z.object({
     port: z.number(),
     nWorkers: z.number(),
@@ -79,9 +80,6 @@ export async function startServer(options) {
     registerSdkLogger();
     logger.info(`Registering graphs from ${options.cwd}`);
     await registerFromEnv(options.graphs, { cwd: options.cwd });
-    // Make sure to register the runtime formatter after we've loaded the graphs
-    // to ensure that we're not loading `@langchain/langgraph` from different path.
-    const { getConfig } = await import("@langchain/langgraph");
     registerRuntimeLogFormatter((info) => {
         const config = getConfig();
         if (config == null)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/langgraph-api",
-  "version": "0.0.54",
+  "version": "0.0.56",
   "type": "module",
   "engines": {
     "node": "^18.19.0 || >=20.16.0"
@@ -52,7 +52,7 @@
     "@babel/code-frame": "^7.26.2",
     "@hono/node-server": "^1.12.0",
     "@hono/zod-validator": "^0.2.2",
-    "@langchain/langgraph-ui": "0.0.54",
+    "@langchain/langgraph-ui": "0.0.56",
     "@types/json-schema": "^7.0.15",
     "@typescript/vfs": "^1.6.0",
     "dedent": "^1.5.3",
@@ -84,9 +84,9 @@
   },
   "devDependencies": {
     "@langchain/core": "^0.3.59",
-    "@langchain/langgraph": "0.4.0",
+    "@langchain/langgraph": "0.4.2",
     "@langchain/langgraph-checkpoint": "0.1.0",
-    "@langchain/langgraph-sdk": "0.0.104",
+    "@langchain/langgraph-sdk": "0.0.105",
     "@types/babel__code-frame": "^7.0.6",
     "@types/node": "^18.15.11",
     "@types/react": "^19.0.8",