@langchain/langgraph-api 0.0.59 → 0.0.61

package/dist/storage/types.d.mts

@@ -0,0 +1,288 @@
+import type { LangGraphRunnableConfig, CheckpointMetadata as LangGraphCheckpointMetadata, StateSnapshot as LangGraphStateSnapshot } from "@langchain/langgraph";
+import type { RunCommand } from "../command.mjs";
+import type { AuthContext } from "../auth/index.mjs";
+export type { RunCommand } from "../command.mjs";
+export type StorageEnv = {
+    Variables: {
+        LANGGRAPH_OPS: Ops;
+    };
+};
+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"];
+}
+export 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;
+}
+export 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;
+}
+export interface Store {
+    runs: Record<string, Run>;
+    threads: Record<string, Thread>;
+    assistants: Record<string, Assistant>;
+    assistant_versions: AssistantVersion[];
+    retry_counter: Record<string, number>;
+}
+export interface Message {
+    topic: `run:${string}:stream:${string}`;
+    data: unknown;
+}
+export 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>;
+}
+export interface CheckpointTask {
+    id: string;
+    name: string;
+    error?: string;
+    interrupts: Record<string, unknown>;
+    state?: RunnableConfig;
+}
+export 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;
+}
+export 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[];
+}
+export interface RunsRepo {
+    next(): AsyncGenerator<{
+        run: Run;
+        attempt: number;
+        signal: AbortSignal;
+    }>;
+    put(runId: string, assistantId: string, kwargs: RunKwargs, options: {
+        threadId?: string;
+        userId?: string;
+        status?: RunStatus;
+        metadata?: Metadata;
+        preventInsertInInflight?: boolean;
+        multitaskStrategy?: MultitaskStrategy;
+        ifNotExists?: IfNotExists;
+        afterSeconds?: number;
+    }, auth: AuthContext | undefined): Promise<Run[]>;
+    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<unknown>;
+    setStatus(runId: string, status: RunStatus): Promise<unknown>;
+    cancel(threadId: string | undefined, runIds: string[], options: {
+        action?: "interrupt" | "rollback";
+    }, auth: AuthContext | undefined): Promise<void>;
+    search(threadId: string, options: {
+        limit?: number | null;
+        offset?: number | null;
+        status?: string | null;
+        metadata?: Metadata | null;
+    }, auth: AuthContext | undefined): Promise<Run[]>;
+    readonly stream: RunsStreamRepo;
+}
+export interface RunsStreamRepo {
+    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;
+        resumable: boolean;
+        event: string;
+        data: unknown | Error;
+    }): Promise<void>;
+}
+export interface ThreadsRepo {
+    search(options: {
+        metadata?: Metadata;
+        status?: ThreadStatus;
+        values?: Record<string, unknown>;
+        limit: number;
+        offset: number;
+        sort_by?: "thread_id" | "status" | "created_at" | "updated_at";
+        sort_order?: "asc" | "desc";
+    }, auth: AuthContext | undefined): AsyncGenerator<{
+        thread: Thread;
+        total: number;
+    }>;
+    get(thread_id: string, auth: AuthContext | undefined): Promise<Thread>;
+    put(thread_id: string, options: {
+        metadata?: Metadata;
+        if_exists: OnConflictBehavior;
+    }, auth: AuthContext | undefined): Promise<Thread>;
+    patch(threadId: string, options: {
+        metadata?: Metadata;
+    }, auth: AuthContext | undefined): Promise<Thread>;
+    setStatus(threadId: string, options: {
+        checkpoint?: CheckpointPayload;
+        exception?: Error;
+    }): Promise<void>;
+    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>;
+    readonly state: ThreadsStateRepo;
+}
+export interface ThreadsStateRepo {
+    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, unknown> | 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<{
+        checkpoint: Record<string, unknown> | undefined;
+    } | unknown[]>;
+    list(config: RunnableConfig, options: {
+        limit?: number;
+        before?: string | RunnableConfig;
+        metadata?: Metadata;
+    }, auth: AuthContext | undefined): Promise<LangGraphStateSnapshot[]>;
+}
+export interface AssistantsRepo {
+    search(options: {
+        graph_id?: string;
+        metadata?: Metadata;
+        limit: number;
+        offset: number;
+    }, auth: AuthContext | undefined): AsyncGenerator<{
+        assistant: Assistant;
+        total: number;
+    }>;
+    get(assistant_id: string, auth: AuthContext | undefined): Promise<Assistant>;
+    put(assistant_id: string, options: {
+        config: RunnableConfig;
+        context: unknown;
+        graph_id: string;
+        metadata?: Metadata;
+        if_exists: OnConflictBehavior;
+        name?: string;
+    }, auth: AuthContext | undefined): Promise<Assistant>;
+    patch(assistantId: string, options: {
+        config?: RunnableConfig;
+        context?: unknown;
+        graph_id?: string;
+        metadata?: Metadata;
+        name?: string;
+    }, auth: AuthContext | undefined): Promise<Assistant>;
+    delete(assistant_id: string, auth: AuthContext | undefined): Promise<string[]>;
+    count(options: {
+        graph_id?: string;
+        metadata?: Metadata;
+    }, auth: AuthContext | undefined): Promise<number>;
+    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[]>;
+}
+export interface Ops {
+    readonly assistants: AssistantsRepo;
+    readonly threads: ThreadsRepo;
+    readonly runs: RunsRepo;
+    truncate(flags: {
+        runs?: boolean;
+        threads?: boolean;
+        assistants?: boolean;
+        checkpointer?: boolean;
+        store?: boolean;
+    }): Promise<void>;
+}

