@langchain/langgraph 1.1.4 → 1.1.5

package/dist/prebuilt/react_agent_executor.d.ts

@@ -6,11 +6,13 @@ import { AnnotationRoot, SingleReducer, StateDefinition } from "../graph/annotat
 import { START } from "../constants.js";
 import { CompiledStateGraph } from "../graph/state.js";
 import { Messages } from "../graph/messages_reducer.js";
+import "../graph/index.js";
 import { MessagesAnnotation } from "../graph/messages_annotation.js";
+import "../web.js";
 import { ToolNode } from "./tool_node.js";
 import { All, BaseCheckpointSaver, BaseStore } from "@langchain/langgraph-checkpoint";
 import { Runnable, RunnableBinding, RunnableLike, RunnableSequence, RunnableToolLike } from "@langchain/core/runnables";
-import * as _langchain_core_messages35 from "@langchain/core/messages";
+import * as _langchain_core_messages0 from "@langchain/core/messages";
 import { BaseMessage, BaseMessageLike, SystemMessage } from "@langchain/core/messages";
 import { InteropZodObject, InteropZodType } from "@langchain/core/utils/types";
 import { DynamicTool, StructuredToolInterface } from "@langchain/core/tools";
@@ -40,7 +42,7 @@ type StateModifier = Prompt;
 /** @deprecated Use Prompt instead. */
 type MessageModifier = SystemMessage | string | ((messages: BaseMessage[]) => BaseMessage[]) | ((messages: BaseMessage[]) => Promise<BaseMessage[]>) | Runnable;
 declare const createReactAgentAnnotation: <T extends Record<string, any> = Record<string, any>>() => AnnotationRoot<{
-  messages: BinaryOperatorAggregate<BaseMessage<_langchain_core_messages35.MessageStructure<_langchain_core_messages35.MessageToolSet>, _langchain_core_messages35.MessageType>[], Messages>;
+  messages: BinaryOperatorAggregate<BaseMessage<_langchain_core_messages0.MessageStructure<_langchain_core_messages0.MessageToolSet>, _langchain_core_messages0.MessageType>[], Messages>;
   structuredResponse: {
     (): LastValue<T>;
     (annotation: SingleReducer<T, T>): BinaryOperatorAggregate<T, T>;
@@ -48,7 +50,7 @@ declare const createReactAgentAnnotation: <T extends Record<string, any> = Recor
   };
 }>;
 declare const PreHookAnnotation: AnnotationRoot<{
-  llmInputMessages: BinaryOperatorAggregate<BaseMessage<_langchain_core_messages35.MessageStructure<_langchain_core_messages35.MessageToolSet>, _langchain_core_messages35.MessageType>[], Messages>;
+  llmInputMessages: BinaryOperatorAggregate<BaseMessage<_langchain_core_messages0.MessageStructure<_langchain_core_messages0.MessageToolSet>, _langchain_core_messages0.MessageType>[], Messages>;
 }>;
 type PreHookAnnotation = typeof PreHookAnnotation;
 type AnyAnnotationRoot = AnnotationRoot<any>;
@@ -58,9 +60,7 @@ type ToAnnotationRoot<A extends AnyAnnotationRoot | InteropZodObject> = A extend
  * Update your import to `import { CreateAgentParams } from "langchain";`
  */
 type CreateReactAgentParams<A extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, StructuredResponseType extends Record<string, any> = Record<string, any>, C extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot> = {
-  /** The chat model that can utilize OpenAI-style tool calling. */
-  llm: LanguageModelLike | ((state: ToAnnotationRoot<A>["State"] & PreHookAnnotation["State"], runtime: Runtime<ToAnnotationRoot<C>["State"]>) => Promise<LanguageModelLike> | LanguageModelLike);
-  /** A list of tools or a ToolNode. */
+  /** The chat model that can utilize OpenAI-style tool calling. */llm: LanguageModelLike | ((state: ToAnnotationRoot<A>["State"] & PreHookAnnotation["State"], runtime: Runtime<ToAnnotationRoot<C>["State"]>) => Promise<LanguageModelLike> | LanguageModelLike); /** A list of tools or a ToolNode. */
   tools: ToolNode | (ServerTool | ClientTool)[];
   /**
    * @deprecated Use prompt instead.
@@ -92,14 +92,10 @@ type CreateReactAgentParams<A extends AnyAnnotationRoot | InteropZodObject = Any
   /**
    * An optional schema for the context.
    */
-  contextSchema?: C;
-  /** An optional checkpoint saver to persist the agent's state. */
-  checkpointSaver?: BaseCheckpointSaver | boolean;
-  /** An optional checkpoint saver to persist the agent's state. Alias of "checkpointSaver". */
-  checkpointer?: BaseCheckpointSaver | boolean;
-  /** An optional list of node names to interrupt before running. */
-  interruptBefore?: N[] | All;
-  /** An optional list of node names to interrupt after running. */
+  contextSchema?: C; /** An optional checkpoint saver to persist the agent's state. */
+  checkpointSaver?: BaseCheckpointSaver | boolean; /** An optional checkpoint saver to persist the agent's state. Alias of "checkpointSaver". */
+  checkpointer?: BaseCheckpointSaver | boolean; /** An optional list of node names to interrupt before running. */
+  interruptBefore?: N[] | All; /** An optional list of node names to interrupt after running. */
   interruptAfter?: N[] | All;
   store?: BaseStore;
   /**

package/dist/prebuilt/react_agent_executor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"react_agent_executor.d.ts","names":["_langchain_core_messages35","_langchain_core_language_models_chat_models0","___web_js2","BaseChatModel","LanguageModelLike","BaseMessage","BaseMessageLike","SystemMessage","Runnable","RunnableToolLike","RunnableSequence","RunnableBinding","RunnableLike","DynamicTool","StructuredToolInterface","InteropZodObject","InteropZodType","All","BaseCheckpointSaver","BaseStore","CompiledStateGraph","AnnotationRoot","MessagesAnnotation","ToolNode","LangGraphRunnableConfig","Runtime","Messages","START","InteropZodToStateDefinition","AgentState","Record","StructuredResponseType","N","StructuredResponseSchemaOptions","ServerTool","ClientTool","ConfigurableModelInterface","Promise","_shouldBindTools","_bindTools","_langchain_core_language_models_base0","BaseLanguageModelInput","MessageToolSet","MessageStructure","AIMessageChunk","BaseChatModelCallOptions","_getModel","Prompt","State","StateModifier","MessageModifier","createReactAgentAnnotation","MessageType","BinaryOperatorAggregate","T","LastValue","SingleReducer","StateDefinition","S","PreHookAnnotation","AnyAnnotationRoot","ToAnnotationRoot","A","CreateReactAgentParams","C","createReactAgent","StructuredResponseFormat","spec","ReturnType"],"sources":["../../src/prebuilt/react_agent_executor.d.ts"],"sourcesContent":["import { BaseChatModel } from \"@langchain/core/language_models/chat_models\";\nimport { LanguageModelLike } from \"@langchain/core/language_models/base\";\nimport { BaseMessage, BaseMessageLike, SystemMessage } from \"@langchain/core/messages\";\nimport { Runnable, RunnableToolLike, RunnableSequence, RunnableBinding, type RunnableLike } from \"@langchain/core/runnables\";\nimport { DynamicTool, StructuredToolInterface } from \"@langchain/core/tools\";\nimport type { InteropZodObject, InteropZodType } from \"@langchain/core/utils/types\";\nimport { All, BaseCheckpointSaver, BaseStore } from \"@langchain/langgraph-checkpoint\";\nimport { type CompiledStateGraph, AnnotationRoot } from \"../graph/index.js\";\nimport { MessagesAnnotation } from \"../graph/messages_annotation.js\";\nimport { ToolNode } from \"./tool_node.js\";\nimport { LangGraphRunnableConfig, Runtime } from \"../pregel/runnable_types.js\";\nimport { Messages } from \"../graph/messages_reducer.js\";\nimport { START } from \"../constants.js\";\nimport type { InteropZodToStateDefinition } from \"../graph/zod/meta.js\";\n/**\n * @deprecated `AgentState` has been moved to {@link https://www.npmjs.com/package/langchain langchain} package.\n * Update your import to `import { AgentState } from \"langchain\";`\n */\nexport interface AgentState<StructuredResponseType extends Record<string, any> = Record<string, any>> {\n    messages: BaseMessage[];\n    structuredResponse: StructuredResponseType;\n}\nexport type N = typeof START | \"agent\" | \"tools\";\ntype StructuredResponseSchemaOptions<StructuredResponseType> = {\n    schema: InteropZodType<StructuredResponseType> | Record<string, any>;\n    prompt?: string;\n    strict?: boolean;\n    [key: string]: unknown;\n};\ntype ServerTool = Record<string, unknown>;\ntype ClientTool = StructuredToolInterface | DynamicTool | RunnableToolLike;\ninterface ConfigurableModelInterface {\n    _queuedMethodOperations: Record<string, any>;\n    _model: () => Promise<BaseChatModel>;\n}\nexport declare function _shouldBindTools(llm: LanguageModelLike, tools: (ClientTool | ServerTool)[]): Promise<boolean>;\nexport declare function _bindTools(llm: LanguageModelLike, toolClasses: (ClientTool | ServerTool)[]): Promise<Runnable<import(\"@langchain/core/language_models/base\").BaseLanguageModelInput, import(\"@langchain/core/messages\").AIMessageChunk<import(\"@langchain/core/messages\").MessageStructure<import(\"@langchain/core/messages\").MessageToolSet>>, import(\"@langchain/core/language_models/chat_models\").BaseChatModelCallOptions> | RunnableBinding<any, any, any> | RunnableSequence<any, any>>;\nexport declare function _getModel(llm: LanguageModelLike | ConfigurableModelInterface): Promise<LanguageModelLike>;\nexport type Prompt = SystemMessage | string | ((state: typeof MessagesAnnotation.State, config: LangGraphRunnableConfig) => BaseMessageLike[]) | ((state: typeof MessagesAnnotation.State, config: LangGraphRunnableConfig) => Promise<BaseMessageLike[]>) | Runnable;\n/** @deprecated Use Prompt instead. */\nexport type StateModifier = Prompt;\n/** @deprecated Use Prompt instead. */\nexport type MessageModifier = SystemMessage | string | ((messages: BaseMessage[]) => BaseMessage[]) | ((messages: BaseMessage[]) => Promise<BaseMessage[]>) | Runnable;\nexport declare const createReactAgentAnnotation: <T extends Record<string, any> = Record<string, any>>() => AnnotationRoot<{\n    messages: import(\"../web.js\").BinaryOperatorAggregate<BaseMessage<import(\"@langchain/core/messages\").MessageStructure<import(\"@langchain/core/messages\").MessageToolSet>, import(\"@langchain/core/messages\").MessageType>[], Messages>;\n    structuredResponse: {\n        (): import(\"../web.js\").LastValue<T>;\n        (annotation: import(\"../web.js\").SingleReducer<T, T>): import(\"../web.js\").BinaryOperatorAggregate<T, T>;\n        Root: <S extends import(\"../web.js\").StateDefinition>(sd: S) => AnnotationRoot<S>;\n    };\n}>;\ndeclare const PreHookAnnotation: AnnotationRoot<{\n    llmInputMessages: import(\"../web.js\").BinaryOperatorAggregate<BaseMessage<import(\"@langchain/core/messages\").MessageStructure<import(\"@langchain/core/messages\").MessageToolSet>, import(\"@langchain/core/messages\").MessageType>[], Messages>;\n}>;\ntype PreHookAnnotation = typeof PreHookAnnotation;\ntype AnyAnnotationRoot = AnnotationRoot<any>;\ntype ToAnnotationRoot<A extends AnyAnnotationRoot | InteropZodObject> = A extends AnyAnnotationRoot ? A : A extends InteropZodObject ? AnnotationRoot<InteropZodToStateDefinition<A>> : never;\n/**\n * @deprecated `CreateReactAgentParams` has been moved to {@link https://www.npmjs.com/package/langchain langchain} package.\n * Update your import to `import { CreateAgentParams } from \"langchain\";`\n */\nexport type CreateReactAgentParams<A extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot, StructuredResponseType extends Record<string, any> = Record<string, any>, C extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot> = {\n    /** The chat model that can utilize OpenAI-style tool calling. */\n    llm: LanguageModelLike | ((state: ToAnnotationRoot<A>[\"State\"] & PreHookAnnotation[\"State\"], runtime: Runtime<ToAnnotationRoot<C>[\"State\"]>) => Promise<LanguageModelLike> | LanguageModelLike);\n    /** A list of tools or a ToolNode. */\n    tools: ToolNode | (ServerTool | ClientTool)[];\n    /**\n     * @deprecated Use prompt instead.\n     */\n    messageModifier?: MessageModifier;\n    /**\n     * @deprecated Use prompt instead.\n     */\n    stateModifier?: StateModifier;\n    /**\n     * An optional prompt for the LLM. This takes full graph state BEFORE the LLM is called and prepares the input to LLM.\n     *\n     * Can take a few different forms:\n     *\n     * - str: This is converted to a SystemMessage and added to the beginning of the list of messages in state[\"messages\"].\n     * - SystemMessage: this is added to the beginning of the list of messages in state[\"messages\"].\n     * - Function: This function should take in full graph state and the output is then passed to the language model.\n     * - Runnable: This runnable should take in full graph state and the output is then passed to the language model.\n     *\n     * Note:\n     * Prior to `v0.2.46`, the prompt was set using `stateModifier` / `messagesModifier` parameters.\n     * This is now deprecated and will be removed in a future release.\n     */\n    prompt?: Prompt;\n    /**\n     * Additional state schema for the agent.\n     */\n    stateSchema?: A;\n    /**\n     * An optional schema for the context.\n     */\n    contextSchema?: C;\n    /** An optional checkpoint saver to persist the agent's state. */\n    checkpointSaver?: BaseCheckpointSaver | boolean;\n    /** An optional checkpoint saver to persist the agent's state. Alias of \"checkpointSaver\". */\n    checkpointer?: BaseCheckpointSaver | boolean;\n    /** An optional list of node names to interrupt before running. */\n    interruptBefore?: N[] | All;\n    /** An optional list of node names to interrupt after running. */\n    interruptAfter?: N[] | All;\n    store?: BaseStore;\n    /**\n     * An optional schema for the final agent output.\n     *\n     * If provided, output will be formatted to match the given schema and returned in the 'structuredResponse' state key.\n     * If not provided, `structuredResponse` will not be present in the output state.\n     *\n     * Can be passed in as:\n     *   - Zod schema\n     *   - JSON schema\n     *   - { prompt, schema }, where schema is one of the above.\n     *        The prompt will be used together with the model that is being used to generate the structured response.\n     *\n     * @remarks\n     * **Important**: `responseFormat` requires the model to support `.withStructuredOutput()`.\n     *\n     * **Note**: The graph will make a separate call to the LLM to generate the structured response after the agent loop is finished.\n     * This is not the only strategy to get structured responses, see more options in [this guide](https://langchain-ai.github.io/langgraph/how-tos/react-agent-structured-output/).\n     */\n    responseFormat?: InteropZodType<StructuredResponseType> | StructuredResponseSchemaOptions<StructuredResponseType> | Record<string, any>;\n    /**\n     * An optional name for the agent.\n     */\n    name?: string;\n    /**\n     * An optional description for the agent.\n     * This can be used to describe the agent to the underlying supervisor LLM.\n     */\n    description?: string | undefined;\n    /**\n     * Use to specify how to expose the agent name to the underlying supervisor LLM.\n  \n        - undefined: Relies on the LLM provider {@link AIMessage#name}. Currently, only OpenAI supports this.\n        - `\"inline\"`: Add the agent name directly into the content field of the {@link AIMessage} using XML-style tags.\n            Example: `\"How can I help you\"` -> `\"<name>agent_name</name><content>How can I help you?</content>\"`\n     */\n    includeAgentName?: \"inline\" | undefined;\n    /**\n     * An optional node to add before the `agent` node (i.e., the node that calls the LLM).\n     * Useful for managing long message histories (e.g., message trimming, summarization, etc.).\n     */\n    preModelHook?: RunnableLike<ToAnnotationRoot<A>[\"State\"] & PreHookAnnotation[\"State\"], ToAnnotationRoot<A>[\"Update\"] & PreHookAnnotation[\"Update\"], LangGraphRunnableConfig>;\n    /**\n     * An optional node to add after the `agent` node (i.e., the node that calls the LLM).\n     * Useful for implementing human-in-the-loop, guardrails, validation, or other post-processing.\n     */\n    postModelHook?: RunnableLike<ToAnnotationRoot<A>[\"State\"], ToAnnotationRoot<A>[\"Update\"], LangGraphRunnableConfig>;\n    /**\n     * Determines the version of the graph to create.\n     *\n     * Can be one of\n     * - `\"v1\"`: The tool node processes a single message. All tool calls in the message are\n     *           executed in parallel within the tool node.\n     * - `\"v2\"`: The tool node processes a single tool call. Tool calls are distributed across\n     *           multiple instances of the tool node using the Send API.\n     *\n     * @default `\"v1\"`\n     */\n    version?: \"v1\" | \"v2\";\n};\n/**\n * @deprecated `createReactAgent` has been moved to {@link https://www.npmjs.com/package/langchain langchain} package.\n * Update your import to `import { createAgent } from \"langchain\";`\n *\n * Creates a StateGraph agent that relies on a chat model utilizing tool calling.\n *\n * @example\n * ```ts\n * import { ChatOpenAI } from \"@langchain/openai\";\n * import { tool } from \"@langchain/core/tools\";\n * import { z } from \"zod\";\n * import { createReactAgent } from \"@langchain/langgraph/prebuilt\";\n *\n * const model = new ChatOpenAI({\n *   model: \"gpt-4o\",\n * });\n *\n * const getWeather = tool((input) => {\n *   if ([\"sf\", \"san francisco\"].includes(input.location.toLowerCase())) {\n *     return \"It's 60 degrees and foggy.\";\n *   } else {\n *     return \"It's 90 degrees and sunny.\";\n *   }\n * }, {\n *   name: \"get_weather\",\n *   description: \"Call to get the current weather.\",\n *   schema: z.object({\n *     location: z.string().describe(\"Location to get the weather for.\"),\n *   })\n * })\n *\n * const agent = createReactAgent({ llm: model, tools: [getWeather] });\n *\n * const inputs = {\n *   messages: [{ role: \"user\", content: \"what is the weather in SF?\" }],\n * };\n *\n * const stream = await agent.stream(inputs, { streamMode: \"values\" });\n *\n * for await (const { messages } of stream) {\n *   console.log(messages);\n * }\n * // Returns the messages in the state at each step of execution\n * ```\n */\nexport declare function createReactAgent<A extends AnyAnnotationRoot | InteropZodObject = typeof MessagesAnnotation, StructuredResponseFormat extends Record<string, any> = Record<string, any>, C extends AnyAnnotationRoot | InteropZodObject = AnyAnnotationRoot>(params: CreateReactAgentParams<A, StructuredResponseFormat, C>): CompiledStateGraph<ToAnnotationRoot<A>[\"State\"], ToAnnotationRoot<A>[\"Update\"], any, typeof MessagesAnnotation.spec & ToAnnotationRoot<A>[\"spec\"], ReturnType<typeof createReactAgentAnnotation<StructuredResponseFormat>>[\"spec\"] & ToAnnotationRoot<A>[\"spec\"]>;\nexport {};\n"],"mappings":"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"}
+{"version":3,"file":"react_agent_executor.d.ts","names":[],"sources":["../../src/prebuilt/react_agent_executor.ts"],"mappings":"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"}

