@langchain/langgraph-api 1.1.2 → 1.1.8

package/dist/experimental/embed.mjs

@@ -1,299 +0,0 @@
-import { Hono } from "hono";
-import { zValidator } from "@hono/zod-validator";
-import { streamSSE } from "hono/streaming";
-import { v4 as uuidv4 } from "uuid";
-import * as schemas from "../schemas.mjs";
-import { z } from "zod/v3";
-import { streamState } from "../stream.mjs";
-import { serialiseAsDict, serializeError } from "../utils/serde.mjs";
-import { getDisconnectAbortSignal, jsonExtra } from "../utils/hono.mjs";
-import { stateSnapshotToThreadState } from "../state.mjs";
-import { ensureContentType } from "../http/middleware.mjs";
-function createStubRun(threadId, payload) {
-    const now = new Date();
-    const runId = uuidv4();
-    let streamMode = Array.isArray(payload.stream_mode)
-        ? payload.stream_mode
-        : payload.stream_mode
-            ? [payload.stream_mode]
-            : undefined;
-    if (streamMode == null || streamMode.length === 0)
-        streamMode = ["values"];
-    const config = Object.assign({}, payload.config ?? {}, {
-        configurable: {
-            run_id: runId,
-            thread_id: threadId,
-            graph_id: payload.assistant_id,
-            ...(payload.checkpoint_id
-                ? { checkpoint_id: payload.checkpoint_id }
-                : null),
-            ...payload.checkpoint,
-            ...(payload.langsmith_tracer
-                ? {
-                    langsmith_project: payload.langsmith_tracer.project_name,
-                    langsmith_example_id: payload.langsmith_tracer.example_id,
-                }
-                : null),
-        },
-    }, { metadata: payload.metadata ?? {} });
-    return {
-        run_id: runId,
-        thread_id: threadId,
-        assistant_id: payload.assistant_id,
-        metadata: payload.metadata ?? {},
-        status: "running",
-        kwargs: {
-            input: payload.input,
-            command: payload.command,
-            config,
-            context: payload.context,
-            stream_mode: streamMode,
-            interrupt_before: payload.interrupt_before,
-            interrupt_after: payload.interrupt_after,
-            feedback_keys: payload.feedback_keys,
-            subgraphs: payload.stream_subgraphs,
-            temporary: false,
-        },
-        multitask_strategy: "reject",
-        created_at: now,
-        updated_at: now,
-    };
-}
-/**
- * Create a Hono server with a subset of LangGraph Platform routes.
- *
- * @experimental Does not follow semver.
- */
-export function createEmbedServer(options) {
-    async function getGraph(graphId) {
-        const targetGraph = options.graph[graphId];
-        targetGraph.store = options.store;
-        targetGraph.checkpointer = options.checkpointer;
-        return targetGraph;
-    }
-    const api = new Hono();
-    api.use(ensureContentType());
-    api.post("/threads", zValidator("json", schemas.ThreadCreate), async (c) => {
-        // create a new thread
-        const payload = c.req.valid("json");
-        const threadId = payload.thread_id || uuidv4();
-        return jsonExtra(c, await options.threads.set(threadId, {
-            kind: "put",
-            metadata: payload.metadata,
-        }));
-    });
-    api.get("/threads/:thread_id", zValidator("param", z.object({ thread_id: z.string().uuid() })), async (c) => {
-        // Get Thread
-        const { thread_id } = c.req.valid("param");
-        return jsonExtra(c, await options.threads.get(thread_id));
-    });
-    api.patch("/threads/:thread_id", zValidator("param", z.object({ thread_id: z.string().uuid() })), zValidator("json", schemas.ThreadCreate), async (c) => {
-        // Update Thread
-        const { thread_id } = c.req.valid("param");
-        const payload = c.req.valid("json");
-        return jsonExtra(c, await options.threads.set(thread_id, {
-            kind: "patch",
-            metadata: payload.metadata,
-        }));
-    });
-    api.delete("/threads/:thread_id", zValidator("param", z.object({ thread_id: z.string().uuid() })), async (c) => {
-        // Delete Thread
-        const { thread_id } = c.req.valid("param");
-        await options.threads.delete(thread_id);
-        return new Response(null, { status: 204 });
-    });
-    api.post("/threads/search", zValidator("json", schemas.ThreadSearchRequest), async (c) => {
-        const payload = c.req.valid("json");
-        const result = [];
-        if (!options.threads.search)
-            return c.json({ error: "Threads search not implemented" }, 422);
-        const sortBy = payload.sort_by === "created_at" || payload.sort_by === "updated_at"
-            ? payload.sort_by
-            : "created_at";
-        let total = 0;
-        for await (const item of options.threads.search({
-            metadata: payload.metadata,
-            limit: payload.limit ?? 10,
-            offset: payload.offset ?? 0,
-            sortBy,
-            sortOrder: payload.sort_order ?? "desc",
-        })) {
-            result.push(item.thread);
-            // Only set total if it's the first item
-            if (total === 0)
-                total = item.total;
-        }
-        c.res.headers.set("X-Pagination-Total", total.toString());
-        return jsonExtra(c, result);
-    });
-    api.get("/threads/:thread_id/state", zValidator("param", z.object({ thread_id: z.string().uuid() })), zValidator("query", z.object({ subgraphs: schemas.coercedBoolean.optional() })), async (c) => {
-        // Get Latest Thread State
-        const { thread_id } = c.req.valid("param");
-        const { subgraphs } = c.req.valid("query");
-        const thread = await options.threads.get(thread_id);
-        const graphId = thread.metadata?.graph_id;
-        const graph = graphId ? await getGraph(graphId) : undefined;
-        if (graph == null) {
-            return jsonExtra(c, stateSnapshotToThreadState({
-                values: {},
-                next: [],
-                config: {},
-                metadata: undefined,
-                createdAt: undefined,
-                parentConfig: undefined,
-                tasks: [],
-            }));
-        }
-        const config = { configurable: { thread_id } };
-        const result = await graph.getState(config, { subgraphs });
-        return jsonExtra(c, stateSnapshotToThreadState(result));
-    });
-    api.post("/threads/:thread_id/state", zValidator("param", z.object({ thread_id: z.string().uuid() })), zValidator("json", schemas.ThreadStateUpdate), async (c) => {
-        // Update Thread State
-        const { thread_id } = c.req.valid("param");
-        const payload = c.req.valid("json");
-        const config = { configurable: { thread_id } };
-        config.configurable ??= {};
-        if (payload.checkpoint_id) {
-            config.configurable.checkpoint_id = payload.checkpoint_id;
-        }
-        if (payload.checkpoint) {
-            Object.assign(config.configurable, payload.checkpoint);
-        }
-        const thread = await options.threads.get(thread_id);
-        const graphId = thread.metadata?.graph_id;
-        const graph = graphId ? await getGraph(graphId) : undefined;
-        if (graph == null)
-            return c.json({ error: "Graph not found" }, 404);
-        const result = await graph.updateState(config, payload.values, payload.as_node);
-        return jsonExtra(c, { checkpoint: result.configurable });
-    });
-    // get thread state at checkpoint
-    api.get("/threads/:thread_id/state/:checkpoint_id", zValidator("param", z.object({
-        thread_id: z.string().uuid(),
-        checkpoint_id: z.string().uuid(),
-    })), zValidator("query", z.object({ subgraphs: schemas.coercedBoolean.optional() })), async (c) => {
-        // Get Thread State At Checkpoint
-        const { thread_id, checkpoint_id } = c.req.valid("param");
-        const { subgraphs } = c.req.valid("query");
-        const thread = await options.threads.get(thread_id);
-        const graphId = thread.metadata?.graph_id;
-        const graph = graphId ? await getGraph(graphId) : undefined;
-        if (graph == null)
-            return c.json({ error: "Graph not found" }, 404);
-        const result = await graph.getState({ configurable: { thread_id, checkpoint_id } }, { subgraphs });
-        return jsonExtra(c, stateSnapshotToThreadState(result));
-    });
-    api.post("/threads/:thread_id/state/checkpoint", zValidator("param", z.object({ thread_id: z.string().uuid() })), zValidator("json", z.object({
-        subgraphs: schemas.coercedBoolean.optional(),
-        checkpoint: schemas.CheckpointSchema.nullish(),
-    })), async (c) => {
-        // Get Thread State At Checkpoint post
-        const { thread_id } = c.req.valid("param");
-        const { checkpoint, subgraphs } = c.req.valid("json");
-        const thread = await options.threads.get(thread_id);
-        const graphId = thread.metadata?.graph_id;
-        const graph = graphId ? await getGraph(graphId) : undefined;
-        if (graph == null)
-            return c.json({ error: "Graph not found" }, 404);
-        const result = await graph.getState({ configurable: { thread_id, ...checkpoint } }, { subgraphs });
-        return jsonExtra(c, stateSnapshotToThreadState(result));
-    });
-    api.post("/threads/:thread_id/history", zValidator("param", z.object({ thread_id: z.string().uuid() })), zValidator("json", schemas.ThreadHistoryRequest), async (c) => {
-        // Get Thread History Post
-        const { thread_id } = c.req.valid("param");
-        const { limit, before, metadata, checkpoint } = c.req.valid("json");
-        const thread = await options.threads.get(thread_id);
-        const graphId = thread.metadata?.graph_id;
-        const graph = graphId ? await getGraph(graphId) : undefined;
-        if (graph == null)
-            return jsonExtra(c, []);
-        const config = { configurable: { thread_id, ...checkpoint } };
-        const result = [];
-        const beforeConfig = typeof before === "string"
-            ? { configurable: { checkpoint_id: before } }
-            : before;
-        for await (const state of graph.getStateHistory(config, {
-            limit,
-            before: beforeConfig,
-            filter: metadata,
-        })) {
-            result.push(stateSnapshotToThreadState(state));
-        }
-        return jsonExtra(c, result);
-    });
-    api.post("/threads/:thread_id/runs/stream", zValidator("param", z.object({ thread_id: z.string().uuid() })), zValidator("json", schemas.RunCreate), async (c) => {
-        // Stream Run
-        const { thread_id } = c.req.valid("param");
-        const payload = c.req.valid("json");
-        const thread = await options.threads.get(thread_id);
-        if (thread == null)
-            return c.json({ error: "Thread not found" }, 404);
-        return streamSSE(c, async (stream) => {
-            const signal = getDisconnectAbortSignal(c, stream);
-            const run = createStubRun(thread_id, payload);
-            await options.threads.set(thread_id, {
-                kind: "patch",
-                metadata: {
-                    graph_id: payload.assistant_id,
-                    assistant_id: payload.assistant_id,
-                },
-            });
-            try {
-                for await (const { event, data } of streamState(run, {
-                    attempt: 1,
-                    getGraph,
-                    signal,
-                })) {
-                    await stream.writeSSE({ data: serialiseAsDict(data), event });
-                }
-            }
-            catch (error) {
-                await stream.writeSSE({
-                    data: serialiseAsDict(serializeError(error)),
-                    event: "error",
-                });
-            }
-        });
-    });
-    api.post("/runs/stream", zValidator("json", schemas.RunCreate), async (c) => {
-        // Stream Stateless Run
-        return streamSSE(c, async (stream) => {
-            const payload = c.req.valid("json");
-            const signal = getDisconnectAbortSignal(c, stream);
-            const threadId = uuidv4();
-            await options.threads.set(threadId, {
-                kind: "put",
-                metadata: {
-                    graph_id: payload.assistant_id,
-                    assistant_id: payload.assistant_id,
-                },
-            });
-            try {
-                const run = createStubRun(threadId, payload);
-                try {
-                    for await (const { event, data } of streamState(run, {
-                        attempt: 1,
-                        getGraph,
-                        signal,
-                    })) {
-                        await stream.writeSSE({ data: serialiseAsDict(data), event });
-                    }
-                }
-                catch (error) {
-                    await stream.writeSSE({
-                        data: serialiseAsDict(serializeError(error)),
-                        event: "error",
-                    });
-                }
-            }
-            finally {
-                await options.threads.delete(threadId);
-            }
-        });
-    });
-    api.notFound((c) => {
-        return c.json({ error: `${c.req.method} ${c.req.path} not implemented` }, 404);
-    });
-    return api;
-}