package/dist/storage/types.mjs

@@ -0,0 +1 @@
+export {};

package/dist/stream.d.mts

@@ -1,6 +1,6 @@
 import type { BaseCheckpointSaver, LangGraphRunnableConfig, CheckpointMetadata, Interrupt, StateSnapshot } from "@langchain/langgraph";
 import type { Pregel } from "@langchain/langgraph/pregel";
-import type { Checkpoint, Run, RunnableConfig } from "./storage/ops.mjs";
+import type { Checkpoint, Run, RunnableConfig } from "./storage/types.mjs";
 interface DebugTask {
     id: string;
     name: string;

package/dist/stream.mjs

@@ -140,6 +140,18 @@ export async function* streamState(run, options) {
                     data = { ...debugChunk, payload: debugResult };
                 }
             }
+            else if (mode === "checkpoints") {
+                const debugCheckpoint = preprocessDebugCheckpoint(chunk);
+                options?.onCheckpoint?.(debugCheckpoint);
+                data = debugCheckpoint;
+            }
+            else if (mode === "tasks") {
+                const debugTask = preprocessDebugCheckpointTask(chunk);
+                if ("result" in debugTask || "error" in debugTask) {
+                    options?.onTaskResult?.(debugTask);
+                }
+                data = debugTask;
+            }
             if (mode === "messages") {
                 if (userStreamMode.includes("messages-tuple")) {
                     if (kwargs.subgraphs && ns?.length) {

package/dist/utils/runnableConfig.d.mts

@@ -1,3 +1,3 @@
-import type { Checkpoint, RunnableConfig } from "../storage/ops.mjs";
+import type { Checkpoint, RunnableConfig } from "../storage/types.mjs";
 export declare const runnableConfigToCheckpoint: (config: RunnableConfig | null | undefined) => Checkpoint | null;
 export declare const taskRunnableConfigToCheckpoint: (config: RunnableConfig | null | undefined) => Partial<Checkpoint> | null;

package/dist/webhook.d.mts

@@ -1,4 +1,4 @@
-import type { Run } from "./storage/ops.mjs";
+import type { Run } from "./storage/types.mjs";
 import type { StreamCheckpoint } from "./stream.mjs";
 export declare function callWebhook(result: {
     checkpoint: StreamCheckpoint | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/langgraph-api",
-  "version": "0.0.59",
+  "version": "0.0.61",
   "type": "module",
   "engines": {
     "node": "^18.19.0 || >=20.16.0"
@@ -15,10 +15,18 @@
       "types": "./dist/cli/spawn.d.mts",
       "default": "./dist/cli/spawn.mjs"
     },
+    "./server": {
+      "types": "./dist/server.d.mts",
+      "default": "./dist/server.mjs"
+    },
     "./auth": {
       "types": "./dist/auth/index.d.mts",
       "default": "./dist/auth/index.mjs"
     },
+    "./graph": {
+      "types": "./dist/graph/api.d.mts",
+      "default": "./dist/graph/api.mjs"
+    },
     "./semver": {
       "types": "./dist/semver/index.d.mts",
       "default": "./dist/semver/index.mjs"
@@ -27,6 +35,10 @@
       "types": "./dist/graph/parser/index.d.mts",
       "default": "./dist/graph/parser/index.mjs"
     },
+    "./storage": {
+      "types": "./dist/storage/types.d.mts",
+      "default": "./dist/storage/types.mjs"
+    },
     "./experimental/embed": {
       "types": "./dist/experimental/embed.d.mts",
       "default": "./dist/experimental/embed.mjs"
@@ -52,7 +64,7 @@
     "@babel/code-frame": "^7.26.2",
     "@hono/node-server": "^1.12.0",
     "@hono/zod-validator": "^0.2.2",
-    "@langchain/langgraph-ui": "0.0.59",
+    "@langchain/langgraph-ui": "0.0.61",
     "@types/json-schema": "^7.0.15",
     "@typescript/vfs": "^1.6.0",
     "dedent": "^1.5.3",
@@ -84,9 +96,9 @@
   },
   "devDependencies": {
     "@langchain/core": "^0.3.59",
-    "@langchain/langgraph": "0.4.5",
+    "@langchain/langgraph": "0.4.7",
     "@langchain/langgraph-checkpoint": "0.1.0",
-    "@langchain/langgraph-sdk": "0.0.107",
+    "@langchain/langgraph-sdk": "0.0.111",
     "@types/babel__code-frame": "^7.0.6",
     "@types/node": "^18.15.11",
     "@types/react": "^19.0.8",