@langchain/langgraph-api 0.0.30 → 0.0.32

package/dist/server.d.mts

@@ -0,0 +1,157 @@
+import { z } from "zod";
+export declare const StartServerSchema: z.ZodObject<{
+    port: z.ZodNumber;
+    nWorkers: z.ZodNumber;
+    host: z.ZodString;
+    cwd: z.ZodString;
+    graphs: z.ZodRecord<z.ZodString, z.ZodString>;
+    auth: z.ZodOptional<z.ZodObject<{
+        path: z.ZodOptional<z.ZodString>;
+        disable_studio_auth: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        disable_studio_auth: boolean;
+        path?: string | undefined;
+    }, {
+        path?: string | undefined;
+        disable_studio_auth?: boolean | undefined;
+    }>>;
+    ui: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    ui_config: z.ZodOptional<z.ZodObject<{
+        shared: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        shared?: string[] | undefined;
+    }, {
+        shared?: string[] | undefined;
+    }>>;
+    http: z.ZodOptional<z.ZodObject<{
+        app: z.ZodOptional<z.ZodString>;
+        disable_assistants: z.ZodDefault<z.ZodBoolean>;
+        disable_threads: z.ZodDefault<z.ZodBoolean>;
+        disable_runs: z.ZodDefault<z.ZodBoolean>;
+        disable_store: z.ZodDefault<z.ZodBoolean>;
+        disable_meta: z.ZodDefault<z.ZodBoolean>;
+        cors: z.ZodOptional<z.ZodObject<{
+            allow_origins: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            allow_methods: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            allow_headers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            allow_credentials: z.ZodOptional<z.ZodBoolean>;
+            allow_origin_regex: z.ZodOptional<z.ZodString>;
+            expose_headers: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            max_age: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            allow_origin_regex?: string | undefined;
+            allow_origins?: string[] | undefined;
+            allow_methods?: string[] | undefined;
+            allow_headers?: string[] | undefined;
+            allow_credentials?: boolean | undefined;
+            expose_headers?: string[] | undefined;
+            max_age?: number | undefined;
+        }, {
+            allow_origin_regex?: string | undefined;
+            allow_origins?: string[] | undefined;
+            allow_methods?: string[] | undefined;
+            allow_headers?: string[] | undefined;
+            allow_credentials?: boolean | undefined;
+            expose_headers?: string[] | undefined;
+            max_age?: number | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        disable_assistants: boolean;
+        disable_threads: boolean;
+        disable_runs: boolean;
+        disable_store: boolean;
+        disable_meta: boolean;
+        cors?: {
+            allow_origin_regex?: string | undefined;
+            allow_origins?: string[] | undefined;
+            allow_methods?: string[] | undefined;
+            allow_headers?: string[] | undefined;
+            allow_credentials?: boolean | undefined;
+            expose_headers?: string[] | undefined;
+            max_age?: number | undefined;
+        } | undefined;
+        app?: string | undefined;
+    }, {
+        cors?: {
+            allow_origin_regex?: string | undefined;
+            allow_origins?: string[] | undefined;
+            allow_methods?: string[] | undefined;
+            allow_headers?: string[] | undefined;
+            allow_credentials?: boolean | undefined;
+            expose_headers?: string[] | undefined;
+            max_age?: number | undefined;
+        } | undefined;
+        app?: string | undefined;
+        disable_assistants?: boolean | undefined;
+        disable_threads?: boolean | undefined;
+        disable_runs?: boolean | undefined;
+        disable_store?: boolean | undefined;
+        disable_meta?: boolean | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    cwd: string;
+    host: string;
+    port: number;
+    nWorkers: number;
+    graphs: Record<string, string>;
+    auth?: {
+        disable_studio_auth: boolean;
+        path?: string | undefined;
+    } | undefined;
+    ui?: Record<string, string> | undefined;
+    ui_config?: {
+        shared?: string[] | undefined;
+    } | undefined;
+    http?: {
+        disable_assistants: boolean;
+        disable_threads: boolean;
+        disable_runs: boolean;
+        disable_store: boolean;
+        disable_meta: boolean;
+        cors?: {
+            allow_origin_regex?: string | undefined;
+            allow_origins?: string[] | undefined;
+            allow_methods?: string[] | undefined;
+            allow_headers?: string[] | undefined;
+            allow_credentials?: boolean | undefined;
+            expose_headers?: string[] | undefined;
+            max_age?: number | undefined;
+        } | undefined;
+        app?: string | undefined;
+    } | undefined;
+}, {
+    cwd: string;
+    host: string;
+    port: number;
+    nWorkers: number;
+    graphs: Record<string, string>;
+    auth?: {
+        path?: string | undefined;
+        disable_studio_auth?: boolean | undefined;
+    } | undefined;
+    ui?: Record<string, string> | undefined;
+    ui_config?: {
+        shared?: string[] | undefined;
+    } | undefined;
+    http?: {
+        cors?: {
+            allow_origin_regex?: string | undefined;
+            allow_origins?: string[] | undefined;
+            allow_methods?: string[] | undefined;
+            allow_headers?: string[] | undefined;
+            allow_credentials?: boolean | undefined;
+            expose_headers?: string[] | undefined;
+            max_age?: number | undefined;
+        } | undefined;
+        app?: string | undefined;
+        disable_assistants?: boolean | undefined;
+        disable_threads?: boolean | undefined;
+        disable_runs?: boolean | undefined;
+        disable_store?: boolean | undefined;
+        disable_meta?: boolean | undefined;
+    } | undefined;
+}>;
+export declare function startServer(options: z.infer<typeof StartServerSchema>): Promise<{
+    host: string;
+    cleanup: () => Promise<void>;
+}>;

package/dist/state.d.mts

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

package/dist/storage/checkpoint.d.mts

@@ -0,0 +1,19 @@
+import type { RunnableConfig } from "@langchain/core/runnables";
+import { type Checkpoint, type CheckpointMetadata, MemorySaver } from "@langchain/langgraph";
+import { FileSystemPersistence } from "./persist.mjs";
+declare class InMemorySaver extends MemorySaver {
+    initialize(cwd: string): Promise<FileSystemPersistence<{
+        storage: typeof MemorySaver.prototype.storage;
+        writes: typeof MemorySaver.prototype.writes;
+    }>>;
+    clear(): void;
+    getTuple(...args: Parameters<MemorySaver["getTuple"]>): ReturnType<MemorySaver["getTuple"]>;
+    list(...args: Parameters<MemorySaver["list"]>): ReturnType<MemorySaver["list"]>;
+    putWrites(...args: Parameters<MemorySaver["putWrites"]>): Promise<void>;
+    put(config: RunnableConfig, checkpoint: Checkpoint, metadata: CheckpointMetadata): Promise<RunnableConfig>;
+    delete(threadId: string, runId: string | null | undefined): Promise<void>;
+    copy(threadId: string, newThreadId: string): Promise<void>;
+    toJSON(): string;
+}
+export declare const checkpointer: InMemorySaver;
+export {};

package/dist/storage/importMap.d.mts

@@ -0,0 +1,55 @@
+import { PromptTemplate, AIMessagePromptTemplate, ChatMessagePromptTemplate, ChatPromptTemplate, HumanMessagePromptTemplate, MessagesPlaceholder, SystemMessagePromptTemplate, ImagePromptTemplate, PipelinePromptTemplate } from "@langchain/core/prompts";
+import { AIMessage, AIMessageChunk, BaseMessage, BaseMessageChunk, ChatMessage, ChatMessageChunk, FunctionMessage, FunctionMessageChunk, HumanMessage, HumanMessageChunk, SystemMessage, SystemMessageChunk, ToolMessage, ToolMessageChunk } from "@langchain/core/messages";
+import { StringPromptValue } from "@langchain/core/prompt_values";
+export declare const prompts__prompt: {
+    PromptTemplate: typeof PromptTemplate;
+};
+export declare const schema__messages: {
+    AIMessage: typeof AIMessage;
+    AIMessageChunk: typeof AIMessageChunk;
+    BaseMessage: typeof BaseMessage;
+    BaseMessageChunk: typeof BaseMessageChunk;
+    ChatMessage: typeof ChatMessage;
+    ChatMessageChunk: typeof ChatMessageChunk;
+    FunctionMessage: typeof FunctionMessage;
+    FunctionMessageChunk: typeof FunctionMessageChunk;
+    HumanMessage: typeof HumanMessage;
+    HumanMessageChunk: typeof HumanMessageChunk;
+    SystemMessage: typeof SystemMessage;
+    SystemMessageChunk: typeof SystemMessageChunk;
+    ToolMessage: typeof ToolMessage;
+    ToolMessageChunk: typeof ToolMessageChunk;
+};
+export declare const schema: {
+    AIMessage: typeof AIMessage;
+    AIMessageChunk: typeof AIMessageChunk;
+    BaseMessage: typeof BaseMessage;
+    BaseMessageChunk: typeof BaseMessageChunk;
+    ChatMessage: typeof ChatMessage;
+    ChatMessageChunk: typeof ChatMessageChunk;
+    FunctionMessage: typeof FunctionMessage;
+    FunctionMessageChunk: typeof FunctionMessageChunk;
+    HumanMessage: typeof HumanMessage;
+    HumanMessageChunk: typeof HumanMessageChunk;
+    SystemMessage: typeof SystemMessage;
+    SystemMessageChunk: typeof SystemMessageChunk;
+    ToolMessage: typeof ToolMessage;
+    ToolMessageChunk: typeof ToolMessageChunk;
+};
+export declare const prompts__chat: {
+    AIMessagePromptTemplate: typeof AIMessagePromptTemplate;
+    ChatMessagePromptTemplate: typeof ChatMessagePromptTemplate;
+    ChatPromptTemplate: typeof ChatPromptTemplate;
+    HumanMessagePromptTemplate: typeof HumanMessagePromptTemplate;
+    MessagesPlaceholder: typeof MessagesPlaceholder;
+    SystemMessagePromptTemplate: typeof SystemMessagePromptTemplate;
+};
+export declare const prompts__image: {
+    ImagePromptTemplate: typeof ImagePromptTemplate;
+};
+export declare const prompts__pipeline: {
+    PipelinePromptTemplate: typeof PipelinePromptTemplate;
+};
+export declare const prompts__base: {
+    StringPromptValue: typeof StringPromptValue;
+};

package/dist/storage/ops.d.mts

@@ -0,0 +1,284 @@
+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";
+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;
+    metadata: Metadata;
+}
+interface AssistantVersion {
+    assistant_id: string;
+    version: number;
+    graph_id: string;
+    config: RunnableConfig;
+    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;
+    subgraphs?: 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;
+}
+declare class Queue {
+    private buffer;
+    private listeners;
+    push(item: Message): void;
+    get(options: {
+        timeout: number;
+        signal?: AbortSignal;
+    }): Promise<Message>;
+}
+declare class CancellationAbortController extends AbortController {
+    abort(reason: "rollback" | "interrupt"): void;
+}
+declare class StreamManagerImpl {
+    readers: Record<string, Queue>;
+    control: Record<string, CancellationAbortController>;
+    getQueue(runId: string, options: {
+        ifNotFound: "create";
+    }): Queue;
+    getQueue(runId: string, options: {
+        ifNotFound: "ignore";
+    }): Queue | undefined;
+    getControl(runId: string): CancellationAbortController | undefined;
+    isLocked(runId: string): boolean;
+    lock(runId: string): AbortSignal;
+    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: {
+        graph_id?: string;
+        metadata?: Metadata;
+        limit: number;
+        offset: number;
+    }, auth: AuthContext | undefined): AsyncGenerator<any, void, unknown>;
+    static get(assistant_id: string, auth: AuthContext | undefined): Promise<Assistant>;
+    static put(assistant_id: string, options: {
+        config: RunnableConfig;
+        graph_id: string;
+        metadata?: Metadata;
+        if_exists: OnConflictBehavior;
+        name?: string;
+    }, auth: AuthContext | undefined): Promise<Assistant>;
+    static patch(assistantId: string, options: {
+        config?: RunnableConfig;
+        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: {
+        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: Record<string, 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 declare class Threads {
+    static 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;
+    }>;
+    static get(thread_id: string, auth: AuthContext | undefined): Promise<Thread>;
+    static put(thread_id: string, options: {
+        metadata?: Metadata;
+        if_exists: OnConflictBehavior;
+    }, auth: AuthContext | undefined): Promise<Thread>;
+    static patch(threadId: string, options: {
+        metadata?: Metadata;
+    }, auth: AuthContext | undefined): Promise<Thread>;
+    static 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<{
+        run: Run;
+        attempt: number;
+        signal: AbortSignal;
+    }>;
+    static 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[]>;
+    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<{} | undefined>;
+    static cancel(threadId: string | undefined, runIds: string[], options: {
+        action?: "interrupt" | "rollback";
+    }, auth: AuthContext | undefined): Promise<void>;
+    static 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;
+        }, auth: AuthContext | undefined): AsyncGenerator<{
+            event: string;
+            data: unknown;
+        }>;
+        publish(runId: string, topic: string, data: unknown): Promise<void>;
+    };
+}
+export declare class Crons {
+}
+export {};