package/dist/prebuilt/tool_executor.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"tool_executor.d.cts","names":["RunnableBinding","RunnableConfig","RunnableToolLike","StructuredToolInterface","ToolExecutorArgs","Array","ToolInvocationInterface","ToolExecutorInputType","ToolExecutorOutputType","ToolExecutor","Record","Promise"],"sources":["../../src/prebuilt/tool_executor.d.ts"],"sourcesContent":["import { RunnableBinding, RunnableConfig, RunnableToolLike } from \"@langchain/core/runnables\";\nimport { StructuredToolInterface } from \"@langchain/core/tools\";\n/** @deprecated Use {@link ToolNode} instead. */\nexport interface ToolExecutorArgs {\n    tools: Array<StructuredToolInterface | RunnableToolLike>;\n    /**\n     * @default {INVALID_TOOL_MSG_TEMPLATE}\n     */\n    invalidToolMsgTemplate?: string;\n}\n/**\n * Interface for invoking a tool\n */\nexport interface ToolInvocationInterface {\n    tool: string;\n    toolInput: string;\n}\ntype ToolExecutorInputType = any;\ntype ToolExecutorOutputType = any;\n/** @deprecated Use {@link ToolNode} instead. */\nexport declare class ToolExecutor extends RunnableBinding<ToolExecutorInputType, ToolExecutorOutputType> {\n    lc_graph_name: string;\n    tools: Array<StructuredToolInterface | RunnableToolLike>;\n    toolMap: Record<string, StructuredToolInterface | RunnableToolLike>;\n    invalidToolMsgTemplate: string;\n    constructor(fields: ToolExecutorArgs);\n    /**\n     * Execute a tool invocation\n     *\n     * @param {ToolInvocationInterface} toolInvocation The tool to invoke and the input to pass to it.\n     * @param {RunnableConfig | undefined} config Optional configuration to pass to the tool when invoked.\n     * @returns Either the result of the tool invocation (`string` or `ToolMessage`, set by the `ToolOutput` generic) or a string error message.\n     */\n    _execute(toolInvocation: ToolInvocationInterface, config?: RunnableConfig): Promise<ToolExecutorOutputType>;\n}\nexport {};\n"],"mappings":";;;;;UAGiBI,gBAAAA;EAAAA,KAAAA,EACNC,KADMD,CACAD,uBADgB,GACUD,gBADV,CAAA;EAAA;;;wBACtBG,CAAAA,EAAAA,MAAAA;;AASX;AAGC;AACyB;AAGLI,UAPJH,uBAAAA,CAOgB;EAAA,IAAA,EAAA,MAAA;WAAyBC,EAAAA,MAAAA;;KAHrDA,qBAAAA,GAKYJ,GAAAA;KAJZK,sBAAAA,GAIsCN,GAAAA;;AACfC,cAHPM,YAAAA,SAAqBT,eAGdG,CAH8BI,qBAG9BJ,EAHqDK,sBAGrDL,CAAAA,CAAAA;eAA0BD,EAAAA,MAAAA;OAAzCQ,EADFL,KACEK,CADIP,uBACJO,GAD8BR,gBAC9BQ,CAAAA;SAEWN,EAFXM,MAEWN,CAAAA,MAAAA,EAFID,uBAEJC,GAF8BF,gBAE9BE,CAAAA;wBAQKE,EAAAA,MAAAA;aAAkCL,CAAAA,MAAAA,EARvCG,gBAQuCH;;;;;;;;2BAAlCK,kCAAkCL,iBAAiBU,QAAQH"}
+{"version":3,"file":"tool_executor.d.cts","names":[],"sources":["../../src/prebuilt/tool_executor.ts"],"mappings":";;;;;UAWiB,gBAAA;EACf,KAAA,EAAO,KAAA,CAAM,uBAAA,GAA0B,gBAAA;EADR;;;EAK/B,sBAAA;AAAA;;;;UAMe,uBAAA;EACf,IAAA;EACA,SAAA;AAAA;AAAA,KAIG,qBAAA;AAAA,KAGA,sBAAA;AATL;AAAA,cAYa,YAAA,SAAqB,eAAA,CAChC,qBAAA,EACA,sBAAA;EAEA,aAAA;EAEA,KAAA,EAAO,KAAA,CAAM,uBAAA,GAA0B,gBAAA;EAEvC,OAAA,EAAS,MAAA,SAAe,uBAAA,GAA0B,gBAAA;EAElD,sBAAA;EAEA,WAAA,CAAY,MAAA,EAAQ,gBAAA;;;;AAlBI;;;;EA8ClB,QAAA,CACJ,cAAA,EAAgB,uBAAA,EAChB,MAAA,GAAS,cAAA,GACR,OAAA,CAAQ,sBAAA;AAAA"}

package/dist/prebuilt/tool_executor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tool_executor.d.ts","names":["RunnableBinding","RunnableConfig","RunnableToolLike","StructuredToolInterface","ToolExecutorArgs","Array","ToolInvocationInterface","ToolExecutorInputType","ToolExecutorOutputType","ToolExecutor","Record","Promise"],"sources":["../../src/prebuilt/tool_executor.d.ts"],"sourcesContent":["import { RunnableBinding, RunnableConfig, RunnableToolLike } from \"@langchain/core/runnables\";\nimport { StructuredToolInterface } from \"@langchain/core/tools\";\n/** @deprecated Use {@link ToolNode} instead. */\nexport interface ToolExecutorArgs {\n    tools: Array<StructuredToolInterface | RunnableToolLike>;\n    /**\n     * @default {INVALID_TOOL_MSG_TEMPLATE}\n     */\n    invalidToolMsgTemplate?: string;\n}\n/**\n * Interface for invoking a tool\n */\nexport interface ToolInvocationInterface {\n    tool: string;\n    toolInput: string;\n}\ntype ToolExecutorInputType = any;\ntype ToolExecutorOutputType = any;\n/** @deprecated Use {@link ToolNode} instead. */\nexport declare class ToolExecutor extends RunnableBinding<ToolExecutorInputType, ToolExecutorOutputType> {\n    lc_graph_name: string;\n    tools: Array<StructuredToolInterface | RunnableToolLike>;\n    toolMap: Record<string, StructuredToolInterface | RunnableToolLike>;\n    invalidToolMsgTemplate: string;\n    constructor(fields: ToolExecutorArgs);\n    /**\n     * Execute a tool invocation\n     *\n     * @param {ToolInvocationInterface} toolInvocation The tool to invoke and the input to pass to it.\n     * @param {RunnableConfig | undefined} config Optional configuration to pass to the tool when invoked.\n     * @returns Either the result of the tool invocation (`string` or `ToolMessage`, set by the `ToolOutput` generic) or a string error message.\n     */\n    _execute(toolInvocation: ToolInvocationInterface, config?: RunnableConfig): Promise<ToolExecutorOutputType>;\n}\nexport {};\n"],"mappings":";;;;;UAGiBI,gBAAAA;EAAAA,KAAAA,EACNC,KADMD,CACAD,uBADgB,GACUD,gBADV,CAAA;EAAA;;;wBACtBG,CAAAA,EAAAA,MAAAA;;AASX;AAGC;AACyB;AAGLI,UAPJH,uBAAAA,CAOgB;EAAA,IAAA,EAAA,MAAA;WAAyBC,EAAAA,MAAAA;;KAHrDA,qBAAAA,GAKYJ,GAAAA;KAJZK,sBAAAA,GAIsCN,GAAAA;;AACfC,cAHPM,YAAAA,SAAqBT,eAGdG,CAH8BI,qBAG9BJ,EAHqDK,sBAGrDL,CAAAA,CAAAA;eAA0BD,EAAAA,MAAAA;OAAzCQ,EADFL,KACEK,CADIP,uBACJO,GAD8BR,gBAC9BQ,CAAAA;SAEWN,EAFXM,MAEWN,CAAAA,MAAAA,EAFID,uBAEJC,GAF8BF,gBAE9BE,CAAAA;wBAQKE,EAAAA,MAAAA;aAAkCL,CAAAA,MAAAA,EARvCG,gBAQuCH;;;;;;;;2BAAlCK,kCAAkCL,iBAAiBU,QAAQH"}
+{"version":3,"file":"tool_executor.d.ts","names":[],"sources":["../../src/prebuilt/tool_executor.ts"],"mappings":";;;;;UAWiB,gBAAA;EACf,KAAA,EAAO,KAAA,CAAM,uBAAA,GAA0B,gBAAA;EADR;;;EAK/B,sBAAA;AAAA;;;;UAMe,uBAAA;EACf,IAAA;EACA,SAAA;AAAA;AAAA,KAIG,qBAAA;AAAA,KAGA,sBAAA;AATL;AAAA,cAYa,YAAA,SAAqB,eAAA,CAChC,qBAAA,EACA,sBAAA;EAEA,aAAA;EAEA,KAAA,EAAO,KAAA,CAAM,uBAAA,GAA0B,gBAAA;EAEvC,OAAA,EAAS,MAAA,SAAe,uBAAA,GAA0B,gBAAA;EAElD,sBAAA;EAEA,WAAA,CAAY,MAAA,EAAQ,gBAAA;;;;AAlBI;;;;EA8ClB,QAAA,CACJ,cAAA,EAAgB,uBAAA,EAChB,MAAA,GAAS,cAAA,GACR,OAAA,CAAQ,sBAAA;AAAA"}

package/dist/prebuilt/tool_node.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"tool_node.d.cts","names":["BaseMessage","ToolMessage","RunnableConfig","RunnableToolLike","DynamicTool","StructuredToolInterface","ToolCall","RunnableCallable","MessagesAnnotation","END","Command","ToolNodeOptions","ToolNode","T","Promise","toolsCondition","State"],"sources":["../../src/prebuilt/tool_node.d.ts"],"sourcesContent":["import { BaseMessage, ToolMessage } from \"@langchain/core/messages\";\nimport { RunnableConfig, RunnableToolLike } from \"@langchain/core/runnables\";\nimport { DynamicTool, StructuredToolInterface } from \"@langchain/core/tools\";\nimport type { ToolCall } from \"@langchain/core/messages/tool\";\nimport { RunnableCallable } from \"../utils.js\";\nimport { MessagesAnnotation } from \"../graph/messages_annotation.js\";\nimport { END, Command } from \"../constants.js\";\nexport type ToolNodeOptions = {\n    name?: string;\n    tags?: string[];\n    handleToolErrors?: boolean;\n};\n/**\n * A node that runs the tools requested in the last AIMessage. It can be used\n * either in StateGraph with a \"messages\" key or in MessageGraph. If multiple\n * tool calls are requested, they will be run in parallel. The output will be\n * a list of ToolMessages, one for each tool call.\n *\n * @example\n * ```ts\n * import { ToolNode } from \"@langchain/langgraph/prebuilt\";\n * import { tool } from \"@langchain/core/tools\";\n * import { z } from \"zod\";\n * import { AIMessage } from \"@langchain/core/messages\";\n *\n * const getWeather = tool((input) => {\n *   if ([\"sf\", \"san francisco\"].includes(input.location.toLowerCase())) {\n *     return \"It's 60 degrees and foggy.\";\n *   } else {\n *     return \"It's 90 degrees and sunny.\";\n *   }\n * }, {\n *   name: \"get_weather\",\n *   description: \"Call to get the current weather.\",\n *   schema: z.object({\n *     location: z.string().describe(\"Location to get the weather for.\"),\n *   }),\n * });\n *\n * const tools = [getWeather];\n * const toolNode = new ToolNode(tools);\n *\n * const messageWithSingleToolCall = new AIMessage({\n *   content: \"\",\n *   tool_calls: [\n *     {\n *       name: \"get_weather\",\n *       args: { location: \"sf\" },\n *       id: \"tool_call_id\",\n *       type: \"tool_call\",\n *     }\n *   ]\n * })\n *\n * await toolNode.invoke({ messages: [messageWithSingleToolCall] });\n * // Returns tool invocation responses as:\n * // { messages: ToolMessage[] }\n * ```\n *\n * @example\n * ```ts\n * import {\n *   StateGraph,\n *   MessagesAnnotation,\n * } from \"@langchain/langgraph\";\n * import { ToolNode } from \"@langchain/langgraph/prebuilt\";\n * import { tool } from \"@langchain/core/tools\";\n * import { z } from \"zod\";\n * import { ChatAnthropic } from \"@langchain/anthropic\";\n *\n * const getWeather = tool((input) => {\n *   if ([\"sf\", \"san francisco\"].includes(input.location.toLowerCase())) {\n *     return \"It's 60 degrees and foggy.\";\n *   } else {\n *     return \"It's 90 degrees and sunny.\";\n *   }\n * }, {\n *   name: \"get_weather\",\n *   description: \"Call to get the current weather.\",\n *   schema: z.object({\n *     location: z.string().describe(\"Location to get the weather for.\"),\n *   }),\n * });\n *\n * const tools = [getWeather];\n * const modelWithTools = new ChatAnthropic({\n *   model: \"claude-3-haiku-20240307\",\n *   temperature: 0\n * }).bindTools(tools);\n *\n * const toolNodeForGraph = new ToolNode(tools)\n *\n * const shouldContinue = (state: typeof MessagesAnnotation.State) => {\n *   const { messages } = state;\n *   const lastMessage = messages[messages.length - 1];\n *   if (\"tool_calls\" in lastMessage && Array.isArray(lastMessage.tool_calls) && lastMessage.tool_calls?.length) {\n *     return \"tools\";\n *   }\n *   return \"__end__\";\n * }\n *\n * const callModel = async (state: typeof MessagesAnnotation.State) => {\n *   const { messages } = state;\n *   const response = await modelWithTools.invoke(messages);\n *   return { messages: response };\n * }\n *\n * const graph = new StateGraph(MessagesAnnotation)\n *   .addNode(\"agent\", callModel)\n *   .addNode(\"tools\", toolNodeForGraph)\n *   .addEdge(\"__start__\", \"agent\")\n *   .addConditionalEdges(\"agent\", shouldContinue)\n *   .addEdge(\"tools\", \"agent\")\n *   .compile();\n *\n * const inputs = {\n *   messages: [{ role: \"user\", content: \"what is the weather in SF?\" }],\n * };\n *\n * const stream = await graph.stream(inputs, {\n *   streamMode: \"values\",\n * });\n *\n * for await (const { messages } of stream) {\n *   console.log(messages);\n * }\n * // Returns the messages in the state at each step of execution\n * ```\n */\nexport declare class ToolNode<T = any> extends RunnableCallable<T, T> {\n    tools: (StructuredToolInterface | DynamicTool | RunnableToolLike)[];\n    handleToolErrors: boolean;\n    trace: boolean;\n    constructor(tools: (StructuredToolInterface | DynamicTool | RunnableToolLike)[], options?: ToolNodeOptions);\n    protected runTool(call: ToolCall, config: RunnableConfig): Promise<ToolMessage | Command>;\n    protected run(input: unknown, config: RunnableConfig): Promise<T>;\n}\n/**\n * A conditional edge function that determines whether to route to a tools node or end the graph.\n *\n * This function is designed to be used as a conditional edge in a LangGraph state graph to implement\n * the common pattern of checking if an AI message contains tool calls that need to be executed.\n *\n * @param state - The current state of the graph, which can be either:\n *   - An array of `BaseMessage` objects, where the last message is checked for tool calls\n *   - A state object conforming to `MessagesAnnotation.State`, which contains a `messages` array\n *\n * @returns A string indicating the next node to route to:\n *   - `\"tools\"` - If the last message contains tool calls that need to be executed\n *   - `END` - If there are no tool calls, indicating the graph should terminate\n *\n * @example\n * ```typescript\n * import { StateGraph, MessagesAnnotation, END, START } from \"@langchain/langgraph\";\n * import { ToolNode, toolsCondition } from \"@langchain/langgraph/prebuilt\";\n *\n * const graph = new StateGraph(MessagesAnnotation)\n *   .addNode(\"agent\", agentNode)\n *   .addNode(\"tools\", new ToolNode([searchTool, calculatorTool]))\n *   .addEdge(START, \"agent\")\n *   .addConditionalEdges(\"agent\", toolsCondition, [\"tools\", END])\n *   .addEdge(\"tools\", \"agent\")\n *   .compile();\n * ```\n *\n * @remarks\n * The function checks the last message in the state for the presence of `tool_calls`.\n * If the message is an `AIMessage` with one or more tool calls, it returns `\"tools\"`,\n * indicating that the graph should route to a tools node (typically a `ToolNode`) to\n * execute those tool calls. Otherwise, it returns `END` to terminate the graph execution.\n *\n * This is a common pattern in agentic workflows where an AI model decides whether to\n * use tools or provide a final response.\n */\nexport declare function toolsCondition(state: BaseMessage[] | typeof MessagesAnnotation.State): \"tools\" | typeof END;\n"],"mappings":";;;;;;;;;KAOYW,eAAAA;;EAAAA,IAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EA0HSC,gBAAQ,CAAA,EAAA,OAAA;CAAA;;;;;;;;;;;;;;;;;;;;AA6C7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA7CqBA,0BAA0BL,iBAAiBM,GAAGA;UACvDR,0BAA0BD,cAAcD;;;sBAG5BE,0BAA0BD,cAAcD,+BAA+BQ;0BACnEL,kBAAkBJ,iBAAiBY,QAAQb,cAAcS;wCAC3CR,iBAAiBY,QAAQD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuC3CE,cAAAA,QAAsBf,uBAAuBQ,kBAAAA,CAAmBQ,yBAAyBP"}
+{"version":3,"file":"tool_node.d.cts","names":[],"sources":["../../src/prebuilt/tool_node.ts"],"mappings":";;;;;;;;;KAeY,eAAA;EACV,IAAA;EACA,IAAA;EACA,gBAAA;AAAA;;;;;;;AAuIF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4LA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA5La,QAAA,kBAA0B,gBAAA,CAAiB,CAAA,EAAG,CAAA;EACzD,KAAA,GAAQ,uBAAA,GAA0B,WAAA,GAAc,gBAAA;EAEhD,gBAAA;EAEA,KAAA;EAEA,WAAA,CACE,KAAA,GAAQ,uBAAA,GAA0B,WAAA,GAAc,gBAAA,KAChD,OAAA,GAAU,eAAA;EAAA,UAQI,OAAA,CACd,IAAA,EAAM,QAAA,EACN,MAAA,EAAQ,cAAA,GACP,OAAA,CAAQ,WAAA,GAAc,OAAA;EAAA,UA0CT,GAAA,CAAI,KAAA,WAAgB,MAAA,EAAQ,cAAA,GAAiB,OAAA,CAAQ,CAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8HvD,cAAA,CACd,KAAA,EAAO,WAAA,YAAuB,kBAAA,CAAmB,KAAA,oBAC/B,GAAA"}

