@langchain/langgraph-api 1.1.8 → 1.1.10

package/dist/graph/load.mjs

@@ -0,0 +1,96 @@
+import { z } from "zod/v3";
+import * as uuid from "uuid";
+import { HTTPException } from "hono/http-exception";
+import { resolveGraph } from "./load.utils.mjs";
+import { getStaticGraphSchema } from "./parser/index.mjs";
+import { checkpointer } from "../storage/checkpoint.mjs";
+import { store } from "../storage/store.mjs";
+import { logger } from "../logging.mjs";
+export const GRAPHS = {};
+export const GRAPH_SPEC = {};
+export const GRAPH_SCHEMA = {};
+export const NAMESPACE_GRAPH = uuid.parse("6ba7b821-9dad-11d1-80b4-00c04fd430c8");
+const ConfigSchema = z.record(z.record(z.unknown()));
+export const getAssistantId = (graphId) => {
+    if (graphId in GRAPHS)
+        return uuid.v5(graphId, NAMESPACE_GRAPH);
+    return graphId;
+};
+export async function registerFromEnv(assistants, specs, options) {
+    const envConfig = process.env.LANGGRAPH_CONFIG
+        ? ConfigSchema.parse(JSON.parse(process.env.LANGGRAPH_CONFIG))
+        : undefined;
+    return await Promise.all(Object.entries(specs).map(async ([graphId, rawSpec]) => {
+        logger.info(`Registering graph with id '${graphId}'`, {
+            graph_id: graphId,
+        });
+        const { context, ...config } = envConfig?.[graphId] ?? {};
+        const { resolved, ...spec } = await resolveGraph(rawSpec, {
+            cwd: options.cwd,
+        });
+        // registering the graph runtime
+        GRAPHS[graphId] = resolved;
+        GRAPH_SPEC[graphId] = spec;
+        await assistants.put(uuid.v5(graphId, NAMESPACE_GRAPH), {
+            graph_id: graphId,
+            metadata: { created_by: "system" },
+            config,
+            context,
+            if_exists: "do_nothing",
+            name: graphId,
+        }, undefined);
+        return resolved;
+    }));
+}
+export async function getGraph(graphId, config, options) {
+    assertGraphExists(graphId);
+    const compiled = typeof GRAPHS[graphId] === "function"
+        ? await GRAPHS[graphId](config ?? { configurable: {} })
+        : GRAPHS[graphId];
+    if (typeof options?.checkpointer !== "undefined") {
+        compiled.checkpointer = options?.checkpointer ?? undefined;
+    }
+    else {
+        compiled.checkpointer = checkpointer;
+    }
+    compiled.store = options?.store ?? store;
+    return compiled;
+}
+export function assertGraphExists(graphId) {
+    if (!GRAPHS[graphId])
+        throw new HTTPException(404, {
+            message: `Graph "${graphId}" not found`,
+        });
+}
+export function getGraphKeys() {
+    return Object.keys(GRAPHS);
+}
+export async function getCachedStaticGraphSchema(graphId) {
+    if (!GRAPH_SPEC[graphId])
+        throw new HTTPException(404, {
+            message: `Spec for "${graphId}" not found`,
+        });
+    if (!GRAPH_SCHEMA[graphId]) {
+        let timeoutMs = 30_000;
+        try {
+            const envTimeout = Number.parseInt(process.env.LANGGRAPH_SCHEMA_RESOLVE_TIMEOUT_MS ?? "0", 10);
+            if (!Number.isNaN(envTimeout) && envTimeout > 0) {
+                timeoutMs = envTimeout;
+            }
+        }
+        catch {
+            // ignore
+        }
+        try {
+            GRAPH_SCHEMA[graphId] = await getStaticGraphSchema(GRAPH_SPEC[graphId], {
+                timeoutMs,
+            });
+        }
+        catch (error) {
+            throw new Error(`Failed to extract schema for "${graphId}"`, {
+                cause: error,
+            });
+        }
+    }
+    return GRAPH_SCHEMA[graphId];
+}

package/dist/graph/load.utils.d.mts

@@ -0,0 +1,22 @@
+import type { CompiledGraph } from "@langchain/langgraph";
+export declare const GRAPHS: Record<string, CompiledGraph<string>>;
+export declare const NAMESPACE_GRAPH: Uint8Array<ArrayBufferLike>;
+export type CompiledGraphFactory<T extends string> = (config: {
+    configurable?: Record<string, unknown>;
+}) => Promise<CompiledGraph<T>>;
+export declare function resolveGraph(spec: string, options: {
+    cwd: string;
+    onlyFilePresence?: false;
+}): Promise<{
+    sourceFile: string;
+    exportSymbol: string;
+    resolved: CompiledGraph<string> | CompiledGraphFactory<string>;
+}>;
+export declare function resolveGraph(spec: string, options: {
+    cwd: string;
+    onlyFilePresence: true;
+}): Promise<{
+    sourceFile: string;
+    exportSymbol: string;
+    resolved: undefined;
+}>;

package/dist/graph/load.utils.mjs