package/dist/storage/persist.d.mts

@@ -0,0 +1,18 @@
+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, unknown>;
+}

package/dist/storage/store.d.mts

@@ -0,0 +1,17 @@
+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/stream.d.mts

@@ -0,0 +1,38 @@
+import type { Run, RunnableConfig, Checkpoint } from "./storage/ops.mjs";
+import { type CheckpointMetadata, type Interrupt, type StateSnapshot } from "@langchain/langgraph";
+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, attempt?: number, options?: {
+    onCheckpoint?: (checkpoint: StreamCheckpoint) => void;
+    onTaskResult?: (taskResult: StreamTaskResult) => void;
+    signal?: AbortSignal;
+}): AsyncGenerator<{
+    event: string;
+    data: unknown;
+}>;
+export {};

package/dist/ui/load.d.mts

@@ -0,0 +1,8 @@
+import { Hono } from "hono";
+export declare function registerGraphUi(defs: Record<string, string>, options: {
+    cwd: string;
+    config?: {
+        shared?: string[];
+    };
+}): Promise<void>;
+export declare const api: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;

package/dist/utils/abort.d.mts

@@ -0,0 +1 @@
+export declare const combineAbortSignals: (...input: (AbortSignal | undefined | null)[]) => AbortSignal;

package/dist/utils/hono.d.mts