package/dist/prebuilt/tool_node.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tool_node.d.ts","names":["BaseMessage","ToolMessage","RunnableConfig","RunnableToolLike","DynamicTool","StructuredToolInterface","ToolCall","RunnableCallable","MessagesAnnotation","END","Command","ToolNodeOptions","ToolNode","T","Promise","toolsCondition","State"],"sources":["../../src/prebuilt/tool_node.d.ts"],"sourcesContent":["import { BaseMessage, ToolMessage } from \"@langchain/core/messages\";\nimport { RunnableConfig, RunnableToolLike } from \"@langchain/core/runnables\";\nimport { DynamicTool, StructuredToolInterface } from \"@langchain/core/tools\";\nimport type { ToolCall } from \"@langchain/core/messages/tool\";\nimport { RunnableCallable } from \"../utils.js\";\nimport { MessagesAnnotation } from \"../graph/messages_annotation.js\";\nimport { END, Command } from \"../constants.js\";\nexport type ToolNodeOptions = {\n    name?: string;\n    tags?: string[];\n    handleToolErrors?: boolean;\n};\n/**\n * A node that runs the tools requested in the last AIMessage. It can be used\n * either in StateGraph with a \"messages\" key or in MessageGraph. If multiple\n * tool calls are requested, they will be run in parallel. The output will be\n * a list of ToolMessages, one for each tool call.\n *\n * @example\n * ```ts\n * import { ToolNode } from \"@langchain/langgraph/prebuilt\";\n * import { tool } from \"@langchain/core/tools\";\n * import { z } from \"zod\";\n * import { AIMessage } from \"@langchain/core/messages\";\n *\n * const getWeather = tool((input) => {\n *   if ([\"sf\", \"san francisco\"].includes(input.location.toLowerCase())) {\n *     return \"It's 60 degrees and foggy.\";\n *   } else {\n *     return \"It's 90 degrees and sunny.\";\n *   }\n * }, {\n *   name: \"get_weather\",\n *   description: \"Call to get the current weather.\",\n *   schema: z.object({\n *     location: z.string().describe(\"Location to get the weather for.\"),\n *   }),\n * });\n *\n * const tools = [getWeather];\n * const toolNode = new ToolNode(tools);\n *\n * const messageWithSingleToolCall = new AIMessage({\n *   content: \"\",\n *   tool_calls: [\n *     {\n *       name: \"get_weather\",\n *       args: { location: \"sf\" },\n *       id: \"tool_call_id\",\n *       type: \"tool_call\",\n *     }\n *   ]\n * })\n *\n * await toolNode.invoke({ messages: [messageWithSingleToolCall] });\n * // Returns tool invocation responses as:\n * // { messages: ToolMessage[] }\n * ```\n *\n * @example\n * ```ts\n * import {\n *   StateGraph,\n *   MessagesAnnotation,\n * } from \"@langchain/langgraph\";\n * import { ToolNode } from \"@langchain/langgraph/prebuilt\";\n * import { tool } from \"@langchain/core/tools\";\n * import { z } from \"zod\";\n * import { ChatAnthropic } from \"@langchain/anthropic\";\n *\n * const getWeather = tool((input) => {\n *   if ([\"sf\", \"san francisco\"].includes(input.location.toLowerCase())) {\n *     return \"It's 60 degrees and foggy.\";\n *   } else {\n *     return \"It's 90 degrees and sunny.\";\n *   }\n * }, {\n *   name: \"get_weather\",\n *   description: \"Call to get the current weather.\",\n *   schema: z.object({\n *     location: z.string().describe(\"Location to get the weather for.\"),\n *   }),\n * });\n *\n * const tools = [getWeather];\n * const modelWithTools = new ChatAnthropic({\n *   model: \"claude-3-haiku-20240307\",\n *   temperature: 0\n * }).bindTools(tools);\n *\n * const toolNodeForGraph = new ToolNode(tools)\n *\n * const shouldContinue = (state: typeof MessagesAnnotation.State) => {\n *   const { messages } = state;\n *   const lastMessage = messages[messages.length - 1];\n *   if (\"tool_calls\" in lastMessage && Array.isArray(lastMessage.tool_calls) && lastMessage.tool_calls?.length) {\n *     return \"tools\";\n *   }\n *   return \"__end__\";\n * }\n *\n * const callModel = async (state: typeof MessagesAnnotation.State) => {\n *   const { messages } = state;\n *   const response = await modelWithTools.invoke(messages);\n *   return { messages: response };\n * }\n *\n * const graph = new StateGraph(MessagesAnnotation)\n *   .addNode(\"agent\", callModel)\n *   .addNode(\"tools\", toolNodeForGraph)\n *   .addEdge(\"__start__\", \"agent\")\n *   .addConditionalEdges(\"agent\", shouldContinue)\n *   .addEdge(\"tools\", \"agent\")\n *   .compile();\n *\n * const inputs = {\n *   messages: [{ role: \"user\", content: \"what is the weather in SF?\" }],\n * };\n *\n * const stream = await graph.stream(inputs, {\n *   streamMode: \"values\",\n * });\n *\n * for await (const { messages } of stream) {\n *   console.log(messages);\n * }\n * // Returns the messages in the state at each step of execution\n * ```\n */\nexport declare class ToolNode<T = any> extends RunnableCallable<T, T> {\n    tools: (StructuredToolInterface | DynamicTool | RunnableToolLike)[];\n    handleToolErrors: boolean;\n    trace: boolean;\n    constructor(tools: (StructuredToolInterface | DynamicTool | RunnableToolLike)[], options?: ToolNodeOptions);\n    protected runTool(call: ToolCall, config: RunnableConfig): Promise<ToolMessage | Command>;\n    protected run(input: unknown, config: RunnableConfig): Promise<T>;\n}\n/**\n * A conditional edge function that determines whether to route to a tools node or end the graph.\n *\n * This function is designed to be used as a conditional edge in a LangGraph state graph to implement\n * the common pattern of checking if an AI message contains tool calls that need to be executed.\n *\n * @param state - The current state of the graph, which can be either:\n *   - An array of `BaseMessage` objects, where the last message is checked for tool calls\n *   - A state object conforming to `MessagesAnnotation.State`, which contains a `messages` array\n *\n * @returns A string indicating the next node to route to:\n *   - `\"tools\"` - If the last message contains tool calls that need to be executed\n *   - `END` - If there are no tool calls, indicating the graph should terminate\n *\n * @example\n * ```typescript\n * import { StateGraph, MessagesAnnotation, END, START } from \"@langchain/langgraph\";\n * import { ToolNode, toolsCondition } from \"@langchain/langgraph/prebuilt\";\n *\n * const graph = new StateGraph(MessagesAnnotation)\n *   .addNode(\"agent\", agentNode)\n *   .addNode(\"tools\", new ToolNode([searchTool, calculatorTool]))\n *   .addEdge(START, \"agent\")\n *   .addConditionalEdges(\"agent\", toolsCondition, [\"tools\", END])\n *   .addEdge(\"tools\", \"agent\")\n *   .compile();\n * ```\n *\n * @remarks\n * The function checks the last message in the state for the presence of `tool_calls`.\n * If the message is an `AIMessage` with one or more tool calls, it returns `\"tools\"`,\n * indicating that the graph should route to a tools node (typically a `ToolNode`) to\n * execute those tool calls. Otherwise, it returns `END` to terminate the graph execution.\n *\n * This is a common pattern in agentic workflows where an AI model decides whether to\n * use tools or provide a final response.\n */\nexport declare function toolsCondition(state: BaseMessage[] | typeof MessagesAnnotation.State): \"tools\" | typeof END;\n"],"mappings":";;;;;;;;;KAOYW,eAAAA;;EAAAA,IAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EA0HSC,gBAAQ,CAAA,EAAA,OAAA;CAAA;;;;;;;;;;;;;;;;;;;;AA6C7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA7CqBA,0BAA0BL,iBAAiBM,GAAGA;UACvDR,0BAA0BD,cAAcD;;;sBAG5BE,0BAA0BD,cAAcD,+BAA+BQ;0BACnEL,kBAAkBJ,iBAAiBY,QAAQb,cAAcS;wCAC3CR,iBAAiBY,QAAQD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuC3CE,cAAAA,QAAsBf,uBAAuBQ,kBAAAA,CAAmBQ,yBAAyBP"}
+{"version":3,"file":"tool_node.d.ts","names":[],"sources":["../../src/prebuilt/tool_node.ts"],"mappings":";;;;;;;;;KAeY,eAAA;EACV,IAAA;EACA,IAAA;EACA,gBAAA;AAAA;;;;;;;AAuIF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4LA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA5La,QAAA,kBAA0B,gBAAA,CAAiB,CAAA,EAAG,CAAA;EACzD,KAAA,GAAQ,uBAAA,GAA0B,WAAA,GAAc,gBAAA;EAEhD,gBAAA;EAEA,KAAA;EAEA,WAAA,CACE,KAAA,GAAQ,uBAAA,GAA0B,WAAA,GAAc,gBAAA,KAChD,OAAA,GAAU,eAAA;EAAA,UAQI,OAAA,CACd,IAAA,EAAM,QAAA,EACN,MAAA,EAAQ,cAAA,GACP,OAAA,CAAQ,WAAA,GAAc,OAAA;EAAA,UA0CT,GAAA,CAAI,KAAA,WAAgB,MAAA,EAAQ,cAAA,GAAiB,OAAA,CAAQ,CAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8HvD,cAAA,CACd,KAAA,EAAO,WAAA,YAAuB,kBAAA,CAAmB,KAAA,oBAC/B,GAAA"}

package/dist/pregel/algo.d.cts

@@ -3,7 +3,6 @@ import { RunnableConfig } from "@langchain/core/runnables";
 import { CallbackManagerForChainRun } from "@langchain/core/callbacks/manager";
 
 //#region src/pregel/algo.d.ts
-
 /**
  * Construct a type with a set of properties K of type T
  */

package/dist/pregel/algo.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"algo.d.cts","names":["RunnableConfig","CallbackManagerForChainRun","All","BaseCheckpointSaver","Checkpoint","ReadonlyCheckpoint","PendingWrite","BaseStore","CheckpointPendingWrite","BaseChannel","PregelNode","Send","PregelExecutableTask","PregelTaskDescription","SimpleTaskPath","TaskPath","IterableReadableWritableStream","StrRecord","K","T","WritesProtocol","C","increment","shouldInterrupt","PropertyKey","N","_localRead","Record","Cc","Array","_localWrite","_applyWrites","Set","NextTaskExtraFields","NextTaskExtraFieldsWithStore","NextTaskExtraFieldsWithoutStore","_prepareNextTasks","Nn","_prepareSingleTask","sanitizeUntrackedValuesInSend"],"sources":["../../src/pregel/algo.d.ts"],"sourcesContent":["import { RunnableConfig } from \"@langchain/core/runnables\";\nimport { CallbackManagerForChainRun } from \"@langchain/core/callbacks/manager\";\nimport { All, BaseCheckpointSaver, Checkpoint, ReadonlyCheckpoint, type PendingWrite, BaseStore, CheckpointPendingWrite } from \"@langchain/langgraph-checkpoint\";\nimport { BaseChannel } from \"../channels/base.js\";\nimport { PregelNode } from \"./read.js\";\nimport { Send } from \"../constants.js\";\nimport { PregelExecutableTask, PregelTaskDescription, SimpleTaskPath, TaskPath } from \"./types.js\";\nimport { IterableReadableWritableStream } from \"./stream.js\";\n/**\n * Construct a type with a set of properties K of type T\n */\nexport type StrRecord<K extends string, T> = {\n    [P in K]: T;\n};\nexport type WritesProtocol<C = string> = {\n    name: string;\n    writes: PendingWrite<C>[];\n    triggers: string[];\n    path?: TaskPath;\n};\nexport declare const increment: (current?: number | undefined) => number;\nexport declare function shouldInterrupt<N extends PropertyKey, C extends PropertyKey>(checkpoint: Checkpoint, interruptNodes: All | N[], tasks: PregelExecutableTask<N, C>[]): boolean;\nexport declare function _localRead<Cc extends Record<string, BaseChannel>>(checkpoint: ReadonlyCheckpoint, channels: Cc, task: WritesProtocol<keyof Cc>, select: Array<keyof Cc> | keyof Cc, fresh?: boolean): Record<string, unknown> | unknown;\nexport declare function _localWrite(commit: (writes: [string, any][]) => any, processes: Record<string, PregelNode>, writes: [string, any][]): void;\nexport declare function _applyWrites<Cc extends Record<string, BaseChannel>>(checkpoint: Checkpoint, channels: Cc, tasks: WritesProtocol<keyof Cc>[], getNextVersion: ((version: any) => any) | undefined, triggerToNodes: Record<string, string[]> | undefined): Set<string>;\nexport type NextTaskExtraFields = {\n    step: number;\n    isResuming?: boolean;\n    checkpointer?: BaseCheckpointSaver;\n    manager?: CallbackManagerForChainRun;\n    store?: BaseStore;\n    stream?: IterableReadableWritableStream;\n    triggerToNodes?: Record<string, string[]>;\n    updatedChannels?: Set<string>;\n};\nexport type NextTaskExtraFieldsWithStore = NextTaskExtraFields & {\n    store?: BaseStore;\n};\nexport type NextTaskExtraFieldsWithoutStore = NextTaskExtraFields & {\n    store?: never;\n};\nexport declare function _prepareNextTasks<Nn extends StrRecord<string, PregelNode>, Cc extends StrRecord<string, BaseChannel>>(checkpoint: ReadonlyCheckpoint, pendingWrites: [string, string, unknown][] | undefined, processes: Nn, channels: Cc, config: RunnableConfig, forExecution: false, extra: NextTaskExtraFieldsWithoutStore): Record<string, PregelTaskDescription>;\nexport declare function _prepareNextTasks<Nn extends StrRecord<string, PregelNode>, Cc extends StrRecord<string, BaseChannel>>(checkpoint: ReadonlyCheckpoint, pendingWrites: [string, string, unknown][] | undefined, processes: Nn, channels: Cc, config: RunnableConfig, forExecution: true, extra: NextTaskExtraFieldsWithStore): Record<string, PregelExecutableTask<keyof Nn, keyof Cc>>;\nexport declare function _prepareSingleTask<Nn extends StrRecord<string, PregelNode>, Cc extends StrRecord<string, BaseChannel>>(taskPath: SimpleTaskPath, checkpoint: ReadonlyCheckpoint, pendingWrites: CheckpointPendingWrite[] | undefined, processes: Nn, channels: Cc, config: RunnableConfig, forExecution: false, extra: NextTaskExtraFields): PregelTaskDescription | undefined;\nexport declare function _prepareSingleTask<Nn extends StrRecord<string, PregelNode>, Cc extends StrRecord<string, BaseChannel>>(taskPath: TaskPath, checkpoint: ReadonlyCheckpoint, pendingWrites: CheckpointPendingWrite[] | undefined, processes: Nn, channels: Cc, config: RunnableConfig, forExecution: true, extra: NextTaskExtraFields): PregelExecutableTask<keyof Nn, keyof Cc> | undefined;\nexport declare function _prepareSingleTask<Nn extends StrRecord<string, PregelNode>, Cc extends StrRecord<string, BaseChannel>>(taskPath: TaskPath, checkpoint: ReadonlyCheckpoint, pendingWrites: CheckpointPendingWrite[] | undefined, processes: Nn, channels: Cc, config: RunnableConfig, forExecution: boolean, extra: NextTaskExtraFieldsWithStore): PregelTaskDescription | PregelExecutableTask<keyof Nn, keyof Cc> | undefined;\n/**\n * Remove any values belonging to UntrackedValue channels from a Send packet\n * before checkpointing.\n *\n * Send is often called with state to be passed to the destination node,\n * which may contain UntrackedValues at the top level.\n *\n * @internal\n */\nexport declare function sanitizeUntrackedValuesInSend(packet: Send, channels: StrRecord<string, BaseChannel>): Send;\n"],"mappings":";;;;;;;;;KAWYiB,yCACFC,IAAIC"}
+{"version":3,"file":"algo.d.cts","names":[],"sources":["../../src/pregel/algo.ts"],"mappings":";;;;;;;;KA+EY,SAAA,gCACJ,CAAA,GAAI,CAAA"}

