@langchain/langgraph-api 1.1.2 → 1.1.8

package/dist/storage/ops.mjs

@@ -1,1262 +0,0 @@
-import { HTTPException } from "hono/http-exception";
-import { v4 as uuid4, v5 as uuid5 } from "uuid";
-import { handleAuthEvent, isAuthMatching } from "../auth/index.mjs";
-import { getLangGraphCommand } from "../command.mjs";
-import { getGraph, NAMESPACE_GRAPH } from "../graph/load.mjs";
-import { logger } from "../logging.mjs";
-import { serializeError } from "../utils/serde.mjs";
-import { checkpointer } from "./checkpoint.mjs";
-import { store } from "./store.mjs";
-export class FileSystemOps {
-    conn;
-    assistants;
-    runs;
-    threads;
-    constructor(conn) {
-        this.conn = conn;
-        this.assistants = new FileSystemAssistants(this.conn);
-        this.runs = new FileSystemRuns(this.conn);
-        this.threads = new FileSystemThreads(this.conn);
-    }
-    truncate(flags) {
-        return this.conn.with((STORE) => {
-            if (flags.runs)
-                STORE.runs = {};
-            if (flags.threads)
-                STORE.threads = {};
-            if (flags.assistants) {
-                STORE.assistants = Object.fromEntries(Object.entries(STORE.assistants).filter(([key, assistant]) => assistant.metadata?.created_by === "system" &&
-                    uuid5(assistant.graph_id, NAMESPACE_GRAPH) === key));
-            }
-            if (flags.checkpointer)
-                checkpointer.clear();
-            if (flags.store)
-                store.clear();
-        });
-    }
-}
-class TimeoutError extends Error {
-}
-class AbortError extends Error {
-}
-class Queue {
-    log = [];
-    listeners = [];
-    nextId = 0;
-    resumable = false;
-    constructor(options) {
-        this.resumable = options.resumable;
-    }
-    push(item) {
-        this.log.push(item);
-        for (const listener of this.listeners)
-            listener(this.nextId);
-        this.nextId += 1;
-    }
-    async get(options) {
-        if (this.resumable) {
-            const lastEventId = options.lastEventId;
-            // Generator stores internal state of the read head index,
-            let targetId = lastEventId != null ? +lastEventId + 1 : null;
-            if (targetId == null ||
-                isNaN(targetId) ||
-                targetId < 0 ||
-                targetId >= this.log.length) {
-                targetId = null;
-            }
-            if (targetId != null)
-                return [String(targetId), this.log[targetId]];
-        }
-        else {
-            if (this.log.length) {
-                const nextId = this.nextId - this.log.length;
-                const nextItem = this.log.shift();
-                return [String(nextId), nextItem];
-            }
-        }
-        let timeout = undefined;
-        let resolver = undefined;
-        const clean = new AbortController();
-        // listen to new item
-        return await new Promise((resolve, reject) => {
-            timeout = setTimeout(() => reject(new TimeoutError()), options.timeout);
-            resolver = resolve;
-            options.signal?.addEventListener("abort", () => reject(new AbortError()), { signal: clean.signal });
-            this.listeners.push(resolver);
-        })
-            .then((idx) => {
-            if (this.resumable) {
-                return [String(idx), this.log[idx]];
-            }
-            const nextId = this.nextId - this.log.length;
-            const nextItem = this.log.shift();
-            return [String(nextId), nextItem];
-        })
-            .finally(() => {
-            this.listeners = this.listeners.filter((l) => l !== resolver);
-            clearTimeout(timeout);
-            clean.abort();
-        });
-    }
-}
-class CancellationAbortController extends AbortController {
-    abort(reason) {
-        super.abort(reason);
-    }
-}
-class StreamManagerImpl {
-    readers = {};
-    control = {};
-    getQueue(runId, options) {
-        if (this.readers[runId] == null) {
-            this.readers[runId] = new Queue(options);
-        }
-        return this.readers[runId];
-    }
-    getControl(runId) {
-        if (this.control[runId] == null)
-            return undefined;
-        return this.control[runId];
-    }
-    isLocked(runId) {
-        return this.control[runId] != null;
-    }
-    lock(runId) {
-        if (this.control[runId] != null) {
-            logger.warn("Run already locked", { run_id: runId });
-        }
-        this.control[runId] = new CancellationAbortController();
-        return this.control[runId].signal;
-    }
-    unlock(runId) {
-        delete this.control[runId];
-    }
-}
-export const StreamManager = new StreamManagerImpl();
-const isObject = (value) => {
-    return typeof value === "object" && value !== null;
-};
-const isJsonbContained = (superset, subset) => {
-    if (superset == null || subset == null)
-        return true;
-    for (const [key, value] of Object.entries(subset)) {
-        if (superset[key] == null)
-            return false;
-        if (isObject(value) && isObject(superset[key])) {
-            if (!isJsonbContained(superset[key], value))
-                return false;
-        }
-        else if (superset[key] !== value) {
-            return false;
-        }
-    }
-    return true;
-};
-export class FileSystemAssistants {
-    conn;
-    constructor(conn) {
-        this.conn = conn;
-    }
-    async *search(options, auth) {
-        const [filters] = await handleAuthEvent(auth, "assistants:search", {
-            graph_id: options.graph_id,
-            metadata: options.metadata,
-            limit: options.limit,
-            offset: options.offset,
-        });
-        yield* this.conn.withGenerator(async function* (STORE) {
-            let filtered = Object.values(STORE.assistants)
-                .filter((assistant) => {
-                if (options.graph_id != null &&
-                    assistant["graph_id"] !== options.graph_id) {
-                    return false;
-                }
-                if (options.name != null &&
-                    !assistant["name"]
-                        .toLowerCase()
-                        .includes(options.name.toLowerCase())) {
-                    return false;
-                }
-                if (options.metadata != null &&
-                    !isJsonbContained(assistant["metadata"], options.metadata)) {
-                    return false;
-                }
-                if (!isAuthMatching(assistant["metadata"], filters)) {
-                    return false;
-                }
-                return true;
-            })
-                .sort((a, b) => {
-                const aCreatedAt = a["created_at"]?.getTime() ?? 0;
-                const bCreatedAt = b["created_at"]?.getTime() ?? 0;
-                return bCreatedAt - aCreatedAt;
-            });
-            // Calculate total count before pagination
-            const total = filtered.length;
-            for (const assistant of filtered.slice(options.offset, options.offset + options.limit)) {
-                yield {
-                    assistant: {
-                        ...assistant,
-                        name: assistant.name ?? assistant.graph_id,
-                    },
-                    total,
-                };
-            }
-        });
-    }
-    async get(assistant_id, auth) {
-        const [filters] = await handleAuthEvent(auth, "assistants:read", {
-            assistant_id,
-        });
-        return this.conn.with((STORE) => {
-            const result = STORE.assistants[assistant_id];
-            if (result == null)
-                throw new HTTPException(404, { message: "Assistant not found" });
-            if (!isAuthMatching(result["metadata"], filters)) {
-                throw new HTTPException(404, { message: "Assistant not found" });
-            }
-            return { ...result, name: result.name ?? result.graph_id };
-        });
-    }
-    async put(assistant_id, options, auth) {
-        const [filters, mutable] = await handleAuthEvent(auth, "assistants:create", {
-            assistant_id,
-            config: options.config,
-            context: options.context,
-            graph_id: options.graph_id,
-            metadata: options.metadata,
-            if_exists: options.if_exists,
-            name: options.name,
-            description: options.description,
-        });
-        return this.conn.with((STORE) => {
-            if (STORE.assistants[assistant_id] != null) {
-                const existingAssistant = STORE.assistants[assistant_id];
-                if (!isAuthMatching(existingAssistant?.metadata, filters)) {
-                    throw new HTTPException(409, { message: "Assistant already exists" });
-                }
-                if (options.if_exists === "raise") {
-                    throw new HTTPException(409, { message: "Assistant already exists" });
-                }
-                return existingAssistant;
-            }
-            const now = new Date();
-            STORE.assistants[assistant_id] ??= {
-                assistant_id: assistant_id,
-                version: 1,
-                config: options.config ?? {},
-                context: options.context ?? {},
-                created_at: now,
-                updated_at: now,
-                graph_id: options.graph_id,
-                metadata: mutable.metadata ?? {},
-                name: options.name || options.graph_id,
-                description: options.description ?? null,
-            };
-            STORE.assistant_versions.push({
-                assistant_id: assistant_id,
-                version: 1,
-                graph_id: options.graph_id,
-                config: options.config ?? {},
-                context: options.context ?? {},
-                metadata: mutable.metadata ?? {},
-                created_at: now,
-                name: options.name || options.graph_id,
-                description: options.description ?? null,
-            });
-            return STORE.assistants[assistant_id];
-        });
-    }
-    async patch(assistantId, options, auth) {
-        const [filters, mutable] = await handleAuthEvent(auth, "assistants:update", {
-            assistant_id: assistantId,
-            graph_id: options?.graph_id,
-            config: options?.config,
-            metadata: options?.metadata,
-            name: options?.name,
-            description: options?.description,
-        });
-        return this.conn.with((STORE) => {
-            const assistant = STORE.assistants[assistantId];
-            if (!assistant) {
-                throw new HTTPException(404, { message: "Assistant not found" });
-            }
-            if (!isAuthMatching(assistant["metadata"], filters)) {
-                throw new HTTPException(404, { message: "Assistant not found" });
-            }
-            const now = new Date();
-            const metadata = mutable.metadata != null
-                ? {
-                    ...assistant["metadata"],
-                    ...mutable.metadata,
-                }
-                : null;
-            if (options?.graph_id != null) {
-                assistant["graph_id"] = options?.graph_id ?? assistant["graph_id"];
-            }
-            if (options?.config != null) {
-                assistant["config"] = options?.config ?? assistant["config"];
-            }
-            if (options?.context != null) {
-                assistant["context"] = options?.context ?? assistant["context"];
-            }
-            if (options?.name != null) {
-                assistant["name"] = options?.name ?? assistant["name"];
-            }
-            if (options?.description != null) {
-                assistant["description"] =
-                    options?.description ?? assistant["description"];
-            }
-            if (metadata != null) {
-                assistant["metadata"] = metadata ?? assistant["metadata"];
-            }
-            assistant["updated_at"] = now;
-            const newVersion = Math.max(...STORE.assistant_versions
-                .filter((v) => v["assistant_id"] === assistantId)
-                .map((v) => v["version"])) + 1;
-            assistant.version = newVersion;
-            const newVersionEntry = {
-                assistant_id: assistantId,
-                version: newVersion,
-                graph_id: options?.graph_id ?? assistant["graph_id"],
-                config: options?.config ?? assistant["config"],
-                context: options?.context ?? assistant["context"],
-                name: options?.name ?? assistant["name"],
-                description: options?.description ?? assistant["description"],
-                metadata: metadata ?? assistant["metadata"],
-                created_at: now,
-            };
-            STORE.assistant_versions.push(newVersionEntry);
-            return assistant;
-        });
-    }
-    async delete(assistant_id, auth) {
-        const [filters] = await handleAuthEvent(auth, "assistants:delete", {
-            assistant_id,
-        });
-        return this.conn.with((STORE) => {
-            const assistant = STORE.assistants[assistant_id];
-            if (!assistant) {
-                throw new HTTPException(404, { message: "Assistant not found" });
-            }
-            if (!isAuthMatching(assistant["metadata"], filters)) {
-                throw new HTTPException(404, { message: "Assistant not found" });
-            }
-            delete STORE.assistants[assistant_id];
-            // Cascade delete for assistant versions and crons
-            STORE.assistant_versions = STORE.assistant_versions.filter((v) => v["assistant_id"] !== assistant_id);
-            for (const run of Object.values(STORE.runs)) {
-                if (run["assistant_id"] === assistant_id) {
-                    delete STORE.runs[run["run_id"]];
-                }
-            }
-            return [assistant.assistant_id];
-        });
-    }
-    async setLatest(assistant_id, version, auth) {
-        const [filters] = await handleAuthEvent(auth, "assistants:update", {
-            assistant_id,
-            version,
-        });
-        return this.conn.with((STORE) => {
-            const assistant = STORE.assistants[assistant_id];
-            if (!assistant) {
-                throw new HTTPException(404, { message: "Assistant not found" });
-            }
-            if (!isAuthMatching(assistant["metadata"], filters)) {
-                throw new HTTPException(404, { message: "Assistant not found" });
-            }
-            const assistantVersion = STORE.assistant_versions.find((v) => v["assistant_id"] === assistant_id && v["version"] === version);
-            if (!assistantVersion)
-                throw new HTTPException(404, {
-                    message: "Assistant version not found",
-                });
-            const now = new Date();
-            STORE.assistants[assistant_id] = {
-                ...assistant,
-                config: assistantVersion["config"],
-                metadata: assistantVersion["metadata"],
-                version: assistantVersion["version"],
-                name: assistantVersion["name"],
-                updated_at: now,
-            };
-            return STORE.assistants[assistant_id];
-        });
-    }
-    async getVersions(assistant_id, options, auth) {
-        const [filters] = await handleAuthEvent(auth, "assistants:read", {
-            assistant_id,
-        });
-        return this.conn.with((STORE) => {
-            const versions = STORE.assistant_versions
-                .filter((version) => {
-                if (version["assistant_id"] !== assistant_id)
-                    return false;
-                if (options.metadata != null &&
-                    !isJsonbContained(version["metadata"], options.metadata)) {
-                    return false;
-                }
-                if (!isAuthMatching(version["metadata"], filters)) {
-                    return false;
-                }
-                return true;
-            })
-                .sort((a, b) => b["version"] - a["version"]);
-            return versions.slice(options.offset, options.offset + options.limit);
-        });
-    }
-    async count(options, auth) {
-        const [filters] = await handleAuthEvent(auth, "assistants:search", {
-            graph_id: options.graph_id,
-            metadata: options.metadata,
-            limit: 0,
-            offset: 0,
-        });
-        return this.conn.with((STORE) => {
-            return Object.values(STORE.assistants).filter((assistant) => {
-                if (options.graph_id != null &&
-                    assistant["graph_id"] !== options.graph_id) {
-                    return false;
-                }
-                if (options.name != null &&
-                    !assistant["name"].toLowerCase().includes(options.name.toLowerCase())) {
-                    return false;
-                }
-                if (options.metadata != null &&
-                    !isJsonbContained(assistant["metadata"], options.metadata)) {
-                    return false;
-                }
-                if (!isAuthMatching(assistant["metadata"], filters)) {
-                    return false;
-                }
-                return true;
-            }).length;
-        });
-    }
-}
-export class FileSystemThreads {
-    conn;
-    state;
-    constructor(conn) {
-        this.conn = conn;
-        this.state = new FileSystemThreads.State(conn, this);
-    }
-    async *search(options, auth) {
-        const [filters] = await handleAuthEvent(auth, "threads:search", {
-            metadata: options.metadata,
-            ids: options.ids,
-            status: options.status,
-            values: options.values,
-            limit: options.limit,
-            offset: options.offset,
-        });
-        yield* this.conn.withGenerator(async function* (STORE) {
-            const filtered = Object.values(STORE.threads)
-                .filter((thread) => {
-                if (options.ids != null && options.ids.length > 0) {
-                    if (!options.ids.includes(thread["thread_id"]))
-                        return false;
-                }
-                if (options.metadata != null &&
-                    !isJsonbContained(thread["metadata"], options.metadata))
-                    return false;
-                if (options.values != null &&
-                    typeof thread["values"] !== "undefined" &&
-                    !isJsonbContained(thread["values"], options.values))
-                    return false;
-                if (options.status != null && thread["status"] !== options.status)
-                    return false;
-                if (!isAuthMatching(thread["metadata"], filters))
-                    return false;
-                return true;
-            })
-                .sort((a, b) => {
-                const sortBy = options.sort_by ?? "created_at";
-                const sortOrder = options.sort_order ?? "desc";
-                if (sortBy === "created_at" || sortBy === "updated_at") {
-                    const aTime = a[sortBy].getTime();
-                    const bTime = b[sortBy].getTime();
-                    return sortOrder === "desc" ? bTime - aTime : aTime - bTime;
-                }
-                if (sortBy === "thread_id" || sortBy === "status") {
-                    const aVal = a[sortBy];
-                    const bVal = b[sortBy];
-                    return sortOrder === "desc"
-                        ? bVal.localeCompare(aVal)
-                        : aVal.localeCompare(bVal);
-                }
-                return 0;
-            });
-            // Calculate total count before pagination
-            const total = filtered.length;
-            for (const thread of filtered.slice(options.offset, options.offset + options.limit)) {
-                yield { thread, total };
-            }
-        });
-    }
-    // TODO: make this accept `undefined`
-    async get(thread_id, auth) {
-        const [filters] = await handleAuthEvent(auth, "threads:read", {
-            thread_id,
-        });
-        return this.conn.with((STORE) => {
-            const result = STORE.threads[thread_id];
-            if (result == null) {
-                throw new HTTPException(404, {
-                    message: `Thread with ID ${thread_id} not found`,
-                });
-            }
-            if (!isAuthMatching(result["metadata"], filters)) {
-                throw new HTTPException(404, {
-                    message: `Thread with ID ${thread_id} not found`,
-                });
-            }
-            return result;
-        });
-    }
-    async put(thread_id, options, auth) {
-        const [filters, mutable] = await handleAuthEvent(auth, "threads:create", {
-            thread_id,
-            metadata: options.metadata,
-            if_exists: options.if_exists,
-        });
-        return this.conn.with((STORE) => {
-            const now = new Date();
-            if (STORE.threads[thread_id] != null) {
-                const existingThread = STORE.threads[thread_id];
-                if (!isAuthMatching(existingThread["metadata"], filters)) {
-                    throw new HTTPException(409, { message: "Thread already exists" });
-                }
-                if (options?.if_exists === "raise") {
-                    throw new HTTPException(409, { message: "Thread already exists" });
-                }
-                return existingThread;
-            }
-            STORE.threads[thread_id] ??= {
-                thread_id: thread_id,
-                created_at: now,
-                updated_at: now,
-                metadata: mutable?.metadata ?? {},
-                status: "idle",
-                config: {},
-                values: undefined,
-            };
-            return STORE.threads[thread_id];
-        });
-    }
-    async patch(threadId, options, auth) {
-        const [filters, mutable] = await handleAuthEvent(auth, "threads:update", {
-            thread_id: threadId,
-            metadata: options.metadata,
-        });
-        return this.conn.with((STORE) => {
-            const thread = STORE.threads[threadId];
-            if (!thread) {
-                throw new HTTPException(404, { message: "Thread not found" });
-            }
-            if (!isAuthMatching(thread["metadata"], filters)) {
-                // TODO: is this correct status code?
-                throw new HTTPException(404, { message: "Thread not found" });
-            }
-            const now = new Date();
-            if (mutable.metadata != null) {
-                thread["metadata"] = {
-                    ...thread["metadata"],
-                    ...mutable.metadata,
-                };
-            }
-            thread["updated_at"] = now;
-            return thread;
-        });
-    }
-    async setStatus(threadId, options) {
-        return this.conn.with((STORE) => {
-            const thread = STORE.threads[threadId];
-            if (!thread)
-                throw new HTTPException(404, { message: "Thread not found" });
-            let hasNext = false;
-            if (options.checkpoint != null) {
-                hasNext = options.checkpoint.next.length > 0;
-            }
-            const hasPendingRuns = Object.values(STORE.runs).some((run) => run["thread_id"] === threadId && run["status"] === "pending");
-            let status = "idle";
-            if (options.exception != null) {
-                status = "error";
-            }
-            else if (hasNext) {
-                status = "interrupted";
-            }
-            else if (hasPendingRuns) {
-                status = "busy";
-            }
-            const now = new Date();
-            thread.updated_at = now;
-            thread.status = status;
-            thread.values =
-                options.checkpoint != null ? options.checkpoint.values : undefined;
-            thread.interrupts =
-                options.checkpoint != null
-                    ? options.checkpoint.tasks.reduce((acc, task) => {
-                        if (task.interrupts)
-                            acc[task.id] = task.interrupts;
-                        return acc;
-                    }, {})
-                    : undefined;
-        });
-    }
-    async delete(thread_id, auth) {
-        const [filters] = await handleAuthEvent(auth, "threads:delete", {
-            thread_id,
-        });
-        return this.conn.with((STORE) => {
-            const thread = STORE.threads[thread_id];
-            if (!thread) {
-                throw new HTTPException(404, {
-                    message: `Thread with ID ${thread_id} not found`,
-                });
-            }
-            if (!isAuthMatching(thread["metadata"], filters)) {
-                throw new HTTPException(404, {
-                    message: `Thread with ID ${thread_id} not found`,
-                });
-            }
-            delete STORE.threads[thread_id];
-            for (const run of Object.values(STORE.runs)) {
-                if (run["thread_id"] === thread_id) {
-                    delete STORE.runs[run["run_id"]];
-                }
-            }
-            checkpointer.delete(thread_id, null);
-            return [thread.thread_id];
-        });
-    }
-    async copy(thread_id, auth) {
-        const [filters] = await handleAuthEvent(auth, "threads:read", {
-            thread_id,
-        });
-        const fromThread = await this.conn.with((STORE) => {
-            const thread = STORE.threads[thread_id];
-            if (!thread)
-                throw new HTTPException(409, { message: "Thread not found" });
-            if (!isAuthMatching(thread["metadata"], filters)) {
-                throw new HTTPException(409, { message: "Thread not found" });
-            }
-            return thread;
-        });
-        const newThreadId = uuid4();
-        const now = new Date();
-        const newMetadata = { ...fromThread.metadata, thread_id: newThreadId };
-        await handleAuthEvent(auth, "threads:create", {
-            thread_id: newThreadId,
-            metadata: newMetadata,
-        });
-        return this.conn.with((STORE) => {
-            STORE.threads[newThreadId] = {
-                thread_id: newThreadId,
-                created_at: now,
-                updated_at: now,
-                metadata: newMetadata,
-                config: {},
-                status: "idle",
-            };
-            checkpointer.copy(thread_id, newThreadId);
-            return STORE.threads[newThreadId];
-        });
-    }
-    async count(options, auth) {
-        const [filters] = await handleAuthEvent(auth, "threads:search", {
-            metadata: options.metadata,
-            values: options.values,
-            status: options.status,
-            limit: 0,
-            offset: 0,
-        });
-        return this.conn.with((STORE) => {
-            return Object.values(STORE.threads).filter((thread) => {
-                if (options.metadata != null &&
-                    !isJsonbContained(thread["metadata"], options.metadata)) {
-                    return false;
-                }
-                if (options.values != null &&
-                    typeof thread["values"] !== "undefined" &&
-                    !isJsonbContained(thread["values"], options.values)) {
-                    return false;
-                }
-                if (options.status != null && thread["status"] !== options.status) {
-                    return false;
-                }
-                if (!isAuthMatching(thread["metadata"], filters)) {
-                    return false;
-                }
-                return true;
-            }).length;
-        });
-    }
-    static State = class {
-        conn;
-        threads;
-        constructor(conn, threads) {
-            this.conn = conn;
-            this.threads = threads;
-        }
-        async get(config, options, auth) {
-            const subgraphs = options.subgraphs ?? false;
-            const threadId = config.configurable?.thread_id;
-            const thread = threadId
-                ? await this.threads.get(threadId, auth)
-                : undefined;
-            const metadata = thread?.metadata ?? {};
-            const graphId = metadata?.graph_id;
-            if (!thread || graphId == null) {
-                return {
-                    values: {},
-                    next: [],
-                    config: {},
-                    metadata: undefined,
-                    createdAt: undefined,
-                    parentConfig: undefined,
-                    tasks: [],
-                };
-            }
-            const graph = await getGraph(graphId, thread.config, {
-                checkpointer,
-                store,
-            });
-            const result = await graph.getState(config, { subgraphs });
-            if (result.metadata != null &&
-                "checkpoint_ns" in result.metadata &&
-                result.metadata["checkpoint_ns"] === "") {
-                delete result.metadata["checkpoint_ns"];
-            }
-            return result;
-        }
-        async post(config, values, asNode, auth) {
-            const threadId = config.configurable?.thread_id;
-            const [filters] = await handleAuthEvent(auth, "threads:update", {
-                thread_id: threadId,
-            });
-            const thread = threadId
-                ? await this.threads.get(threadId, auth)
-                : undefined;
-            if (!thread)
-                throw new HTTPException(404, {
-                    message: `Thread ${threadId} not found`,
-                });
-            if (!isAuthMatching(thread["metadata"], filters)) {
-                throw new HTTPException(403);
-            }
-            // do a check if there are no pending runs
-            await this.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, {
-                    message: `Thread ${threadId} has no graph ID`,
-                });
-            }
-            config.configurable ??= {};
-            config.configurable.graph_id ??= graphId;
-            const graph = await getGraph(graphId, thread.config, {
-                checkpointer,
-                store,
-            });
-            const updateConfig = structuredClone(config);
-            updateConfig.configurable ??= {};
-            updateConfig.configurable.checkpoint_ns ??= "";
-            const nextConfig = await graph.updateState(updateConfig, values, asNode);
-            const state = await this.get(config, { subgraphs: false }, auth);
-            // update thread values
-            await this.conn.with(async (STORE) => {
-                for (const thread of Object.values(STORE.threads)) {
-                    if (thread.thread_id === threadId) {
-                        thread.values = state.values;
-                        break;
-                    }
-                }
-            });
-            return { checkpoint: nextConfig.configurable };
-        }
-        async bulk(config, supersteps, auth) {
-            const threadId = config.configurable?.thread_id;
-            if (!threadId)
-                return [];
-            const [filters] = await handleAuthEvent(auth, "threads:update", {
-                thread_id: threadId,
-            });
-            const thread = await this.threads.get(threadId, auth);
-            if (!isAuthMatching(thread["metadata"], filters)) {
-                throw new HTTPException(403);
-            }
-            const graphId = thread.metadata?.graph_id;
-            if (graphId == null) {
-                throw new HTTPException(400, {
-                    message: `Thread ${threadId} has no graph ID`,
-                });
-            }
-            config.configurable ??= {};
-            config.configurable.graph_id ??= graphId;
-            const graph = await getGraph(graphId, thread.config, {
-                checkpointer,
-                store,
-            });
-            const updateConfig = structuredClone(config);
-            updateConfig.configurable ??= {};
-            updateConfig.configurable.checkpoint_ns ??= "";
-            const nextConfig = await graph.bulkUpdateState(updateConfig, supersteps.map((i) => ({
-                updates: i.updates.map((j) => ({
-                    values: j.command != null ? getLangGraphCommand(j.command) : j.values,
-                    asNode: j.as_node,
-                })),
-            })));
-            const state = await this.get(config, { subgraphs: false }, auth);
-            // update thread values
-            await this.conn.with(async (STORE) => {
-                for (const thread of Object.values(STORE.threads)) {
-                    if (thread.thread_id === threadId) {
-                        thread.values = state.values;
-                        break;
-                    }
-                }
-            });
-            return { checkpoint: nextConfig.configurable };
-        }
-        async list(config, options, auth) {
-            const threadId = config.configurable?.thread_id;
-            if (!threadId)
-                return [];
-            const [filters] = await handleAuthEvent(auth, "threads:read", {
-                thread_id: threadId,
-            });
-            const thread = await this.threads.get(threadId, auth);
-            if (!isAuthMatching(thread["metadata"], filters))
-                return [];
-            const graphId = thread.metadata?.graph_id;
-            if (graphId == null)
-                return [];
-            const graph = await getGraph(graphId, thread.config, {
-                checkpointer,
-                store,
-            });
-            const before = typeof options?.before === "string"
-                ? { configurable: { checkpoint_id: options.before } }
-                : options?.before;
-            const states = [];
-            for await (const state of graph.getStateHistory(config, {
-                limit: options?.limit ?? 10,
-                before,
-                filter: options?.metadata,
-            })) {
-                states.push(state);
-            }
-            return states;
-        }
-    };
-}
-export class FileSystemRuns {
-    conn;
-    threads;
-    stream;
-    constructor(conn) {
-        this.conn = conn;
-        this.threads = new FileSystemThreads(conn);
-        this.stream = new FileSystemRuns.Stream(conn, this);
-    }
-    async *next() {
-        yield* this.conn.withGenerator(async function* (STORE, options) {
-            const now = new Date();
-            const pendingRunIds = Object.values(STORE.runs)
-                .filter((run) => run.status === "pending" && run.created_at < now)
-                .sort((a, b) => a.created_at.getTime() - b.created_at.getTime())
-                .map((run) => run.run_id);
-            if (!pendingRunIds.length) {
-                return;
-            }
-            for (const runId of pendingRunIds) {
-                if (StreamManager.isLocked(runId))
-                    continue;
-                try {
-                    const signal = StreamManager.lock(runId);
-                    const run = STORE.runs[runId];
-                    if (!run)
-                        continue;
-                    const threadId = run.thread_id;
-                    const thread = STORE.threads[threadId];
-                    if (!thread) {
-                        logger.warn(`Unexpected missing thread in Runs.next: ${threadId}`);
-                        continue;
-                    }
-                    // is the run still valid?
-                    if (run.status !== "pending")
-                        continue;
-                    if (Object.values(STORE.runs).some((run) => run.thread_id === threadId && run.status === "running")) {
-                        continue;
-                    }
-                    options.schedulePersist();
-                    STORE.retry_counter[runId] ??= 0;
-                    STORE.retry_counter[runId] += 1;
-                    STORE.runs[runId].status = "running";
-                    yield { run, attempt: STORE.retry_counter[runId], signal };
-                }
-                finally {
-                    StreamManager.unlock(runId);
-                }
-            }
-        });
-    }
-    async put(runId, assistantId, kwargs, options, auth) {
-        return this.conn.with(async (STORE) => {
-            const assistant = STORE.assistants[assistantId];
-            if (!assistant) {
-                throw new HTTPException(404, {
-                    message: `No assistant found for "${assistantId}". Make sure the assistant ID is for a valid assistant or a valid graph ID.`,
-                });
-            }
-            const ifNotExists = options?.ifNotExists ?? "reject";
-            const multitaskStrategy = options?.multitaskStrategy ?? "reject";
-            const afterSeconds = options?.afterSeconds ?? 0;
-            const status = options?.status ?? "pending";
-            let threadId = options?.threadId;
-            const [filters, mutable] = await handleAuthEvent(auth, "threads:create_run", {
-                thread_id: threadId,
-                assistant_id: assistantId,
-                run_id: runId,
-                status: status,
-                metadata: options?.metadata ?? {},
-                prevent_insert_if_inflight: options?.preventInsertInInflight,
-                multitask_strategy: multitaskStrategy,
-                if_not_exists: ifNotExists,
-                after_seconds: afterSeconds,
-                kwargs,
-            });
-            const metadata = mutable.metadata ?? {};
-            const config = kwargs.config ?? {};
-            const existingThread = Object.values(STORE.threads).find((thread) => thread.thread_id === threadId);
-            if (existingThread &&
-                !isAuthMatching(existingThread["metadata"], filters)) {
-                throw new HTTPException(404);
-            }
-            const now = new Date();
-            if (!existingThread && (threadId == null || ifNotExists === "create")) {
-                threadId ??= uuid4();
-                const thread = {
-                    thread_id: threadId,
-                    status: "busy",
-                    metadata: {
-                        graph_id: assistant.graph_id,
-                        assistant_id: assistantId,
-                        ...metadata,
-                    },
-                    config: Object.assign({}, assistant.config, config, {
-                        configurable: Object.assign({}, assistant.config?.configurable, config?.configurable),
-                    }),
-                    created_at: now,
-                    updated_at: now,
-                };
-                STORE.threads[threadId] = thread;
-            }
-            else if (existingThread) {
-                if (existingThread.status !== "busy") {
-                    existingThread.status = "busy";
-                    existingThread.metadata = Object.assign({}, existingThread.metadata, {
-                        graph_id: assistant.graph_id,
-                        assistant_id: assistantId,
-                    });
-                    existingThread.config = Object.assign({}, assistant.config, existingThread.config, config, {
-                        configurable: Object.assign({}, assistant.config?.configurable, existingThread?.config?.configurable, config?.configurable),
-                    });
-                    existingThread.updated_at = now;
-                }
-            }
-            else {
-                return [];
-            }
-            // if multitask_mode = reject, check for inflight runs
-            // and if there are any, return them to reject putting a new run
-            const inflightRuns = Object.values(STORE.runs).filter((run) => run.thread_id === threadId &&
-                (run.status === "pending" || run.status === "running"));
-            if (options?.preventInsertInInflight) {
-                if (inflightRuns.length > 0)
-                    return inflightRuns;
-            }
-            // create new run
-            const configurable = Object.assign({}, assistant.config?.configurable, existingThread?.config?.configurable, config?.configurable, {
-                run_id: runId,
-                thread_id: threadId,
-                graph_id: assistant.graph_id,
-                assistant_id: assistantId,
-                user_id: config.configurable?.user_id ??
-                    existingThread?.config?.configurable?.user_id ??
-                    assistant.config?.configurable?.user_id ??
-                    options?.userId,
-            });
-            const mergedMetadata = Object.assign({}, assistant.metadata, existingThread?.metadata, metadata);
-            const newRun = {
-                run_id: runId,
-                thread_id: threadId,
-                assistant_id: assistantId,
-                metadata: mergedMetadata,
-                status: status,
-                kwargs: Object.assign({}, kwargs, {
-                    config: Object.assign({}, assistant.config, config, { configurable }, { metadata: mergedMetadata }),
-                    context: typeof assistant.context !== "object" && assistant.context != null
-                        ? assistant.context ?? kwargs.context
-                        : Object.assign({}, assistant.context, kwargs.context),
-                }),
-                multitask_strategy: multitaskStrategy,
-                created_at: new Date(now.valueOf() + afterSeconds * 1000),
-                updated_at: now,
-            };
-            STORE.runs[runId] = newRun;
-            return [newRun, ...inflightRuns];
-        });
-    }
-    async get(runId, thread_id, auth) {
-        const [filters] = await handleAuthEvent(auth, "threads:read", {
-            thread_id,
-        });
-        return this.conn.with(async (STORE) => {
-            const run = STORE.runs[runId];
-            if (!run ||
-                run.run_id !== runId ||
-                (thread_id != null && run.thread_id !== thread_id))
-                return null;
-            if (filters != null) {
-                const thread = STORE.threads[run.thread_id];
-                if (!isAuthMatching(thread["metadata"], filters))
-                    return null;
-            }
-            return run;
-        });
-    }
-    async delete(run_id, thread_id, auth) {
-        const [filters] = await handleAuthEvent(auth, "threads:delete", {
-            run_id,
-            thread_id,
-        });
-        return this.conn.with(async (STORE) => {
-            const run = STORE.runs[run_id];
-            if (!run || (thread_id != null && run.thread_id !== thread_id))
-                throw new HTTPException(404, { message: "Run not found" });
-            if (filters != null) {
-                const thread = STORE.threads[run.thread_id];
-                if (!isAuthMatching(thread["metadata"], filters)) {
-                    throw new HTTPException(404, { message: "Run not found" });
-                }
-            }
-            if (thread_id != null)
-                checkpointer.delete(thread_id, run_id);
-            delete STORE.runs[run_id];
-            return run.run_id;
-        });
-    }
-    async wait(runId, threadId, auth) {
-        const runStream = this.stream.join(runId, threadId, { ignore404: threadId == null, lastEventId: undefined }, auth);
-        const lastChunk = new Promise(async (resolve, reject) => {
-            try {
-                let lastChunk = null;
-                for await (const { event, data } of runStream) {
-                    if (event === "values") {
-                        lastChunk = data;
-                    }
-                    else if (event === "error") {
-                        lastChunk = { __error__: serializeError(data) };
-                    }
-                }
-                resolve(lastChunk);
-            }
-            catch (error) {
-                reject(error);
-            }
-        });
-        return lastChunk;
-    }
-    async join(runId, threadId, auth) {
-        // check if thread exists
-        await this.threads.get(threadId, auth);
-        const lastChunk = await this.wait(runId, threadId, auth);
-        if (lastChunk != null)
-            return lastChunk;
-        const thread = await this.threads.get(threadId, auth);
-        return thread.values ?? null;
-    }
-    async cancel(threadId, runIds, options, auth) {
-        return this.conn.with(async (STORE) => {
-            const action = options.action ?? "interrupt";
-            const promises = [];
-            const [filters] = await handleAuthEvent(auth, "threads:update", {
-                thread_id: threadId,
-                action,
-                metadata: { run_ids: runIds, status: "pending" },
-            });
-            let foundRunsCount = 0;
-            for (const runId of runIds) {
-                const run = STORE.runs[runId];
-                if (!run || (threadId != null && run.thread_id !== threadId))
-                    continue;
-                if (filters != null) {
-                    const thread = STORE.threads[run.thread_id];
-                    if (!isAuthMatching(thread["metadata"], filters))
-                        continue;
-                }
-                foundRunsCount += 1;
-                // send cancellation message
-                const control = StreamManager.getControl(runId);
-                control?.abort(options.action ?? "interrupt");
-                if (run.status === "pending") {
-                    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", {
-                            run_id: runId,
-                            thread_id: threadId,
-                        });
-                        promises.push(this.delete(runId, threadId, auth));
-                    }
-                }
-                else {
-                    logger.warn("Attempted to cancel non-pending run.", {
-                        run_id: runId,
-                        status: run.status,
-                    });
-                }
-            }
-            await Promise.all(promises);
-            if (foundRunsCount === runIds.length) {
-                logger.info("Cancelled runs", {
-                    run_ids: runIds,
-                    thread_id: threadId,
-                    action,
-                });
-            }
-            else {
-                throw new HTTPException(404, { message: "Run not found" });
-            }
-        });
-    }
-    async search(threadId, options, auth) {
-        const [filters] = await handleAuthEvent(auth, "threads:search", {
-            thread_id: threadId,
-            metadata: options.metadata,
-            status: options.status,
-        });
-        return this.conn.with(async (STORE) => {
-            const runs = Object.values(STORE.runs).filter((run) => {
-                if (run.thread_id !== threadId)
-                    return false;
-                if (options?.status != null && run.status !== options.status)
-                    return false;
-                if (options?.metadata != null &&
-                    !isJsonbContained(run.metadata, options.metadata))
-                    return false;
-                if (filters != null) {
-                    const thread = STORE.threads[run.thread_id];
-                    if (!isAuthMatching(thread["metadata"], filters))
-                        return false;
-                }
-                return true;
-            });
-            return runs.slice(options?.offset ?? 0, options?.limit ?? 10);
-        });
-    }
-    async setStatus(runId, status) {
-        return this.conn.with(async (STORE) => {
-            const run = STORE.runs[runId];
-            if (!run)
-                throw new Error(`Run ${runId} not found`);
-            run.status = status;
-            run.updated_at = new Date();
-        });
-    }
-    static Stream = class {
-        conn;
-        runs;
-        constructor(conn, runs) {
-            this.conn = conn;
-            this.runs = runs;
-        }
-        async *join(runId, threadId, options, auth) {
-            const conn = this.conn;
-            const runs = this.runs;
-            yield* conn.withGenerator(async function* (STORE) {
-                // TODO: what if we're joining an already completed run? Should we check before?
-                const signal = options?.cancelOnDisconnect;
-                const queue = StreamManager.getQueue(runId, {
-                    ifNotFound: "create",
-                    resumable: options.lastEventId != null,
-                });
-                const [filters] = await handleAuthEvent(auth, "threads:read", {
-                    thread_id: threadId,
-                });
-                // TODO: consolidate into a single function
-                if (filters != null && threadId != null) {
-                    const thread = STORE.threads[threadId];
-                    if (!isAuthMatching(thread["metadata"], filters)) {
-                        yield {
-                            event: "error",
-                            data: { error: "Error", message: "404: Thread not found" },
-                        };
-                        return;
-                    }
-                }
-                let lastEventId = options?.lastEventId;
-                while (!signal?.aborted) {
-                    try {
-                        const [id, message] = await queue.get({
-                            timeout: 500,
-                            signal,
-                            lastEventId,
-                        });
-                        lastEventId = id;
-                        if (message.topic === `run:${runId}:control`) {
-                            if (message.data === "done")
-                                break;
-                        }
-                        else {
-                            const streamTopic = message.topic.substring(`run:${runId}:stream:`.length);
-                            yield { id, event: streamTopic, data: message.data };
-                        }
-                    }
-                    catch (error) {
-                        if (error instanceof AbortError)
-                            break;
-                        const run = await runs.get(runId, threadId, auth);
-                        if (run == null) {
-                            if (!options?.ignore404)
-                                yield { event: "error", data: "Run not found" };
-                            break;
-                        }
-                        else if (run.status !== "pending" && run.status !== "running") {
-                            break;
-                        }
-                    }
-                }
-                if (signal?.aborted && threadId != null) {
-                    await runs.cancel(threadId, [runId], { action: "interrupt" }, auth);
-                }
-            });
-        }
-        async publish(payload) {
-            const queue = StreamManager.getQueue(payload.runId, {
-                ifNotFound: "create",
-                resumable: payload.resumable,
-            });
-            queue.push({
-                topic: `run:${payload.runId}:stream:${payload.event}`,
-                data: payload.data,
-            });
-        }
-    };
-}
-export class Crons {
-}