@@ -0,0 +1,5 @@
+import type { Context } from "hono";
+import { StreamingApi } from "hono/utils/stream";
+export declare function jsonExtra<T>(c: Context, object: T): Response & import("hono").TypedResponse<unknown, import("hono/utils/http-status").ContentfulStatusCode, "body">;
+export declare function waitKeepAlive(c: Context, promise: Promise<unknown>): Response;
+export declare const getDisconnectAbortSignal: (c: Context, stream: StreamingApi) => AbortSignal;

package/dist/utils/importMap.d.mts

@@ -0,0 +1,55 @@
+import { PromptTemplate, AIMessagePromptTemplate, ChatMessagePromptTemplate, ChatPromptTemplate, HumanMessagePromptTemplate, MessagesPlaceholder, SystemMessagePromptTemplate, ImagePromptTemplate, PipelinePromptTemplate } from "@langchain/core/prompts";
+import { AIMessage, AIMessageChunk, BaseMessage, BaseMessageChunk, ChatMessage, ChatMessageChunk, FunctionMessage, FunctionMessageChunk, HumanMessage, HumanMessageChunk, SystemMessage, SystemMessageChunk, ToolMessage, ToolMessageChunk } from "@langchain/core/messages";
+import { StringPromptValue } from "@langchain/core/prompt_values";
+export declare const prompts__prompt: {
+    PromptTemplate: typeof PromptTemplate;
+};
+export declare const schema__messages: {
+    AIMessage: typeof AIMessage;
+    AIMessageChunk: typeof AIMessageChunk;
+    BaseMessage: typeof BaseMessage;
+    BaseMessageChunk: typeof BaseMessageChunk;
+    ChatMessage: typeof ChatMessage;
+    ChatMessageChunk: typeof ChatMessageChunk;
+    FunctionMessage: typeof FunctionMessage;
+    FunctionMessageChunk: typeof FunctionMessageChunk;
+    HumanMessage: typeof HumanMessage;
+    HumanMessageChunk: typeof HumanMessageChunk;
+    SystemMessage: typeof SystemMessage;
+    SystemMessageChunk: typeof SystemMessageChunk;
+    ToolMessage: typeof ToolMessage;
+    ToolMessageChunk: typeof ToolMessageChunk;
+};
+export declare const schema: {
+    AIMessage: typeof AIMessage;
+    AIMessageChunk: typeof AIMessageChunk;
+    BaseMessage: typeof BaseMessage;
+    BaseMessageChunk: typeof BaseMessageChunk;
+    ChatMessage: typeof ChatMessage;
+    ChatMessageChunk: typeof ChatMessageChunk;
+    FunctionMessage: typeof FunctionMessage;
+    FunctionMessageChunk: typeof FunctionMessageChunk;
+    HumanMessage: typeof HumanMessage;
+    HumanMessageChunk: typeof HumanMessageChunk;
+    SystemMessage: typeof SystemMessage;
+    SystemMessageChunk: typeof SystemMessageChunk;
+    ToolMessage: typeof ToolMessage;
+    ToolMessageChunk: typeof ToolMessageChunk;
+};
+export declare const prompts__chat: {
+    AIMessagePromptTemplate: typeof AIMessagePromptTemplate;
+    ChatMessagePromptTemplate: typeof ChatMessagePromptTemplate;
+    ChatPromptTemplate: typeof ChatPromptTemplate;
+    HumanMessagePromptTemplate: typeof HumanMessagePromptTemplate;
+    MessagesPlaceholder: typeof MessagesPlaceholder;
+    SystemMessagePromptTemplate: typeof SystemMessagePromptTemplate;
+};
+export declare const prompts__image: {
+    ImagePromptTemplate: typeof ImagePromptTemplate;
+};
+export declare const prompts__pipeline: {
+    PipelinePromptTemplate: typeof PipelinePromptTemplate;
+};
+export declare const prompts__base: {
+    StringPromptValue: typeof StringPromptValue;
+};

package/dist/utils/runnableConfig.d.mts

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