@langchain/langgraph 0.0.11 → 0.0.13

package/dist/pregel/index.d.ts

@@ -1,75 +1,111 @@
-import { Runnable, RunnableConfig } from "@langchain/core/runnables";
+import { Runnable, RunnableConfig, RunnableFunc } from "@langchain/core/runnables";
 import { CallbackManagerForChainRun } from "@langchain/core/callbacks/manager";
 import { IterableReadableStream } from "@langchain/core/utils/stream";
 import { BaseChannel } from "../channels/base.js";
-import { BaseCheckpointSaver } from "../checkpoint/base.js";
-import { ChannelInvoke } from "./read.js";
+import { BaseCheckpointSaver, Checkpoint, ReadonlyCheckpoint } from "../checkpoint/base.js";
+import { PregelNode } from "./read.js";
 import { ChannelWrite } from "./write.js";
-export declare class GraphRecursionError extends Error {
-    constructor(message?: string);
-}
+import { All, PregelExecutableTask, PregelTaskDescription } from "./types.js";
+type WriteValue = Runnable | RunnableFunc<unknown, unknown> | unknown;
 export declare class Channel {
     static subscribeTo(channels: string, options?: {
         key?: string;
-        when?: (arg: any) => boolean;
         tags?: string[];
-    }): ChannelInvoke;
+    }): PregelNode;
     static subscribeTo(channels: string[], options?: {
-        key?: string;
-        when?: (arg: any) => boolean;
         tags?: string[];
-    }): ChannelInvoke;
-    static writeTo(...args: any[]): ChannelWrite;
+    }): PregelNode;
+    static writeTo(channels: string[], kwargs?: Record<string, WriteValue>): ChannelWrite;
 }
