@langchain/react 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2024 LangChain
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/README.md

@@ -0,0 +1,301 @@
+# @langchain/react
+
+React SDK for building AI-powered applications with [LangChain](https://js.langchain.com/) and [LangGraph](https://langchain-ai.github.io/langgraphjs/). Provides a `useStream` hook that manages streaming, state, branching, and interrupts out of the box.
+
+## Installation
+
+```bash
+npm install @langchain/react @langchain/core
+```
+
+**Peer dependencies:** `react` (^18 || ^19), `react-dom` (^18 || ^19), `@langchain/core` (^1.0.1)
+
+## Quick Start
+
+```tsx
+import { useStream } from "@langchain/react";
+
+function Chat() {
+  const { messages, submit, isLoading } = useStream({
+    assistantId: "agent",
+    apiUrl: "http://localhost:2024",
+  });
+
+  return (
+    <div>
+      {messages.map((msg, i) => (
+        <div key={msg.id ?? i}>{msg.content}</div>
+      ))}
+
+      <button
+        disabled={isLoading}
+        onClick={() =>
+          void submit({
+            messages: [{ type: "human", content: "Hello!" }],
+          })
+        }
+      >
+        Send
+      </button>
+    </div>
+  );
+}
+```
+
+## `useStream` Options
+
+| Option | Type | Description |
+|---|---|---|
+| `assistantId` | `string` | **Required.** The assistant/graph ID to stream from. |
+| `apiUrl` | `string` | Base URL of the LangGraph API. |
+| `client` | `Client` | Pre-configured `Client` instance (alternative to `apiUrl`). |
+| `messagesKey` | `string` | State key containing messages. Defaults to `"messages"`. |
+| `initialValues` | `StateType` | Initial state values before any stream data arrives. |
+| `fetchStateHistory` | `boolean \| { limit: number }` | Fetch thread history on stream completion. Enables branching. |
+| `throttle` | `boolean \| number` | Throttle state updates for performance. |
+| `onFinish` | `(state, error?) => void` | Called when the stream completes. |
+| `onError` | `(error, state?) => void` | Called on stream errors. |
+| `onThreadId` | `(threadId) => void` | Called when a new thread is created. |
+| `onUpdateEvent` | `(event) => void` | Receive update events from the stream. |
+| `onCustomEvent` | `(event) => void` | Receive custom events from the stream. |
+| `onStop` | `() => void` | Called when the stream is stopped by the user. |
+
+## Return Values
+
+| Property | Type | Description |
+|---|---|---|
+| `values` | `StateType` | Current graph state. |
+| `messages` | `Message[]` | Messages from the current state. |
+| `isLoading` | `boolean` | Whether a stream is currently active. |
+| `error` | `unknown` | The most recent error, if any. |
+| `interrupt` | `Interrupt \| undefined` | Current interrupt requiring user input. |
+| `branch` | `string` | Active branch identifier. |
+| `submit(values, options?)` | `function` | Submit new input to the graph. When called while a stream is active, the run is created on the server with `multitaskStrategy: "enqueue"` and queued automatically. |
+| `stop()` | `function` | Cancel the active stream. |
+| `setBranch(branch)` | `function` | Switch to a different conversation branch. |
+| `getMessagesMetadata(msg, index?)` | `function` | Get branching and checkpoint metadata for a message. |
+| `switchThread(id)` | `(id: string \| null) => void` | Switch to a different thread. Pass `null` to start a new thread on next submit. |
+| `queue.entries` | `ReadonlyArray<QueueEntry>` | Pending server-side runs. Each entry has `id` (server run ID), `values`, `options`, and `createdAt`. |
+| `queue.size` | `number` | Number of pending runs on the server. |
+| `queue.cancel(id)` | `(id: string) => Promise<boolean>` | Cancel a pending run on the server by its run ID. |
+| `queue.clear()` | `() => Promise<void>` | Cancel all pending runs on the server. |
+
+## Type Safety
+
+### With `createAgent`
+
+When using `createAgent`, pass `typeof agent` to automatically infer tool call types:
+
+```tsx
+import type { agent } from "./agent";
+
+function Chat() {
+  const stream = useStream<typeof agent>({
+    assistantId: "agent",
+    apiUrl: "http://localhost:2024",
+  });
+
+  // stream.messages, tool calls, etc. are fully typed
+}
+```
+
+### With `StateGraph`
+
+For custom graphs, provide your state type directly:
+
+```tsx
+import type { Message } from "@langchain/langgraph-sdk";
+
+interface MyState {
+  messages: Message[];
+  context?: string;
+}
+
+function Chat() {
+  const { messages, submit } = useStream<MyState>({
+    assistantId: "my-graph",
+    apiUrl: "http://localhost:2024",
+  });
+}
+```
+
+### Typed Interrupts
+
+Pass interrupt types via the second generic parameter:
+
+```tsx
+const { interrupt, submit } = useStream<
+  MyState,
+  { InterruptType: { question: string } }
+>({
+  assistantId: "my-graph",
+  apiUrl: "http://localhost:2024",
+});
+
+if (interrupt) {
+  // interrupt.value is typed as { question: string }
+}
+```
+
+## Handling Interrupts
+
+Interrupts let you pause graph execution and wait for user input:
+
+```tsx
+function Chat() {
+  const { messages, interrupt, submit } = useStream<
+    { messages: Message[] },
+    { InterruptType: { question: string } }
+  >({
+    assistantId: "agent",
+    apiUrl: "http://localhost:2024",
+  });
+
+  return (
+    <div>
+      {messages.map((msg, i) => (
+        <div key={msg.id ?? i}>{msg.content}</div>
+      ))}
+
+      {interrupt && (
+        <div>
+          <p>{interrupt.value.question}</p>
+          <button
+            onClick={() =>
+              void submit(null, { command: { resume: "Approved" } })
+            }
+          >
+            Approve
+          </button>
+        </div>
+      )}
+
+      <button
+        onClick={() =>
+          void submit({
+            messages: [{ type: "human", content: "Hello" }],
+          })
+        }
+      >
+        Send
+      </button>
+    </div>
+  );
+}
+```
+
+## Branching
+
+Enable conversation branching by setting `fetchStateHistory: true`:
+
+```tsx
+function Chat() {
+  const { messages, submit, getMessagesMetadata, setBranch } = useStream({
+    assistantId: "agent",
+    apiUrl: "http://localhost:2024",
+    fetchStateHistory: true,
+  });
+
+  return (
+    <div>
+      {messages.map((msg, i) => {
+        const metadata = getMessagesMetadata(msg, i);
+        const branchOptions = metadata?.branchOptions;
+        const branch = metadata?.branch;
+
+        return (
+          <div key={msg.id ?? i}>
+            <p>{msg.content}</p>
+            {branchOptions && branch && (
+              <div>
+                <button onClick={() => {
+                  const prev = branchOptions[branchOptions.indexOf(branch) - 1];
+                  if (prev) setBranch(prev);
+                }}>
+                  Previous
+                </button>
+                <button onClick={() => {
+                  const next = branchOptions[branchOptions.indexOf(branch) + 1];
+                  if (next) setBranch(next);
+                }}>
+                  Next
+                </button>
+              </div>
+            )}
+          </div>
+        );
+      })}
+    </div>
+  );
+}
+```
+
+## Server-Side Queuing
+
+When `submit()` is called while a stream is already active, the SDK automatically creates the run on the server with `multitaskStrategy: "enqueue"`. The pending runs are tracked in `queue` and processed in order as each finishes:
+
+```tsx
+function Chat() {
+  const { messages, submit, isLoading, queue, switchThread } = useStream({
+    assistantId: "agent",
+    apiUrl: "http://localhost:2024",
+  });
+
+  return (
+    <div>
+      {messages.map((msg, i) => (
+        <div key={msg.id ?? i}>{msg.content}</div>
+      ))}
+
+      {queue.size > 0 && (
+        <div>
+          <p>{queue.size} message(s) queued</p>
+          <button onClick={() => void queue.clear()}>Clear Queue</button>
+        </div>
+      )}
+
+      <button
+        disabled={isLoading}
+        onClick={() =>
+          void submit({
+            messages: [{ type: "human", content: "Hello!" }],
+          })
+        }
+      >
+        Send
+      </button>
+      <button onClick={() => switchThread(null)}>New Thread</button>
+    </div>
+  );
+}
+```
+
+Switching threads via `switchThread()` cancels all pending runs and clears the queue.
+
+## React UI (Advanced)
+
+The `@langchain/react/react-ui` sub-package provides utilities for rendering server-defined UI components:
+
+```tsx
+import { useStreamContext, LoadExternalComponent } from "@langchain/react/react-ui";
+import { uiMessageReducer } from "@langchain/react/react-ui";
+import type { UIMessage } from "@langchain/react/react-ui";
+```
+
+- **`useStreamContext`** - Access the stream context from deeply nested components
+- **`LoadExternalComponent`** - Render UI components defined by the server
+- **`uiMessageReducer`** - Reducer for managing UI message state
+
+A server-side helper is also available:
+
+```tsx
+import { typedUi } from "@langchain/react/react-ui/server";
+```
+
+## Playground
+
+For complete end-to-end examples with full agentic UIs, visit the [LangGraph Playground](https://github.com/langchain-ai/langgraphjs).
+
+## License
+
+MIT

package/dist/_virtual/_rolldown/runtime.cjs

@@ -0,0 +1,29 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+exports.__toESM = __toESM;

package/dist/index.cjs

@@ -0,0 +1,38 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('./_virtual/_rolldown/runtime.cjs');
+require('./stream.custom.cjs');
+const require_stream = require('./stream.cjs');
+let _langchain_langgraph_sdk_ui = require("@langchain/langgraph-sdk/ui");
+
+exports.FetchStreamTransport = _langchain_langgraph_sdk_ui.FetchStreamTransport;
+Object.defineProperty(exports, 'SubagentManager', {
+  enumerable: true,
+  get: function () {
+    return _langchain_langgraph_sdk_ui.SubagentManager;
+  }
+});
+Object.defineProperty(exports, 'calculateDepthFromNamespace', {
+  enumerable: true,
+  get: function () {
+    return _langchain_langgraph_sdk_ui.calculateDepthFromNamespace;
+  }
+});
+Object.defineProperty(exports, 'extractParentIdFromNamespace', {
+  enumerable: true,
+  get: function () {
+    return _langchain_langgraph_sdk_ui.extractParentIdFromNamespace;
+  }
+});
+Object.defineProperty(exports, 'extractToolCallIdFromNamespace', {
+  enumerable: true,
+  get: function () {
+    return _langchain_langgraph_sdk_ui.extractToolCallIdFromNamespace;
+  }
+});
+Object.defineProperty(exports, 'isSubagentNamespace', {
+  enumerable: true,
+  get: function () {
+    return _langchain_langgraph_sdk_ui.isSubagentNamespace;
+  }
+});
+exports.useStream = require_stream.useStream;

package/dist/index.d.cts

@@ -0,0 +1,12 @@
+import { SubagentStream, SubagentStreamInterface, UseStream, UseStreamCustom } from "./types.cjs";
+import { useStream } from "./stream.cjs";
+import { FetchStreamTransport } from "./stream.custom.cjs";
+import { AIMessage, ToolMessage } from "@langchain/core/messages";
+import { DefaultToolCall, DefaultToolCall as DefaultToolCall$1, ToolCallFromTool, ToolCallState, ToolCallWithResult as ToolCallWithResult$1, ToolCallsFromTools } from "@langchain/langgraph-sdk";
+import { AgentTypeConfigLike, BaseStream, BaseSubagentState, CompiledSubAgentLike, DeepAgentTypeConfigLike, DefaultSubagentStates, ExtractAgentConfig, ExtractDeepAgentConfig, ExtractSubAgentMiddleware, GetToolCallsType, InferAgentToolCalls, InferBag, InferDeepAgentSubagents, InferNodeNames, InferStateType, InferSubagentByName, InferSubagentNames, InferSubagentState, InferSubagentStates, InferToolCalls, IsAgentLike, IsDeepAgentLike, MessageMetadata, ResolveStreamInterface, ResolveStreamOptions, SubAgentLike, SubagentManager, SubagentStateMap, SubagentStatus, SubagentToolCall, UseAgentStream, UseAgentStreamOptions, UseDeepAgentStream, UseDeepAgentStreamOptions, UseStreamCustomOptions, UseStreamOptions, UseStreamThread, UseStreamTransport, calculateDepthFromNamespace, extractParentIdFromNamespace, extractToolCallIdFromNamespace, isSubagentNamespace } from "@langchain/langgraph-sdk/ui";
+
+//#region src/index.d.ts
+type ToolCallWithResult<ToolCall = DefaultToolCall$1> = ToolCallWithResult$1<ToolCall, ToolMessage, AIMessage>;
+//#endregion
+export { type AgentTypeConfigLike, type BaseStream, type BaseSubagentState, type CompiledSubAgentLike, type DeepAgentTypeConfigLike, type DefaultSubagentStates, type DefaultToolCall, type ExtractAgentConfig, type ExtractDeepAgentConfig, type ExtractSubAgentMiddleware, FetchStreamTransport, type GetToolCallsType, type InferAgentToolCalls, type InferBag, type InferDeepAgentSubagents, type InferNodeNames, type InferStateType, type InferSubagentByName, type InferSubagentNames, type InferSubagentState, type InferSubagentStates, type InferToolCalls, type IsAgentLike, type IsDeepAgentLike, type MessageMetadata, type ResolveStreamInterface, type ResolveStreamOptions, type SubAgentLike, SubagentManager, type SubagentStateMap, type SubagentStatus, type SubagentStream, type SubagentStreamInterface, type SubagentToolCall, type ToolCallFromTool, type ToolCallState, ToolCallWithResult, type ToolCallsFromTools, type UseAgentStream, type UseAgentStreamOptions, type UseDeepAgentStream, type UseDeepAgentStreamOptions, type UseStream, type UseStreamCustom, type UseStreamCustomOptions, type UseStreamOptions, type UseStreamThread, type UseStreamTransport, calculateDepthFromNamespace, extractParentIdFromNamespace, extractToolCallIdFromNamespace, isSubagentNamespace, useStream };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/index.ts"],"mappings":";;;;;;;;KAoEY,kBAAA,YAA8B,iBAAA,IACxC,oBAAA,CAAoB,QAAA,EAAU,WAAA,EAAiB,SAAA"}

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+import { SubagentStream, SubagentStreamInterface, UseStream, UseStreamCustom } from "./types.js";
+import { useStream } from "./stream.js";
+import { FetchStreamTransport } from "./stream.custom.js";
+import { AgentTypeConfigLike, BaseStream, BaseSubagentState, CompiledSubAgentLike, DeepAgentTypeConfigLike, DefaultSubagentStates, ExtractAgentConfig, ExtractDeepAgentConfig, ExtractSubAgentMiddleware, GetToolCallsType, InferAgentToolCalls, InferBag, InferDeepAgentSubagents, InferNodeNames, InferStateType, InferSubagentByName, InferSubagentNames, InferSubagentState, InferSubagentStates, InferToolCalls, IsAgentLike, IsDeepAgentLike, MessageMetadata, ResolveStreamInterface, ResolveStreamOptions, SubAgentLike, SubagentManager, SubagentStateMap, SubagentStatus, SubagentToolCall, UseAgentStream, UseAgentStreamOptions, UseDeepAgentStream, UseDeepAgentStreamOptions, UseStreamCustomOptions, UseStreamOptions, UseStreamThread, UseStreamTransport, calculateDepthFromNamespace, extractParentIdFromNamespace, extractToolCallIdFromNamespace, isSubagentNamespace } from "@langchain/langgraph-sdk/ui";
+import { AIMessage, ToolMessage } from "@langchain/core/messages";
+import { DefaultToolCall, DefaultToolCall as DefaultToolCall$1, ToolCallFromTool, ToolCallState, ToolCallWithResult as ToolCallWithResult$1, ToolCallsFromTools } from "@langchain/langgraph-sdk";
+
+//#region src/index.d.ts
+type ToolCallWithResult<ToolCall = DefaultToolCall$1> = ToolCallWithResult$1<ToolCall, ToolMessage, AIMessage>;
+//#endregion
+export { type AgentTypeConfigLike, type BaseStream, type BaseSubagentState, type CompiledSubAgentLike, type DeepAgentTypeConfigLike, type DefaultSubagentStates, type DefaultToolCall, type ExtractAgentConfig, type ExtractDeepAgentConfig, type ExtractSubAgentMiddleware, FetchStreamTransport, type GetToolCallsType, type InferAgentToolCalls, type InferBag, type InferDeepAgentSubagents, type InferNodeNames, type InferStateType, type InferSubagentByName, type InferSubagentNames, type InferSubagentState, type InferSubagentStates, type InferToolCalls, type IsAgentLike, type IsDeepAgentLike, type MessageMetadata, type ResolveStreamInterface, type ResolveStreamOptions, type SubAgentLike, SubagentManager, type SubagentStateMap, type SubagentStatus, type SubagentStream, type SubagentStreamInterface, type SubagentToolCall, type ToolCallFromTool, type ToolCallState, ToolCallWithResult, type ToolCallsFromTools, type UseAgentStream, type UseAgentStreamOptions, type UseDeepAgentStream, type UseDeepAgentStreamOptions, type UseStream, type UseStreamCustom, type UseStreamCustomOptions, type UseStreamOptions, type UseStreamThread, type UseStreamTransport, calculateDepthFromNamespace, extractParentIdFromNamespace, extractToolCallIdFromNamespace, isSubagentNamespace, useStream };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/index.ts"],"mappings":";;;;;;;;KAoEY,kBAAA,YAA8B,iBAAA,IACxC,oBAAA,CAAoB,QAAA,EAAU,WAAA,EAAiB,SAAA"}

package/dist/index.js

@@ -0,0 +1,5 @@
+import { FetchStreamTransport } from "./stream.custom.js";
+import { useStream } from "./stream.js";
+import { SubagentManager, calculateDepthFromNamespace, extractParentIdFromNamespace, extractToolCallIdFromNamespace, isSubagentNamespace } from "@langchain/langgraph-sdk/ui";
+
+export { FetchStreamTransport, SubagentManager, calculateDepthFromNamespace, extractParentIdFromNamespace, extractToolCallIdFromNamespace, isSubagentNamespace, useStream };

package/dist/node_modules/.pnpm/@langchain_langgraph@1.1.5_@langchain_core@1.1.28_openai@6.16.0_ws@8.19.0_zod@4.3.5___z_0d5e45651b6fb9f696195862204d53c7/node_modules/@langchain/langgraph/dist/channels/base.d.cts

@@ -0,0 +1,83 @@
+//#region ../../node_modules/.pnpm/@langchain+langgraph@1.1.5_@langchain+core@1.1.28_openai@6.16.0_ws@8.19.0_zod@4.3.5___z_0d5e45651b6fb9f696195862204d53c7/node_modules/@langchain/langgraph/dist/channels/base.d.ts
+//#region src/channels/base.d.ts
+/** @internal */
+declare abstract class BaseChannel<ValueType = unknown, UpdateType = unknown, CheckpointType = unknown> {
+  ValueType: ValueType;
+  UpdateType: UpdateType;
+  /**
+   * The name of the channel.
+   */
+  abstract lc_graph_name: string;
+  /** @ignore */
+  lg_is_channel: boolean;
+  /**
+   * Return a new identical channel, optionally initialized from a checkpoint.
+   * Can be thought of as a "restoration" from a checkpoint which is a "snapshot" of the channel's state.
+   *
+   * @param {CheckpointType | undefined} checkpoint
+   * @param {CheckpointType | undefined} initialValue
+   * @returns {this}
+   */
+  abstract fromCheckpoint(checkpoint?: CheckpointType): this;
+  /**
+   * Update the channel's value with the given sequence of updates.
+   * The order of the updates in the sequence is arbitrary.
+   * This method is called by Pregel for all channels at the end of each step.
+   * If there are no updates, it is called with an empty sequence.
+   *
+   * Raises InvalidUpdateError if the sequence of updates is invalid.
+   * Returns True if the channel was updated, False otherwise.
+   *
+   * @throws {InvalidUpdateError} if the sequence of updates is invalid.
+   * @param {Array<UpdateType>} values
+   * @returns {void}
+   */
+  abstract update(values: UpdateType[]): boolean;
+  /**
+   * Return the current value of the channel.
+   *
+   * @throws {EmptyChannelError} if the channel is empty (never updated yet).
+   * @returns {ValueType}
+   */
+  abstract get(): ValueType;
+  /**
+   * Return a string representation of the channel's current state.
+   *
+   * @throws {EmptyChannelError} if the channel is empty (never updated yet), or doesn't support checkpoints.
+   * @returns {CheckpointType | undefined}
+   */
+  abstract checkpoint(): CheckpointType | undefined;
+  /**
+   * Mark the current value of the channel as consumed. By default, no-op.
+   * A channel can use this method to modify its state, preventing the value
+   * from being consumed again.
+   *
+   * Returns True if the channel was updated, False otherwise.
+   */
+  consume(): boolean;
+  /**
+   * Notify the channel that the Pregel run is finishing. By default, no-op.
+   * A channel can use this method to modify its state, preventing finish.
+   *
+   * Returns True if the channel was updated, False otherwise.
+   */
+  finish(): boolean;
+  /**
+   * Return True if the channel is available (not empty), False otherwise.
+   * Subclasses should override this method to provide a more efficient
+   * implementation than calling get() and catching EmptyChannelError.
+   */
+  isAvailable(): boolean;
+  /**
+   * Compare this channel with another channel for equality.
+   * Used to determine if two channels with the same key are semantically equivalent.
+   * Subclasses should override this method to provide a meaningful comparison.
+   *
+   * @param {BaseChannel} other - The other channel to compare with.
+   * @returns {boolean} True if the channels are equal, false otherwise.
+   */
+  equals(other: BaseChannel): boolean;
+}
+//#endregion
+export { BaseChannel };
+//# sourceMappingURL=base.d.cts.map

package/dist/node_modules/.pnpm/@langchain_langgraph@1.1.5_@langchain_core@1.1.28_openai@6.16.0_ws@8.19.0_zod@4.3.5___z_0d5e45651b6fb9f696195862204d53c7/node_modules/@langchain/langgraph/dist/channels/base.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.cts","names":["Checkpoint","ReadonlyCheckpoint","BaseChannel","ValueType","UpdateType","CheckpointType","lc_graph_name","lg_is_channel","fromCheckpoint","checkpoint","update","values","get","consume","finish","isAvailable","equals","other","emptyChannels","Cc","Record","channels","createCheckpoint","step","id","options"],"sources":["../../../../../../../../../../../node_modules/.pnpm/@langchain+langgraph@1.1.5_@langchain+core@1.1.28_openai@6.16.0_ws@8.19.0_zod@4.3.5___z_0d5e45651b6fb9f696195862204d53c7/node_modules/@langchain/langgraph/dist/channels/base.d.ts"],"x_google_ignoreList":[0],"mappings":";;;uBAIuBE,WAAAA;EACrBC,SAAAA,EAAWA,SAAAA;EACXC,UAAAA,EAAYA,UAAAA;EA6BYA;;;EAAAA,SAzBfE,aAAAA;EAqEgB;EAnEzBC,aAAAA;EARiCJ;;;;;;;;EAAAA,SAiBxBK,cAAAA,CAAeC,UAAAA,GAAaJ,cAAAA;EAA5BG;;;;;;;;;;;;;EAAAA,SAcAE,MAAAA,CAAOC,MAAAA,EAAQP,UAAAA;EA4CVF;;;;;;EAAAA,SArCLU,GAAAA,CAAAA,GAAOT,SAAAA;;;;;;;WAOPM,UAAAA,CAAAA,GAAcJ,cAAAA;;;;;;;;EAQvBQ,OAAAA,CAAAA;;;;;;;EAOAC,MAAAA,CAAAA;;;;;;EAMAC,WAAAA,CAAAA;;;;;;;;;EASAC,MAAAA,CAAOC,KAAAA,EAAOf,WAAAA;AAAAA"}

package/dist/node_modules/.pnpm/@langchain_langgraph@1.1.5_@langchain_core@1.1.28_openai@6.16.0_ws@8.19.0_zod@4.3.5___z_0d5e45651b6fb9f696195862204d53c7/node_modules/@langchain/langgraph/dist/channels/base.d.ts

@@ -0,0 +1,83 @@
+//#region ../../node_modules/.pnpm/@langchain+langgraph@1.1.5_@langchain+core@1.1.28_openai@6.16.0_ws@8.19.0_zod@4.3.5___z_0d5e45651b6fb9f696195862204d53c7/node_modules/@langchain/langgraph/dist/channels/base.d.ts
+//#region src/channels/base.d.ts
+/** @internal */
+declare abstract class BaseChannel<ValueType = unknown, UpdateType = unknown, CheckpointType = unknown> {
+  ValueType: ValueType;
+  UpdateType: UpdateType;
+  /**
+   * The name of the channel.
+   */
+  abstract lc_graph_name: string;
+  /** @ignore */
+  lg_is_channel: boolean;
+  /**
+   * Return a new identical channel, optionally initialized from a checkpoint.
+   * Can be thought of as a "restoration" from a checkpoint which is a "snapshot" of the channel's state.
+   *
+   * @param {CheckpointType | undefined} checkpoint
+   * @param {CheckpointType | undefined} initialValue
+   * @returns {this}
+   */
+  abstract fromCheckpoint(checkpoint?: CheckpointType): this;
+  /**
+   * Update the channel's value with the given sequence of updates.
+   * The order of the updates in the sequence is arbitrary.
+   * This method is called by Pregel for all channels at the end of each step.
+   * If there are no updates, it is called with an empty sequence.
+   *
+   * Raises InvalidUpdateError if the sequence of updates is invalid.
+   * Returns True if the channel was updated, False otherwise.
+   *
+   * @throws {InvalidUpdateError} if the sequence of updates is invalid.
+   * @param {Array<UpdateType>} values
+   * @returns {void}
+   */
+  abstract update(values: UpdateType[]): boolean;
+  /**
+   * Return the current value of the channel.
+   *
+   * @throws {EmptyChannelError} if the channel is empty (never updated yet).
+   * @returns {ValueType}
+   */
+  abstract get(): ValueType;
+  /**
+   * Return a string representation of the channel's current state.
+   *
+   * @throws {EmptyChannelError} if the channel is empty (never updated yet), or doesn't support checkpoints.
+   * @returns {CheckpointType | undefined}
+   */
+  abstract checkpoint(): CheckpointType | undefined;
+  /**
+   * Mark the current value of the channel as consumed. By default, no-op.
+   * A channel can use this method to modify its state, preventing the value
+   * from being consumed again.
+   *
+   * Returns True if the channel was updated, False otherwise.
+   */
+  consume(): boolean;
+  /**
+   * Notify the channel that the Pregel run is finishing. By default, no-op.
+   * A channel can use this method to modify its state, preventing finish.
+   *
+   * Returns True if the channel was updated, False otherwise.
+   */
+  finish(): boolean;
+  /**
+   * Return True if the channel is available (not empty), False otherwise.
+   * Subclasses should override this method to provide a more efficient
+   * implementation than calling get() and catching EmptyChannelError.
+   */
+  isAvailable(): boolean;
+  /**
+   * Compare this channel with another channel for equality.
+   * Used to determine if two channels with the same key are semantically equivalent.
+   * Subclasses should override this method to provide a meaningful comparison.
+   *
+   * @param {BaseChannel} other - The other channel to compare with.
+   * @returns {boolean} True if the channels are equal, false otherwise.
+   */
+  equals(other: BaseChannel): boolean;
+}
+//#endregion
+export { BaseChannel };
+//# sourceMappingURL=base.d.ts.map

package/dist/node_modules/.pnpm/@langchain_langgraph@1.1.5_@langchain_core@1.1.28_openai@6.16.0_ws@8.19.0_zod@4.3.5___z_0d5e45651b6fb9f696195862204d53c7/node_modules/@langchain/langgraph/dist/channels/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","names":["Checkpoint","ReadonlyCheckpoint","BaseChannel","ValueType","UpdateType","CheckpointType","lc_graph_name","lg_is_channel","fromCheckpoint","checkpoint","update","values","get","consume","finish","isAvailable","equals","other","emptyChannels","Cc","Record","channels","createCheckpoint","step","id","options"],"sources":["../../../../../../../../../../../node_modules/.pnpm/@langchain+langgraph@1.1.5_@langchain+core@1.1.28_openai@6.16.0_ws@8.19.0_zod@4.3.5___z_0d5e45651b6fb9f696195862204d53c7/node_modules/@langchain/langgraph/dist/channels/base.d.ts"],"x_google_ignoreList":[0],"mappings":";;;uBAIuBE,WAAAA;EACrBC,SAAAA,EAAWA,SAAAA;EACXC,UAAAA,EAAYA,UAAAA;EA6BYA;;;EAAAA,SAzBfE,aAAAA;EAqEgB;EAnEzBC,aAAAA;EARiCJ;;;;;;;;EAAAA,SAiBxBK,cAAAA,CAAeC,UAAAA,GAAaJ,cAAAA;EAA5BG;;;;;;;;;;;;;EAAAA,SAcAE,MAAAA,CAAOC,MAAAA,EAAQP,UAAAA;EA4CVF;;;;;;EAAAA,SArCLU,GAAAA,CAAAA,GAAOT,SAAAA;;;;;;;WAOPM,UAAAA,CAAAA,GAAcJ,cAAAA;;;;;;;;EAQvBQ,OAAAA,CAAAA;;;;;;;EAOAC,MAAAA,CAAAA;;;;;;EAMAC,WAAAA,CAAAA;;;;;;;;;EASAC,MAAAA,CAAOC,KAAAA,EAAOf,WAAAA;AAAAA"}

package/dist/node_modules/.pnpm/@langchain_langgraph@1.1.5_@langchain_core@1.1.28_openai@6.16.0_ws@8.19.0_zod@4.3.5___z_0d5e45651b6fb9f696195862204d53c7/node_modules/@langchain/langgraph/dist/graph/zod/index.d.cts

@@ -0,0 +1,3 @@
+import { InteropZodToStateDefinition, ReducedZodChannel, SchemaMeta, SchemaMetaRegistry } from "./meta.cjs";
+import "./plugin.cjs";
+import { LanggraphZodMetaRegistry } from "./zod-registry.cjs";

package/dist/node_modules/.pnpm/@langchain_langgraph@1.1.5_@langchain_core@1.1.28_openai@6.16.0_ws@8.19.0_zod@4.3.5___z_0d5e45651b6fb9f696195862204d53c7/node_modules/@langchain/langgraph/dist/graph/zod/index.d.ts

@@ -0,0 +1,3 @@
+import { InteropZodToStateDefinition, ReducedZodChannel, SchemaMeta, SchemaMetaRegistry } from "./meta.js";
+import "./plugin.js";
+import { LanggraphZodMetaRegistry } from "./zod-registry.js";