package/dist/pregel/algo.d.ts

@@ -1,9 +1,13 @@
+import "../channels/base.js";
+import "./read.js";
+import "../constants.js";
+import "./types.js";
+import "./stream.js";
 import { All, BaseCheckpointSaver, BaseStore, Checkpoint, PendingWrite, ReadonlyCheckpoint } from "@langchain/langgraph-checkpoint";
 import { RunnableConfig } from "@langchain/core/runnables";
 import { CallbackManagerForChainRun } from "@langchain/core/callbacks/manager";
 
 //#region src/pregel/algo.d.ts
-
 /**
  * Construct a type with a set of properties K of type T
  */

package/dist/pregel/algo.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"algo.d.ts","names":["RunnableConfig","CallbackManagerForChainRun","All","BaseCheckpointSaver","Checkpoint","ReadonlyCheckpoint","PendingWrite","BaseStore","CheckpointPendingWrite","BaseChannel","PregelNode","Send","PregelExecutableTask","PregelTaskDescription","SimpleTaskPath","TaskPath","IterableReadableWritableStream","StrRecord","K","T","WritesProtocol","C","increment","shouldInterrupt","PropertyKey","N","_localRead","Record","Cc","Array","_localWrite","_applyWrites","Set","NextTaskExtraFields","NextTaskExtraFieldsWithStore","NextTaskExtraFieldsWithoutStore","_prepareNextTasks","Nn","_prepareSingleTask","sanitizeUntrackedValuesInSend"],"sources":["../../src/pregel/algo.d.ts"],"sourcesContent":["import { RunnableConfig } from \"@langchain/core/runnables\";\nimport { CallbackManagerForChainRun } from \"@langchain/core/callbacks/manager\";\nimport { All, BaseCheckpointSaver, Checkpoint, ReadonlyCheckpoint, type PendingWrite, BaseStore, CheckpointPendingWrite } from \"@langchain/langgraph-checkpoint\";\nimport { BaseChannel } from \"../channels/base.js\";\nimport { PregelNode } from \"./read.js\";\nimport { Send } from \"../constants.js\";\nimport { PregelExecutableTask, PregelTaskDescription, SimpleTaskPath, TaskPath } from \"./types.js\";\nimport { IterableReadableWritableStream } from \"./stream.js\";\n/**\n * Construct a type with a set of properties K of type T\n */\nexport type StrRecord<K extends string, T> = {\n    [P in K]: T;\n};\nexport type WritesProtocol<C = string> = {\n    name: string;\n    writes: PendingWrite<C>[];\n    triggers: string[];\n    path?: TaskPath;\n};\nexport declare const increment: (current?: number | undefined) => number;\nexport declare function shouldInterrupt<N extends PropertyKey, C extends PropertyKey>(checkpoint: Checkpoint, interruptNodes: All | N[], tasks: PregelExecutableTask<N, C>[]): boolean;\nexport declare function _localRead<Cc extends Record<string, BaseChannel>>(checkpoint: ReadonlyCheckpoint, channels: Cc, task: WritesProtocol<keyof Cc>, select: Array<keyof Cc> | keyof Cc, fresh?: boolean): Record<string, unknown> | unknown;\nexport declare function _localWrite(commit: (writes: [string, any][]) => any, processes: Record<string, PregelNode>, writes: [string, any][]): void;\nexport declare function _applyWrites<Cc extends Record<string, BaseChannel>>(checkpoint: Checkpoint, channels: Cc, tasks: WritesProtocol<keyof Cc>[], getNextVersion: ((version: any) => any) | undefined, triggerToNodes: Record<string, string[]> | undefined): Set<string>;\nexport type NextTaskExtraFields = {\n    step: number;\n    isResuming?: boolean;\n    checkpointer?: BaseCheckpointSaver;\n    manager?: CallbackManagerForChainRun;\n    store?: BaseStore;\n    stream?: IterableReadableWritableStream;\n    triggerToNodes?: Record<string, string[]>;\n    updatedChannels?: Set<string>;\n};\nexport type NextTaskExtraFieldsWithStore = NextTaskExtraFields & {\n    store?: BaseStore;\n};\nexport type NextTaskExtraFieldsWithoutStore = NextTaskExtraFields & {\n    store?: never;\n};\nexport declare function _prepareNextTasks<Nn extends StrRecord<string, PregelNode>, Cc extends StrRecord<string, BaseChannel>>(checkpoint: ReadonlyCheckpoint, pendingWrites: [string, string, unknown][] | undefined, processes: Nn, channels: Cc, config: RunnableConfig, forExecution: false, extra: NextTaskExtraFieldsWithoutStore): Record<string, PregelTaskDescription>;\nexport declare function _prepareNextTasks<Nn extends StrRecord<string, PregelNode>, Cc extends StrRecord<string, BaseChannel>>(checkpoint: ReadonlyCheckpoint, pendingWrites: [string, string, unknown][] | undefined, processes: Nn, channels: Cc, config: RunnableConfig, forExecution: true, extra: NextTaskExtraFieldsWithStore): Record<string, PregelExecutableTask<keyof Nn, keyof Cc>>;\nexport declare function _prepareSingleTask<Nn extends StrRecord<string, PregelNode>, Cc extends StrRecord<string, BaseChannel>>(taskPath: SimpleTaskPath, checkpoint: ReadonlyCheckpoint, pendingWrites: CheckpointPendingWrite[] | undefined, processes: Nn, channels: Cc, config: RunnableConfig, forExecution: false, extra: NextTaskExtraFields): PregelTaskDescription | undefined;\nexport declare function _prepareSingleTask<Nn extends StrRecord<string, PregelNode>, Cc extends StrRecord<string, BaseChannel>>(taskPath: TaskPath, checkpoint: ReadonlyCheckpoint, pendingWrites: CheckpointPendingWrite[] | undefined, processes: Nn, channels: Cc, config: RunnableConfig, forExecution: true, extra: NextTaskExtraFields): PregelExecutableTask<keyof Nn, keyof Cc> | undefined;\nexport declare function _prepareSingleTask<Nn extends StrRecord<string, PregelNode>, Cc extends StrRecord<string, BaseChannel>>(taskPath: TaskPath, checkpoint: ReadonlyCheckpoint, pendingWrites: CheckpointPendingWrite[] | undefined, processes: Nn, channels: Cc, config: RunnableConfig, forExecution: boolean, extra: NextTaskExtraFieldsWithStore): PregelTaskDescription | PregelExecutableTask<keyof Nn, keyof Cc> | undefined;\n/**\n * Remove any values belonging to UntrackedValue channels from a Send packet\n * before checkpointing.\n *\n * Send is often called with state to be passed to the destination node,\n * which may contain UntrackedValues at the top level.\n *\n * @internal\n */\nexport declare function sanitizeUntrackedValuesInSend(packet: Send, channels: StrRecord<string, BaseChannel>): Send;\n"],"mappings":";;;;;;;;;KAWYiB,yCACFC,IAAIC"}
+{"version":3,"file":"algo.d.ts","names":[],"sources":["../../src/pregel/algo.ts"],"mappings":";;;;;;;;;;;;AA+EA;KAAY,SAAA,gCACJ,CAAA,GAAI,CAAA"}