-export interface PregelInterface {
+export type StreamMode = "values" | "updates";
+/**
+ * Construct a type with a set of properties K of type T
+ */
+type StrRecord<K extends string, T> = {
+    [P in K]: T;
+};
+export interface PregelInterface<Nn extends StrRecord<string, PregelNode>, Cc extends StrRecord<string, BaseChannel>> {
+    nodes: Nn;
+    channels: Cc;
+    inputs: keyof Cc | Array<keyof Cc>;
+    outputs: keyof Cc | Array<keyof Cc>;
     /**
-     * @default {}
+     * @default true
      */
-    channels?: Record<string, BaseChannel>;
+    autoValidate?: boolean;
     /**
-     * @default "output"
+     * @default "values"
      */
-    output?: string | Array<string>;
+    streamMode?: StreamMode;
+    streamChannels?: keyof Cc | Array<keyof Cc>;
     /**
-     * @default "input"
+     * @default []
      */
-    input?: string | Array<string>;
+    interruptAfter?: Array<keyof Nn> | All;
     /**
      * @default []
      */
-    hidden?: Array<string>;
+    interruptBefore?: Array<keyof Nn> | All;
     /**
-     * @default false
+     * @default undefined
      */
-    debug?: boolean;
+    stepTimeout?: number;
     /**
-     * @default []
+     * @default false
      */
-    interrupt?: string[];
-    nodes: Record<string, ChannelInvoke>;
+    debug?: boolean;
     checkpointer?: BaseCheckpointSaver;
-    stepTimeout?: number;
 }
-export interface PregelOptions extends RunnableConfig {
-    outputKeys?: string | string[];
+export interface PregelOptions<Nn extends StrRecord<string, PregelNode>, Cc extends StrRecord<string, BaseChannel>> extends RunnableConfig {
+    streamMode?: StreamMode;
+    inputKeys?: keyof Cc | Array<keyof Cc>;
+    outputKeys?: keyof Cc | Array<keyof Cc>;
+    interruptBefore?: All | Array<keyof Nn>;
+    interruptAfter?: All | Array<keyof Nn>;
+    debug?: boolean;
 }
 export type PregelInputType = any;
 export type PregelOutputType = any;
-export declare class Pregel extends Runnable<PregelInputType, PregelOutputType, PregelOptions> implements PregelInterface {
+export declare class Pregel<const Nn extends StrRecord<string, PregelNode>, const Cc extends StrRecord<string, BaseChannel>> extends Runnable<PregelInputType, PregelOutputType, PregelOptions<Nn, Cc>> implements PregelInterface<Nn, Cc> {
     static lc_name(): string;
     lc_namespace: string[];
-    channels: Record<string, BaseChannel>;
-    output: string | Array<string>;
-    input: string | Array<string>;
-    hidden: Array<string>;
+    nodes: Nn;
+    channels: Cc;
+    inputs: keyof Cc | Array<keyof Cc>;
+    outputs: keyof Cc | Array<keyof Cc>;
+    autoValidate: boolean;
+    streamMode: StreamMode;
+    streamChannels?: keyof Cc | Array<keyof Cc>;
+    interruptAfter?: Array<keyof Nn> | All;
+    interruptBefore?: Array<keyof Nn> | All;
+    stepTimeout?: number;
     debug: boolean;
-    nodes: Record<string, ChannelInvoke>;
     checkpointer?: BaseCheckpointSaver;
-    stepTimeout?: number;
-    interrupt: string[];
-    constructor(fields: PregelInterface);
-    _transform(input: AsyncGenerator<PregelInputType>, runManager?: CallbackManagerForChainRun, config?: RunnableConfig & Partial<Record<string, unknown>>): AsyncGenerator<PregelOutputType>;
-    invoke(input: PregelInputType, options?: PregelOptions): Promise<PregelOutputType>;
-    stream(input: PregelInputType, config?: PregelOptions): Promise<IterableReadableStream<PregelOutputType>>;
-    transform(generator: AsyncGenerator<PregelInputType>, config?: PregelOptions): AsyncGenerator<PregelOutputType>;
+    constructor(fields: PregelInterface<Nn, Cc>);
+    validate(): this;
+    get streamChannelsList(): Array<keyof Cc>;
+    get streamChannelsAsIs(): keyof Cc | Array<keyof Cc>;
+    _defaults(config: PregelOptions<Nn, Cc>): [
+        boolean,
+        StreamMode,
+        // stream mode
+        keyof Cc | Array<keyof Cc>,
+        // input keys
+        keyof Cc | Array<keyof Cc>,
+        RunnableConfig,
+        // config without pregel keys
+        All | Array<keyof Nn>,
+        // interrupt before
+        All | Array<keyof Nn>
+    ];
+    _transform(input: AsyncGenerator<PregelInputType>, runManager?: CallbackManagerForChainRun, config?: PregelOptions<Nn, Cc>): AsyncGenerator<PregelOutputType>;
+    invoke(input: PregelInputType, options?: PregelOptions<Nn, Cc>): Promise<PregelOutputType>;
+    stream(input: PregelInputType, config?: PregelOptions<Nn, Cc>): Promise<IterableReadableStream<PregelOutputType>>;
+    transform(generator: AsyncGenerator<PregelInputType>, config?: PregelOptions<Nn, Cc>): AsyncGenerator<PregelOutputType>;
 }
+export declare function _shouldInterrupt<N extends PropertyKey, C extends PropertyKey>(checkpoint: ReadonlyCheckpoint, interruptNodes: All | Array<N>, snapshotChannels: Array<C>, tasks: Array<PregelExecutableTask<N, C>>): boolean;
+export declare function _localRead<Cc extends StrRecord<string, BaseChannel>>(checkpoint: ReadonlyCheckpoint, channels: Cc, writes: Array<[keyof Cc, unknown]>, select: Array<keyof Cc> | keyof Cc, fresh?: boolean): Record<string, unknown> | unknown;
+export declare function _applyWrites<Cc extends Record<string, BaseChannel>>(checkpoint: Checkpoint, channels: Cc, pendingWrites: Array<[keyof Cc, unknown]>): void;
+export declare function _prepareNextTasks<Nn extends StrRecord<string, PregelNode>, Cc extends StrRecord<string, BaseChannel>>(checkpoint: ReadonlyCheckpoint, processes: Nn, channels: Cc, forExecution: false): [Checkpoint, Array<PregelTaskDescription>];
+export declare function _prepareNextTasks<Nn extends StrRecord<string, PregelNode>, Cc extends StrRecord<string, BaseChannel>>(checkpoint: ReadonlyCheckpoint, processes: Nn, channels: Cc, forExecution: true): [Checkpoint, Array<PregelExecutableTask<keyof Nn, keyof Cc>>];
+export {};