package/dist/graph/api.d.mts

@@ -1 +0,0 @@
-export { assertGraphExists, getAssistantId, getGraph, getGraphKeys, } from "./load.mjs";

package/dist/graph/api.mjs

@@ -1,2 +0,0 @@
-// Public API for graph operations (useful for writing custom operation backends).
-export { assertGraphExists, getAssistantId, getGraph, getGraphKeys, } from "./load.mjs";

package/dist/graph/load.d.mts

@@ -1,19 +0,0 @@
-import type { AssistantsRepo } from "../storage/types.mjs";
-import type { BaseCheckpointSaver, BaseStore, CompiledGraph, LangGraphRunnableConfig } from "@langchain/langgraph";
-import { type CompiledGraphFactory } from "./load.utils.mjs";
-import type { GraphSchema, GraphSpec } from "./parser/index.mjs";
-export declare const GRAPHS: Record<string, CompiledGraph<string> | CompiledGraphFactory<string>>;
-export declare const GRAPH_SPEC: Record<string, GraphSpec>;
-export declare const GRAPH_SCHEMA: Record<string, Record<string, GraphSchema>>;
-export declare const NAMESPACE_GRAPH: Uint8Array<ArrayBufferLike>;
-export declare const getAssistantId: (graphId: string) => string;
-export declare function registerFromEnv(assistants: AssistantsRepo, specs: Record<string, string>, options: {
-    cwd: string;
-}): Promise<(CompiledGraph<string, any, any, Record<string, any>, any, any, unknown, unknown, any> | CompiledGraphFactory<string>)[]>;
-export declare function getGraph(graphId: string, config: LangGraphRunnableConfig | undefined, options?: {
-    checkpointer?: BaseCheckpointSaver | null;
-    store?: BaseStore;
-}): Promise<CompiledGraph<string, any, any, Record<string, any>, any, any, unknown, unknown, any>>;
-export declare function assertGraphExists(graphId: string): void;
-export declare function getGraphKeys(): string[];
-export declare function getCachedStaticGraphSchema(graphId: string): Promise<Record<string, GraphSchema>>;

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