package/dist/pregel/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":["Runnable","RunnableConfig","RunnableFunc","StreamEvent","IterableReadableStream","All","BaseCache","BaseCheckpointSaver","BaseStore","CheckpointListOptions","CheckpointTuple","BaseChannel","Command","CommandInstance","StrRecord","PregelNode","LangGraphRunnableConfig","Durability","GetStateOptions","MultipleChannelSubscriptionOptions","PregelInputType","PregelInterface","PregelOptions","PregelOutputType","PregelParams","SingleChannelSubscriptionOptions","StateSnapshot","StreamMode","StreamOutputMap","RetryPolicy","ChannelWrite","WriteValue","StreamEventsOptions","Parameters","Channel","Record","PartialRunnable","RunInput","RunOutput","CallOptions","Partial","Promise","Pregel","InputType","OutputType","CommandType","Nodes","Channels","ContextType","Array","Omit","_langchain_core_runnables_graph0","Graph","Generator","AsyncGenerator","config","saved","subgraphCheckpointer","applyPendingWrites","AsyncIterableIterator","TStreamMode","TSubgraphs","TEncoding","StreamUpdatesType","StreamValuesType","NodeReturnType","StreamCustom","Uint8Array"],"sources":["../../src/pregel/index.d.ts"],"sourcesContent":["import { Runnable, RunnableConfig, RunnableFunc } from \"@langchain/core/runnables\";\nimport type { StreamEvent } from \"@langchain/core/tracers/log_stream\";\nimport { IterableReadableStream } from \"@langchain/core/utils/stream\";\nimport { All, BaseCache, BaseCheckpointSaver, BaseStore, CheckpointListOptions, CheckpointTuple } from \"@langchain/langgraph-checkpoint\";\nimport { BaseChannel } from \"../channels/base.js\";\nimport { Command, type CommandInstance } from \"../constants.js\";\nimport { StrRecord } from \"./algo.js\";\nimport { PregelNode } from \"./read.js\";\nimport { LangGraphRunnableConfig } from \"./runnable_types.js\";\nimport type { Durability, GetStateOptions, MultipleChannelSubscriptionOptions, PregelInputType, PregelInterface, PregelOptions, PregelOutputType, PregelParams, SingleChannelSubscriptionOptions, StateSnapshot, StreamMode, StreamOutputMap } from \"./types.js\";\nimport { RetryPolicy } from \"./utils/index.js\";\nimport { ChannelWrite } from \"./write.js\";\ntype WriteValue = Runnable | RunnableFunc<unknown, unknown> | unknown;\ntype StreamEventsOptions = Parameters<Runnable[\"streamEvents\"]>[2];\n/**\n * Utility class for working with channels in the Pregel system.\n * Provides static methods for subscribing to channels and writing to them.\n *\n * Channels are the communication pathways between nodes in a Pregel graph.\n * They enable message passing and state updates between different parts of the graph.\n */\nexport declare class Channel {\n    /**\n     * Creates a PregelNode that subscribes to a single channel.\n     * This is used to define how nodes receive input from channels.\n     *\n     * @example\n     * ```typescript\n     * // Subscribe to a single channel\n     * const node = Channel.subscribeTo(\"messages\");\n     *\n     * // Subscribe to multiple channels\n     * const node = Channel.subscribeTo([\"messages\", \"state\"]);\n     *\n     * // Subscribe with a custom key\n     * const node = Channel.subscribeTo(\"messages\", { key: \"chat\" });\n     * ```\n     *\n     * @param channel Single channel name to subscribe to\n     * @param options Subscription options\n     * @returns A PregelNode configured to receive from the specified channels\n     * @throws {Error} If a key is specified when subscribing to multiple channels\n     */\n    static subscribeTo(channel: string, options?: SingleChannelSubscriptionOptions): PregelNode;\n    /**\n     * Creates a PregelNode that subscribes to multiple channels.\n     * This is used to define how nodes receive input from channels.\n     *\n     * @example\n     * ```typescript\n     * // Subscribe to a single channel\n     * const node = Channel.subscribeTo(\"messages\");\n     *\n     * // Subscribe to multiple channels\n     * const node = Channel.subscribeTo([\"messages\", \"state\"]);\n     *\n     * // Subscribe with a custom key\n     * const node = Channel.subscribeTo(\"messages\", { key: \"chat\" });\n     * ```\n     *\n     * @param channels Single channel name to subscribe to\n     * @param options Subscription options\n     * @returns A PregelNode configured to receive from the specified channels\n     * @throws {Error} If a key is specified when subscribing to multiple channels\n     */\n    static subscribeTo(channels: string[], options?: MultipleChannelSubscriptionOptions): PregelNode;\n    /**\n     * Creates a ChannelWrite that specifies how to write values to channels.\n     * This is used to define how nodes send output to channels.\n     *\n     * @example\n     * ```typescript\n     * // Write to multiple channels\n     * const write = Channel.writeTo([\"output\", \"state\"]);\n     *\n     * // Write with specific values\n     * const write = Channel.writeTo([\"output\"], {\n     *   state: \"completed\",\n     *   result: calculateResult()\n     * });\n     *\n     * // Write with a transformation function\n     * const write = Channel.writeTo([\"output\"], {\n     *   result: (x) => processResult(x)\n     * });\n     * ```\n     *\n     * @param channels - Array of channel names to write to\n     * @param writes - Optional map of channel names to values or transformations\n     * @returns A ChannelWrite object that can be used to write to the specified channels\n     */\n    static writeTo(channels: string[], writes?: Record<string, WriteValue>): ChannelWrite;\n}\nexport type { PregelInputType, PregelOptions, PregelOutputType };\ndeclare class PartialRunnable<RunInput, RunOutput, CallOptions extends RunnableConfig> extends Runnable<RunInput, RunOutput, CallOptions> {\n    lc_namespace: string[];\n    invoke(_input: RunInput, _options?: Partial<CallOptions>): Promise<any>;\n    withConfig(_config: CallOptions): typeof this;\n    stream(input: RunInput, options?: Partial<CallOptions>): Promise<IterableReadableStream<any>>;\n}\n/**\n * The Pregel class is the core runtime engine of LangGraph, implementing a message-passing graph computation model\n * inspired by [Google's Pregel system](https://research.google/pubs/pregel-a-system-for-large-scale-graph-processing/).\n * It provides the foundation for building reliable, controllable agent workflows that can evolve state over time.\n *\n * Key features:\n * - Message passing between nodes in discrete \"supersteps\"\n * - Built-in persistence layer through checkpointers\n * - First-class streaming support for values, updates, and events\n * - Human-in-the-loop capabilities via interrupts\n * - Support for parallel node execution within supersteps\n *\n * The Pregel class is not intended to be instantiated directly by consumers. Instead, use the following higher-level APIs:\n * - {@link StateGraph}: The main graph class for building agent workflows\n *   - Compiling a {@link StateGraph} will return a {@link CompiledGraph} instance, which extends `Pregel`\n * - Functional API: A declarative approach using tasks and entrypoints\n *   - A `Pregel` instance is returned by the {@link entrypoint} function\n *\n * @example\n * ```typescript\n * // Using StateGraph API\n * const graph = new StateGraph(annotation)\n *   .addNode(\"nodeA\", myNodeFunction)\n *   .addEdge(\"nodeA\", \"nodeB\")\n *   .compile();\n *\n * // The compiled graph is a Pregel instance\n * const result = await graph.invoke(input);\n * ```\n *\n * @example\n * ```typescript\n * // Using Functional API\n * import { task, entrypoint } from \"@langchain/langgraph\";\n * import { MemorySaver } from \"@langchain/langgraph-checkpoint\";\n *\n * // Define tasks that can be composed\n * const addOne = task(\"add\", async (x: number) => x + 1);\n *\n * // Create a workflow using the entrypoint function\n * const workflow = entrypoint({\n *   name: \"workflow\",\n *   checkpointer: new MemorySaver()\n * }, async (numbers: number[]) => {\n *   // Tasks can be run in parallel\n *   const results = await Promise.all(numbers.map(n => addOne(n)));\n *   return results;\n * });\n *\n * // The workflow is a Pregel instance\n * const result = await workflow.invoke([1, 2, 3]); // Returns [2, 3, 4]\n * ```\n *\n * @typeParam Nodes - Mapping of node names to their {@link PregelNode} implementations\n * @typeParam Channels - Mapping of channel names to their {@link BaseChannel} or {@link ManagedValueSpec} implementations\n * @typeParam ContextType - Type of context that can be passed to the graph\n * @typeParam InputType - Type of input values accepted by the graph\n * @typeParam OutputType - Type of output values produced by the graph\n */\nexport declare class Pregel<Nodes extends StrRecord<string, PregelNode>, Channels extends StrRecord<string, BaseChannel>, ContextType extends Record<string, any> = StrRecord<string, any>, InputType = PregelInputType, OutputType = PregelOutputType, StreamUpdatesType = InputType, StreamValuesType = OutputType, NodeReturnType = unknown, CommandType = CommandInstance, StreamCustom = any> extends PartialRunnable<InputType | CommandType | null, OutputType, PregelOptions<Nodes, Channels, ContextType>> implements PregelInterface<Nodes, Channels, ContextType> {\n    /**\n     * Name of the class when serialized\n     * @internal\n     */\n    static lc_name(): string;\n    /** @internal Used for type inference */\n    \"~InputType\": InputType;\n    /** @internal Used for type inference */\n    \"~OutputType\": OutputType;\n    /** @internal LangChain namespace for serialization necessary because Pregel extends Runnable */\n    lc_namespace: string[];\n    /** @internal Flag indicating this is a Pregel instance - necessary for serialization */\n    lg_is_pregel: boolean;\n    /** The nodes in the graph, mapping node names to their PregelNode instances */\n    nodes: Nodes;\n    /** The channels in the graph, mapping channel names to their BaseChannel or ManagedValueSpec instances */\n    channels: Channels;\n    /**\n     * The input channels for the graph. These channels receive the initial input when the graph is invoked.\n     * Can be a single channel key or an array of channel keys.\n     */\n    inputChannels: keyof Channels | Array<keyof Channels>;\n    /**\n     * The output channels for the graph. These channels contain the final output when the graph completes.\n     * Can be a single channel key or an array of channel keys.\n     */\n    outputChannels: keyof Channels | Array<keyof Channels>;\n    /** Whether to automatically validate the graph structure when it is compiled. Defaults to true. */\n    autoValidate: boolean;\n    /**\n     * The streaming modes enabled for this graph. Defaults to [\"values\"].\n     * Supported modes:\n     * - \"values\": Streams the full state after each step\n     * - \"updates\": Streams state updates after each step\n     * - \"messages\": Streams messages from within nodes\n     * - \"custom\": Streams custom events from within nodes\n     * - \"debug\": Streams events related to the execution of the graph - useful for tracing & debugging graph execution\n     */\n    streamMode: StreamMode[];\n    /**\n     * Optional channels to stream. If not specified, all channels will be streamed.\n     * Can be a single channel key or an array of channel keys.\n     */\n    streamChannels?: keyof Channels | Array<keyof Channels>;\n    /**\n     * Optional array of node names or \"all\" to interrupt after executing these nodes.\n     * Used for implementing human-in-the-loop workflows.\n     */\n    interruptAfter?: Array<keyof Nodes> | All;\n    /**\n     * Optional array of node names or \"all\" to interrupt before executing these nodes.\n     * Used for implementing human-in-the-loop workflows.\n     */\n    interruptBefore?: Array<keyof Nodes> | All;\n    /** Optional timeout in milliseconds for the execution of each superstep */\n    stepTimeout?: number;\n    /** Whether to enable debug logging. Defaults to false. */\n    debug: boolean;\n    /**\n     * Optional checkpointer for persisting graph state.\n     * When provided, saves a checkpoint of the graph state at every superstep.\n     * When false or undefined, checkpointing is disabled, and the graph will not be able to save or restore state.\n     */\n    checkpointer?: BaseCheckpointSaver | boolean;\n    /** Optional retry policy for handling failures in node execution */\n    retryPolicy?: RetryPolicy;\n    /** The default configuration for graph execution, can be overridden on a per-invocation basis */\n    config?: LangGraphRunnableConfig;\n    /**\n     * Optional long-term memory store for the graph, allows for persistence & retrieval of data across threads\n     */\n    store?: BaseStore;\n    /**\n     * Optional cache for the graph, useful for caching tasks.\n     */\n    cache?: BaseCache;\n    /**\n     * Optional interrupt helper function.\n     * @internal\n     */\n    private userInterrupt?;\n    /**\n     * The trigger to node mapping for the graph run.\n     * @internal\n     */\n    private triggerToNodes;\n    /**\n     * Constructor for Pregel - meant for internal use only.\n     *\n     * @internal\n     */\n    constructor(fields: PregelParams<Nodes, Channels>);\n    /**\n     * Creates a new instance of the Pregel graph with updated configuration.\n     * This method follows the immutable pattern - instead of modifying the current instance,\n     * it returns a new instance with the merged configuration.\n     *\n     * @example\n     * ```typescript\n     * // Create a new instance with debug enabled\n     * const debugGraph = graph.withConfig({ debug: true });\n     *\n     * // Create a new instance with a specific thread ID\n     * const threadGraph = graph.withConfig({\n     *   configurable: { thread_id: \"123\" }\n     * });\n     * ```\n     *\n     * @param config - The configuration to merge with the current configuration\n     * @returns A new Pregel instance with the merged configuration\n     */\n    withConfig(config: Omit<LangGraphRunnableConfig, \"store\" | \"writer\" | \"interrupt\">): typeof this;\n    /**\n     * Validates the graph structure to ensure it is well-formed.\n     * Checks for:\n     * - No orphaned nodes\n     * - Valid input/output channel configurations\n     * - Valid interrupt configurations\n     *\n     * @returns this - The Pregel instance for method chaining\n     * @throws {GraphValidationError} If the graph structure is invalid\n     */\n    validate(): this;\n    /**\n     * Gets a list of all channels that should be streamed.\n     * If streamChannels is specified, returns those channels.\n     * Otherwise, returns all channels in the graph.\n     *\n     * @returns Array of channel keys to stream\n     */\n    get streamChannelsList(): Array<keyof Channels>;\n    /**\n     * Gets the channels to stream in their original format.\n     * If streamChannels is specified, returns it as-is (either single key or array).\n     * Otherwise, returns all channels in the graph as an array.\n     *\n     * @returns Channel keys to stream, either as a single key or array\n     */\n    get streamChannelsAsIs(): keyof Channels | Array<keyof Channels>;\n    /**\n     * Gets a drawable representation of the graph structure.\n     * This is an async version of getGraph() and is the preferred method to use.\n     *\n     * @param config - Configuration for generating the graph visualization\n     * @returns A representation of the graph that can be visualized\n     */\n    getGraphAsync(config: RunnableConfig): Promise<import(\"@langchain/core/runnables/graph\").Graph>;\n    /**\n     * Gets all subgraphs within this graph.\n     * A subgraph is a Pregel instance that is nested within a node of this graph.\n     *\n     * @deprecated Use getSubgraphsAsync instead. The async method will become the default in the next minor release.\n     * @param namespace - Optional namespace to filter subgraphs\n     * @param recurse - Whether to recursively get subgraphs of subgraphs\n     * @returns Generator yielding tuples of [name, subgraph]\n     */\n    getSubgraphs(namespace?: string, recurse?: boolean): Generator<[string, Pregel<any, any>]>;\n    /**\n     * Gets all subgraphs within this graph asynchronously.\n     * A subgraph is a Pregel instance that is nested within a node of this graph.\n     *\n     * @param namespace - Optional namespace to filter subgraphs\n     * @param recurse - Whether to recursively get subgraphs of subgraphs\n     * @returns AsyncGenerator yielding tuples of [name, subgraph]\n     */\n    getSubgraphsAsync(namespace?: string, recurse?: boolean): AsyncGenerator<[string, Pregel<any, any>]>;\n    /**\n     * Prepares a state snapshot from saved checkpoint data.\n     * This is an internal method used by getState and getStateHistory.\n     *\n     * @param config - Configuration for preparing the snapshot\n     * @param saved - Optional saved checkpoint data\n     * @param subgraphCheckpointer - Optional checkpointer for subgraphs\n     * @param applyPendingWrites - Whether to apply pending writes to tasks and then to channels\n     * @returns A snapshot of the graph state\n     * @internal\n     */\n    protected _prepareStateSnapshot({ config, saved, subgraphCheckpointer, applyPendingWrites }: {\n        config: RunnableConfig;\n        saved?: CheckpointTuple;\n        subgraphCheckpointer?: BaseCheckpointSaver;\n        applyPendingWrites?: boolean;\n    }): Promise<StateSnapshot>;\n    /**\n     * Gets the current state of the graph.\n     * Requires a checkpointer to be configured.\n     *\n     * @param config - Configuration for retrieving the state\n     * @param options - Additional options\n     * @returns A snapshot of the current graph state\n     * @throws {GraphValueError} If no checkpointer is configured\n     */\n    getState(config: RunnableConfig, options?: GetStateOptions): Promise<StateSnapshot>;\n    /**\n     * Gets the history of graph states.\n     * Requires a checkpointer to be configured.\n     * Useful for:\n     * - Debugging execution history\n     * - Implementing time travel\n     * - Analyzing graph behavior\n     *\n     * @param config - Configuration for retrieving the history\n     * @param options - Options for filtering the history\n     * @returns An async iterator of state snapshots\n     * @throws {Error} If no checkpointer is configured\n     */\n    getStateHistory(config: RunnableConfig, options?: CheckpointListOptions): AsyncIterableIterator<StateSnapshot>;\n    /**\n     * Apply updates to the graph state in bulk.\n     * Requires a checkpointer to be configured.\n     *\n     * This method is useful for recreating a thread\n     * from a list of updates, especially if a checkpoint\n     * is created as a result of multiple tasks.\n     *\n     * @internal The API might change in the future.\n     *\n     * @param startConfig - Configuration for the update\n     * @param updates - The list of updates to apply to graph state\n     * @returns Updated configuration\n     * @throws {GraphValueError} If no checkpointer is configured\n     * @throws {InvalidUpdateError} If the update cannot be attributed to a node or an update can be only applied in sequence.\n     */\n    bulkUpdateState(startConfig: LangGraphRunnableConfig, supersteps: Array<{\n        updates: Array<{\n            values?: Record<string, unknown> | unknown;\n            asNode?: keyof Nodes | string;\n        }>;\n    }>): Promise<RunnableConfig>;\n    /**\n     * Updates the state of the graph with new values.\n     * Requires a checkpointer to be configured.\n     *\n     * This method can be used for:\n     * - Implementing human-in-the-loop workflows\n     * - Modifying graph state during breakpoints\n     * - Integrating external inputs into the graph\n     *\n     * @param inputConfig - Configuration for the update\n     * @param values - The values to update the state with\n     * @param asNode - Optional node name to attribute the update to\n     * @returns Updated configuration\n     * @throws {GraphValueError} If no checkpointer is configured\n     * @throws {InvalidUpdateError} If the update cannot be attributed to a node\n     */\n    updateState(inputConfig: LangGraphRunnableConfig, values: Record<string, unknown> | unknown, asNode?: keyof Nodes | string): Promise<RunnableConfig>;\n    /**\n     * Gets the default values for various graph configuration options.\n     * This is an internal method used to process and normalize configuration options.\n     *\n     * @param config - The input configuration options\n     * @returns A tuple containing normalized values for:\n     * - debug mode\n     * - stream modes\n     * - input keys\n     * - output keys\n     * - remaining config\n     * - interrupt before nodes\n     * - interrupt after nodes\n     * - checkpointer\n     * - store\n     * - whether stream mode is single\n     * - node cache\n     * - whether checkpoint during is enabled\n     * @internal\n     */\n    _defaults(config: PregelOptions<Nodes, Channels>): [\n        boolean,\n        StreamMode[],\n        string | string[],\n        string | string[],\n        LangGraphRunnableConfig,\n        All | string[],\n        All | string[],\n        BaseCheckpointSaver | undefined,\n        BaseStore | undefined,\n        boolean,\n        BaseCache | undefined,\n        Durability\n    ];\n    /**\n     * Streams the execution of the graph, emitting state updates as they occur.\n     * This is the primary method for observing graph execution in real-time.\n     *\n     * Stream modes:\n     * - \"values\": Emits complete state after each step\n     * - \"updates\": Emits only state changes after each step\n     * - \"debug\": Emits detailed debug information\n     * - \"messages\": Emits messages from within nodes\n     * - \"custom\": Emits custom events from within nodes\n     * - \"checkpoints\": Emits checkpoints from within nodes\n     * - \"tasks\": Emits tasks from within nodes\n     *\n     * @param input - The input to start graph execution with\n     * @param options - Configuration options for streaming\n     * @returns An async iterable stream of graph state updates\n     */\n    stream<TStreamMode extends StreamMode | StreamMode[] | undefined, TSubgraphs extends boolean, TEncoding extends \"text/event-stream\" | undefined>(input: InputType | CommandType | null, options?: Partial<PregelOptions<Nodes, Channels, ContextType, TStreamMode, TSubgraphs, TEncoding>>): Promise<IterableReadableStream<StreamOutputMap<TStreamMode, TSubgraphs, StreamUpdatesType, StreamValuesType, keyof Nodes, NodeReturnType, StreamCustom, TEncoding>>>;\n    /**\n     * @inheritdoc\n     */\n    streamEvents(input: InputType | CommandType | null, options: Partial<PregelOptions<Nodes, Channels, ContextType>> & {\n        version: \"v1\" | \"v2\";\n    }, streamOptions?: StreamEventsOptions): IterableReadableStream<StreamEvent>;\n    streamEvents(input: InputType | CommandType | null, options: Partial<PregelOptions<Nodes, Channels, ContextType>> & {\n        version: \"v1\" | \"v2\";\n        encoding: \"text/event-stream\";\n    }, streamOptions?: StreamEventsOptions): IterableReadableStream<Uint8Array>;\n    /**\n     * Validates the input for the graph.\n     * @param input - The input to validate\n     * @returns The validated input\n     * @internal\n     */\n    protected _validateInput(input: PregelInputType): Promise<any>;\n    /**\n     * Validates the context options for the graph.\n     * @param context - The context options to validate\n     * @returns The validated context options\n     * @internal\n     */\n    protected _validateContext(context: Partial<LangGraphRunnableConfig[\"context\"]>): Promise<LangGraphRunnableConfig[\"context\"]>;\n    /**\n     * Internal iterator used by stream() to generate state updates.\n     * This method handles the core logic of graph execution and streaming.\n     *\n     * @param input - The input to start graph execution with\n     * @param options - Configuration options for streaming\n     * @returns AsyncGenerator yielding state updates\n     * @internal\n     */\n    _streamIterator(input: PregelInputType | Command, options?: Partial<PregelOptions<Nodes, Channels>>): AsyncGenerator<PregelOutputType>;\n    /**\n     * Run the graph with a single input and config.\n     * @param input The input to the graph.\n     * @param options The configuration to use for the run.\n     */\n    invoke(input: InputType | CommandType | null, options?: Partial<Omit<PregelOptions<Nodes, Channels, ContextType>, \"encoding\">>): Promise<OutputType>;\n    private _runLoop;\n    clearCache(): Promise<void>;\n}\n"],"mappings":"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"}
+{"version":3,"file":"index.d.cts","names":[],"sources":["../../src/pregel/index.ts"],"mappings":"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"}

