@langchain/langgraph-api 0.0.59 → 0.0.61

package/dist/storage/ops.mjs

@@ -1,20 +1,40 @@
 import { HTTPException } from "hono/http-exception";
 import { v4 as uuid4, v5 as uuid5 } from "uuid";
-import { handleAuthEvent, isAuthMatching } from "../auth/custom.mjs";
+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 { FileSystemPersistence } from "./persist.mjs";
 import { store } from "./store.mjs";
-export const conn = new FileSystemPersistence(".langgraphjs_ops.json", () => ({
-    runs: {},
-    threads: {},
-    assistants: {},
-    assistant_versions: [],
-    retry_counter: {},
-}));
+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 {
@@ -113,22 +133,6 @@ class StreamManagerImpl {
     }
 }
 export const StreamManager = new StreamManagerImpl();
-export const truncate = (flags) => {
-    return 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();
-    });
-};
 const isObject = (value) => {
     return typeof value === "object" && value !== null;
 };
@@ -148,15 +152,19 @@ const isJsonbContained = (superset, subset) => {
     }
     return true;
 };
-export class Assistants {
-    static async *search(options, auth) {
+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* conn.withGenerator(async function* (STORE) {
+        yield* this.conn.withGenerator(async function* (STORE) {
             let filtered = Object.values(STORE.assistants)
                 .filter((assistant) => {
                 if (options.graph_id != null &&
@@ -190,11 +198,11 @@ export class Assistants {
             }
         });
     }
-    static async get(assistant_id, auth) {
+    async get(assistant_id, auth) {
         const [filters] = await handleAuthEvent(auth, "assistants:read", {
             assistant_id,
         });
-        return conn.with((STORE) => {
+        return this.conn.with((STORE) => {
             const result = STORE.assistants[assistant_id];
             if (result == null)
                 throw new HTTPException(404, { message: "Assistant not found" });
@@ -204,7 +212,7 @@ export class Assistants {
             return { ...result, name: result.name ?? result.graph_id };
         });
     }
-    static async put(assistant_id, options, auth) {
+    async put(assistant_id, options, auth) {
         const [filters, mutable] = await handleAuthEvent(auth, "assistants:create", {
             assistant_id,
             config: options.config,
@@ -214,7 +222,7 @@ export class Assistants {
             if_exists: options.if_exists,
             name: options.name,
         });
-        return conn.with((STORE) => {
+        return this.conn.with((STORE) => {
             if (STORE.assistants[assistant_id] != null) {
                 const existingAssistant = STORE.assistants[assistant_id];
                 if (!isAuthMatching(existingAssistant?.metadata, filters)) {
@@ -250,7 +258,7 @@ export class Assistants {
             return STORE.assistants[assistant_id];
         });
     }
-    static async patch(assistantId, options, auth) {
+    async patch(assistantId, options, auth) {
         const [filters, mutable] = await handleAuthEvent(auth, "assistants:update", {
             assistant_id: assistantId,
             graph_id: options?.graph_id,
@@ -258,7 +266,7 @@ export class Assistants {
             metadata: options?.metadata,
             name: options?.name,
         });
-        return conn.with((STORE) => {
+        return this.conn.with((STORE) => {
             const assistant = STORE.assistants[assistantId];
             if (!assistant) {
                 throw new HTTPException(404, { message: "Assistant not found" });
@@ -307,11 +315,11 @@ export class Assistants {
             return assistant;
         });
     }
-    static async delete(assistant_id, auth) {
+    async delete(assistant_id, auth) {
         const [filters] = await handleAuthEvent(auth, "assistants:delete", {
             assistant_id,
         });
-        return conn.with((STORE) => {
+        return this.conn.with((STORE) => {
             const assistant = STORE.assistants[assistant_id];
             if (!assistant) {
                 throw new HTTPException(404, { message: "Assistant not found" });
@@ -330,12 +338,12 @@ export class Assistants {
             return [assistant.assistant_id];
         });
     }
-    static async setLatest(assistant_id, version, auth) {
+    async setLatest(assistant_id, version, auth) {
         const [filters] = await handleAuthEvent(auth, "assistants:update", {
             assistant_id,
             version,
         });
-        return conn.with((STORE) => {
+        return this.conn.with((STORE) => {
             const assistant = STORE.assistants[assistant_id];
             if (!assistant) {
                 throw new HTTPException(404, { message: "Assistant not found" });
@@ -360,11 +368,11 @@ export class Assistants {
             return STORE.assistants[assistant_id];
         });
     }
-    static async getVersions(assistant_id, options, auth) {
+    async getVersions(assistant_id, options, auth) {
         const [filters] = await handleAuthEvent(auth, "assistants:read", {
             assistant_id,
         });
-        return conn.with((STORE) => {
+        return this.conn.with((STORE) => {
             const versions = STORE.assistant_versions
                 .filter((version) => {
                 if (version["assistant_id"] !== assistant_id)
@@ -382,9 +390,39 @@ export class Assistants {
             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.metadata != null &&
+                    !isJsonbContained(assistant["metadata"], options.metadata)) {
+                    return false;
+                }
+                if (!isAuthMatching(assistant["metadata"], filters)) {
+                    return false;
+                }
+                return true;
+            }).length;
+        });
+    }
 }
-export class Threads {
-    static async *search(options, auth) {
+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,
             status: options.status,
@@ -392,7 +430,7 @@ export class Threads {
             limit: options.limit,
             offset: options.offset,
         });
-        yield* conn.withGenerator(async function* (STORE) {
+        yield* this.conn.withGenerator(async function* (STORE) {
             const filtered = Object.values(STORE.threads)
                 .filter((thread) => {
                 if (options.metadata != null &&
@@ -433,11 +471,11 @@ export class Threads {
         });
     }
     // TODO: make this accept `undefined`
-    static async get(thread_id, auth) {
+    async get(thread_id, auth) {
         const [filters] = await handleAuthEvent(auth, "threads:read", {
             thread_id,
         });
-        return conn.with((STORE) => {
+        return this.conn.with((STORE) => {
             const result = STORE.threads[thread_id];
             if (result == null) {
                 throw new HTTPException(404, {
@@ -452,13 +490,13 @@ export class Threads {
             return result;
         });
     }
-    static async put(thread_id, options, auth) {
+    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 conn.with((STORE) => {
+        return this.conn.with((STORE) => {
             const now = new Date();
             if (STORE.threads[thread_id] != null) {
                 const existingThread = STORE.threads[thread_id];
@@ -482,12 +520,12 @@ export class Threads {
             return STORE.threads[thread_id];
         });
     }
-    static async patch(threadId, options, auth) {
+    async patch(threadId, options, auth) {
         const [filters, mutable] = await handleAuthEvent(auth, "threads:update", {
             thread_id: threadId,
             metadata: options.metadata,
         });
-        return conn.with((STORE) => {
+        return this.conn.with((STORE) => {
             const thread = STORE.threads[threadId];
             if (!thread) {
                 throw new HTTPException(404, { message: "Thread not found" });
@@ -507,8 +545,8 @@ export class Threads {
             return thread;
         });
     }
-    static async setStatus(threadId, options) {
-        return conn.with((STORE) => {
+    async setStatus(threadId, options) {
+        return this.conn.with((STORE) => {
             const thread = STORE.threads[threadId];
             if (!thread)
                 throw new HTTPException(404, { message: "Thread not found" });
@@ -542,11 +580,11 @@ export class Threads {
                     : undefined;
         });
     }
-    static async delete(thread_id, auth) {
+    async delete(thread_id, auth) {
         const [filters] = await handleAuthEvent(auth, "threads:delete", {
             thread_id,
         });
-        return conn.with((STORE) => {
+        return this.conn.with((STORE) => {
             const thread = STORE.threads[thread_id];
             if (!thread) {
                 throw new HTTPException(404, {
@@ -568,11 +606,11 @@ export class Threads {
             return [thread.thread_id];
         });
     }
-    static async copy(thread_id, auth) {
+    async copy(thread_id, auth) {
         const [filters] = await handleAuthEvent(auth, "threads:read", {
             thread_id,
         });
-        return conn.with((STORE) => {
+        return this.conn.with((STORE) => {
             const thread = STORE.threads[thread_id];
             if (!thread)
                 throw new HTTPException(409, { message: "Thread not found" });
@@ -593,11 +631,48 @@ export class Threads {
             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 {
-        static async get(config, options, auth) {
+        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 Threads.get(threadId, auth) : undefined;
+            const thread = threadId
+                ? await this.threads.get(threadId, auth)
+                : undefined;
             const metadata = thread?.metadata ?? {};
             const graphId = metadata?.graph_id;
             if (!thread || graphId == null) {
@@ -623,12 +698,14 @@ export class Threads {
             }
             return result;
         }
-        static async post(config, values, asNode, auth) {
+        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 Threads.get(threadId, auth) : undefined;
+            const thread = threadId
+                ? await this.threads.get(threadId, auth)
+                : undefined;
             if (!thread)
                 throw new HTTPException(404, {
                     message: `Thread ${threadId} not found`,
@@ -637,7 +714,7 @@ export class Threads {
                 throw new HTTPException(403);
             }
             // do a check if there are no pending runs
-            await conn.with(async (STORE) => {
+            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" });
@@ -659,9 +736,9 @@ export class Threads {
             updateConfig.configurable ??= {};
             updateConfig.configurable.checkpoint_ns ??= "";
             const nextConfig = await graph.updateState(updateConfig, values, asNode);
-            const state = await Threads.State.get(config, { subgraphs: false }, auth);
+            const state = await this.get(config, { subgraphs: false }, auth);
             // update thread values
-            await conn.with(async (STORE) => {
+            await this.conn.with(async (STORE) => {
                 for (const thread of Object.values(STORE.threads)) {
                     if (thread.thread_id === threadId) {
                         thread.values = state.values;
@@ -671,14 +748,14 @@ export class Threads {
             });
             return { checkpoint: nextConfig.configurable };
         }
-        static async bulk(config, supersteps, auth) {
+        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 Threads.get(threadId, auth);
+            const thread = await this.threads.get(threadId, auth);
             if (!isAuthMatching(thread["metadata"], filters)) {
                 throw new HTTPException(403);
             }
@@ -703,9 +780,9 @@ export class Threads {
                     asNode: j.as_node,
                 })),
             })));
-            const state = await Threads.State.get(config, { subgraphs: false }, auth);
+            const state = await this.get(config, { subgraphs: false }, auth);
             // update thread values
-            await conn.with(async (STORE) => {
+            await this.conn.with(async (STORE) => {
                 for (const thread of Object.values(STORE.threads)) {
                     if (thread.thread_id === threadId) {
                         thread.values = state.values;
@@ -715,14 +792,14 @@ export class Threads {
             });
             return { checkpoint: nextConfig.configurable };
         }
-        static async list(config, options, auth) {
+        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 Threads.get(threadId, auth);
+            const thread = await this.threads.get(threadId, auth);
             if (!isAuthMatching(thread["metadata"], filters))
                 return [];
             const graphId = thread.metadata?.graph_id;
@@ -747,9 +824,17 @@ export class Threads {
         }
     };
 }
-export class Runs {
-    static async *next() {
-        yield* conn.withGenerator(async function* (STORE, options) {
+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)
@@ -790,8 +875,8 @@ export class Runs {
             }
         });
     }
-    static async put(runId, assistantId, kwargs, options, auth) {
-        return conn.with(async (STORE) => {
+    async put(runId, assistantId, kwargs, options, auth) {
+        return this.conn.with(async (STORE) => {
             const assistant = STORE.assistants[assistantId];
             if (!assistant) {
                 throw new HTTPException(404, {
@@ -897,11 +982,11 @@ export class Runs {
             return [newRun, ...inflightRuns];
         });
     }
-    static async get(runId, thread_id, auth) {
+    async get(runId, thread_id, auth) {
         const [filters] = await handleAuthEvent(auth, "threads:read", {
             thread_id,
         });
-        return conn.with(async (STORE) => {
+        return this.conn.with(async (STORE) => {
             const run = STORE.runs[runId];
             if (!run ||
                 run.run_id !== runId ||
@@ -915,12 +1000,12 @@ export class Runs {
             return run;
         });
     }
-    static async delete(run_id, thread_id, auth) {
+    async delete(run_id, thread_id, auth) {
         const [filters] = await handleAuthEvent(auth, "threads:delete", {
             run_id,
             thread_id,
         });
-        return conn.with(async (STORE) => {
+        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" });
@@ -936,8 +1021,8 @@ export class Runs {
             return run.run_id;
         });
     }
-    static async wait(runId, threadId, auth) {
-        const runStream = Runs.Stream.join(runId, threadId, { ignore404: threadId == null, lastEventId: undefined }, auth);
+    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;
@@ -957,17 +1042,17 @@ export class Runs {
         });
         return lastChunk;
     }
-    static async join(runId, threadId, auth) {
+    async join(runId, threadId, auth) {
         // check if thread exists
-        await Threads.get(threadId, auth);
-        const lastChunk = await Runs.wait(runId, threadId, auth);
+        await this.threads.get(threadId, auth);
+        const lastChunk = await this.wait(runId, threadId, auth);
         if (lastChunk != null)
             return lastChunk;
-        const thread = await Threads.get(threadId, auth);
+        const thread = await this.threads.get(threadId, auth);
         return thread.values ?? null;
     }
-    static async cancel(threadId, runIds, options, auth) {
-        return conn.with(async (STORE) => {
+    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", {
@@ -1004,7 +1089,7 @@ export class Runs {
                             run_id: runId,
                             thread_id: threadId,
                         });
-                        promises.push(Runs.delete(runId, threadId, auth));
+                        promises.push(this.delete(runId, threadId, auth));
                     }
                 }
                 else {
@@ -1027,13 +1112,13 @@ export class Runs {
             }
         });
     }
-    static async search(threadId, options, auth) {
+    async search(threadId, options, auth) {
         const [filters] = await handleAuthEvent(auth, "threads:search", {
             thread_id: threadId,
             metadata: options.metadata,
             status: options.status,
         });
-        return conn.with(async (STORE) => {
+        return this.conn.with(async (STORE) => {
             const runs = Object.values(STORE.runs).filter((run) => {
                 if (run.thread_id !== threadId)
                     return false;
@@ -1052,8 +1137,8 @@ export class Runs {
             return runs.slice(options?.offset ?? 0, options?.limit ?? 10);
         });
     }
-    static async setStatus(runId, status) {
-        return conn.with(async (STORE) => {
+    async setStatus(runId, status) {
+        return this.conn.with(async (STORE) => {
             const run = STORE.runs[runId];
             if (!run)
                 throw new Error(`Run ${runId} not found`);
@@ -1062,7 +1147,15 @@ export class Runs {
         });
     }
     static Stream = class {
-        static async *join(runId, threadId, options, auth) {
+        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;
@@ -1105,7 +1198,7 @@ export class Runs {
                     catch (error) {
                         if (error instanceof AbortError)
                             break;
-                        const run = await Runs.get(runId, threadId, auth);
+                        const run = await runs.get(runId, threadId, auth);
                         if (run == null) {
                             if (!options?.ignore404)
                                 yield { event: "error", data: "Run not found" };
@@ -1117,11 +1210,11 @@ export class Runs {
                     }
                 }
                 if (signal?.aborted && threadId != null) {
-                    await Runs.cancel(threadId, [runId], { action: "interrupt" }, auth);
+                    await runs.cancel(threadId, [runId], { action: "interrupt" }, auth);
                 }
             });
         }
-        static async publish(payload) {
+        async publish(payload) {
             const queue = StreamManager.getQueue(payload.runId, {
                 ifNotFound: "create",
                 resumable: payload.resumable,