@langchain/langgraph-api 1.1.1 → 1.1.8

package/dist/storage/persist.d.mts

@@ -1,18 +0,0 @@
-export declare function serialize(data: unknown): string;
-export declare function deserialize<T>(input: string): Promise<T>;
-export declare class FileSystemPersistence<Schema> {
-    private filepath;
-    private data;
-    private defaultSchema;
-    private name;
-    private flushTimeout;
-    constructor(name: `.${string}.json`, defaultSchema: () => Schema);
-    initialize(cwd: string): Promise<this>;
-    protected persist(): Promise<void>;
-    protected schedulePersist(): void;
-    flush(): Promise<void>;
-    with<T>(fn: (data: Schema) => T): Promise<T>;
-    withGenerator<T extends AsyncGenerator<any>>(fn: ((data: Schema, options: {
-        schedulePersist: () => void;
-    }) => T) | T): AsyncGenerator<any, void, any>;
-}

package/dist/storage/persist.mjs

@@ -1,81 +0,0 @@
-import * as path from "node:path";
-import * as fs from "node:fs/promises";
-import * as superjson from "superjson";
-import * as importMap from "./importMap.mjs";
-import { load } from "@langchain/core/load";
-// Add custom transformers for Uint8Array
-superjson.registerCustom({
-    isApplicable: (v) => v instanceof Uint8Array,
-    serialize: (v) => Buffer.from(v).toString("base64"),
-    deserialize: (v) => new Uint8Array(Buffer.from(v, "base64")),
-}, "Uint8Array");
-export function serialize(data) {
-    return superjson.stringify(data);
-}
-export async function deserialize(input) {
-    const result = await load(input, { importMap });
-    return superjson.deserialize(result);
-}
-export class FileSystemPersistence {
-    filepath = null;
-    data = null;
-    defaultSchema;
-    name;
-    flushTimeout = undefined;
-    constructor(name, defaultSchema) {
-        this.name = name;
-        this.defaultSchema = defaultSchema;
-    }
-    async initialize(cwd) {
-        this.filepath = path.resolve(cwd, ".langgraph_api", `${this.name}`);
-        try {
-            this.data = await deserialize(await fs.readFile(this.filepath, "utf-8"));
-        }
-        catch {
-            this.data = this.defaultSchema();
-        }
-        await fs
-            .mkdir(path.dirname(this.filepath), { recursive: true })
-            .catch(() => void 0);
-        return this;
-    }
-    async persist() {
-        if (this.data == null || this.filepath == null)
-            return;
-        clearTimeout(this.flushTimeout);
-        await fs.writeFile(this.filepath, serialize(this.data), "utf-8");
-    }
-    schedulePersist() {
-        clearTimeout(this.flushTimeout);
-        this.flushTimeout = setTimeout(() => this.persist(), 3000);
-    }
-    async flush() {
-        await this.persist();
-    }
-    async with(fn) {
-        if (this.filepath == null || this.data == null) {
-            throw new Error(`${this.name} not initialized`);
-        }
-        try {
-            return await fn(this.data);
-        }
-        finally {
-            this.schedulePersist();
-        }
-    }
-    async *withGenerator(fn) {
-        if (this.filepath == null || this.data == null) {
-            throw new Error(`${this.name} not initialized`);
-        }
-        let shouldPersist = false;
-        let schedulePersist = () => void (shouldPersist = true);
-        try {
-            const gen = typeof fn === "function" ? fn(this.data, { schedulePersist }) : fn;
-            yield* gen;
-        }
-        finally {
-            if (shouldPersist)
-                this.schedulePersist();
-        }
-    }
-}

package/dist/storage/store.d.mts

@@ -1,17 +0,0 @@
-import { InMemoryStore as BaseMemoryStore, type Operation, type OperationResults } from "@langchain/langgraph";
-import { FileSystemPersistence } from "./persist.mjs";
-declare class InMemoryStore extends BaseMemoryStore {
-    initialize(cwd: string): Promise<FileSystemPersistence<{
-        data: Map<string, any>;
-        vectors: Map<string, any>;
-    }>>;
-    clear(): Promise<void>;
-    batch<Op extends readonly Operation[]>(operations: Op): Promise<OperationResults<Op>>;
-    get(...args: Parameters<BaseMemoryStore["get"]>): ReturnType<BaseMemoryStore["get"]>;
-    search(...args: Parameters<BaseMemoryStore["search"]>): ReturnType<BaseMemoryStore["search"]>;
-    put(...args: Parameters<BaseMemoryStore["put"]>): ReturnType<BaseMemoryStore["put"]>;
-    listNamespaces(...args: Parameters<BaseMemoryStore["listNamespaces"]>): ReturnType<BaseMemoryStore["listNamespaces"]>;
-    toJSON(): string;
-}
-export declare const store: InMemoryStore;
-export {};

package/dist/storage/store.mjs