package/dist/pregel/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":["Runnable","RunnableConfig","RunnableFunc","StreamEvent","IterableReadableStream","All","BaseCache","BaseCheckpointSaver","BaseStore","CheckpointListOptions","CheckpointTuple","BaseChannel","Command","CommandInstance","StrRecord","PregelNode","LangGraphRunnableConfig","Durability","GetStateOptions","MultipleChannelSubscriptionOptions","PregelInputType","PregelInterface","PregelOptions","PregelOutputType","PregelParams","SingleChannelSubscriptionOptions","StateSnapshot","StreamMode","StreamOutputMap","RetryPolicy","ChannelWrite","WriteValue","StreamEventsOptions","Parameters","Channel","Record","PartialRunnable","RunInput","RunOutput","CallOptions","Partial","Promise","Pregel","InputType","OutputType","CommandType","Nodes","Channels","ContextType","Array","Omit","_langchain_core_runnables_graph0","Graph","Generator","AsyncGenerator","config","saved","subgraphCheckpointer","applyPendingWrites","AsyncIterableIterator","TStreamMode","TSubgraphs","TEncoding","StreamUpdatesType","StreamValuesType","NodeReturnType","StreamCustom","Uint8Array"],"sources":["../../src/pregel/index.d.ts"],"sourcesContent":["import { Runnable, RunnableConfig, RunnableFunc } from \"@langchain/core/runnables\";\nimport type { StreamEvent } from \"@langchain/core/tracers/log_stream\";\nimport { IterableReadableStream } from \"@langchain/core/utils/stream\";\nimport { All, BaseCache, BaseCheckpointSaver, BaseStore, CheckpointListOptions, CheckpointTuple } from \"@langchain/langgraph-checkpoint\";\nimport { BaseChannel } from \"../channels/base.js\";\nimport { Command, type CommandInstance } from \"../constants.js\";\nimport { StrRecord } from \"./algo.js\";\nimport { PregelNode } from \"./read.js\";\nimport { LangGraphRunnableConfig } from \"./runnable_types.js\";\nimport type { Durability, GetStateOptions, MultipleChannelSubscriptionOptions, PregelInputType, PregelInterface, PregelOptions, PregelOutputType, PregelParams, SingleChannelSubscriptionOptions, StateSnapshot, StreamMode, StreamOutputMap } from \"./types.js\";\nimport { RetryPolicy } from \"./utils/index.js\";\nimport { ChannelWrite } from \"./write.js\";\ntype WriteValue = Runnable | RunnableFunc<unknown, unknown> | unknown;\ntype StreamEventsOptions = Parameters<Runnable[\"streamEvents\"]>[2];\n/**\n * Utility class for working with channels in the Pregel system.\n * Provides static methods for subscribing to channels and writing to them.\n *\n * Channels are the communication pathways between nodes in a Pregel graph.\n * They enable message passing and state updates between different parts of the graph.\n */\nexport declare class Channel {\n    /**\n     * Creates a PregelNode that subscribes to a single channel.\n     * This is used to define how nodes receive input from channels.\n     *\n     * @example\n     * ```typescript\n     * // Subscribe to a single channel\n     * const node = Channel.subscribeTo(\"messages\");\n     *\n     * // Subscribe to multiple channels\n     * const node = Channel.subscribeTo([\"messages\", \"state\"]);\n     *\n     * // Subscribe with a custom key\n     * const node = Channel.subscribeTo(\"messages\", { key: \"chat\" });\n     * ```\n     *\n     * @param channel Single channel name to subscribe to\n     * @param options Subscription options\n     * @returns A PregelNode configured to receive from the specified channels\n     * @throws {Error} If a key is specified when subscribing to multiple channels\n     */\n    static subscribeTo(channel: string, options?: SingleChannelSubscriptionOptions): PregelNode;\n    /**\n     * Creates a PregelNode that subscribes to multiple channels.\n     * This is used to define how nodes receive input from channels.\n     *\n     * @example\n     * ```typescript\n     * // Subscribe to a single channel\n     * const node = Channel.subscribeTo(\"messages\");\n     *\n     * // Subscribe to multiple channels\n     * const node = Channel.subscribeTo([\"messages\", \"state\"]);\n     *\n     * // Subscribe with a custom key\n     * const node = Channel.subscribeTo(\"messages\", { key: \"chat\" });\n     * ```\n     *\n     * @param channels Single channel name to subscribe to\n     * @param options Subscription options\n     * @returns A PregelNode configured to receive from the specified channels\n     * @throws {Error} If a key is specified when subscribing to multiple channels\n     */\n    static subscribeTo(channels: string[], options?: MultipleChannelSubscriptionOptions): PregelNode;\n    /**\n     * Creates a ChannelWrite that specifies how to write values to channels.\n     * This is used to define how nodes send output to channels.\n     *\n     * @example\n     * ```typescript\n     * // Write to multiple channels\n     * const write = Channel.writeTo([\"output\", \"state\"]);\n     *\n     * // Write with specific values\n     * const write = Channel.writeTo([\"output\"], {\n     *   state: \"completed\",\n     *   result: calculateResult()\n     * });\n     *\n     * // Write with a transformation function\n     * const write = Channel.writeTo([\"output\"], {\n     *   result: (x) => processResult(x)\n     * });\n     * ```\n     *\n     * @param channels - Array of channel names to write to\n     * @param writes - Optional map of channel names to values or transformations\n     * @returns A ChannelWrite object that can be used to write to the specified channels\n     */\n    static writeTo(channels: string[], writes?: Record<string, WriteValue>): ChannelWrite;\n}\nexport type { PregelInputType, PregelOptions, PregelOutputType };\ndeclare class PartialRunnable<RunInput, RunOutput, CallOptions extends RunnableConfig> extends Runnable<RunInput, RunOutput, CallOptions> {\n    lc_namespace: string[];\n    invoke(_input: RunInput, _options?: Partial<CallOptions>): Promise<any>;\n    withConfig(_config: CallOptions): typeof this;\n    stream(input: RunInput, options?: Partial<CallOptions>): Promise<IterableReadableStream<any>>;\n}\n/**\n * The Pregel class is the core runtime engine of LangGraph, implementing a message-passing graph computation model\n * inspired by [Google's Pregel system](https://research.google/pubs/pregel-a-system-for-large-scale-graph-processing/).\n * It provides the foundation for building reliable, controllable agent workflows that can evolve state over time.\n *\n * Key features:\n * - Message passing between nodes in discrete \"supersteps\"\n * - Built-in persistence layer through checkpointers\n * - First-class streaming support for values, updates, and events\n * - Human-in-the-loop capabilities via interrupts\n * - Support for parallel node execution within supersteps\n *\n * The Pregel class is not intended to be instantiated directly by consumers. Instead, use the following higher-level APIs:\n * - {@link StateGraph}: The main graph class for building agent workflows\n *   - Compiling a {@link StateGraph} will return a {@link CompiledGraph} instance, which extends `Pregel`\n * - Functional API: A declarative approach using tasks and entrypoints\n *   - A `Pregel` instance is returned by the {@link entrypoint} function\n *\n * @example\n * ```typescript\n * // Using StateGraph API\n * const graph = new StateGraph(annotation)\n *   .addNode(\"nodeA\", myNodeFunction)\n *   .addEdge(\"nodeA\", \"nodeB\")\n *   .compile();\n *\n * // The compiled graph is a Pregel instance\n * const result = await graph.invoke(input);\n * ```\n *\n * @example\n * ```typescript\n * // Using Functional API\n * import { task, entrypoint } from \"@langchain/langgraph\";\n * import { MemorySaver } from \"@langchain/langgraph-checkpoint\";\n *\n * // Define tasks that can be composed\n * const addOne = task(\"add\", async (x: number) => x + 1);\n *\n * // Create a workflow using the entrypoint function\n * const workflow = entrypoint({\n *   name: \"workflow\",\n *   checkpointer: new MemorySaver()\n * }, async (numbers: number[]) => {\n *   // Tasks can be run in parallel\n *   const results = await Promise.all(numbers.map(n => addOne(n)));\n *   return results;\n * });\n *\n * // The workflow is a Pregel instance\n * const result = await workflow.invoke([1, 2, 3]); // Returns [2, 3, 4]\n * ```\n *\n * @typeParam Nodes - Mapping of node names to their {@link PregelNode} implementations\n * @typeParam Channels - Mapping of channel names to their {@link BaseChannel} or {@link ManagedValueSpec} implementations\n * @typeParam ContextType - Type of context that can be passed to the graph\n * @typeParam InputType - Type of input values accepted by the graph\n * @typeParam OutputType - Type of output values produced by the graph\n */\nexport declare class Pregel<Nodes extends StrRecord<string, PregelNode>, Channels extends StrRecord<string, BaseChannel>, ContextType extends Record<string, any> = StrRecord<string, any>, InputType = PregelInputType, OutputType = PregelOutputType, StreamUpdatesType = InputType, StreamValuesType = OutputType, NodeReturnType = unknown, CommandType = CommandInstance, StreamCustom = any> extends PartialRunnable<InputType | CommandType | null, OutputType, PregelOptions<Nodes, Channels, ContextType>> implements PregelInterface<Nodes, Channels, ContextType> {\n    /**\n     * Name of the class when serialized\n     * @internal\n     */\n    static lc_name(): string;\n    /** @internal Used for type inference */\n    \"~InputType\": InputType;\n    /** @internal Used for type inference */\n    \"~OutputType\": OutputType;\n    /** @internal LangChain namespace for serialization necessary because Pregel extends Runnable */\n    lc_namespace: string[];\n    /** @internal Flag indicating this is a Pregel instance - necessary for serialization */\n    lg_is_pregel: boolean;\n    /** The nodes in the graph, mapping node names to their PregelNode instances */\n    nodes: Nodes;\n    /** The channels in the graph, mapping channel names to their BaseChannel or ManagedValueSpec instances */\n    channels: Channels;\n    /**\n     * The input channels for the graph. These channels receive the initial input when the graph is invoked.\n     * Can be a single channel key or an array of channel keys.\n     */\n    inputChannels: keyof Channels | Array<keyof Channels>;\n    /**\n     * The output channels for the graph. These channels contain the final output when the graph completes.\n     * Can be a single channel key or an array of channel keys.\n     */\n    outputChannels: keyof Channels | Array<keyof Channels>;\n    /** Whether to automatically validate the graph structure when it is compiled. Defaults to true. */\n    autoValidate: boolean;\n    /**\n     * The streaming modes enabled for this graph. Defaults to [\"values\"].\n     * Supported modes:\n     * - \"values\": Streams the full state after each step\n     * - \"updates\": Streams state updates after each step\n     * - \"messages\": Streams messages from within nodes\n     * - \"custom\": Streams custom events from within nodes\n     * - \"debug\": Streams events related to the execution of the graph - useful for tracing & debugging graph execution\n     */\n    streamMode: StreamMode[];\n    /**\n     * Optional channels to stream. If not specified, all channels will be streamed.\n     * Can be a single channel key or an array of channel keys.\n     */\n    streamChannels?: keyof Channels | Array<keyof Channels>;\n    /**\n     * Optional array of node names or \"all\" to interrupt after executing these nodes.\n     * Used for implementing human-in-the-loop workflows.\n     */\n    interruptAfter?: Array<keyof Nodes> | All;\n    /**\n     * Optional array of node names or \"all\" to interrupt before executing these nodes.\n     * Used for implementing human-in-the-loop workflows.\n     */\n    interruptBefore?: Array<keyof Nodes> | All;\n    /** Optional timeout in milliseconds for the execution of each superstep */\n    stepTimeout?: number;\n    /** Whether to enable debug logging. Defaults to false. */\n    debug: boolean;\n    /**\n     * Optional checkpointer for persisting graph state.\n     * When provided, saves a checkpoint of the graph state at every superstep.\n     * When false or undefined, checkpointing is disabled, and the graph will not be able to save or restore state.\n     */\n    checkpointer?: BaseCheckpointSaver | boolean;\n    /** Optional retry policy for handling failures in node execution */\n    retryPolicy?: RetryPolicy;\n    /** The default configuration for graph execution, can be overridden on a per-invocation basis */\n    config?: LangGraphRunnableConfig;\n    /**\n     * Optional long-term memory store for the graph, allows for persistence & retrieval of data across threads\n     */\n    store?: BaseStore;\n    /**\n     * Optional cache for the graph, useful for caching tasks.\n     */\n    cache?: BaseCache;\n    /**\n     * Optional interrupt helper function.\n     * @internal\n     */\n    private userInterrupt?;\n    /**\n     * The trigger to node mapping for the graph run.\n     * @internal\n     */\n    private triggerToNodes;\n    /**\n     * Constructor for Pregel - meant for internal use only.\n     *\n     * @internal\n     */\n    constructor(fields: PregelParams<Nodes, Channels>);\n    /**\n     * Creates a new instance of the Pregel graph with updated configuration.\n     * This method follows the immutable pattern - instead of modifying the current instance,\n     * it returns a new instance with the merged configuration.\n     *\n     * @example\n     * ```typescript\n     * // Create a new instance with debug enabled\n     * const debugGraph = graph.withConfig({ debug: true });\n     *\n     * // Create a new instance with a specific thread ID\n     * const threadGraph = graph.withConfig({\n     *   configurable: { thread_id: \"123\" }\n     * });\n     * ```\n     *\n     * @param config - The configuration to merge with the current configuration\n     * @returns A new Pregel instance with the merged configuration\n     */\n    withConfig(config: Omit<LangGraphRunnableConfig, \"store\" | \"writer\" | \"interrupt\">): typeof this;\n    /**\n     * Validates the graph structure to ensure it is well-formed.\n     * Checks for:\n     * - No orphaned nodes\n     * - Valid input/output channel configurations\n     * - Valid interrupt configurations\n     *\n     * @returns this - The Pregel instance for method chaining\n     * @throws {GraphValidationError} If the graph structure is invalid\n     */\n    validate(): this;\n    /**\n     * Gets a list of all channels that should be streamed.\n     * If streamChannels is specified, returns those channels.\n     * Otherwise, returns all channels in the graph.\n     *\n     * @returns Array of channel keys to stream\n     */\n    get streamChannelsList(): Array<keyof Channels>;\n    /**\n     * Gets the channels to stream in their original format.\n     * If streamChannels is specified, returns it as-is (either single key or array).\n     * Otherwise, returns all channels in the graph as an array.\n     *\n     * @returns Channel keys to stream, either as a single key or array\n     */\n    get streamChannelsAsIs(): keyof Channels | Array<keyof Channels>;\n    /**\n     * Gets a drawable representation of the graph structure.\n     * This is an async version of getGraph() and is the preferred method to use.\n     *\n     * @param config - Configuration for generating the graph visualization\n     * @returns A representation of the graph that can be visualized\n     */\n    getGraphAsync(config: RunnableConfig): Promise<import(\"@langchain/core/runnables/graph\").Graph>;\n    /**\n     * Gets all subgraphs within this graph.\n     * A subgraph is a Pregel instance that is nested within a node of this graph.\n     *\n     * @deprecated Use getSubgraphsAsync instead. The async method will become the default in the next minor release.\n     * @param namespace - Optional namespace to filter subgraphs\n     * @param recurse - Whether to recursively get subgraphs of subgraphs\n     * @returns Generator yielding tuples of [name, subgraph]\n     */\n    getSubgraphs(namespace?: string, recurse?: boolean): Generator<[string, Pregel<any, any>]>;\n    /**\n     * Gets all subgraphs within this graph asynchronously.\n     * A subgraph is a Pregel instance that is nested within a node of this graph.\n     *\n     * @param namespace - Optional namespace to filter subgraphs\n     * @param recurse - Whether to recursively get subgraphs of subgraphs\n     * @returns AsyncGenerator yielding tuples of [name, subgraph]\n     */\n    getSubgraphsAsync(namespace?: string, recurse?: boolean): AsyncGenerator<[string, Pregel<any, any>]>;\n    /**\n     * Prepares a state snapshot from saved checkpoint data.\n     * This is an internal method used by getState and getStateHistory.\n     *\n     * @param config - Configuration for preparing the snapshot\n     * @param saved - Optional saved checkpoint data\n     * @param subgraphCheckpointer - Optional checkpointer for subgraphs\n     * @param applyPendingWrites - Whether to apply pending writes to tasks and then to channels\n     * @returns A snapshot of the graph state\n     * @internal\n     */\n    protected _prepareStateSnapshot({ config, saved, subgraphCheckpointer, applyPendingWrites }: {\n        config: RunnableConfig;\n        saved?: CheckpointTuple;\n        subgraphCheckpointer?: BaseCheckpointSaver;\n        applyPendingWrites?: boolean;\n    }): Promise<StateSnapshot>;\n    /**\n     * Gets the current state of the graph.\n     * Requires a checkpointer to be configured.\n     *\n     * @param config - Configuration for retrieving the state\n     * @param options - Additional options\n     * @returns A snapshot of the current graph state\n     * @throws {GraphValueError} If no checkpointer is configured\n     */\n    getState(config: RunnableConfig, options?: GetStateOptions): Promise<StateSnapshot>;\n    /**\n     * Gets the history of graph states.\n     * Requires a checkpointer to be configured.\n     * Useful for:\n     * - Debugging execution history\n     * - Implementing time travel\n     * - Analyzing graph behavior\n     *\n     * @param config - Configuration for retrieving the history\n     * @param options - Options for filtering the history\n     * @returns An async iterator of state snapshots\n     * @throws {Error} If no checkpointer is configured\n     */\n    getStateHistory(config: RunnableConfig, options?: CheckpointListOptions): AsyncIterableIterator<StateSnapshot>;\n    /**\n     * Apply updates to the graph state in bulk.\n     * Requires a checkpointer to be configured.\n     *\n     * This method is useful for recreating a thread\n     * from a list of updates, especially if a checkpoint\n     * is created as a result of multiple tasks.\n     *\n     * @internal The API might change in the future.\n     *\n     * @param startConfig - Configuration for the update\n     * @param updates - The list of updates to apply to graph state\n     * @returns Updated configuration\n     * @throws {GraphValueError} If no checkpointer is configured\n     * @throws {InvalidUpdateError} If the update cannot be attributed to a node or an update can be only applied in sequence.\n     */\n    bulkUpdateState(startConfig: LangGraphRunnableConfig, supersteps: Array<{\n        updates: Array<{\n            values?: Record<string, unknown> | unknown;\n            asNode?: keyof Nodes | string;\n        }>;\n    }>): Promise<RunnableConfig>;\n    /**\n     * Updates the state of the graph with new values.\n     * Requires a checkpointer to be configured.\n     *\n     * This method can be used for:\n     * - Implementing human-in-the-loop workflows\n     * - Modifying graph state during breakpoints\n     * - Integrating external inputs into the graph\n     *\n     * @param inputConfig - Configuration for the update\n     * @param values - The values to update the state with\n     * @param asNode - Optional node name to attribute the update to\n     * @returns Updated configuration\n     * @throws {GraphValueError} If no checkpointer is configured\n     * @throws {InvalidUpdateError} If the update cannot be attributed to a node\n     */\n    updateState(inputConfig: LangGraphRunnableConfig, values: Record<string, unknown> | unknown, asNode?: keyof Nodes | string): Promise<RunnableConfig>;\n    /**\n     * Gets the default values for various graph configuration options.\n     * This is an internal method used to process and normalize configuration options.\n     *\n     * @param config - The input configuration options\n     * @returns A tuple containing normalized values for:\n     * - debug mode\n     * - stream modes\n     * - input keys\n     * - output keys\n     * - remaining config\n     * - interrupt before nodes\n     * - interrupt after nodes\n     * - checkpointer\n     * - store\n     * - whether stream mode is single\n     * - node cache\n     * - whether checkpoint during is enabled\n     * @internal\n     */\n    _defaults(config: PregelOptions<Nodes, Channels>): [\n        boolean,\n        StreamMode[],\n        string | string[],\n        string | string[],\n        LangGraphRunnableConfig,\n        All | string[],\n        All | string[],\n        BaseCheckpointSaver | undefined,\n        BaseStore | undefined,\n        boolean,\n        BaseCache | undefined,\n        Durability\n    ];\n    /**\n     * Streams the execution of the graph, emitting state updates as they occur.\n     * This is the primary method for observing graph execution in real-time.\n     *\n     * Stream modes:\n     * - \"values\": Emits complete state after each step\n     * - \"updates\": Emits only state changes after each step\n     * - \"debug\": Emits detailed debug information\n     * - \"messages\": Emits messages from within nodes\n     * - \"custom\": Emits custom events from within nodes\n     * - \"checkpoints\": Emits checkpoints from within nodes\n     * - \"tasks\": Emits tasks from within nodes\n     *\n     * @param input - The input to start graph execution with\n     * @param options - Configuration options for streaming\n     * @returns An async iterable stream of graph state updates\n     */\n    stream<TStreamMode extends StreamMode | StreamMode[] | undefined, TSubgraphs extends boolean, TEncoding extends \"text/event-stream\" | undefined>(input: InputType | CommandType | null, options?: Partial<PregelOptions<Nodes, Channels, ContextType, TStreamMode, TSubgraphs, TEncoding>>): Promise<IterableReadableStream<StreamOutputMap<TStreamMode, TSubgraphs, StreamUpdatesType, StreamValuesType, keyof Nodes, NodeReturnType, StreamCustom, TEncoding>>>;\n    /**\n     * @inheritdoc\n     */\n    streamEvents(input: InputType | CommandType | null, options: Partial<PregelOptions<Nodes, Channels, ContextType>> & {\n        version: \"v1\" | \"v2\";\n    }, streamOptions?: StreamEventsOptions): IterableReadableStream<StreamEvent>;\n    streamEvents(input: InputType | CommandType | null, options: Partial<PregelOptions<Nodes, Channels, ContextType>> & {\n        version: \"v1\" | \"v2\";\n        encoding: \"text/event-stream\";\n    }, streamOptions?: StreamEventsOptions): IterableReadableStream<Uint8Array>;\n    /**\n     * Validates the input for the graph.\n     * @param input - The input to validate\n     * @returns The validated input\n     * @internal\n     */\n    protected _validateInput(input: PregelInputType): Promise<any>;\n    /**\n     * Validates the context options for the graph.\n     * @param context - The context options to validate\n     * @returns The validated context options\n     * @internal\n     */\n    protected _validateContext(context: Partial<LangGraphRunnableConfig[\"context\"]>): Promise<LangGraphRunnableConfig[\"context\"]>;\n    /**\n     * Internal iterator used by stream() to generate state updates.\n     * This method handles the core logic of graph execution and streaming.\n     *\n     * @param input - The input to start graph execution with\n     * @param options - Configuration options for streaming\n     * @returns AsyncGenerator yielding state updates\n     * @internal\n     */\n    _streamIterator(input: PregelInputType | Command, options?: Partial<PregelOptions<Nodes, Channels>>): AsyncGenerator<PregelOutputType>;\n    /**\n     * Run the graph with a single input and config.\n     * @param input The input to the graph.\n     * @param options The configuration to use for the run.\n     */\n    invoke(input: InputType | CommandType | null, options?: Partial<Omit<PregelOptions<Nodes, Channels, ContextType>, \"encoding\">>): Promise<OutputType>;\n    private _runLoop;\n    clearCache(): Promise<void>;\n}\n"],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/pregel/index.ts"],"mappings":"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"}

