@langchain/langgraph-api 0.0.59 → 0.0.61

package/dist/server.d.mts

@@ -1,3 +1,4 @@
+import type { Ops } from "./storage/types.mjs";
 import { z } from "zod";
 export declare const StartServerSchema: z.ZodObject<{
     port: z.ZodNumber;
@@ -50,19 +51,19 @@ export declare const StartServerSchema: z.ZodObject<{
         }, "strip", z.ZodTypeAny, {
             allow_origin_regex?: string | undefined;
             expose_headers?: string[] | undefined;
-            allow_origins?: string[] | undefined;
+            max_age?: number | undefined;
             allow_methods?: string[] | undefined;
             allow_headers?: string[] | undefined;
             allow_credentials?: boolean | undefined;
-            max_age?: number | undefined;
+            allow_origins?: string[] | undefined;
         }, {
             allow_origin_regex?: string | undefined;
             expose_headers?: string[] | undefined;
-            allow_origins?: string[] | undefined;
+            max_age?: number | undefined;
             allow_methods?: string[] | undefined;
             allow_headers?: string[] | undefined;
             allow_credentials?: boolean | undefined;
-            max_age?: number | undefined;
+            allow_origins?: string[] | undefined;
         }>>;
     }, "strip", z.ZodTypeAny, {
         disable_assistants: boolean;
@@ -73,22 +74,22 @@ export declare const StartServerSchema: z.ZodObject<{
         cors?: {
             allow_origin_regex?: string | undefined;
             expose_headers?: string[] | undefined;
-            allow_origins?: string[] | undefined;
+            max_age?: number | undefined;
             allow_methods?: string[] | undefined;
             allow_headers?: string[] | undefined;
             allow_credentials?: boolean | undefined;
-            max_age?: number | undefined;
+            allow_origins?: string[] | undefined;
         } | undefined;
         app?: string | undefined;
     }, {
         cors?: {
             allow_origin_regex?: string | undefined;
             expose_headers?: string[] | undefined;
-            allow_origins?: string[] | undefined;
+            max_age?: number | undefined;
             allow_methods?: string[] | undefined;
             allow_headers?: string[] | undefined;
             allow_credentials?: boolean | undefined;
-            max_age?: number | undefined;
+            allow_origins?: string[] | undefined;
         } | undefined;
         app?: string | undefined;
         disable_assistants?: boolean | undefined;
@@ -123,11 +124,11 @@ export declare const StartServerSchema: z.ZodObject<{
         cors?: {
             allow_origin_regex?: string | undefined;
             expose_headers?: string[] | undefined;
-            allow_origins?: string[] | undefined;
+            max_age?: number | undefined;
             allow_methods?: string[] | undefined;
             allow_headers?: string[] | undefined;
             allow_credentials?: boolean | undefined;
-            max_age?: number | undefined;
+            allow_origins?: string[] | undefined;
         } | undefined;
         app?: string | undefined;
     } | undefined;
@@ -152,11 +153,11 @@ export declare const StartServerSchema: z.ZodObject<{
         cors?: {
             allow_origin_regex?: string | undefined;
             expose_headers?: string[] | undefined;
-            allow_origins?: string[] | undefined;
+            max_age?: number | undefined;
             allow_methods?: string[] | undefined;
             allow_headers?: string[] | undefined;
             allow_credentials?: boolean | undefined;
-            max_age?: number | undefined;
+            allow_origins?: string[] | undefined;
         } | undefined;
         app?: string | undefined;
         disable_assistants?: boolean | undefined;
@@ -166,7 +167,9 @@ export declare const StartServerSchema: z.ZodObject<{
         disable_meta?: boolean | undefined;
     } | undefined;
 }>;
-export declare function startServer(options: z.infer<typeof StartServerSchema>): Promise<{
+export declare function startServer(options: z.infer<typeof StartServerSchema>, storage?: {
+    ops?: Ops;
+}): Promise<{
     host: string;
     cleanup: () => Promise<void>;
 }>;

package/dist/server.mjs

@@ -1,17 +1,18 @@
 import { serve } from "@hono/node-server";
 import { Hono } from "hono";
+import { contextStorage } from "hono/context-storage";
 import { registerFromEnv } from "./graph/load.mjs";
 import runs from "./api/runs.mjs";
 import threads from "./api/threads.mjs";
 import assistants from "./api/assistants.mjs";
 import store from "./api/store.mjs";
 import meta from "./api/meta.mjs";
-import { truncate, conn as opsConn } from "./storage/ops.mjs";
 import { zValidator } from "@hono/zod-validator";
 import { z } from "zod";
 import { queue } from "./queue.mjs";
 import { logger, requestLogger, registerRuntimeLogFormatter, registerSdkLogger, } from "./logging.mjs";
 import { checkpointer } from "./storage/checkpoint.mjs";
+import { FileSystemOps } from "./storage/ops.mjs";
 import { store as graphStore } from "./storage/store.mjs";
 import { auth } from "./auth/custom.mjs";
 import { registerAuth } from "./auth/index.mjs";
@@ -20,6 +21,7 @@ import { cors, ensureContentType } from "./http/middleware.mjs";
 import { bindLoopbackFetch } from "./loopback.mjs";
 import { checkLangGraphSemver } from "./semver/index.mjs";
 import { getConfig } from "@langchain/langgraph";
+import { FileSystemPersistence } from "./storage/persist.mjs";
 export const StartServerSchema = z.object({
     port: z.number(),
     nWorkers: z.number(),
@@ -59,7 +61,7 @@ export const StartServerSchema = z.object({
     })
         .optional(),
 });
-export async function startServer(options) {
+export async function startServer(options, storage) {
     const semver = await checkLangGraphSemver();
     const invalidPackages = semver.filter((s) => !s.satisfies);
     if (invalidPackages.length > 0) {
@@ -69,11 +71,23 @@ export async function startServer(options) {
         ])));
     }
     logger.info(`Initializing storage...`);
-    const callbacks = await Promise.all([
-        opsConn.initialize(options.cwd),
+    let initCalls = [
         checkpointer.initialize(options.cwd),
         graphStore.initialize(options.cwd),
-    ]);
+    ];
+    let ops = storage?.ops;
+    if (ops == null) {
+        const opsConn = new FileSystemPersistence(".langgraphjs_ops.json", () => ({
+            runs: {},
+            threads: {},
+            assistants: {},
+            assistant_versions: [],
+            retry_counter: {},
+        }));
+        initCalls.push(opsConn.initialize(options.cwd));
+        ops = new FileSystemOps(opsConn);
+    }
+    const callbacks = await Promise.all(initCalls);
     const cleanup = async () => {
         logger.info(`Flushing to persistent storage, exiting...`);
         await Promise.all(callbacks.map((c) => c.flush()));
@@ -95,7 +109,7 @@ export async function startServer(options) {
     if (hasGraphDescriptions) {
         logger.warn("A graph definition in `langgraph.json` has a `description` property. Local MCP features are not yet supported with the JS CLI and will be ignored.");
     }
-    await registerFromEnv(graphPaths, { cwd: options.cwd });
+    await registerFromEnv(ops.assistants, graphPaths, { cwd: options.cwd });
     registerRuntimeLogFormatter((info) => {
         const config = getConfig();
         if (config == null)
@@ -106,6 +120,11 @@ export async function startServer(options) {
         return info;
     });
     const app = new Hono();
+    app.use(contextStorage());
+    app.use(async (c, next) => {
+        c.set("LANGGRAPH_OPS", ops);
+        await next();
+    });
     // Loopback fetch used by webhooks and custom routes
     bindLoopbackFetch(app);
     app.post("/internal/truncate", zValidator("json", z.object({
@@ -116,7 +135,7 @@ export async function startServer(options) {
         store: z.boolean().optional(),
     })), (c) => {
         const { runs, threads, assistants, checkpointer, store } = c.req.valid("json");
-        truncate({ runs, threads, assistants, checkpointer, store });
+        ops.truncate({ runs, threads, assistants, checkpointer, store });
         return c.json({ ok: true });
     });
     app.use(cors(options.http?.cors));
@@ -153,7 +172,7 @@ export async function startServer(options) {
     }
     logger.info(`Starting ${options.nWorkers} workers`);
     for (let i = 0; i < options.nWorkers; i++)
-        queue();
+        queue(ops);
     return new Promise((resolve) => {
         serve({ fetch: app.fetch, port: options.port, hostname: options.host }, (c) => {
             resolve({ host: `${c.address}:${c.port}`, cleanup });

package/dist/state.d.mts

@@ -1,3 +1,3 @@
 import type { StateSnapshot } from "@langchain/langgraph";
-import type { ThreadState } from "./storage/ops.mjs";
+import type { ThreadState } from "./storage/types.mjs";
 export declare const stateSnapshotToThreadState: (state: StateSnapshot) => ThreadState;

package/dist/storage/context.d.mts

@@ -0,0 +1,3 @@
+export declare const assistants: () => import("./types.mjs").AssistantsRepo;
+export declare const runs: () => import("./types.mjs").RunsRepo;
+export declare const threads: () => import("./types.mjs").ThreadsRepo;

package/dist/storage/context.mjs

@@ -0,0 +1,11 @@
+// Hono context helpers for accessing repositories, etc.
+import { getContext } from "hono/context-storage";
+export const assistants = () => {
+    return getContext().var.LANGGRAPH_OPS.assistants;
+};
+export const runs = () => {
+    return getContext().var.LANGGRAPH_OPS.runs;
+};
+export const threads = () => {
+    return getContext().var.LANGGRAPH_OPS.threads;
+};

package/dist/storage/ops.d.mts

@@ -1,82 +1,19 @@
-import type { CheckpointMetadata as LangGraphCheckpointMetadata, LangGraphRunnableConfig, StateSnapshot as LangGraphStateSnapshot } from "@langchain/langgraph";
 import type { AuthContext } from "../auth/index.mjs";
-import { type RunCommand } from "../command.mjs";
 import { FileSystemPersistence } from "./persist.mjs";
-export type Metadata = Record<string, unknown>;
-export type ThreadStatus = "idle" | "busy" | "interrupted" | "error";
-export type RunStatus = "pending" | "running" | "error" | "success" | "timeout" | "interrupted";
-export type StreamMode = "values" | "messages" | "messages-tuple" | "custom" | "updates" | "events" | "debug" | "tasks" | "checkpoints";
-export type MultitaskStrategy = "reject" | "rollback" | "interrupt" | "enqueue";
-export type OnConflictBehavior = "raise" | "do_nothing";
-export type IfNotExists = "create" | "reject";
-export interface RunnableConfig {
-    tags?: string[];
-    recursion_limit?: number;
-    configurable?: {
-        thread_id?: string;
-        thread_ts?: string;
-        [key: string]: unknown;
-    };
-    metadata?: LangGraphRunnableConfig["metadata"];
-}
-interface Assistant {
-    name: string | undefined;
-    assistant_id: string;
-    graph_id: string;
-    created_at: Date;
-    updated_at: Date;
-    version: number;
-    config: RunnableConfig;
-    context: unknown;
-    metadata: Metadata;
-}
-interface AssistantVersion {
-    assistant_id: string;
-    version: number;
-    graph_id: string;
-    config: RunnableConfig;
-    context: unknown;
-    metadata: Metadata;
-    created_at: Date;
-    name: string | undefined;
-}
-export interface RunKwargs {
-    input?: unknown;
-    command?: RunCommand;
-    stream_mode?: Array<StreamMode>;
-    interrupt_before?: "*" | string[] | undefined;
-    interrupt_after?: "*" | string[] | undefined;
-    config?: RunnableConfig;
-    context?: unknown;
-    subgraphs?: boolean;
-    resumable?: boolean;
-    temporary?: boolean;
-    webhook?: unknown;
-    feedback_keys?: string[] | undefined;
-    [key: string]: unknown;
-}
-export interface Run {
-    run_id: string;
-    thread_id: string;
-    assistant_id: string;
-    created_at: Date;
-    updated_at: Date;
-    status: RunStatus;
-    metadata: Metadata;
-    kwargs: RunKwargs;
-    multitask_strategy: MultitaskStrategy;
-}
-interface Store {
-    runs: Record<string, Run>;
-    threads: Record<string, Thread>;
-    assistants: Record<string, Assistant>;
-    assistant_versions: AssistantVersion[];
-    retry_counter: Record<string, number>;
-}
-export declare const conn: FileSystemPersistence<Store>;
-interface Message {
-    topic: `run:${string}:stream:${string}`;
-    data: unknown;
+import type { Metadata, ThreadStatus, RunStatus, MultitaskStrategy, OnConflictBehavior, IfNotExists, RunnableConfig, Assistant, RunKwargs, Run, Store, Message, Thread, CheckpointPayload, Ops, AssistantsRepo, RunsRepo, RunsStreamRepo, ThreadsRepo, ThreadsStateRepo } from "./types.mjs";
+export declare class FileSystemOps implements Ops {
+    private readonly conn;
+    readonly assistants: FileSystemAssistants;
+    readonly runs: FileSystemRuns;
+    readonly threads: FileSystemThreads;
+    constructor(conn: FileSystemPersistence<Store>);
+    truncate(flags: {
+        runs?: boolean;
+        threads?: boolean;
+        assistants?: boolean;
+        checkpointer?: boolean;
+        store?: boolean;
+    }): Promise<void>;
 }
 declare class Queue {
     private log;
@@ -109,15 +46,10 @@ declare class StreamManagerImpl {
     unlock(runId: string): void;
 }
 export declare const StreamManager: StreamManagerImpl;
-export declare const truncate: (flags: {
-    runs?: boolean;
-    threads?: boolean;
-    assistants?: boolean;
-    checkpointer?: boolean;
-    store?: boolean;
-}) => Promise<void>;
-export declare class Assistants {
-    static search(options: {
+export declare class FileSystemAssistants implements AssistantsRepo {
+    private readonly conn;
+    constructor(conn: FileSystemPersistence<Store>);
+    search(options: {
         graph_id?: string;
         metadata?: Metadata;
         limit: number;
@@ -126,8 +58,8 @@ export declare class Assistants {
         assistant: Assistant;
         total: number;
     }>;
-    static get(assistant_id: string, auth: AuthContext | undefined): Promise<Assistant>;
-    static put(assistant_id: string, options: {
+    get(assistant_id: string, auth: AuthContext | undefined): Promise<Assistant>;
+    put(assistant_id: string, options: {
         config: RunnableConfig;
         context: unknown;
         graph_id: string;
@@ -135,72 +67,30 @@ export declare class Assistants {
         if_exists: OnConflictBehavior;
         name?: string;
     }, auth: AuthContext | undefined): Promise<Assistant>;
-    static patch(assistantId: string, options: {
+    patch(assistantId: string, options: {
         config?: RunnableConfig;
         context?: unknown;
         graph_id?: string;
         metadata?: Metadata;
         name?: string;
     }, auth: AuthContext | undefined): Promise<Assistant>;
-    static delete(assistant_id: string, auth: AuthContext | undefined): Promise<string[]>;
-    static setLatest(assistant_id: string, version: number, auth: AuthContext | undefined): Promise<Assistant>;
-    static getVersions(assistant_id: string, options: {
+    delete(assistant_id: string, auth: AuthContext | undefined): Promise<string[]>;
+    setLatest(assistant_id: string, version: number, auth: AuthContext | undefined): Promise<Assistant>;
+    getVersions(assistant_id: string, options: {
         limit: number;
         offset: number;
         metadata?: Metadata;
-    }, auth: AuthContext | undefined): Promise<AssistantVersion[]>;
-}
-interface Thread {
-    thread_id: string;
-    created_at: Date;
-    updated_at: Date;
-    metadata?: Metadata;
-    config?: RunnableConfig;
-    status: ThreadStatus;
-    values?: Record<string, unknown>;
-    interrupts?: Record<string, unknown>;
-}
-interface CheckpointTask {
-    id: string;
-    name: string;
-    error?: string;
-    interrupts: Record<string, unknown>;
-    state?: RunnableConfig;
-}
-interface CheckpointPayload {
-    config?: RunnableConfig;
-    metadata: LangGraphCheckpointMetadata;
-    values: Record<string, unknown>;
-    next: string[];
-    parent_config?: RunnableConfig;
-    tasks: CheckpointTask[];
-}
-export interface Checkpoint {
-    thread_id: string;
-    checkpoint_ns: string;
-    checkpoint_id: string | null;
-    checkpoint_map: Record<string, unknown> | null;
-}
-interface ThreadTask {
-    id: string;
-    name: string;
-    error: string | null;
-    interrupts: Record<string, unknown>[];
-    checkpoint: Checkpoint | null;
-    state: ThreadState | null;
-    result: unknown | null;
-}
-export interface ThreadState {
-    values: Record<string, unknown>;
-    next: string[];
-    checkpoint: Checkpoint | null;
-    metadata: Record<string, unknown> | undefined;
-    created_at: Date | null;
-    parent_checkpoint: Checkpoint | null;
-    tasks: ThreadTask[];
+    }, auth: AuthContext | undefined): Promise<import("./types.mjs").AssistantVersion[]>;
+    count(options: {
+        graph_id?: string;
+        metadata?: Metadata;
+    }, auth: AuthContext | undefined): Promise<number>;
 }
-export declare class Threads {
-    static search(options: {
+export declare class FileSystemThreads implements ThreadsRepo {
+    private readonly conn;
+    readonly state: ThreadsStateRepo;
+    constructor(conn: FileSystemPersistence<Store>);
+    search(options: {
         metadata?: Metadata;
         status?: ThreadStatus;
         values?: Record<string, unknown>;
@@ -212,51 +102,38 @@ export declare class Threads {
         thread: Thread;
         total: number;
     }>;
-    static get(thread_id: string, auth: AuthContext | undefined): Promise<Thread>;
-    static put(thread_id: string, options: {
+    get(thread_id: string, auth: AuthContext | undefined): Promise<Thread>;
+    put(thread_id: string, options: {
         metadata?: Metadata;
         if_exists: OnConflictBehavior;
     }, auth: AuthContext | undefined): Promise<Thread>;
-    static patch(threadId: string, options: {
+    patch(threadId: string, options: {
         metadata?: Metadata;
     }, auth: AuthContext | undefined): Promise<Thread>;
-    static setStatus(threadId: string, options: {
+    setStatus(threadId: string, options: {
         checkpoint?: CheckpointPayload;
         exception?: Error;
     }): Promise<void>;
-    static delete(thread_id: string, auth: AuthContext | undefined): Promise<string[]>;
-    static copy(thread_id: string, auth: AuthContext | undefined): Promise<Thread>;
-    static State: {
-        new (): {};
-        get(config: RunnableConfig, options: {
-            subgraphs?: boolean;
-        }, auth: AuthContext | undefined): Promise<LangGraphStateSnapshot>;
-        post(config: RunnableConfig, values: Record<string, unknown>[] | Record<string, unknown> | null | undefined, asNode: string | undefined, auth: AuthContext | undefined): Promise<{
-            checkpoint: Record<string, any> | undefined;
-        }>;
-        bulk(config: RunnableConfig, supersteps: Array<{
-            updates: Array<{
-                values?: Record<string, unknown>[] | Record<string, unknown> | unknown | null | undefined;
-                command?: RunCommand | undefined | null;
-                as_node?: string | undefined;
-            }>;
-        }>, auth: AuthContext | undefined): Promise<never[] | {
-            checkpoint: Record<string, any> | undefined;
-        }>;
-        list(config: RunnableConfig, options: {
-            limit?: number;
-            before?: string | RunnableConfig;
-            metadata?: Metadata;
-        }, auth: AuthContext | undefined): Promise<LangGraphStateSnapshot[]>;
-    };
-}
-export declare class Runs {
-    static next(): AsyncGenerator<{
+    delete(thread_id: string, auth: AuthContext | undefined): Promise<string[]>;
+    copy(thread_id: string, auth: AuthContext | undefined): Promise<Thread>;
+    count(options: {
+        metadata?: Metadata;
+        values?: Record<string, unknown>;
+        status?: ThreadStatus;
+    }, auth: AuthContext | undefined): Promise<number>;
+    private static State;
+}
+export declare class FileSystemRuns implements RunsRepo {
+    private readonly conn;
+    private readonly threads;
+    readonly stream: RunsStreamRepo;
+    constructor(conn: FileSystemPersistence<Store>);
+    next(): AsyncGenerator<{
         run: Run;
         attempt: number;
         signal: AbortSignal;
     }>;
-    static put(runId: string, assistantId: string, kwargs: RunKwargs, options: {
+    put(runId: string, assistantId: string, kwargs: RunKwargs, options: {
         threadId?: string;
         userId?: string;
         status?: RunStatus;
@@ -266,38 +143,21 @@ export declare class Runs {
         ifNotExists?: IfNotExists;
         afterSeconds?: number;
     }, auth: AuthContext | undefined): Promise<Run[]>;
-    static get(runId: string, thread_id: string | undefined, auth: AuthContext | undefined): Promise<Run | null>;
-    static delete(run_id: string, thread_id: string | undefined, auth: AuthContext | undefined): Promise<string | null>;
-    static wait(runId: string, threadId: string | undefined, auth: AuthContext | undefined): Promise<unknown>;
-    static join(runId: string, threadId: string, auth: AuthContext | undefined): Promise<{} | null>;
-    static cancel(threadId: string | undefined, runIds: string[], options: {
+    get(runId: string, thread_id: string | undefined, auth: AuthContext | undefined): Promise<Run | null>;
+    delete(run_id: string, thread_id: string | undefined, auth: AuthContext | undefined): Promise<string | null>;
+    wait(runId: string, threadId: string | undefined, auth: AuthContext | undefined): Promise<unknown>;
+    join(runId: string, threadId: string, auth: AuthContext | undefined): Promise<{} | null>;
+    cancel(threadId: string | undefined, runIds: string[], options: {
         action?: "interrupt" | "rollback";
     }, auth: AuthContext | undefined): Promise<void>;
-    static search(threadId: string, options: {
+    search(threadId: string, options: {
         limit?: number | null;
         offset?: number | null;
         status?: string | null;
         metadata?: Metadata | null;
     }, auth: AuthContext | undefined): Promise<Run[]>;
-    static setStatus(runId: string, status: RunStatus): Promise<void>;
-    static Stream: {
-        new (): {};
-        join(runId: string, threadId: string | undefined, options: {
-            ignore404?: boolean;
-            cancelOnDisconnect?: AbortSignal;
-            lastEventId: string | undefined;
-        }, auth: AuthContext | undefined): AsyncGenerator<{
-            id?: string;
-            event: string;
-            data: unknown;
-        }>;
-        publish(payload: {
-            runId: string;
-            event: string;
-            data: unknown;
-            resumable: boolean;
-        }): Promise<void>;
-    };
+    setStatus(runId: string, status: RunStatus): Promise<void>;
+    private static Stream;
 }
 export declare class Crons {
 }