@@ -1,41 +0,0 @@
-import { InMemoryStore as BaseMemoryStore, } from "@langchain/langgraph";
-import { FileSystemPersistence } from "./persist.mjs";
-const conn = new FileSystemPersistence(".langgraphjs_api.store.json", () => ({
-    data: new Map(),
-    vectors: new Map(),
-}));
-class InMemoryStore extends BaseMemoryStore {
-    async initialize(cwd) {
-        await conn.initialize(cwd);
-        await conn.with(({ data, vectors }) => {
-            Object.assign(this, { data, vectors });
-        });
-        return conn;
-    }
-    async clear() {
-        await conn.with(({ data, vectors }) => {
-            data.clear();
-            vectors.clear();
-        });
-    }
-    async batch(operations) {
-        return await conn.with(() => super.batch(operations));
-    }
-    async get(...args) {
-        return await conn.with(() => super.get(...args));
-    }
-    async search(...args) {
-        return await conn.with(() => super.search(...args));
-    }
-    async put(...args) {
-        return await conn.with(() => super.put(...args));
-    }
-    async listNamespaces(...args) {
-        return await conn.with(() => super.listNamespaces(...args));
-    }
-    toJSON() {
-        // Prevent serialization of internal state
-        return "[InMemoryStore]";
-    }
-}
-export const store = new InMemoryStore();

package/dist/storage/types.d.mts

@@ -1,301 +0,0 @@
-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 AssistantSelectField = "assistant_id" | "graph_id" | "name" | "description" | "config" | "context" | "created_at" | "updated_at" | "metadata" | "version";
-export type ThreadSelectField = "thread_id" | "created_at" | "updated_at" | "metadata" | "config" | "context" | "status" | "values" | "interrupts";
-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;
-    description: string | null;
-    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;
-    description: string | null;
-}
-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;
-        ids?: string[];
-        status?: ThreadStatus;
-        values?: Record<string, unknown>;
-        limit: number;
-        offset: number;
-        sort_by?: "thread_id" | "status" | "created_at" | "updated_at";
-        sort_order?: "asc" | "desc";
-        select?: ThreadSelectField[];
-    }, 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;
-        name?: string;
-        metadata?: Metadata;
-        limit: number;
-        offset: number;
-        sort_by?: "assistant_id" | "created_at" | "updated_at" | "name" | "graph_id";
-        sort_order?: "asc" | "desc";
-        select?: AssistantSelectField[];
-    }, 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;
-        description?: string;
-    }, auth: AuthContext | undefined): Promise<Assistant>;
-    patch(assistantId: string, options: {
-        config?: RunnableConfig;
-        context?: unknown;
-        graph_id?: string;
-        metadata?: Metadata;
-        name?: string;
-        description?: string;
-    }, auth: AuthContext | undefined): Promise<Assistant>;
-    delete(assistant_id: string, auth: AuthContext | undefined): Promise<string[]>;
-    count(options: {
-        graph_id?: string;
-        name?: 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

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

package/dist/stream.d.mts

@@ -1,43 +0,0 @@
-import type { BaseCheckpointSaver, LangGraphRunnableConfig, CheckpointMetadata, Interrupt, StateSnapshot } from "@langchain/langgraph";
-import type { Pregel } from "@langchain/langgraph/pregel";
-import type { Checkpoint, Run, RunnableConfig } from "./storage/types.mjs";
-interface DebugTask {
-    id: string;
-    name: string;
-    result?: unknown;
-    error?: unknown;
-    interrupts: Interrupt[];
-    state?: RunnableConfig | StateSnapshot;
-    path?: [string, ...(string | number)[]];
-}
-interface DebugCheckpoint {
-    config: RunnableConfig;
-    parentConfig: RunnableConfig | undefined;
-    values: unknown;
-    metadata: CheckpointMetadata;
-    next: string[];
-    tasks: DebugTask[];
-}
-type Prettify<T> = {
-    [K in keyof T]: T[K];
-} & {};
-export type StreamCheckpoint = Prettify<Omit<DebugCheckpoint, "parentConfig"> & {
-    parent_config: DebugCheckpoint["parentConfig"];
-}>;
-export type StreamTaskResult = Prettify<Omit<DebugTask, "state"> & {
-    state?: StateSnapshot;
-    checkpoint?: Checkpoint;
-}>;
-export declare function streamState(run: Run, options: {
-    attempt: number;
-    getGraph: (graphId: string, config: LangGraphRunnableConfig | undefined, options?: {
-        checkpointer?: BaseCheckpointSaver | null;
-    }) => Promise<Pregel<any, any, any, any, any>>;
-    onCheckpoint?: (checkpoint: StreamCheckpoint) => void;
-    onTaskResult?: (taskResult: StreamTaskResult) => void;
-    signal?: AbortSignal;
-}): AsyncGenerator<{
-    event: string;
-    data: unknown;
-}>;
-export {};