package/dist/pregel/read.d.cts

@@ -2,7 +2,6 @@ import { CachePolicy, RetryPolicy } from "./utils/index.cjs";
 import { Runnable, RunnableBinding, RunnableBindingArgs, RunnableConfig, RunnableLike } from "@langchain/core/runnables";
 
 //#region src/pregel/read.d.ts
-
 interface PregelNodeArgs<RunInput, RunOutput> extends Partial<RunnableBindingArgs<RunInput, RunOutput>> {
   channels: Record<string, string> | string[];
   triggers: Array<string>;

package/dist/pregel/read.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"read.d.cts","names":["Runnable","RunnableBinding","RunnableBindingArgs","RunnableConfig","RunnableLike","RunnableCallable","CachePolicy","RetryPolicy","ChannelRead","Array","T","PregelNodeArgs","RunInput","RunOutput","Record","Partial","PregelNodeInputType","PregelNodeOutputType","PregelNode","NewRunOutput","Error","Exclude"],"sources":["../../src/pregel/read.d.ts"],"sourcesContent":["import { Runnable, RunnableBinding, RunnableBindingArgs, RunnableConfig, type RunnableLike } from \"@langchain/core/runnables\";\nimport { RunnableCallable } from \"../utils.js\";\nimport type { CachePolicy, RetryPolicy } from \"./utils/index.js\";\nexport declare class ChannelRead<RunInput = any> extends RunnableCallable {\n    lc_graph_name: string;\n    channel: string | Array<string>;\n    fresh: boolean;\n    mapper?: (args: any) => any;\n    constructor(channel: string | Array<string>, mapper?: (args: any) => any, fresh?: boolean);\n    static doRead<T = unknown>(config: RunnableConfig, channel: string | Array<string>, fresh: boolean, mapper?: (args: unknown) => unknown): T;\n}\ninterface PregelNodeArgs<RunInput, RunOutput> extends Partial<RunnableBindingArgs<RunInput, RunOutput>> {\n    channels: Record<string, string> | string[];\n    triggers: Array<string>;\n    mapper?: (args: any) => any;\n    writers?: Runnable<RunOutput, unknown>[];\n    tags?: string[];\n    bound?: Runnable<RunInput, RunOutput>;\n    kwargs?: Record<string, any>;\n    config?: RunnableConfig;\n    metadata?: Record<string, unknown>;\n    retryPolicy?: RetryPolicy;\n    cachePolicy?: CachePolicy;\n    subgraphs?: Runnable[];\n    ends?: string[];\n}\nexport type PregelNodeInputType = any;\nexport type PregelNodeOutputType = any;\nexport declare class PregelNode<RunInput = PregelNodeInputType, RunOutput = PregelNodeOutputType> extends RunnableBinding<RunInput, RunOutput, RunnableConfig> {\n    lc_graph_name: string;\n    channels: Record<string, string> | string[];\n    triggers: string[];\n    mapper?: (args: any) => any;\n    writers: Runnable[];\n    bound: Runnable<RunInput, RunOutput>;\n    kwargs: Record<string, any>;\n    metadata: Record<string, unknown>;\n    tags: string[];\n    retryPolicy?: RetryPolicy;\n    cachePolicy?: CachePolicy;\n    subgraphs?: Runnable[];\n    ends?: string[];\n    constructor(fields: PregelNodeArgs<RunInput, RunOutput>);\n    getWriters(): Array<Runnable>;\n    getNode(): Runnable<RunInput, RunOutput> | undefined;\n    join(channels: Array<string>): PregelNode<RunInput, RunOutput>;\n    pipe<NewRunOutput>(coerceable: RunnableLike): PregelNode<RunInput, Exclude<NewRunOutput, Error>>;\n}\nexport {};\n"],"mappings":";;;;;UAWUW,cAIaE,CAAAA,QAAAA,EAAAA,SAAAA,CAAAA,SAJ+BE,OAI/BF,CAJuCX,mBAIvCW,CAJ2DD,QAI3DC,EAJqEA,SAIrEA,CAAAA,CAAAA,CAAAA;UAATb,EAHAc,MAGAd,CAAAA,MAAAA,EAAAA,MAAAA,CAAAA,GAAAA,MAAAA,EAAAA;UAEOY,EAJPH,KAIOG,CAAAA,MAAAA,CAAAA;QAAUC,CAAAA,EAAAA,CAAAA,IAAAA,EAAAA,GAAAA,EAAAA,GAAAA,GAAAA;SAAnBb,CAAAA,EAFEA,QAEFA,CAFWa,SAEXb,EAAAA,OAAAA,CAAAA,EAAAA;MACCc,CAAAA,EAAAA,MAAAA,EAAAA;OACAX,CAAAA,EAFDH,QAECG,CAFQS,QAERT,EAFkBU,SAElBV,CAAAA;QACEW,CAAAA,EAFFA,MAEEA,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA;QACGP,CAAAA,EAFLJ,cAEKI;UACAD,CAAAA,EAFHQ,MAEGR,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA;aACFN,CAAAA,EAFEO,WAEFP;aAZsCe,CAAAA,EAWpCT,WAXoCS;EAAO,SAAA,CAAA,EAY7Cf,QAZ6C,EAAA;EAejDgB,IAAAA,CAAAA,EAAAA,MAAAA,EAAAA;AACZ;AACqBE,KAFTF,mBAAAA,GAEmB,GAAA;AAAA,KADnBC,oBAAAA,GACmB,GAAA;AAAYD,cAAtBE,UAAsBF,CAAAA,WAAAA,mBAAAA,EAAAA,YAAiCC,oBAAjCD,CAAAA,SAA+Df,eAA/De,CAA+EJ,QAA/EI,EAAyFH,SAAzFG,EAAoGb,cAApGa,CAAAA,CAAAA;eAAiCC,EAAAA,MAAAA;UAA8CL,EAE5GE,MAF4GF,CAAAA,MAAAA,EAAAA,MAAAA,CAAAA,GAAAA,MAAAA,EAAAA;UAAUC,EAAAA,MAAAA,EAAAA;QAAWV,CAAAA,EAAAA,CAAAA,IAAAA,EAAAA,GAAAA,EAAAA,GAAAA,GAAAA;SAEjIW,EAGDd,QAHCc,EAAAA;OAGDd,EACFA,QADEA,CACOY,QADPZ,EACiBa,SADjBb,CAAAA;QACOY,EACRE,MADQF,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA;UAAUC,EAEhBC,MAFgBD,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA;MAAnBb,EAAAA,MAAAA,EAAAA;aACCc,CAAAA,EAGMP,WAHNO;aACEA,CAAAA,EAGIR,WAHJQ;WAEIP,CAAAA,EAEFP,QAFEO,EAAAA;MACAD,CAAAA,EAAAA,MAAAA,EAAAA;aACFN,CAAAA,MAAAA,EAEQW,cAFRX,CAEuBY,QAFvBZ,EAEiCa,SAFjCb,CAAAA;YAEuBY,CAAAA,CAAAA,EACrBH,KADqBG,CACfZ,QADeY,CAAAA;SAAUC,CAAAA,CAAAA,EAElCb,QAFkCa,CAEzBD,QAFyBC,EAEfA,SAFeA,CAAAA,GAAAA,SAAAA;MAAzBF,CAAAA,QAAAA,EAGLF,KAHKE,CAAAA,MAAAA,CAAAA,CAAAA,EAGWO,UAHXP,CAGsBC,QAHtBD,EAGgCE,SAHhCF,CAAAA;MACAX,CAAAA,YAAAA,CAAAA,CAAAA,UAAAA,EAGWI,YAHXJ,CAAAA,EAG0BkB,UAH1BlB,CAGqCY,QAHrCZ,EAG+CqB,OAH/CrB,CAGuDmB,YAHvDnB,EAGqEoB,KAHrEpB,CAAAA,CAAAA"}
+{"version":3,"file":"read.d.cts","names":[],"sources":["../../src/pregel/read.ts"],"mappings":";;;;UAuEU,cAAA,8BACA,OAAA,CAAQ,mBAAA,CAAoB,QAAA,EAAU,SAAA;EAC9C,QAAA,EAAU,MAAA;EACV,QAAA,EAAU,KAAA;EAEV,MAAA,IAAU,IAAA;EACV,OAAA,GAAU,QAAA,CAAS,SAAA;EACnB,IAAA;EACA,KAAA,GAAQ,QAAA,CAAS,QAAA,EAAU,SAAA;EAE3B,MAAA,GAAS,MAAA;EACT,MAAA,GAAS,cAAA;EACT,QAAA,GAAW,MAAA;EACX,WAAA,GAAc,WAAA;EACd,WAAA,GAAc,WAAA;EACd,SAAA,GAAY,QAAA;EACZ,IAAA;AAAA;AAAA,KAIU,mBAAA;AAAA,KAGA,oBAAA;AAAA,cAEC,UAAA,YACA,mBAAA,cACC,oBAAA,UACJ,eAAA,CAAgB,QAAA,EAAU,SAAA,EAAW,cAAA;EAC7C,aAAA;EAEA,QAAA,EAAU,MAAA;EAEV,QAAA;EAGA,MAAA,IAAU,IAAA;EAEV,OAAA,EAAS,QAAA;EAET,KAAA,EAAO,QAAA,CAAS,QAAA,EAAU,SAAA;EAG1B,MAAA,EAAQ,MAAA;EAER,QAAA,EAAU,MAAA;EAEV,IAAA;EAEA,WAAA,GAAc,WAAA;EAEd,WAAA,GAAc,WAAA;EAEd,SAAA,GAAY,QAAA;EAEZ,IAAA;EAEA,WAAA,CAAY,MAAA,EAAQ,cAAA,CAAe,QAAA,EAAU,SAAA;EA6C7C,UAAA,CAAA,GAAc,KAAA,CAAM,QAAA;EAsBpB,OAAA,CAAA,GAAW,QAAA,CAAS,QAAA,EAAU,SAAA;EAyB9B,IAAA,CAAK,QAAA,EAAU,KAAA,WAAgB,UAAA,CAAW,QAAA,EAAU,SAAA;EAwBpD,IAAA,cAAA,CACE,UAAA,EAAY,YAAA,GACX,UAAA,CAAW,QAAA,EAAU,OAAA,CAAQ,YAAA,EAAc,KAAA;AAAA"}

package/dist/pregel/read.d.ts

@@ -1,8 +1,8 @@
+import "../utils.js";
 import { CachePolicy, RetryPolicy } from "./utils/index.js";
 import { Runnable, RunnableBinding, RunnableBindingArgs, RunnableConfig, RunnableLike } from "@langchain/core/runnables";
 
 //#region src/pregel/read.d.ts