@@ -1,2 +0,0 @@
-export function initialize(args: any): Promise<void>;
-export function resolve(specifier: any, context: any, nextResolve: any): Promise<any>;

package/dist/graph/load.hooks.mjs

@@ -1,52 +0,0 @@
-// This module hook is used to ensure that @langchain/langgraph package
-// is imported from a consistent location.
-// Accepts `{ parentURL: string }` as argument when registering the hook.
-const OVERRIDE_RESOLVE = [
-    // Override `@langchain/langgraph` or `@langchain/langgraph/prebuilt`,
-    // but not `@langchain/langgraph-sdk`
-    new RegExp(`^@langchain\/langgraph(\/.+)?$`),
-    new RegExp(`^@langchain\/langgraph-checkpoint(\/.+)?$`),
-];
-let parentURL;
-let langgraphPackageURL;
-export async function initialize(args) {
-    parentURL = args.parentURL;
-}
-export async function resolve(specifier, context, nextResolve) {
-    // HACK: @tailwindcss/node internally uses an ESM loader cache, which does not play nicely with `tsx`.
-    //       Node.js crashes with "TypeError [ERR_INVALID_URL_SCHEME]: The URL must be of scheme file".
-    //       As it already is a valid URI, we can just short-circuit the resolution and avoid `tsx`.
-    if (specifier.includes("@tailwindcss/node/dist/esm-cache.loader") &&
-        specifier.startsWith("file://")) {
-        return {
-            shortCircuit: true,
-            // Node 18.x will for some reason attempt to load `.mts` instead of `.mjs`
-            url: specifier.replace(".mts", ".mjs"),
-            format: "module",
-        };
-    }
-    if (specifier === "@langchain/langgraph-checkpoint") {
-        // resolve relative to @langchain/langgraph package instead
-        // This is done to avoid adding a direct dependency on @langchain/langgraph-checkpoint
-        // in project, which if not present will cause `pnpm` to not find the package.
-        if (!langgraphPackageURL) {
-            const main = await nextResolve("@langchain/langgraph", {
-                ...context,
-                parentURL,
-            });
-            langgraphPackageURL = main.url.toString();
-        }
-        return await nextResolve(specifier, {
-            ...context,
-            parentURL: langgraphPackageURL,
-        });
-    }
-    if (OVERRIDE_RESOLVE.some((regex) => regex.test(specifier))) {
-        const resolved = await nextResolve(specifier, { ...context, parentURL });
-        // If @langchain/langgraph is resolved first, cache it!
-        if (specifier === "@langchain/langgraph" && !langgraphPackageURL) {
-            langgraphPackageURL = resolved.url.toString();
-        }
-    }
-    return nextResolve(specifier, context);
-}

package/dist/graph/load.mjs

@@ -1,96 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,58 +0,0 @@
-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;
-}