@@ -0,0 +1,49 @@
+import * as uuid from "uuid";
+import * as path from "node:path";
+import * as fs from "node:fs/promises";
+import { pathToFileURL } from "node:url";
+export const GRAPHS = {};
+export const NAMESPACE_GRAPH = uuid.parse("6ba7b821-9dad-11d1-80b4-00c04fd430c8");
+export async function resolveGraph(spec, options) {
+    const [userFile, exportSymbol] = spec.split(":", 2);
+    const sourceFile = path.resolve(options.cwd, userFile);
+    // validate file exists
+    await fs.stat(sourceFile);
+    if (options?.onlyFilePresence) {
+        return { sourceFile, exportSymbol, resolved: undefined };
+    }
+    const isGraph = (graph) => {
+        if (typeof graph !== "object" || graph == null)
+            return false;
+        return "compile" in graph && typeof graph.compile === "function";
+    };
+    const isCompiledGraph = (graph) => {
+        if (typeof graph !== "object" || graph == null)
+            return false;
+        return ("builder" in graph &&
+            typeof graph.builder === "object" &&
+            graph.builder != null);
+    };
+    const graph = await import(pathToFileURL(sourceFile).toString()).then((module) => module[exportSymbol || "default"]);
+    // obtain the graph, and if not compiled, compile it
+    const resolved = await (async () => {
+        if (!graph)
+            throw new Error("Failed to load graph: graph is nullush");
+        const afterResolve = (graphLike) => {
+            const graph = isGraph(graphLike) ? graphLike.compile() : graphLike;
+            // TODO: hack, remove once LangChain 1.x createAgent is fixed
+            if (!isCompiledGraph(graph) && "graph" in graph) {
+                return graph.graph;
+            }
+            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/graph/parser/index.d.mts

@@ -0,0 +1,23 @@
+import type { JSONSchema7 } from "json-schema";
+import type { Pregel } from "@langchain/langgraph";
+export interface GraphSchema {
+    state: JSONSchema7 | undefined;
+    input: JSONSchema7 | undefined;
+    output: JSONSchema7 | undefined;
+    config: JSONSchema7 | undefined;
+}
+export interface GraphSpec {
+    sourceFile: string;
+    exportSymbol: string;
+}
+type GraphSchemaWithSubgraphs = Record<string, GraphSchema>;
+export declare function getStaticGraphSchema(spec: GraphSpec, options?: {
+    mainThread?: boolean;
+    timeoutMs?: number;
+}): 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

@@ -0,0 +1,58 @@
+import { fileURLToPath } from "node:url";
+import { Worker } from "node:worker_threads";
+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);
+        });
+    }
+    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 {
+        const { getInputTypeSchema, getOutputTypeSchema, getUpdateTypeSchema, getConfigTypeSchema, } = await import("@langchain/langgraph/zod/schema");
+        const result = {
+            state: getUpdateTypeSchema(graph),
+            input: getInputTypeSchema(graph),
+            output: getOutputTypeSchema(graph),
+            config: getConfigTypeSchema(graph),
+        };
+        if (Object.values(result).every((i) => i == null))
+            return undefined;
+        return result;
+    }
+    catch {
+        // ignore
+    }
+    return undefined;
+}

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

@@ -0,0 +1,77 @@
+import * as ts from "typescript";
+import type { JSONSchema7 } from "json-schema";
+interface GraphSchema {
+    state: JSONSchema7 | undefined;
+    input: JSONSchema7 | undefined;
+    output: JSONSchema7 | undefined;
+    config: JSONSchema7 | undefined;
+}
+export declare class SubgraphExtractor {
+    protected program: ts.Program;
+    protected checker: ts.TypeChecker;
+    protected sourceFile: ts.SourceFile;
+    protected inferFile: ts.SourceFile;
+    protected anyPregelType: ts.Type;
+    protected anyGraphType: ts.Type;
+    protected strict: boolean;
+    constructor(program: ts.Program, sourceFile: ts.SourceFile, inferFile: ts.SourceFile, options?: {
+        strict?: boolean;
+    });
+    private findTypeByName;
+    private find;
+    protected findSubgraphs: (node: ts.Node, namespace?: string[]) => {
+        node: string;
+        namespace: string[];
+        subgraph: {
+            name: string;
+            node: ts.Node;
+        };
+    }[];
+    protected getSubgraphsVariables: (name: string) => {
+        node: string;
+        namespace: string[];
+        subgraph: {
+            name: string;
+            node: ts.Node;
+        };
+    }[];
+    getAugmentedSourceFile: (sourcePath: string, name: string, options: {
+        allowImportingTsExtensions: boolean;
+    }) => {
+        inferFile: {
+            fileName: string;
+            contents: string;
+        };
+        sourceFile: {
+            fileName: string;
+            contents: string;
+        };
+        exports: {
+            typeName: string;
+            valueName: string;
+            graphName: string;
+        }[];
+    };
+    protected findSubgraphIdentifiers: (acc: {
+        node: ts.Node;
+        name: string;
+    }[], node: ts.Node) => {
+        node: ts.Node;
+        name: string;
+    }[];
+    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: {
+        sourceFile: string | {
+            path: string;
+            contents: string;
+            main?: boolean;
+        }[];
+        exportSymbol: string;
+    }[], options?: {
+        strict?: boolean;
+        tsConfigOptions?: Record<string, unknown>;
+    }): Record<string, GraphSchema>[];
+}
+export {};