-
 interface PregelNodeArgs<RunInput, RunOutput> extends Partial<RunnableBindingArgs<RunInput, RunOutput>> {
   channels: Record<string, string> | string[];
   triggers: Array<string>;

package/dist/pregel/read.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"read.d.ts","names":["Runnable","RunnableBinding","RunnableBindingArgs","RunnableConfig","RunnableLike","RunnableCallable","CachePolicy","RetryPolicy","ChannelRead","Array","T","PregelNodeArgs","RunInput","RunOutput","Record","Partial","PregelNodeInputType","PregelNodeOutputType","PregelNode","NewRunOutput","Error","Exclude"],"sources":["../../src/pregel/read.d.ts"],"sourcesContent":["import { Runnable, RunnableBinding, RunnableBindingArgs, RunnableConfig, type RunnableLike } from \"@langchain/core/runnables\";\nimport { RunnableCallable } from \"../utils.js\";\nimport type { CachePolicy, RetryPolicy } from \"./utils/index.js\";\nexport declare class ChannelRead<RunInput = any> extends RunnableCallable {\n    lc_graph_name: string;\n    channel: string | Array<string>;\n    fresh: boolean;\n    mapper?: (args: any) => any;\n    constructor(channel: string | Array<string>, mapper?: (args: any) => any, fresh?: boolean);\n    static doRead<T = unknown>(config: RunnableConfig, channel: string | Array<string>, fresh: boolean, mapper?: (args: unknown) => unknown): T;\n}\ninterface PregelNodeArgs<RunInput, RunOutput> extends Partial<RunnableBindingArgs<RunInput, RunOutput>> {\n    channels: Record<string, string> | string[];\n    triggers: Array<string>;\n    mapper?: (args: any) => any;\n    writers?: Runnable<RunOutput, unknown>[];\n    tags?: string[];\n    bound?: Runnable<RunInput, RunOutput>;\n    kwargs?: Record<string, any>;\n    config?: RunnableConfig;\n    metadata?: Record<string, unknown>;\n    retryPolicy?: RetryPolicy;\n    cachePolicy?: CachePolicy;\n    subgraphs?: Runnable[];\n    ends?: string[];\n}\nexport type PregelNodeInputType = any;\nexport type PregelNodeOutputType = any;\nexport declare class PregelNode<RunInput = PregelNodeInputType, RunOutput = PregelNodeOutputType> extends RunnableBinding<RunInput, RunOutput, RunnableConfig> {\n    lc_graph_name: string;\n    channels: Record<string, string> | string[];\n    triggers: string[];\n    mapper?: (args: any) => any;\n    writers: Runnable[];\n    bound: Runnable<RunInput, RunOutput>;\n    kwargs: Record<string, any>;\n    metadata: Record<string, unknown>;\n    tags: string[];\n    retryPolicy?: RetryPolicy;\n    cachePolicy?: CachePolicy;\n    subgraphs?: Runnable[];\n    ends?: string[];\n    constructor(fields: PregelNodeArgs<RunInput, RunOutput>);\n    getWriters(): Array<Runnable>;\n    getNode(): Runnable<RunInput, RunOutput> | undefined;\n    join(channels: Array<string>): PregelNode<RunInput, RunOutput>;\n    pipe<NewRunOutput>(coerceable: RunnableLike): PregelNode<RunInput, Exclude<NewRunOutput, Error>>;\n}\nexport {};\n"],"mappings":";;;;;UAWUW,cAIaE,CAAAA,QAAAA,EAAAA,SAAAA,CAAAA,SAJ+BE,OAI/BF,CAJuCX,mBAIvCW,CAJ2DD,QAI3DC,EAJqEA,SAIrEA,CAAAA,CAAAA,CAAAA;UAATb,EAHAc,MAGAd,CAAAA,MAAAA,EAAAA,MAAAA,CAAAA,GAAAA,MAAAA,EAAAA;UAEOY,EAJPH,KAIOG,CAAAA,MAAAA,CAAAA;QAAUC,CAAAA,EAAAA,CAAAA,IAAAA,EAAAA,GAAAA,EAAAA,GAAAA,GAAAA;SAAnBb,CAAAA,EAFEA,QAEFA,CAFWa,SAEXb,EAAAA,OAAAA,CAAAA,EAAAA;MACCc,CAAAA,EAAAA,MAAAA,EAAAA;OACAX,CAAAA,EAFDH,QAECG,CAFQS,QAERT,EAFkBU,SAElBV,CAAAA;QACEW,CAAAA,EAFFA,MAEEA,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA;QACGP,CAAAA,EAFLJ,cAEKI;UACAD,CAAAA,EAFHQ,MAEGR,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA;aACFN,CAAAA,EAFEO,WAEFP;aAZsCe,CAAAA,EAWpCT,WAXoCS;EAAO,SAAA,CAAA,EAY7Cf,QAZ6C,EAAA;EAejDgB,IAAAA,CAAAA,EAAAA,MAAAA,EAAAA;AACZ;AACqBE,KAFTF,mBAAAA,GAEmB,GAAA;AAAA,KADnBC,oBAAAA,GACmB,GAAA;AAAYD,cAAtBE,UAAsBF,CAAAA,WAAAA,mBAAAA,EAAAA,YAAiCC,oBAAjCD,CAAAA,SAA+Df,eAA/De,CAA+EJ,QAA/EI,EAAyFH,SAAzFG,EAAoGb,cAApGa,CAAAA,CAAAA;eAAiCC,EAAAA,MAAAA;UAA8CL,EAE5GE,MAF4GF,CAAAA,MAAAA,EAAAA,MAAAA,CAAAA,GAAAA,MAAAA,EAAAA;UAAUC,EAAAA,MAAAA,EAAAA;QAAWV,CAAAA,EAAAA,CAAAA,IAAAA,EAAAA,GAAAA,EAAAA,GAAAA,GAAAA;SAEjIW,EAGDd,QAHCc,EAAAA;OAGDd,EACFA,QADEA,CACOY,QADPZ,EACiBa,SADjBb,CAAAA;QACOY,EACRE,MADQF,CAAAA,MAAAA,EAAAA,GAAAA,CAAAA;UAAUC,EAEhBC,MAFgBD,CAAAA,MAAAA,EAAAA,OAAAA,CAAAA;MAAnBb,EAAAA,MAAAA,EAAAA;aACCc,CAAAA,EAGMP,WAHNO;aACEA,CAAAA,EAGIR,WAHJQ;WAEIP,CAAAA,EAEFP,QAFEO,EAAAA;MACAD,CAAAA,EAAAA,MAAAA,EAAAA;aACFN,CAAAA,MAAAA,EAEQW,cAFRX,CAEuBY,QAFvBZ,EAEiCa,SAFjCb,CAAAA;YAEuBY,CAAAA,CAAAA,EACrBH,KADqBG,CACfZ,QADeY,CAAAA;SAAUC,CAAAA,CAAAA,EAElCb,QAFkCa,CAEzBD,QAFyBC,EAEfA,SAFeA,CAAAA,GAAAA,SAAAA;MAAzBF,CAAAA,QAAAA,EAGLF,KAHKE,CAAAA,MAAAA,CAAAA,CAAAA,EAGWO,UAHXP,CAGsBC,QAHtBD,EAGgCE,SAHhCF,CAAAA;MACAX,CAAAA,YAAAA,CAAAA,CAAAA,UAAAA,EAGWI,YAHXJ,CAAAA,EAG0BkB,UAH1BlB,CAGqCY,QAHrCZ,EAG+CqB,OAH/CrB,CAGuDmB,YAHvDnB,EAGqEoB,KAHrEpB,CAAAA,CAAAA"}
+{"version":3,"file":"read.d.ts","names":[],"sources":["../../src/pregel/read.ts"],"mappings":";;;;;UAuEU,cAAA,8BACA,OAAA,CAAQ,mBAAA,CAAoB,QAAA,EAAU,SAAA;EAC9C,QAAA,EAAU,MAAA;EACV,QAAA,EAAU,KAAA;EAEV,MAAA,IAAU,IAAA;EACV,OAAA,GAAU,QAAA,CAAS,SAAA;EACnB,IAAA;EACA,KAAA,GAAQ,QAAA,CAAS,QAAA,EAAU,SAAA;EAE3B,MAAA,GAAS,MAAA;EACT,MAAA,GAAS,cAAA;EACT,QAAA,GAAW,MAAA;EACX,WAAA,GAAc,WAAA;EACd,WAAA,GAAc,WAAA;EACd,SAAA,GAAY,QAAA;EACZ,IAAA;AAAA;AAAA,KAIU,mBAAA;AAAA,KAGA,oBAAA;AAAA,cAEC,UAAA,YACA,mBAAA,cACC,oBAAA,UACJ,eAAA,CAAgB,QAAA,EAAU,SAAA,EAAW,cAAA;EAC7C,aAAA;EAEA,QAAA,EAAU,MAAA;EAEV,QAAA;EAGA,MAAA,IAAU,IAAA;EAEV,OAAA,EAAS,QAAA;EAET,KAAA,EAAO,QAAA,CAAS,QAAA,EAAU,SAAA;EAG1B,MAAA,EAAQ,MAAA;EAER,QAAA,EAAU,MAAA;EAEV,IAAA;EAEA,WAAA,GAAc,WAAA;EAEd,WAAA,GAAc,WAAA;EAEd,SAAA,GAAY,QAAA;EAEZ,IAAA;EAEA,WAAA,CAAY,MAAA,EAAQ,cAAA,CAAe,QAAA,EAAU,SAAA;EA6C7C,UAAA,CAAA,GAAc,KAAA,CAAM,QAAA;EAsBpB,OAAA,CAAA,GAAW,QAAA,CAAS,QAAA,EAAU,SAAA;EAyB9B,IAAA,CAAK,QAAA,EAAU,KAAA,WAAgB,UAAA,CAAW,QAAA,EAAU,SAAA;EAwBpD,IAAA,cAAA,CACE,UAAA,EAAY,YAAA,GACX,UAAA,CAAW,QAAA,EAAU,OAAA,CAAQ,YAAA,EAAc,KAAA;AAAA"}

package/dist/pregel/remote.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"remote.d.cts","names":["Client","Checkpoint","ThreadState","Graph","DrawableGraph","Node","DrawableNode","Runnable","RunnableConfig","All","CheckpointListOptions","StreamEvent","IterableReadableStream","BaseChannel","LangGraphRunnableConfig","StrRecord","PregelInputType","PregelOptions","PregelOutputType","PregelNode","PregelParams","PregelInterface","StateSnapshot","RemoteGraphParams","Omit","Record","RemoteGraph","Nn","Cc","ContextType","Array","Partial","Promise","AsyncGenerator","AsyncIterableIterator","Generator"],"sources":["../../src/pregel/remote.d.ts"],"sourcesContent":["import { Client, type Checkpoint, type ThreadState } from \"@langchain/langgraph-sdk\";\nimport { Graph as DrawableGraph, Node as DrawableNode } from \"@langchain/core/runnables/graph\";\nimport { Runnable, RunnableConfig } from \"@langchain/core/runnables\";\nimport { All, CheckpointListOptions } from \"@langchain/langgraph-checkpoint\";\nimport { StreamEvent } from \"@langchain/core/tracers/log_stream\";\nimport { IterableReadableStream } from \"@langchain/core/utils/stream\";\nimport { BaseChannel, LangGraphRunnableConfig } from \"../web.js\";\nimport { StrRecord } from \"./algo.js\";\nimport { PregelInputType, PregelOptions, PregelOutputType } from \"./index.js\";\nimport { PregelNode } from \"./read.js\";\nimport { PregelParams, PregelInterface, StateSnapshot } from \"./types.js\";\nexport type RemoteGraphParams = Omit<PregelParams<StrRecord<string, PregelNode>, StrRecord<string, BaseChannel>>, \"channels\" | \"nodes\" | \"inputChannels\" | \"outputChannels\"> & {\n    graphId: string;\n    client?: Client;\n    url?: string;\n    apiKey?: string;\n    headers?: Record<string, string>;\n    streamResumable?: boolean;\n};\n/**\n * The `RemoteGraph` class is a client implementation for calling remote\n * APIs that implement the LangGraph Server API specification.\n *\n * For example, the `RemoteGraph` class can be used to call APIs from deployments\n * on LangSmith Deployment.\n *\n * `RemoteGraph` behaves the same way as a `StateGraph` and can be used directly as\n * a node in another `StateGraph`.\n *\n * @example\n * ```ts\n * import { RemoteGraph } from \"@langchain/langgraph/remote\";\n *\n * // Can also pass a LangGraph SDK client instance directly\n * const remoteGraph = new RemoteGraph({\n *   graphId: process.env.LANGGRAPH_REMOTE_GRAPH_ID!,\n *   apiKey: process.env.LANGGRAPH_REMOTE_GRAPH_API_KEY,\n *   url: process.env.LANGGRAPH_REMOTE_GRAPH_API_URL,\n * });\n *\n * const input = {\n *   messages: [\n *     {\n *       role: \"human\",\n *       content: \"Hello world!\",\n *     },\n *   ],\n * };\n *\n * const config = {\n *   configurable: { thread_id: \"threadId1\" },\n * };\n *\n * await remoteGraph.invoke(input, config);\n * ```\n */\nexport declare class RemoteGraph<Nn extends StrRecord<string, PregelNode> = StrRecord<string, PregelNode>, Cc extends StrRecord<string, BaseChannel> = StrRecord<string, BaseChannel>, ContextType extends Record<string, any> = StrRecord<string, any>> extends Runnable<PregelInputType, PregelOutputType, PregelOptions<Nn, Cc, ContextType>> implements PregelInterface<Nn, Cc, ContextType> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    lg_is_pregel: boolean;\n    config?: RunnableConfig;\n    graphId: string;\n    protected client: Client;\n    protected interruptBefore?: Array<keyof Nn> | All;\n    protected interruptAfter?: Array<keyof Nn> | All;\n    protected streamResumable?: boolean;\n    constructor(params: RemoteGraphParams);\n    withConfig(config: RunnableConfig): typeof this;\n    protected _sanitizeConfig(config: RunnableConfig): {\n        tags: string[];\n        metadata: Record<string, unknown>;\n        configurable: {\n            [k: string]: any;\n        };\n        recursion_limit: number | undefined;\n    };\n    protected _getConfig(checkpoint: Record<string, unknown>): RunnableConfig;\n    protected _getCheckpoint(config?: RunnableConfig): Checkpoint | undefined;\n    protected _createStateSnapshot(state: ThreadState): StateSnapshot;\n    invoke(input: PregelInputType, options?: Partial<PregelOptions<Nn, Cc, ContextType>>): Promise<PregelOutputType>;\n    streamEvents(input: PregelInputType, options: Partial<PregelOptions<Nn, Cc, ContextType>> & {\n        version: \"v1\" | \"v2\";\n    }): IterableReadableStream<StreamEvent>;\n    streamEvents(input: PregelInputType, options: Partial<PregelOptions<Nn, Cc, ContextType>> & {\n        version: \"v1\" | \"v2\";\n        encoding: never;\n    }): IterableReadableStream<never>;\n    _streamIterator(input: PregelInputType, options?: Partial<PregelOptions<Nn, Cc, ContextType>>): AsyncGenerator<PregelOutputType>;\n    updateState(inputConfig: LangGraphRunnableConfig, values: Record<string, unknown>, asNode?: string): Promise<RunnableConfig>;\n    getStateHistory(config: RunnableConfig, options?: CheckpointListOptions): AsyncIterableIterator<StateSnapshot>;\n    protected _getDrawableNodes(nodes: Array<{\n        id: string | number;\n        name?: string;\n        data?: Record<string, any> | string;\n        metadata?: unknown;\n    }>): Record<string, DrawableNode>;\n    getState(config: RunnableConfig, options?: {\n        subgraphs?: boolean;\n    }): Promise<StateSnapshot>;\n    /** @deprecated Use getGraphAsync instead. The async method will become the default in the next minor release. */\n    getGraph(_?: RunnableConfig & {\n        xray?: boolean | number;\n    }): DrawableGraph;\n    /**\n     * Returns a drawable representation of the computation graph.\n     */\n    getGraphAsync(config?: RunnableConfig & {\n        xray?: boolean | number;\n    }): Promise<DrawableGraph>;\n    /** @deprecated Use getSubgraphsAsync instead. The async method will become the default in the next minor release. */\n    getSubgraphs(): Generator<[string, PregelInterface<Nn, Cc, ContextType>]>;\n    getSubgraphsAsync(namespace?: string, recurse?: boolean): AsyncGenerator<[string, PregelInterface<Nn, Cc, ContextType>]>;\n}\n"],"mappings":"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"}
+{"version":3,"file":"remote.d.cts","names":[],"sources":["../../src/pregel/remote.ts"],"mappings":";;;;;;;;;;;;;KA8CY,iBAAA,GAAoB,IAAA,CAC9B,YAAA,CAAa,SAAA,SAAkB,UAAA,GAAa,SAAA,SAAkB,WAAA;EAG9D,OAAA;EACA,MAAA,GAAS,MAAA;EACT,GAAA;EACA,MAAA;EACA,OAAA,GAAU,MAAA;EACV,eAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;AAwGF;;;;;;;;;;;;;;cAAa,WAAA,YACE,SAAA,SAAkB,UAAA,IAAc,SAAA,SAAkB,UAAA,cAClD,SAAA,SAAkB,WAAA,IAAe,SAAA,SAAkB,WAAA,uBAE1C,MAAA,gBAAsB,SAAA,uBAEpC,QAAA,CACN,eAAA,EACA,gBAAA,EACA,aAAA,CAAc,EAAA,EAAI,EAAA,EAAI,WAAA,cAEb,eAAA,CAAgB,EAAA,EAAI,EAAA,EAAI,WAAA;EAAA,OAE5B,OAAA,CAAA;EAIP,YAAA;EAEA,YAAA;EAEA,MAAA,GAAS,cAAA;EAET,OAAA;EAAA,UAEU,MAAA,EAAQ,MAAA;EAAA,UAER,eAAA,GAAkB,KAAA,OAAY,EAAA,IAAM,GAAA;EAAA,UAEpC,cAAA,GAAiB,KAAA,OAAY,EAAA,IAAM,GAAA;EAAA,UAEnC,eAAA;EAEV,WAAA,CAAY,MAAA,EAAQ,iBAAA;EAmBX,UAAA,CAAW,MAAA,EAAQ,cAAA;EAAA,UAMlB,eAAA,CAAgB,MAAA,EAAQ,cAAA;;;;;;;;YAiDxB,UAAA,CAAW,UAAA,EAAY,MAAA,oBAA0B,cAAA;EAAA,UAWjD,cAAA,CAAe,MAAA,GAAS,cAAA,GAAiB,YAAA;EAAA,UAqBzC,oBAAA,CAAqB,KAAA,EAAO,WAAA,GAAc,aAAA;EAmDrC,MAAA,CACb,KAAA,EAAO,eAAA,EACP,OAAA,GAAU,OAAA,CAAQ,aAAA,CAAc,EAAA,EAAI,EAAA,EAAI,WAAA,KACvC,OAAA,CAAQ,gBAAA;EAYF,YAAA,CACP,KAAA,EAAO,eAAA,EACP,OAAA,EAAS,OAAA,CAAQ,aAAA,CAAc,EAAA,EAAI,EAAA,EAAI,WAAA;IACrC,OAAA;EAAA,IAED,sBAAA,CAAuB,WAAA;EAEjB,YAAA,CACP,KAAA,EAAO,eAAA,EACP,OAAA,EAAS,OAAA,CAAQ,aAAA,CAAc,EAAA,EAAI,EAAA,EAAI,WAAA;IACrC,OAAA;IACA,QAAA;EAAA,IAED,sBAAA;EAYa,eAAA,CACd,KAAA,EAAO,eAAA,EACP,OAAA,GAAU,OAAA,CAAQ,aAAA,CAAc,EAAA,EAAI,EAAA,EAAI,WAAA,KACvC,cAAA,CAAe,gBAAA;EAmHZ,WAAA,CACJ,WAAA,EAAa,uBAAA,EACb,MAAA,EAAQ,MAAA,mBACR,MAAA,YACC,OAAA,CAAQ,cAAA;EAWJ,eAAA,CACL,MAAA,EAAQ,cAAA,EACR,OAAA,GAAU,qBAAA,GACT,qBAAA,CAAsB,aAAA;EAAA,UAkBf,iBAAA,CACR,KAAA,EAAO,KAAA;IACL,EAAA;IACA,IAAA;IAEA,IAAA,GAAO,MAAA;IACP,QAAA;EAAA,KAED,MAAA,SAAe,IAAA;EAgBZ,QAAA,CACJ,MAAA,EAAQ,cAAA,EACR,OAAA;IAAY,SAAA;EAAA,IACX,OAAA,CAAQ,aAAA;EArMsB;EAiNxB,QAAA,CACP,CAAA,GAAI,cAAA;IAAmB,IAAA;EAAA,IACtB,KAAA;EAnNQ;;;EA4NL,aAAA,CAAc,MAAA,GAAS,cAAA;IAAmB,IAAA;EAAA,IAAyB,OAAA,CAAA,KAAA;EA1MrD;EAqNpB,YAAA,CAAA,GAAgB,SAAA,UAAmB,eAAA,CAAgB,EAAA,EAAI,EAAA,EAAI,WAAA;EAMpD,iBAAA,CACL,SAAA,WACA,OAAA,aACC,cAAA,UAAwB,eAAA,CAAgB,EAAA,EAAI,EAAA,EAAI,WAAA;AAAA"}

package/dist/pregel/remote.d.ts

@@ -3,6 +3,8 @@ import { LangGraphRunnableConfig } from "./runnable_types.js";
 import { PregelNode } from "./read.js";
 import { PregelInputType, PregelInterface, PregelOptions, PregelOutputType, PregelParams, StateSnapshot } from "./types.js";
 import { StrRecord } from "./algo.js";
+import "./index.js";
+import "../web.js";
 import { All, CheckpointListOptions } from "@langchain/langgraph-checkpoint";
 import { Runnable, RunnableConfig } from "@langchain/core/runnables";
 import { Graph, Node } from "@langchain/core/runnables/graph";