@langchain/langgraph 1.0.14 → 1.1.0

package/dist/channels/base.cjs

@@ -44,6 +44,17 @@ var BaseChannel = class {
 			throw error;
 		}
 	}
+	/**
+	* 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) {
+		return this === other;
+	}
 };
 const IS_ONLY_BASE_CHANNEL = Symbol.for("LG_IS_ONLY_BASE_CHANNEL");
 function getOnlyChannels(channels) {

package/dist/channels/base.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"base.cjs","names":["EmptyChannelError"],"sources":["../../src/channels/base.ts"],"sourcesContent":["import {\n  ReadonlyCheckpoint,\n  uuid6,\n  Checkpoint,\n} from \"@langchain/langgraph-checkpoint\";\nimport { EmptyChannelError } from \"../errors.js\";\n\nexport function isBaseChannel(obj: unknown): obj is BaseChannel {\n  return obj != null && (obj as BaseChannel).lg_is_channel === true;\n}\n\n/** @internal */\nexport abstract class BaseChannel<\n  ValueType = unknown,\n  UpdateType = unknown,\n  CheckpointType = unknown\n> {\n  ValueType: ValueType;\n\n  UpdateType: UpdateType;\n\n  /**\n   * The name of the channel.\n   */\n  abstract lc_graph_name: string;\n\n  /** @ignore */\n  lg_is_channel = true;\n\n  /**\n   * Return a new identical channel, optionally initialized from a checkpoint.\n   * Can be thought of as a \"restoration\" from a checkpoint which is a \"snapshot\" of the channel's state.\n   *\n   * @param {CheckpointType | undefined} checkpoint\n   * @param {CheckpointType | undefined} initialValue\n   * @returns {this}\n   */\n  abstract fromCheckpoint(checkpoint?: CheckpointType): this;\n\n  /**\n   * Update the channel's value with the given sequence of updates.\n   * The order of the updates in the sequence is arbitrary.\n   * This method is called by Pregel for all channels at the end of each step.\n   * If there are no updates, it is called with an empty sequence.\n   *\n   * Raises InvalidUpdateError if the sequence of updates is invalid.\n   * Returns True if the channel was updated, False otherwise.\n   *\n   * @throws {InvalidUpdateError} if the sequence of updates is invalid.\n   * @param {Array<UpdateType>} values\n   * @returns {void}\n   */\n  abstract update(values: UpdateType[]): boolean;\n\n  /**\n   * Return the current value of the channel.\n   *\n   * @throws {EmptyChannelError} if the channel is empty (never updated yet).\n   * @returns {ValueType}\n   */\n  abstract get(): ValueType;\n\n  /**\n   * Return a string representation of the channel's current state.\n   *\n   * @throws {EmptyChannelError} if the channel is empty (never updated yet), or doesn't support checkpoints.\n   * @returns {CheckpointType | undefined}\n   */\n  abstract checkpoint(): CheckpointType | undefined;\n\n  /**\n   * Mark the current value of the channel as consumed. By default, no-op.\n   * A channel can use this method to modify its state, preventing the value\n   * from being consumed again.\n   *\n   * Returns True if the channel was updated, False otherwise.\n   */\n  consume(): boolean {\n    return false;\n  }\n\n  /**\n   * Notify the channel that the Pregel run is finishing. By default, no-op.\n   * A channel can use this method to modify its state, preventing finish.\n   *\n   * Returns True if the channel was updated, False otherwise.\n   */\n  finish(): boolean {\n    return false;\n  }\n\n  /**\n   * Return True if the channel is available (not empty), False otherwise.\n   * Subclasses should override this method to provide a more efficient\n   * implementation than calling get() and catching EmptyChannelError.\n   */\n  isAvailable(): boolean {\n    try {\n      this.get();\n      return true;\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    } catch (error: any) {\n      if (error.name === EmptyChannelError.unminifiable_name) {\n        return false;\n      }\n      throw error;\n    }\n  }\n}\n\nconst IS_ONLY_BASE_CHANNEL = Symbol.for(\"LG_IS_ONLY_BASE_CHANNEL\");\nexport function getOnlyChannels(\n  channels: Record<string, BaseChannel>\n): Record<string, BaseChannel> {\n  // @ts-expect-error - we know it's a record of base channels\n  if (channels[IS_ONLY_BASE_CHANNEL] === true) return channels;\n\n  const newChannels = {} as Record<string, BaseChannel>;\n  for (const k in channels) {\n    if (!Object.prototype.hasOwnProperty.call(channels, k)) continue;\n    const value = channels[k];\n    if (isBaseChannel(value)) newChannels[k] = value;\n  }\n\n  Object.assign(newChannels, { [IS_ONLY_BASE_CHANNEL]: true });\n  return newChannels;\n}\n\nexport function emptyChannels<Cc extends Record<string, BaseChannel>>(\n  channels: Cc,\n  checkpoint: ReadonlyCheckpoint\n): Cc {\n  const filteredChannels = getOnlyChannels(channels) as Cc;\n\n  const newChannels = {} as Cc;\n  for (const k in filteredChannels) {\n    if (!Object.prototype.hasOwnProperty.call(filteredChannels, k)) continue;\n    const channelValue = checkpoint.channel_values[k];\n    newChannels[k] = filteredChannels[k].fromCheckpoint(channelValue);\n  }\n  Object.assign(newChannels, { [IS_ONLY_BASE_CHANNEL]: true });\n  return newChannels;\n}\n\nexport function createCheckpoint<ValueType>(\n  checkpoint: ReadonlyCheckpoint,\n  channels: Record<string, BaseChannel<ValueType>> | undefined,\n  step: number,\n  options?: { id?: string }\n): Checkpoint {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  let values: Record<string, any>;\n  if (channels === undefined) {\n    values = checkpoint.channel_values;\n  } else {\n    values = {};\n    for (const k in channels) {\n      if (!Object.prototype.hasOwnProperty.call(channels, k)) continue;\n      try {\n        values[k] = channels[k].checkpoint();\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      } catch (error: any) {\n        if (error.name === EmptyChannelError.unminifiable_name) {\n          // no-op\n        } else {\n          throw error; // Rethrow unexpected errors\n        }\n      }\n    }\n  }\n\n  return {\n    v: 4,\n    id: options?.id ?? uuid6(step),\n    ts: new Date().toISOString(),\n    channel_values: values,\n    channel_versions: checkpoint.channel_versions,\n    versions_seen: checkpoint.versions_seen,\n  };\n}\n"],"mappings":";;;;AAOA,SAAgB,cAAc,KAAkC;AAC9D,QAAO,OAAO,QAAS,IAAoB,kBAAkB;;;AAI/D,IAAsB,cAAtB,MAIE;CACA;CAEA;;CAQA,gBAAgB;;;;;;;;CAkDhB,UAAmB;AACjB,SAAO;;;;;;;;CAST,SAAkB;AAChB,SAAO;;;;;;;CAQT,cAAuB;AACrB,MAAI;AACF,QAAK,KAAK;AACV,UAAO;WAEA,OAAY;AACnB,OAAI,MAAM,SAASA,iCAAkB,kBACnC,QAAO;AAET,SAAM;;;;AAKZ,MAAM,uBAAuB,OAAO,IAAI,0BAA0B;AAClE,SAAgB,gBACd,UAC6B;AAE7B,KAAI,SAAS,0BAA0B,KAAM,QAAO;CAEpD,MAAM,cAAc,EAAE;AACtB,MAAK,MAAM,KAAK,UAAU;AACxB,MAAI,CAAC,OAAO,UAAU,eAAe,KAAK,UAAU,EAAE,CAAE;EACxD,MAAM,QAAQ,SAAS;AACvB,MAAI,cAAc,MAAM,CAAE,aAAY,KAAK;;AAG7C,QAAO,OAAO,aAAa,GAAG,uBAAuB,MAAM,CAAC;AAC5D,QAAO;;AAGT,SAAgB,cACd,UACA,YACI;CACJ,MAAM,mBAAmB,gBAAgB,SAAS;CAElD,MAAM,cAAc,EAAE;AACtB,MAAK,MAAM,KAAK,kBAAkB;AAChC,MAAI,CAAC,OAAO,UAAU,eAAe,KAAK,kBAAkB,EAAE,CAAE;EAChE,MAAM,eAAe,WAAW,eAAe;AAC/C,cAAY,KAAK,iBAAiB,GAAG,eAAe,aAAa;;AAEnE,QAAO,OAAO,aAAa,GAAG,uBAAuB,MAAM,CAAC;AAC5D,QAAO;;AAGT,SAAgB,iBACd,YACA,UACA,MACA,SACY;CAEZ,IAAI;AACJ,KAAI,aAAa,OACf,UAAS,WAAW;MACf;AACL,WAAS,EAAE;AACX,OAAK,MAAM,KAAK,UAAU;AACxB,OAAI,CAAC,OAAO,UAAU,eAAe,KAAK,UAAU,EAAE,CAAE;AACxD,OAAI;AACF,WAAO,KAAK,SAAS,GAAG,YAAY;YAE7B,OAAY;AACnB,QAAI,MAAM,SAASA,iCAAkB,mBAAmB,OAGtD,OAAM;;;;AAMd,QAAO;EACL,GAAG;EACH,IAAI,SAAS,iDAAY,KAAK;EAC9B,qBAAI,IAAI,MAAM,EAAC,aAAa;EAC5B,gBAAgB;EAChB,kBAAkB,WAAW;EAC7B,eAAe,WAAW;EAC3B"}
+{"version":3,"file":"base.cjs","names":["EmptyChannelError"],"sources":["../../src/channels/base.ts"],"sourcesContent":["import {\n  ReadonlyCheckpoint,\n  uuid6,\n  Checkpoint,\n} from \"@langchain/langgraph-checkpoint\";\nimport { EmptyChannelError } from \"../errors.js\";\n\nexport function isBaseChannel(obj: unknown): obj is BaseChannel {\n  return obj != null && (obj as BaseChannel).lg_is_channel === true;\n}\n\n/** @internal */\nexport abstract class BaseChannel<\n  ValueType = unknown,\n  UpdateType = unknown,\n  CheckpointType = unknown\n> {\n  ValueType: ValueType;\n\n  UpdateType: UpdateType;\n\n  /**\n   * The name of the channel.\n   */\n  abstract lc_graph_name: string;\n\n  /** @ignore */\n  lg_is_channel = true;\n\n  /**\n   * Return a new identical channel, optionally initialized from a checkpoint.\n   * Can be thought of as a \"restoration\" from a checkpoint which is a \"snapshot\" of the channel's state.\n   *\n   * @param {CheckpointType | undefined} checkpoint\n   * @param {CheckpointType | undefined} initialValue\n   * @returns {this}\n   */\n  abstract fromCheckpoint(checkpoint?: CheckpointType): this;\n\n  /**\n   * Update the channel's value with the given sequence of updates.\n   * The order of the updates in the sequence is arbitrary.\n   * This method is called by Pregel for all channels at the end of each step.\n   * If there are no updates, it is called with an empty sequence.\n   *\n   * Raises InvalidUpdateError if the sequence of updates is invalid.\n   * Returns True if the channel was updated, False otherwise.\n   *\n   * @throws {InvalidUpdateError} if the sequence of updates is invalid.\n   * @param {Array<UpdateType>} values\n   * @returns {void}\n   */\n  abstract update(values: UpdateType[]): boolean;\n\n  /**\n   * Return the current value of the channel.\n   *\n   * @throws {EmptyChannelError} if the channel is empty (never updated yet).\n   * @returns {ValueType}\n   */\n  abstract get(): ValueType;\n\n  /**\n   * Return a string representation of the channel's current state.\n   *\n   * @throws {EmptyChannelError} if the channel is empty (never updated yet), or doesn't support checkpoints.\n   * @returns {CheckpointType | undefined}\n   */\n  abstract checkpoint(): CheckpointType | undefined;\n\n  /**\n   * Mark the current value of the channel as consumed. By default, no-op.\n   * A channel can use this method to modify its state, preventing the value\n   * from being consumed again.\n   *\n   * Returns True if the channel was updated, False otherwise.\n   */\n  consume(): boolean {\n    return false;\n  }\n\n  /**\n   * Notify the channel that the Pregel run is finishing. By default, no-op.\n   * A channel can use this method to modify its state, preventing finish.\n   *\n   * Returns True if the channel was updated, False otherwise.\n   */\n  finish(): boolean {\n    return false;\n  }\n\n  /**\n   * Return True if the channel is available (not empty), False otherwise.\n   * Subclasses should override this method to provide a more efficient\n   * implementation than calling get() and catching EmptyChannelError.\n   */\n  isAvailable(): boolean {\n    try {\n      this.get();\n      return true;\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    } catch (error: any) {\n      if (error.name === EmptyChannelError.unminifiable_name) {\n        return false;\n      }\n      throw error;\n    }\n  }\n\n  /**\n   * Compare this channel with another channel for equality.\n   * Used to determine if two channels with the same key are semantically equivalent.\n   * Subclasses should override this method to provide a meaningful comparison.\n   *\n   * @param {BaseChannel} other - The other channel to compare with.\n   * @returns {boolean} True if the channels are equal, false otherwise.\n   */\n  equals(other: BaseChannel): boolean {\n    return this === other;\n  }\n}\n\nconst IS_ONLY_BASE_CHANNEL = Symbol.for(\"LG_IS_ONLY_BASE_CHANNEL\");\nexport function getOnlyChannels(\n  channels: Record<string, BaseChannel>\n): Record<string, BaseChannel> {\n  // @ts-expect-error - we know it's a record of base channels\n  if (channels[IS_ONLY_BASE_CHANNEL] === true) return channels;\n\n  const newChannels = {} as Record<string, BaseChannel>;\n  for (const k in channels) {\n    if (!Object.prototype.hasOwnProperty.call(channels, k)) continue;\n    const value = channels[k];\n    if (isBaseChannel(value)) newChannels[k] = value;\n  }\n\n  Object.assign(newChannels, { [IS_ONLY_BASE_CHANNEL]: true });\n  return newChannels;\n}\n\nexport function emptyChannels<Cc extends Record<string, BaseChannel>>(\n  channels: Cc,\n  checkpoint: ReadonlyCheckpoint\n): Cc {\n  const filteredChannels = getOnlyChannels(channels) as Cc;\n\n  const newChannels = {} as Cc;\n  for (const k in filteredChannels) {\n    if (!Object.prototype.hasOwnProperty.call(filteredChannels, k)) continue;\n    const channelValue = checkpoint.channel_values[k];\n    newChannels[k] = filteredChannels[k].fromCheckpoint(channelValue);\n  }\n  Object.assign(newChannels, { [IS_ONLY_BASE_CHANNEL]: true });\n  return newChannels;\n}\n\nexport function createCheckpoint<ValueType>(\n  checkpoint: ReadonlyCheckpoint,\n  channels: Record<string, BaseChannel<ValueType>> | undefined,\n  step: number,\n  options?: { id?: string }\n): Checkpoint {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  let values: Record<string, any>;\n  if (channels === undefined) {\n    values = checkpoint.channel_values;\n  } else {\n    values = {};\n    for (const k in channels) {\n      if (!Object.prototype.hasOwnProperty.call(channels, k)) continue;\n      try {\n        values[k] = channels[k].checkpoint();\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      } catch (error: any) {\n        if (error.name === EmptyChannelError.unminifiable_name) {\n          // no-op\n        } else {\n          throw error; // Rethrow unexpected errors\n        }\n      }\n    }\n  }\n\n  return {\n    v: 4,\n    id: options?.id ?? uuid6(step),\n    ts: new Date().toISOString(),\n    channel_values: values,\n    channel_versions: checkpoint.channel_versions,\n    versions_seen: checkpoint.versions_seen,\n  };\n}\n"],"mappings":";;;;AAOA,SAAgB,cAAc,KAAkC;AAC9D,QAAO,OAAO,QAAS,IAAoB,kBAAkB;;;AAI/D,IAAsB,cAAtB,MAIE;CACA;CAEA;;CAQA,gBAAgB;;;;;;;;CAkDhB,UAAmB;AACjB,SAAO;;;;;;;;CAST,SAAkB;AAChB,SAAO;;;;;;;CAQT,cAAuB;AACrB,MAAI;AACF,QAAK,KAAK;AACV,UAAO;WAEA,OAAY;AACnB,OAAI,MAAM,SAASA,iCAAkB,kBACnC,QAAO;AAET,SAAM;;;;;;;;;;;CAYV,OAAO,OAA6B;AAClC,SAAO,SAAS;;;AAIpB,MAAM,uBAAuB,OAAO,IAAI,0BAA0B;AAClE,SAAgB,gBACd,UAC6B;AAE7B,KAAI,SAAS,0BAA0B,KAAM,QAAO;CAEpD,MAAM,cAAc,EAAE;AACtB,MAAK,MAAM,KAAK,UAAU;AACxB,MAAI,CAAC,OAAO,UAAU,eAAe,KAAK,UAAU,EAAE,CAAE;EACxD,MAAM,QAAQ,SAAS;AACvB,MAAI,cAAc,MAAM,CAAE,aAAY,KAAK;;AAG7C,QAAO,OAAO,aAAa,GAAG,uBAAuB,MAAM,CAAC;AAC5D,QAAO;;AAGT,SAAgB,cACd,UACA,YACI;CACJ,MAAM,mBAAmB,gBAAgB,SAAS;CAElD,MAAM,cAAc,EAAE;AACtB,MAAK,MAAM,KAAK,kBAAkB;AAChC,MAAI,CAAC,OAAO,UAAU,eAAe,KAAK,kBAAkB,EAAE,CAAE;EAChE,MAAM,eAAe,WAAW,eAAe;AAC/C,cAAY,KAAK,iBAAiB,GAAG,eAAe,aAAa;;AAEnE,QAAO,OAAO,aAAa,GAAG,uBAAuB,MAAM,CAAC;AAC5D,QAAO;;AAGT,SAAgB,iBACd,YACA,UACA,MACA,SACY;CAEZ,IAAI;AACJ,KAAI,aAAa,OACf,UAAS,WAAW;MACf;AACL,WAAS,EAAE;AACX,OAAK,MAAM,KAAK,UAAU;AACxB,OAAI,CAAC,OAAO,UAAU,eAAe,KAAK,UAAU,EAAE,CAAE;AACxD,OAAI;AACF,WAAO,KAAK,SAAS,GAAG,YAAY;YAE7B,OAAY;AACnB,QAAI,MAAM,SAASA,iCAAkB,mBAAmB,OAGtD,OAAM;;;;AAMd,QAAO;EACL,GAAG;EACH,IAAI,SAAS,iDAAY,KAAK;EAC9B,qBAAI,IAAI,MAAM,EAAC,aAAa;EAC5B,gBAAgB;EAChB,kBAAkB,WAAW;EAC7B,eAAe,WAAW;EAC3B"}

package/dist/channels/base.d.cts

@@ -69,6 +69,15 @@ declare abstract class BaseChannel<ValueType = unknown, UpdateType = unknown, Ch
    * 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;
 }
 declare function emptyChannels<Cc extends Record<string, BaseChannel>>(channels: Cc, checkpoint: ReadonlyCheckpoint): Cc;
 declare function createCheckpoint<ValueType>(checkpoint: ReadonlyCheckpoint, channels: Record<string, BaseChannel<ValueType>> | undefined, step: number, options?: {

package/dist/channels/base.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"base.d.cts","names":["ReadonlyCheckpoint","Checkpoint","isBaseChannel","BaseChannel","ValueType","UpdateType","CheckpointType","getOnlyChannels","Record","emptyChannels","Cc","createCheckpoint"],"sources":["../../src/channels/base.d.ts"],"sourcesContent":["import { ReadonlyCheckpoint, Checkpoint } from \"@langchain/langgraph-checkpoint\";\nexport declare function isBaseChannel(obj: unknown): obj is BaseChannel;\n/** @internal */\nexport declare abstract class BaseChannel<ValueType = unknown, UpdateType = unknown, CheckpointType = unknown> {\n    ValueType: ValueType;\n    UpdateType: UpdateType;\n    /**\n     * The name of the channel.\n     */\n    abstract lc_graph_name: string;\n    /** @ignore */\n    lg_is_channel: boolean;\n    /**\n     * Return a new identical channel, optionally initialized from a checkpoint.\n     * Can be thought of as a \"restoration\" from a checkpoint which is a \"snapshot\" of the channel's state.\n     *\n     * @param {CheckpointType | undefined} checkpoint\n     * @param {CheckpointType | undefined} initialValue\n     * @returns {this}\n     */\n    abstract fromCheckpoint(checkpoint?: CheckpointType): this;\n    /**\n     * Update the channel's value with the given sequence of updates.\n     * The order of the updates in the sequence is arbitrary.\n     * This method is called by Pregel for all channels at the end of each step.\n     * If there are no updates, it is called with an empty sequence.\n     *\n     * Raises InvalidUpdateError if the sequence of updates is invalid.\n     * Returns True if the channel was updated, False otherwise.\n     *\n     * @throws {InvalidUpdateError} if the sequence of updates is invalid.\n     * @param {Array<UpdateType>} values\n     * @returns {void}\n     */\n    abstract update(values: UpdateType[]): boolean;\n    /**\n     * Return the current value of the channel.\n     *\n     * @throws {EmptyChannelError} if the channel is empty (never updated yet).\n     * @returns {ValueType}\n     */\n    abstract get(): ValueType;\n    /**\n     * Return a string representation of the channel's current state.\n     *\n     * @throws {EmptyChannelError} if the channel is empty (never updated yet), or doesn't support checkpoints.\n     * @returns {CheckpointType | undefined}\n     */\n    abstract checkpoint(): CheckpointType | undefined;\n    /**\n     * Mark the current value of the channel as consumed. By default, no-op.\n     * A channel can use this method to modify its state, preventing the value\n     * from being consumed again.\n     *\n     * Returns True if the channel was updated, False otherwise.\n     */\n    consume(): boolean;\n    /**\n     * Notify the channel that the Pregel run is finishing. By default, no-op.\n     * A channel can use this method to modify its state, preventing finish.\n     *\n     * Returns True if the channel was updated, False otherwise.\n     */\n    finish(): boolean;\n    /**\n     * Return True if the channel is available (not empty), False otherwise.\n     * Subclasses should override this method to provide a more efficient\n     * implementation than calling get() and catching EmptyChannelError.\n     */\n    isAvailable(): boolean;\n}\nexport declare function getOnlyChannels(channels: Record<string, BaseChannel>): Record<string, BaseChannel>;\nexport declare function emptyChannels<Cc extends Record<string, BaseChannel>>(channels: Cc, checkpoint: ReadonlyCheckpoint): Cc;\nexport declare function createCheckpoint<ValueType>(checkpoint: ReadonlyCheckpoint, channels: Record<string, BaseChannel<ValueType>> | undefined, step: number, options?: {\n    id?: string;\n}): Checkpoint;\n"],"mappings":";;;;AAG8BG,uBAAAA,WAAW,CAAA,YAAA,OAAA,EAAA,aAAA,OAAA,EAAA,iBAAA,OAAA,CAAA,CAAA;EAAA,SAAA,EAC1BC,SAD0B;YAC1BA,EACCC,UADDD;;;;WAqCKA,aAAAA,EAAAA,MAAAA;;EAOqB,aAAA,EAAA,OAAA;EAwBjBK;;;;;;;;EACAE,SAAAA,cAAgB,CAAA,UAAA,CAAA,EArDCL,cAqDD,CAAA,EAAA,IAAA;EAAA;;;;;;;;;;;;;0BAvCZD;;;;;;;kBAORD;;;;;;;yBAOOE;;;;;;;;;;;;;;;;;;;;;;;iBAwBHG,yBAAyBD,eAAeL,wBAAwBO,gBAAgBV,qBAAqBU;iBACrGC,wCAAwCX,8BAA8BQ,eAAeL,YAAYC;;IAErHH"}
+{"version":3,"file":"base.d.cts","names":["ReadonlyCheckpoint","Checkpoint","isBaseChannel","BaseChannel","ValueType","UpdateType","CheckpointType","getOnlyChannels","Record","emptyChannels","Cc","createCheckpoint"],"sources":["../../src/channels/base.d.ts"],"sourcesContent":["import { ReadonlyCheckpoint, Checkpoint } from \"@langchain/langgraph-checkpoint\";\nexport declare function isBaseChannel(obj: unknown): obj is BaseChannel;\n/** @internal */\nexport declare abstract class BaseChannel<ValueType = unknown, UpdateType = unknown, CheckpointType = unknown> {\n    ValueType: ValueType;\n    UpdateType: UpdateType;\n    /**\n     * The name of the channel.\n     */\n    abstract lc_graph_name: string;\n    /** @ignore */\n    lg_is_channel: boolean;\n    /**\n     * Return a new identical channel, optionally initialized from a checkpoint.\n     * Can be thought of as a \"restoration\" from a checkpoint which is a \"snapshot\" of the channel's state.\n     *\n     * @param {CheckpointType | undefined} checkpoint\n     * @param {CheckpointType | undefined} initialValue\n     * @returns {this}\n     */\n    abstract fromCheckpoint(checkpoint?: CheckpointType): this;\n    /**\n     * Update the channel's value with the given sequence of updates.\n     * The order of the updates in the sequence is arbitrary.\n     * This method is called by Pregel for all channels at the end of each step.\n     * If there are no updates, it is called with an empty sequence.\n     *\n     * Raises InvalidUpdateError if the sequence of updates is invalid.\n     * Returns True if the channel was updated, False otherwise.\n     *\n     * @throws {InvalidUpdateError} if the sequence of updates is invalid.\n     * @param {Array<UpdateType>} values\n     * @returns {void}\n     */\n    abstract update(values: UpdateType[]): boolean;\n    /**\n     * Return the current value of the channel.\n     *\n     * @throws {EmptyChannelError} if the channel is empty (never updated yet).\n     * @returns {ValueType}\n     */\n    abstract get(): ValueType;\n    /**\n     * Return a string representation of the channel's current state.\n     *\n     * @throws {EmptyChannelError} if the channel is empty (never updated yet), or doesn't support checkpoints.\n     * @returns {CheckpointType | undefined}\n     */\n    abstract checkpoint(): CheckpointType | undefined;\n    /**\n     * Mark the current value of the channel as consumed. By default, no-op.\n     * A channel can use this method to modify its state, preventing the value\n     * from being consumed again.\n     *\n     * Returns True if the channel was updated, False otherwise.\n     */\n    consume(): boolean;\n    /**\n     * Notify the channel that the Pregel run is finishing. By default, no-op.\n     * A channel can use this method to modify its state, preventing finish.\n     *\n     * Returns True if the channel was updated, False otherwise.\n     */\n    finish(): boolean;\n    /**\n     * Return True if the channel is available (not empty), False otherwise.\n     * Subclasses should override this method to provide a more efficient\n     * implementation than calling get() and catching EmptyChannelError.\n     */\n    isAvailable(): boolean;\n    /**\n     * Compare this channel with another channel for equality.\n     * Used to determine if two channels with the same key are semantically equivalent.\n     * Subclasses should override this method to provide a meaningful comparison.\n     *\n     * @param {BaseChannel} other - The other channel to compare with.\n     * @returns {boolean} True if the channels are equal, false otherwise.\n     */\n    equals(other: BaseChannel): boolean;\n}\nexport declare function getOnlyChannels(channels: Record<string, BaseChannel>): Record<string, BaseChannel>;\nexport declare function emptyChannels<Cc extends Record<string, BaseChannel>>(channels: Cc, checkpoint: ReadonlyCheckpoint): Cc;\nexport declare function createCheckpoint<ValueType>(checkpoint: ReadonlyCheckpoint, channels: Record<string, BaseChannel<ValueType>> | undefined, step: number, options?: {\n    id?: string;\n}): Checkpoint;\n"],"mappings":";;;;AAG8BG,uBAAAA,WAAW,CAAA,YAAA,OAAA,EAAA,aAAA,OAAA,EAAA,iBAAA,OAAA,CAAA,CAAA;EAAA,SAAA,EAC1BC,SAD0B;YAC1BA,EACCC,UADDD;;;;WAqCKA,aAAAA,EAAAA,MAAAA;;eAqCFD,EAAAA,OAAAA;EAAW;AAG7B;;;;;;;EAA+H,SAAA,cAAA,CAAA,UAAA,CAAA,EA7DtFG,cA6DsF,CAAA,EAAA,IAAA;EACvGK;;;;;;;;;;;;;0BAhDIN;;;;;;;kBAORD;;;;;;;yBAOOE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBA8BTH;;iBAGMM,yBAAyBD,eAAeL,wBAAwBO,gBAAgBV,qBAAqBU;iBACrGC,wCAAwCX,8BAA8BQ,eAAeL,YAAYC;;IAErHH"}

package/dist/channels/base.d.ts

@@ -69,6 +69,15 @@ declare abstract class BaseChannel<ValueType = unknown, UpdateType = unknown, Ch
    * 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;
 }
 declare function emptyChannels<Cc extends Record<string, BaseChannel>>(channels: Cc, checkpoint: ReadonlyCheckpoint): Cc;
 declare function createCheckpoint<ValueType>(checkpoint: ReadonlyCheckpoint, channels: Record<string, BaseChannel<ValueType>> | undefined, step: number, options?: {

package/dist/channels/base.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"base.d.ts","names":["ReadonlyCheckpoint","Checkpoint","isBaseChannel","BaseChannel","ValueType","UpdateType","CheckpointType","getOnlyChannels","Record","emptyChannels","Cc","createCheckpoint"],"sources":["../../src/channels/base.d.ts"],"sourcesContent":["import { ReadonlyCheckpoint, Checkpoint } from \"@langchain/langgraph-checkpoint\";\nexport declare function isBaseChannel(obj: unknown): obj is BaseChannel;\n/** @internal */\nexport declare abstract class BaseChannel<ValueType = unknown, UpdateType = unknown, CheckpointType = unknown> {\n    ValueType: ValueType;\n    UpdateType: UpdateType;\n    /**\n     * The name of the channel.\n     */\n    abstract lc_graph_name: string;\n    /** @ignore */\n    lg_is_channel: boolean;\n    /**\n     * Return a new identical channel, optionally initialized from a checkpoint.\n     * Can be thought of as a \"restoration\" from a checkpoint which is a \"snapshot\" of the channel's state.\n     *\n     * @param {CheckpointType | undefined} checkpoint\n     * @param {CheckpointType | undefined} initialValue\n     * @returns {this}\n     */\n    abstract fromCheckpoint(checkpoint?: CheckpointType): this;\n    /**\n     * Update the channel's value with the given sequence of updates.\n     * The order of the updates in the sequence is arbitrary.\n     * This method is called by Pregel for all channels at the end of each step.\n     * If there are no updates, it is called with an empty sequence.\n     *\n     * Raises InvalidUpdateError if the sequence of updates is invalid.\n     * Returns True if the channel was updated, False otherwise.\n     *\n     * @throws {InvalidUpdateError} if the sequence of updates is invalid.\n     * @param {Array<UpdateType>} values\n     * @returns {void}\n     */\n    abstract update(values: UpdateType[]): boolean;\n    /**\n     * Return the current value of the channel.\n     *\n     * @throws {EmptyChannelError} if the channel is empty (never updated yet).\n     * @returns {ValueType}\n     */\n    abstract get(): ValueType;\n    /**\n     * Return a string representation of the channel's current state.\n     *\n     * @throws {EmptyChannelError} if the channel is empty (never updated yet), or doesn't support checkpoints.\n     * @returns {CheckpointType | undefined}\n     */\n    abstract checkpoint(): CheckpointType | undefined;\n    /**\n     * Mark the current value of the channel as consumed. By default, no-op.\n     * A channel can use this method to modify its state, preventing the value\n     * from being consumed again.\n     *\n     * Returns True if the channel was updated, False otherwise.\n     */\n    consume(): boolean;\n    /**\n     * Notify the channel that the Pregel run is finishing. By default, no-op.\n     * A channel can use this method to modify its state, preventing finish.\n     *\n     * Returns True if the channel was updated, False otherwise.\n     */\n    finish(): boolean;\n    /**\n     * Return True if the channel is available (not empty), False otherwise.\n     * Subclasses should override this method to provide a more efficient\n     * implementation than calling get() and catching EmptyChannelError.\n     */\n    isAvailable(): boolean;\n}\nexport declare function getOnlyChannels(channels: Record<string, BaseChannel>): Record<string, BaseChannel>;\nexport declare function emptyChannels<Cc extends Record<string, BaseChannel>>(channels: Cc, checkpoint: ReadonlyCheckpoint): Cc;\nexport declare function createCheckpoint<ValueType>(checkpoint: ReadonlyCheckpoint, channels: Record<string, BaseChannel<ValueType>> | undefined, step: number, options?: {\n    id?: string;\n}): Checkpoint;\n"],"mappings":";;;;AAG8BG,uBAAAA,WAAW,CAAA,YAAA,OAAA,EAAA,aAAA,OAAA,EAAA,iBAAA,OAAA,CAAA,CAAA;EAAA,SAAA,EAC1BC,SAD0B;YAC1BA,EACCC,UADDD;;;;WAqCKA,aAAAA,EAAAA,MAAAA;;EAOqB,aAAA,EAAA,OAAA;EAwBjBK;;;;;;;;EACAE,SAAAA,cAAgB,CAAA,UAAA,CAAA,EArDCL,cAqDD,CAAA,EAAA,IAAA;EAAA;;;;;;;;;;;;;0BAvCZD;;;;;;;kBAORD;;;;;;;yBAOOE;;;;;;;;;;;;;;;;;;;;;;;iBAwBHG,yBAAyBD,eAAeL,wBAAwBO,gBAAgBV,qBAAqBU;iBACrGC,wCAAwCX,8BAA8BQ,eAAeL,YAAYC;;IAErHH"}
+{"version":3,"file":"base.d.ts","names":["ReadonlyCheckpoint","Checkpoint","isBaseChannel","BaseChannel","ValueType","UpdateType","CheckpointType","getOnlyChannels","Record","emptyChannels","Cc","createCheckpoint"],"sources":["../../src/channels/base.d.ts"],"sourcesContent":["import { ReadonlyCheckpoint, Checkpoint } from \"@langchain/langgraph-checkpoint\";\nexport declare function isBaseChannel(obj: unknown): obj is BaseChannel;\n/** @internal */\nexport declare abstract class BaseChannel<ValueType = unknown, UpdateType = unknown, CheckpointType = unknown> {\n    ValueType: ValueType;\n    UpdateType: UpdateType;\n    /**\n     * The name of the channel.\n     */\n    abstract lc_graph_name: string;\n    /** @ignore */\n    lg_is_channel: boolean;\n    /**\n     * Return a new identical channel, optionally initialized from a checkpoint.\n     * Can be thought of as a \"restoration\" from a checkpoint which is a \"snapshot\" of the channel's state.\n     *\n     * @param {CheckpointType | undefined} checkpoint\n     * @param {CheckpointType | undefined} initialValue\n     * @returns {this}\n     */\n    abstract fromCheckpoint(checkpoint?: CheckpointType): this;\n    /**\n     * Update the channel's value with the given sequence of updates.\n     * The order of the updates in the sequence is arbitrary.\n     * This method is called by Pregel for all channels at the end of each step.\n     * If there are no updates, it is called with an empty sequence.\n     *\n     * Raises InvalidUpdateError if the sequence of updates is invalid.\n     * Returns True if the channel was updated, False otherwise.\n     *\n     * @throws {InvalidUpdateError} if the sequence of updates is invalid.\n     * @param {Array<UpdateType>} values\n     * @returns {void}\n     */\n    abstract update(values: UpdateType[]): boolean;\n    /**\n     * Return the current value of the channel.\n     *\n     * @throws {EmptyChannelError} if the channel is empty (never updated yet).\n     * @returns {ValueType}\n     */\n    abstract get(): ValueType;\n    /**\n     * Return a string representation of the channel's current state.\n     *\n     * @throws {EmptyChannelError} if the channel is empty (never updated yet), or doesn't support checkpoints.\n     * @returns {CheckpointType | undefined}\n     */\n    abstract checkpoint(): CheckpointType | undefined;\n    /**\n     * Mark the current value of the channel as consumed. By default, no-op.\n     * A channel can use this method to modify its state, preventing the value\n     * from being consumed again.\n     *\n     * Returns True if the channel was updated, False otherwise.\n     */\n    consume(): boolean;\n    /**\n     * Notify the channel that the Pregel run is finishing. By default, no-op.\n     * A channel can use this method to modify its state, preventing finish.\n     *\n     * Returns True if the channel was updated, False otherwise.\n     */\n    finish(): boolean;\n    /**\n     * Return True if the channel is available (not empty), False otherwise.\n     * Subclasses should override this method to provide a more efficient\n     * implementation than calling get() and catching EmptyChannelError.\n     */\n    isAvailable(): boolean;\n    /**\n     * Compare this channel with another channel for equality.\n     * Used to determine if two channels with the same key are semantically equivalent.\n     * Subclasses should override this method to provide a meaningful comparison.\n     *\n     * @param {BaseChannel} other - The other channel to compare with.\n     * @returns {boolean} True if the channels are equal, false otherwise.\n     */\n    equals(other: BaseChannel): boolean;\n}\nexport declare function getOnlyChannels(channels: Record<string, BaseChannel>): Record<string, BaseChannel>;\nexport declare function emptyChannels<Cc extends Record<string, BaseChannel>>(channels: Cc, checkpoint: ReadonlyCheckpoint): Cc;\nexport declare function createCheckpoint<ValueType>(checkpoint: ReadonlyCheckpoint, channels: Record<string, BaseChannel<ValueType>> | undefined, step: number, options?: {\n    id?: string;\n}): Checkpoint;\n"],"mappings":";;;;AAG8BG,uBAAAA,WAAW,CAAA,YAAA,OAAA,EAAA,aAAA,OAAA,EAAA,iBAAA,OAAA,CAAA,CAAA;EAAA,SAAA,EAC1BC,SAD0B;YAC1BA,EACCC,UADDD;;;;WAqCKA,aAAAA,EAAAA,MAAAA;;eAqCFD,EAAAA,OAAAA;EAAW;AAG7B;;;;;;;EAA+H,SAAA,cAAA,CAAA,UAAA,CAAA,EA7DtFG,cA6DsF,CAAA,EAAA,IAAA;EACvGK;;;;;;;;;;;;;0BAhDIN;;;;;;;kBAORD;;;;;;;yBAOOE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBA8BTH;;iBAGMM,yBAAyBD,eAAeL,wBAAwBO,gBAAgBV,qBAAqBU;iBACrGC,wCAAwCX,8BAA8BQ,eAAeL,YAAYC;;IAErHH"}

package/dist/channels/base.js

@@ -44,6 +44,17 @@ var BaseChannel = class {
 			throw error;
 		}
 	}
+	/**
+	* 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) {
+		return this === other;
+	}
 };
 const IS_ONLY_BASE_CHANNEL = Symbol.for("LG_IS_ONLY_BASE_CHANNEL");
 function getOnlyChannels(channels) {

package/dist/channels/base.js.map

@@ -1 +1 @@
-{"version":3,"file":"base.js","names":[],"sources":["../../src/channels/base.ts"],"sourcesContent":["import {\n  ReadonlyCheckpoint,\n  uuid6,\n  Checkpoint,\n} from \"@langchain/langgraph-checkpoint\";\nimport { EmptyChannelError } from \"../errors.js\";\n\nexport function isBaseChannel(obj: unknown): obj is BaseChannel {\n  return obj != null && (obj as BaseChannel).lg_is_channel === true;\n}\n\n/** @internal */\nexport abstract class BaseChannel<\n  ValueType = unknown,\n  UpdateType = unknown,\n  CheckpointType = unknown\n> {\n  ValueType: ValueType;\n\n  UpdateType: UpdateType;\n\n  /**\n   * The name of the channel.\n   */\n  abstract lc_graph_name: string;\n\n  /** @ignore */\n  lg_is_channel = true;\n\n  /**\n   * Return a new identical channel, optionally initialized from a checkpoint.\n   * Can be thought of as a \"restoration\" from a checkpoint which is a \"snapshot\" of the channel's state.\n   *\n   * @param {CheckpointType | undefined} checkpoint\n   * @param {CheckpointType | undefined} initialValue\n   * @returns {this}\n   */\n  abstract fromCheckpoint(checkpoint?: CheckpointType): this;\n\n  /**\n   * Update the channel's value with the given sequence of updates.\n   * The order of the updates in the sequence is arbitrary.\n   * This method is called by Pregel for all channels at the end of each step.\n   * If there are no updates, it is called with an empty sequence.\n   *\n   * Raises InvalidUpdateError if the sequence of updates is invalid.\n   * Returns True if the channel was updated, False otherwise.\n   *\n   * @throws {InvalidUpdateError} if the sequence of updates is invalid.\n   * @param {Array<UpdateType>} values\n   * @returns {void}\n   */\n  abstract update(values: UpdateType[]): boolean;\n\n  /**\n   * Return the current value of the channel.\n   *\n   * @throws {EmptyChannelError} if the channel is empty (never updated yet).\n   * @returns {ValueType}\n   */\n  abstract get(): ValueType;\n\n  /**\n   * Return a string representation of the channel's current state.\n   *\n   * @throws {EmptyChannelError} if the channel is empty (never updated yet), or doesn't support checkpoints.\n   * @returns {CheckpointType | undefined}\n   */\n  abstract checkpoint(): CheckpointType | undefined;\n\n  /**\n   * Mark the current value of the channel as consumed. By default, no-op.\n   * A channel can use this method to modify its state, preventing the value\n   * from being consumed again.\n   *\n   * Returns True if the channel was updated, False otherwise.\n   */\n  consume(): boolean {\n    return false;\n  }\n\n  /**\n   * Notify the channel that the Pregel run is finishing. By default, no-op.\n   * A channel can use this method to modify its state, preventing finish.\n   *\n   * Returns True if the channel was updated, False otherwise.\n   */\n  finish(): boolean {\n    return false;\n  }\n\n  /**\n   * Return True if the channel is available (not empty), False otherwise.\n   * Subclasses should override this method to provide a more efficient\n   * implementation than calling get() and catching EmptyChannelError.\n   */\n  isAvailable(): boolean {\n    try {\n      this.get();\n      return true;\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    } catch (error: any) {\n      if (error.name === EmptyChannelError.unminifiable_name) {\n        return false;\n      }\n      throw error;\n    }\n  }\n}\n\nconst IS_ONLY_BASE_CHANNEL = Symbol.for(\"LG_IS_ONLY_BASE_CHANNEL\");\nexport function getOnlyChannels(\n  channels: Record<string, BaseChannel>\n): Record<string, BaseChannel> {\n  // @ts-expect-error - we know it's a record of base channels\n  if (channels[IS_ONLY_BASE_CHANNEL] === true) return channels;\n\n  const newChannels = {} as Record<string, BaseChannel>;\n  for (const k in channels) {\n    if (!Object.prototype.hasOwnProperty.call(channels, k)) continue;\n    const value = channels[k];\n    if (isBaseChannel(value)) newChannels[k] = value;\n  }\n\n  Object.assign(newChannels, { [IS_ONLY_BASE_CHANNEL]: true });\n  return newChannels;\n}\n\nexport function emptyChannels<Cc extends Record<string, BaseChannel>>(\n  channels: Cc,\n  checkpoint: ReadonlyCheckpoint\n): Cc {\n  const filteredChannels = getOnlyChannels(channels) as Cc;\n\n  const newChannels = {} as Cc;\n  for (const k in filteredChannels) {\n    if (!Object.prototype.hasOwnProperty.call(filteredChannels, k)) continue;\n    const channelValue = checkpoint.channel_values[k];\n    newChannels[k] = filteredChannels[k].fromCheckpoint(channelValue);\n  }\n  Object.assign(newChannels, { [IS_ONLY_BASE_CHANNEL]: true });\n  return newChannels;\n}\n\nexport function createCheckpoint<ValueType>(\n  checkpoint: ReadonlyCheckpoint,\n  channels: Record<string, BaseChannel<ValueType>> | undefined,\n  step: number,\n  options?: { id?: string }\n): Checkpoint {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  let values: Record<string, any>;\n  if (channels === undefined) {\n    values = checkpoint.channel_values;\n  } else {\n    values = {};\n    for (const k in channels) {\n      if (!Object.prototype.hasOwnProperty.call(channels, k)) continue;\n      try {\n        values[k] = channels[k].checkpoint();\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      } catch (error: any) {\n        if (error.name === EmptyChannelError.unminifiable_name) {\n          // no-op\n        } else {\n          throw error; // Rethrow unexpected errors\n        }\n      }\n    }\n  }\n\n  return {\n    v: 4,\n    id: options?.id ?? uuid6(step),\n    ts: new Date().toISOString(),\n    channel_values: values,\n    channel_versions: checkpoint.channel_versions,\n    versions_seen: checkpoint.versions_seen,\n  };\n}\n"],"mappings":";;;;AAOA,SAAgB,cAAc,KAAkC;AAC9D,QAAO,OAAO,QAAS,IAAoB,kBAAkB;;;AAI/D,IAAsB,cAAtB,MAIE;CACA;CAEA;;CAQA,gBAAgB;;;;;;;;CAkDhB,UAAmB;AACjB,SAAO;;;;;;;;CAST,SAAkB;AAChB,SAAO;;;;;;;CAQT,cAAuB;AACrB,MAAI;AACF,QAAK,KAAK;AACV,UAAO;WAEA,OAAY;AACnB,OAAI,MAAM,SAAS,kBAAkB,kBACnC,QAAO;AAET,SAAM;;;;AAKZ,MAAM,uBAAuB,OAAO,IAAI,0BAA0B;AAClE,SAAgB,gBACd,UAC6B;AAE7B,KAAI,SAAS,0BAA0B,KAAM,QAAO;CAEpD,MAAM,cAAc,EAAE;AACtB,MAAK,MAAM,KAAK,UAAU;AACxB,MAAI,CAAC,OAAO,UAAU,eAAe,KAAK,UAAU,EAAE,CAAE;EACxD,MAAM,QAAQ,SAAS;AACvB,MAAI,cAAc,MAAM,CAAE,aAAY,KAAK;;AAG7C,QAAO,OAAO,aAAa,GAAG,uBAAuB,MAAM,CAAC;AAC5D,QAAO;;AAGT,SAAgB,cACd,UACA,YACI;CACJ,MAAM,mBAAmB,gBAAgB,SAAS;CAElD,MAAM,cAAc,EAAE;AACtB,MAAK,MAAM,KAAK,kBAAkB;AAChC,MAAI,CAAC,OAAO,UAAU,eAAe,KAAK,kBAAkB,EAAE,CAAE;EAChE,MAAM,eAAe,WAAW,eAAe;AAC/C,cAAY,KAAK,iBAAiB,GAAG,eAAe,aAAa;;AAEnE,QAAO,OAAO,aAAa,GAAG,uBAAuB,MAAM,CAAC;AAC5D,QAAO;;AAGT,SAAgB,iBACd,YACA,UACA,MACA,SACY;CAEZ,IAAI;AACJ,KAAI,aAAa,OACf,UAAS,WAAW;MACf;AACL,WAAS,EAAE;AACX,OAAK,MAAM,KAAK,UAAU;AACxB,OAAI,CAAC,OAAO,UAAU,eAAe,KAAK,UAAU,EAAE,CAAE;AACxD,OAAI;AACF,WAAO,KAAK,SAAS,GAAG,YAAY;YAE7B,OAAY;AACnB,QAAI,MAAM,SAAS,kBAAkB,mBAAmB,OAGtD,OAAM;;;;AAMd,QAAO;EACL,GAAG;EACH,IAAI,SAAS,MAAM,MAAM,KAAK;EAC9B,qBAAI,IAAI,MAAM,EAAC,aAAa;EAC5B,gBAAgB;EAChB,kBAAkB,WAAW;EAC7B,eAAe,WAAW;EAC3B"}
+{"version":3,"file":"base.js","names":[],"sources":["../../src/channels/base.ts"],"sourcesContent":["import {\n  ReadonlyCheckpoint,\n  uuid6,\n  Checkpoint,\n} from \"@langchain/langgraph-checkpoint\";\nimport { EmptyChannelError } from \"../errors.js\";\n\nexport function isBaseChannel(obj: unknown): obj is BaseChannel {\n  return obj != null && (obj as BaseChannel).lg_is_channel === true;\n}\n\n/** @internal */\nexport abstract class BaseChannel<\n  ValueType = unknown,\n  UpdateType = unknown,\n  CheckpointType = unknown\n> {\n  ValueType: ValueType;\n\n  UpdateType: UpdateType;\n\n  /**\n   * The name of the channel.\n   */\n  abstract lc_graph_name: string;\n\n  /** @ignore */\n  lg_is_channel = true;\n\n  /**\n   * Return a new identical channel, optionally initialized from a checkpoint.\n   * Can be thought of as a \"restoration\" from a checkpoint which is a \"snapshot\" of the channel's state.\n   *\n   * @param {CheckpointType | undefined} checkpoint\n   * @param {CheckpointType | undefined} initialValue\n   * @returns {this}\n   */\n  abstract fromCheckpoint(checkpoint?: CheckpointType): this;\n\n  /**\n   * Update the channel's value with the given sequence of updates.\n   * The order of the updates in the sequence is arbitrary.\n   * This method is called by Pregel for all channels at the end of each step.\n   * If there are no updates, it is called with an empty sequence.\n   *\n   * Raises InvalidUpdateError if the sequence of updates is invalid.\n   * Returns True if the channel was updated, False otherwise.\n   *\n   * @throws {InvalidUpdateError} if the sequence of updates is invalid.\n   * @param {Array<UpdateType>} values\n   * @returns {void}\n   */\n  abstract update(values: UpdateType[]): boolean;\n\n  /**\n   * Return the current value of the channel.\n   *\n   * @throws {EmptyChannelError} if the channel is empty (never updated yet).\n   * @returns {ValueType}\n   */\n  abstract get(): ValueType;\n\n  /**\n   * Return a string representation of the channel's current state.\n   *\n   * @throws {EmptyChannelError} if the channel is empty (never updated yet), or doesn't support checkpoints.\n   * @returns {CheckpointType | undefined}\n   */\n  abstract checkpoint(): CheckpointType | undefined;\n\n  /**\n   * Mark the current value of the channel as consumed. By default, no-op.\n   * A channel can use this method to modify its state, preventing the value\n   * from being consumed again.\n   *\n   * Returns True if the channel was updated, False otherwise.\n   */\n  consume(): boolean {\n    return false;\n  }\n\n  /**\n   * Notify the channel that the Pregel run is finishing. By default, no-op.\n   * A channel can use this method to modify its state, preventing finish.\n   *\n   * Returns True if the channel was updated, False otherwise.\n   */\n  finish(): boolean {\n    return false;\n  }\n\n  /**\n   * Return True if the channel is available (not empty), False otherwise.\n   * Subclasses should override this method to provide a more efficient\n   * implementation than calling get() and catching EmptyChannelError.\n   */\n  isAvailable(): boolean {\n    try {\n      this.get();\n      return true;\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    } catch (error: any) {\n      if (error.name === EmptyChannelError.unminifiable_name) {\n        return false;\n      }\n      throw error;\n    }\n  }\n\n  /**\n   * Compare this channel with another channel for equality.\n   * Used to determine if two channels with the same key are semantically equivalent.\n   * Subclasses should override this method to provide a meaningful comparison.\n   *\n   * @param {BaseChannel} other - The other channel to compare with.\n   * @returns {boolean} True if the channels are equal, false otherwise.\n   */\n  equals(other: BaseChannel): boolean {\n    return this === other;\n  }\n}\n\nconst IS_ONLY_BASE_CHANNEL = Symbol.for(\"LG_IS_ONLY_BASE_CHANNEL\");\nexport function getOnlyChannels(\n  channels: Record<string, BaseChannel>\n): Record<string, BaseChannel> {\n  // @ts-expect-error - we know it's a record of base channels\n  if (channels[IS_ONLY_BASE_CHANNEL] === true) return channels;\n\n  const newChannels = {} as Record<string, BaseChannel>;\n  for (const k in channels) {\n    if (!Object.prototype.hasOwnProperty.call(channels, k)) continue;\n    const value = channels[k];\n    if (isBaseChannel(value)) newChannels[k] = value;\n  }\n\n  Object.assign(newChannels, { [IS_ONLY_BASE_CHANNEL]: true });\n  return newChannels;\n}\n\nexport function emptyChannels<Cc extends Record<string, BaseChannel>>(\n  channels: Cc,\n  checkpoint: ReadonlyCheckpoint\n): Cc {\n  const filteredChannels = getOnlyChannels(channels) as Cc;\n\n  const newChannels = {} as Cc;\n  for (const k in filteredChannels) {\n    if (!Object.prototype.hasOwnProperty.call(filteredChannels, k)) continue;\n    const channelValue = checkpoint.channel_values[k];\n    newChannels[k] = filteredChannels[k].fromCheckpoint(channelValue);\n  }\n  Object.assign(newChannels, { [IS_ONLY_BASE_CHANNEL]: true });\n  return newChannels;\n}\n\nexport function createCheckpoint<ValueType>(\n  checkpoint: ReadonlyCheckpoint,\n  channels: Record<string, BaseChannel<ValueType>> | undefined,\n  step: number,\n  options?: { id?: string }\n): Checkpoint {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  let values: Record<string, any>;\n  if (channels === undefined) {\n    values = checkpoint.channel_values;\n  } else {\n    values = {};\n    for (const k in channels) {\n      if (!Object.prototype.hasOwnProperty.call(channels, k)) continue;\n      try {\n        values[k] = channels[k].checkpoint();\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      } catch (error: any) {\n        if (error.name === EmptyChannelError.unminifiable_name) {\n          // no-op\n        } else {\n          throw error; // Rethrow unexpected errors\n        }\n      }\n    }\n  }\n\n  return {\n    v: 4,\n    id: options?.id ?? uuid6(step),\n    ts: new Date().toISOString(),\n    channel_values: values,\n    channel_versions: checkpoint.channel_versions,\n    versions_seen: checkpoint.versions_seen,\n  };\n}\n"],"mappings":";;;;AAOA,SAAgB,cAAc,KAAkC;AAC9D,QAAO,OAAO,QAAS,IAAoB,kBAAkB;;;AAI/D,IAAsB,cAAtB,MAIE;CACA;CAEA;;CAQA,gBAAgB;;;;;;;;CAkDhB,UAAmB;AACjB,SAAO;;;;;;;;CAST,SAAkB;AAChB,SAAO;;;;;;;CAQT,cAAuB;AACrB,MAAI;AACF,QAAK,KAAK;AACV,UAAO;WAEA,OAAY;AACnB,OAAI,MAAM,SAAS,kBAAkB,kBACnC,QAAO;AAET,SAAM;;;;;;;;;;;CAYV,OAAO,OAA6B;AAClC,SAAO,SAAS;;;AAIpB,MAAM,uBAAuB,OAAO,IAAI,0BAA0B;AAClE,SAAgB,gBACd,UAC6B;AAE7B,KAAI,SAAS,0BAA0B,KAAM,QAAO;CAEpD,MAAM,cAAc,EAAE;AACtB,MAAK,MAAM,KAAK,UAAU;AACxB,MAAI,CAAC,OAAO,UAAU,eAAe,KAAK,UAAU,EAAE,CAAE;EACxD,MAAM,QAAQ,SAAS;AACvB,MAAI,cAAc,MAAM,CAAE,aAAY,KAAK;;AAG7C,QAAO,OAAO,aAAa,GAAG,uBAAuB,MAAM,CAAC;AAC5D,QAAO;;AAGT,SAAgB,cACd,UACA,YACI;CACJ,MAAM,mBAAmB,gBAAgB,SAAS;CAElD,MAAM,cAAc,EAAE;AACtB,MAAK,MAAM,KAAK,kBAAkB;AAChC,MAAI,CAAC,OAAO,UAAU,eAAe,KAAK,kBAAkB,EAAE,CAAE;EAChE,MAAM,eAAe,WAAW,eAAe;AAC/C,cAAY,KAAK,iBAAiB,GAAG,eAAe,aAAa;;AAEnE,QAAO,OAAO,aAAa,GAAG,uBAAuB,MAAM,CAAC;AAC5D,QAAO;;AAGT,SAAgB,iBACd,YACA,UACA,MACA,SACY;CAEZ,IAAI;AACJ,KAAI,aAAa,OACf,UAAS,WAAW;MACf;AACL,WAAS,EAAE;AACX,OAAK,MAAM,KAAK,UAAU;AACxB,OAAI,CAAC,OAAO,UAAU,eAAe,KAAK,UAAU,EAAE,CAAE;AACxD,OAAI;AACF,WAAO,KAAK,SAAS,GAAG,YAAY;YAE7B,OAAY;AACnB,QAAI,MAAM,SAAS,kBAAkB,mBAAmB,OAGtD,OAAM;;;;AAMd,QAAO;EACL,GAAG;EACH,IAAI,SAAS,MAAM,MAAM,KAAK;EAC9B,qBAAI,IAAI,MAAM,EAAC,aAAa;EAC5B,gBAAgB;EAChB,kBAAkB,WAAW;EAC7B,eAAe,WAAW;EAC3B"}

package/dist/channels/binop.cjs

@@ -2,6 +2,9 @@ const require_errors = require('../errors.cjs');
 const require_base = require('./base.cjs');
 
 //#region src/channels/binop.ts
+const isBinaryOperatorAggregate = (value) => {
+	return value != null && value.lc_graph_name === "BinaryOperatorAggregate";
+};
 /**
 * Stores the result of applying a binary operator to the current value and each new value.
 */
@@ -42,6 +45,16 @@ var BinaryOperatorAggregate = class BinaryOperatorAggregate extends require_base
 	isAvailable() {
 		return this.value !== void 0;
 	}
+	/**
+	* Compare this channel with another channel for equality.
+	* Two BinaryOperatorAggregate channels are equal if they have the same operator function.
+	* This follows the Python implementation which compares operator references.
+	*/
+	equals(other) {
+		if (this === other) return true;
+		if (!isBinaryOperatorAggregate(other)) return false;
+		return this.operator === other.operator;
+	}
 };
 
 //#endregion

package/dist/channels/binop.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"binop.cjs","names":["BaseChannel","EmptyChannelError"],"sources":["../../src/channels/binop.ts"],"sourcesContent":["import { EmptyChannelError } from \"../errors.js\";\nimport { BaseChannel } from \"./base.js\";\n\nexport type BinaryOperator<ValueType, UpdateType> = (\n  a: ValueType,\n  b: UpdateType\n) => ValueType;\n\n/**\n * Stores the result of applying a binary operator to the current value and each new value.\n */\nexport class BinaryOperatorAggregate<\n  ValueType,\n  UpdateType = ValueType\n> extends BaseChannel<ValueType, UpdateType, ValueType> {\n  lc_graph_name = \"BinaryOperatorAggregate\";\n\n  value: ValueType | undefined;\n\n  operator: BinaryOperator<ValueType, UpdateType>;\n\n  initialValueFactory?: () => ValueType;\n\n  constructor(\n    operator: BinaryOperator<ValueType, UpdateType>,\n    initialValueFactory?: () => ValueType\n  ) {\n    super();\n\n    this.operator = operator;\n    this.initialValueFactory = initialValueFactory;\n    this.value = initialValueFactory?.();\n  }\n\n  public fromCheckpoint(checkpoint?: ValueType) {\n    const empty = new BinaryOperatorAggregate(\n      this.operator,\n      this.initialValueFactory\n    );\n    if (typeof checkpoint !== \"undefined\") {\n      empty.value = checkpoint;\n    }\n    return empty as this;\n  }\n\n  public update(values: UpdateType[]): boolean {\n    let newValues = values;\n    if (!newValues.length) return false;\n\n    if (this.value === undefined) {\n      [this.value as UpdateType] = newValues;\n      newValues = newValues.slice(1);\n    }\n\n    for (const value of newValues) {\n      if (this.value !== undefined) {\n        this.value = this.operator(this.value, value);\n      }\n    }\n    return true;\n  }\n\n  public get(): ValueType {\n    if (this.value === undefined) {\n      throw new EmptyChannelError();\n    }\n    return this.value;\n  }\n\n  public checkpoint(): ValueType {\n    if (this.value === undefined) {\n      throw new EmptyChannelError();\n    }\n    return this.value;\n  }\n\n  isAvailable(): boolean {\n    return this.value !== undefined;\n  }\n}\n"],"mappings":";;;;;;;AAWA,IAAa,0BAAb,MAAa,gCAGHA,yBAA8C;CACtD,gBAAgB;CAEhB;CAEA;CAEA;CAEA,YACE,UACA,qBACA;AACA,SAAO;AAEP,OAAK,WAAW;AAChB,OAAK,sBAAsB;AAC3B,OAAK,QAAQ,uBAAuB;;CAGtC,AAAO,eAAe,YAAwB;EAC5C,MAAM,QAAQ,IAAI,wBAChB,KAAK,UACL,KAAK,oBACN;AACD,MAAI,OAAO,eAAe,YACxB,OAAM,QAAQ;AAEhB,SAAO;;CAGT,AAAO,OAAO,QAA+B;EAC3C,IAAI,YAAY;AAChB,MAAI,CAAC,UAAU,OAAQ,QAAO;AAE9B,MAAI,KAAK,UAAU,QAAW;AAC5B,IAAC,KAAK,SAAuB;AAC7B,eAAY,UAAU,MAAM,EAAE;;AAGhC,OAAK,MAAM,SAAS,UAClB,KAAI,KAAK,UAAU,OACjB,MAAK,QAAQ,KAAK,SAAS,KAAK,OAAO,MAAM;AAGjD,SAAO;;CAGT,AAAO,MAAiB;AACtB,MAAI,KAAK,UAAU,OACjB,OAAM,IAAIC,kCAAmB;AAE/B,SAAO,KAAK;;CAGd,AAAO,aAAwB;AAC7B,MAAI,KAAK,UAAU,OACjB,OAAM,IAAIA,kCAAmB;AAE/B,SAAO,KAAK;;CAGd,cAAuB;AACrB,SAAO,KAAK,UAAU"}
+{"version":3,"file":"binop.cjs","names":["BaseChannel","EmptyChannelError"],"sources":["../../src/channels/binop.ts"],"sourcesContent":["import { EmptyChannelError } from \"../errors.js\";\nimport { BaseChannel } from \"./base.js\";\n\nexport type BinaryOperator<ValueType, UpdateType> = (\n  a: ValueType,\n  b: UpdateType\n) => ValueType;\n\nconst isBinaryOperatorAggregate = (\n  value: BaseChannel\n): value is BinaryOperatorAggregate<unknown, unknown> => {\n  return value != null && value.lc_graph_name === \"BinaryOperatorAggregate\";\n};\n\n/**\n * Stores the result of applying a binary operator to the current value and each new value.\n */\nexport class BinaryOperatorAggregate<\n  ValueType,\n  UpdateType = ValueType\n> extends BaseChannel<ValueType, UpdateType, ValueType> {\n  lc_graph_name = \"BinaryOperatorAggregate\";\n\n  value: ValueType | undefined;\n\n  operator: BinaryOperator<ValueType, UpdateType>;\n\n  initialValueFactory?: () => ValueType;\n\n  constructor(\n    operator: BinaryOperator<ValueType, UpdateType>,\n    initialValueFactory?: () => ValueType\n  ) {\n    super();\n\n    this.operator = operator;\n    this.initialValueFactory = initialValueFactory;\n    this.value = initialValueFactory?.();\n  }\n\n  public fromCheckpoint(checkpoint?: ValueType) {\n    const empty = new BinaryOperatorAggregate(\n      this.operator,\n      this.initialValueFactory\n    );\n    if (typeof checkpoint !== \"undefined\") {\n      empty.value = checkpoint;\n    }\n    return empty as this;\n  }\n\n  public update(values: UpdateType[]): boolean {\n    let newValues = values;\n    if (!newValues.length) return false;\n\n    if (this.value === undefined) {\n      [this.value as UpdateType] = newValues;\n      newValues = newValues.slice(1);\n    }\n\n    for (const value of newValues) {\n      if (this.value !== undefined) {\n        this.value = this.operator(this.value, value);\n      }\n    }\n    return true;\n  }\n\n  public get(): ValueType {\n    if (this.value === undefined) {\n      throw new EmptyChannelError();\n    }\n    return this.value;\n  }\n\n  public checkpoint(): ValueType {\n    if (this.value === undefined) {\n      throw new EmptyChannelError();\n    }\n    return this.value;\n  }\n\n  isAvailable(): boolean {\n    return this.value !== undefined;\n  }\n\n  /**\n   * Compare this channel with another channel for equality.\n   * Two BinaryOperatorAggregate channels are equal if they have the same operator function.\n   * This follows the Python implementation which compares operator references.\n   */\n  equals(other: BaseChannel): boolean {\n    if (this === other) return true;\n    if (!isBinaryOperatorAggregate(other)) return false;\n    return this.operator === other.operator;\n  }\n}\n"],"mappings":";;;;AAQA,MAAM,6BACJ,UACuD;AACvD,QAAO,SAAS,QAAQ,MAAM,kBAAkB;;;;;AAMlD,IAAa,0BAAb,MAAa,gCAGHA,yBAA8C;CACtD,gBAAgB;CAEhB;CAEA;CAEA;CAEA,YACE,UACA,qBACA;AACA,SAAO;AAEP,OAAK,WAAW;AAChB,OAAK,sBAAsB;AAC3B,OAAK,QAAQ,uBAAuB;;CAGtC,AAAO,eAAe,YAAwB;EAC5C,MAAM,QAAQ,IAAI,wBAChB,KAAK,UACL,KAAK,oBACN;AACD,MAAI,OAAO,eAAe,YACxB,OAAM,QAAQ;AAEhB,SAAO;;CAGT,AAAO,OAAO,QAA+B;EAC3C,IAAI,YAAY;AAChB,MAAI,CAAC,UAAU,OAAQ,QAAO;AAE9B,MAAI,KAAK,UAAU,QAAW;AAC5B,IAAC,KAAK,SAAuB;AAC7B,eAAY,UAAU,MAAM,EAAE;;AAGhC,OAAK,MAAM,SAAS,UAClB,KAAI,KAAK,UAAU,OACjB,MAAK,QAAQ,KAAK,SAAS,KAAK,OAAO,MAAM;AAGjD,SAAO;;CAGT,AAAO,MAAiB;AACtB,MAAI,KAAK,UAAU,OACjB,OAAM,IAAIC,kCAAmB;AAE/B,SAAO,KAAK;;CAGd,AAAO,aAAwB;AAC7B,MAAI,KAAK,UAAU,OACjB,OAAM,IAAIA,kCAAmB;AAE/B,SAAO,KAAK;;CAGd,cAAuB;AACrB,SAAO,KAAK,UAAU;;;;;;;CAQxB,OAAO,OAA6B;AAClC,MAAI,SAAS,MAAO,QAAO;AAC3B,MAAI,CAAC,0BAA0B,MAAM,CAAE,QAAO;AAC9C,SAAO,KAAK,aAAa,MAAM"}

package/dist/channels/binop.d.cts

@@ -16,6 +16,12 @@ declare class BinaryOperatorAggregate<ValueType, UpdateType = ValueType> extends
   get(): ValueType;
   checkpoint(): ValueType;
   isAvailable(): boolean;
+  /**
+   * Compare this channel with another channel for equality.
+   * Two BinaryOperatorAggregate channels are equal if they have the same operator function.
+   * This follows the Python implementation which compares operator references.
+   */
+  equals(other: BaseChannel): boolean;
 }
 //#endregion
 export { BinaryOperator, BinaryOperatorAggregate };

package/dist/channels/binop.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"binop.d.cts","names":["BaseChannel","BinaryOperator","ValueType","UpdateType","BinaryOperatorAggregate"],"sources":["../../src/channels/binop.d.ts"],"sourcesContent":["import { BaseChannel } from \"./base.js\";\nexport type BinaryOperator<ValueType, UpdateType> = (a: ValueType, b: UpdateType) => ValueType;\n/**\n * Stores the result of applying a binary operator to the current value and each new value.\n */\nexport declare class BinaryOperatorAggregate<ValueType, UpdateType = ValueType> extends BaseChannel<ValueType, UpdateType, ValueType> {\n    lc_graph_name: string;\n    value: ValueType | undefined;\n    operator: BinaryOperator<ValueType, UpdateType>;\n    initialValueFactory?: () => ValueType;\n    constructor(operator: BinaryOperator<ValueType, UpdateType>, initialValueFactory?: () => ValueType);\n    fromCheckpoint(checkpoint?: ValueType): this;\n    update(values: UpdateType[]): boolean;\n    get(): ValueType;\n    checkpoint(): ValueType;\n    isAvailable(): boolean;\n}\n"],"mappings":";;;KACYC,4CAA4CC,cAAcC,eAAeD;;AAArF;;AAAwDA,cAInCE,uBAJmCF,CAAAA,SAAAA,EAAAA,aAIaA,SAJbA,CAAAA,SAIgCF,WAJhCE,CAI4CA,SAJ5CA,EAIuDC,UAJvDD,EAImEA,SAJnEA,CAAAA,CAAAA;eAAcC,EAAAA,MAAAA;OAAeD,EAM1EA,SAN0EA,GAAAA,SAAAA;EAAS,QAAA,EAOhFD,cAPgF,CAOjEC,SAPiE,EAOtDC,UAPsD,CAAA;EAIzEC,mBAAAA,CAAAA,EAAAA,GAAAA,GAIWF,SAJY;EAAA,WAAA,CAAA,QAAA,EAKlBD,cALkB,CAKHC,SALG,EAKQC,UALR,CAAA,EAAA,mBAAA,CAAA,EAAA,GAAA,GAKiDD,SALjD;gBAAyBA,CAAAA,UAAAA,CAAAA,EAMrCA,SANqCA,CAAAA,EAAAA,IAAAA;QAA+BA,CAAAA,MAAAA,EAOjFC,UAPiFD,EAAAA,CAAAA,EAAAA,OAAAA;KAAWC,CAAAA,CAAAA,EAQpGD,SARoGC;YAAYD,CAAAA,CAAAA,EASzGA,SATyGA;aAEhHA,CAAAA,CAAAA,EAAAA,OAAAA"}
+{"version":3,"file":"binop.d.cts","names":["BaseChannel","BinaryOperator","ValueType","UpdateType","BinaryOperatorAggregate"],"sources":["../../src/channels/binop.d.ts"],"sourcesContent":["import { BaseChannel } from \"./base.js\";\nexport type BinaryOperator<ValueType, UpdateType> = (a: ValueType, b: UpdateType) => ValueType;\n/**\n * Stores the result of applying a binary operator to the current value and each new value.\n */\nexport declare class BinaryOperatorAggregate<ValueType, UpdateType = ValueType> extends BaseChannel<ValueType, UpdateType, ValueType> {\n    lc_graph_name: string;\n    value: ValueType | undefined;\n    operator: BinaryOperator<ValueType, UpdateType>;\n    initialValueFactory?: () => ValueType;\n    constructor(operator: BinaryOperator<ValueType, UpdateType>, initialValueFactory?: () => ValueType);\n    fromCheckpoint(checkpoint?: ValueType): this;\n    update(values: UpdateType[]): boolean;\n    get(): ValueType;\n    checkpoint(): ValueType;\n    isAvailable(): boolean;\n    /**\n     * Compare this channel with another channel for equality.\n     * Two BinaryOperatorAggregate channels are equal if they have the same operator function.\n     * This follows the Python implementation which compares operator references.\n     */\n    equals(other: BaseChannel): boolean;\n}\n"],"mappings":";;;KACYC,4CAA4CC,cAAcC,eAAeD;;AAArF;;AAAwDA,cAInCE,uBAJmCF,CAAAA,SAAAA,EAAAA,aAIaA,SAJbA,CAAAA,SAIgCF,WAJhCE,CAI4CA,SAJ5CA,EAIuDC,UAJvDD,EAImEA,SAJnEA,CAAAA,CAAAA;eAAcC,EAAAA,MAAAA;OAAeD,EAM1EA,SAN0EA,GAAAA,SAAAA;EAAS,QAAA,EAOhFD,cAPgF,CAOjEC,SAPiE,EAOtDC,UAPsD,CAAA;EAIzEC,mBAAAA,CAAAA,EAAAA,GAAAA,GAIWF,SAJY;EAAA,WAAA,CAAA,QAAA,EAKlBD,cALkB,CAKHC,SALG,EAKQC,UALR,CAAA,EAAA,mBAAA,CAAA,EAAA,GAAA,GAKiDD,SALjD;gBAAyBA,CAAAA,UAAAA,CAAAA,EAMrCA,SANqCA,CAAAA,EAAAA,IAAAA;QAA+BA,CAAAA,MAAAA,EAOjFC,UAPiFD,EAAAA,CAAAA,EAAAA,OAAAA;KAAWC,CAAAA,CAAAA,EAQpGD,SARoGC;YAAYD,CAAAA,CAAAA,EASzGA,SATyGA;aAEhHA,CAAAA,CAAAA,EAAAA,OAAAA;;;;;;QAGyCC,CAAAA,KAAAA,EAWlCH,WAXkCG,CAAAA,EAAAA,OAAAA"}

package/dist/channels/binop.d.ts

@@ -16,6 +16,12 @@ declare class BinaryOperatorAggregate<ValueType, UpdateType = ValueType> extends
   get(): ValueType;
   checkpoint(): ValueType;
   isAvailable(): boolean;
+  /**
+   * Compare this channel with another channel for equality.
+   * Two BinaryOperatorAggregate channels are equal if they have the same operator function.
+   * This follows the Python implementation which compares operator references.
+   */
+  equals(other: BaseChannel): boolean;
 }
 //#endregion
 export { BinaryOperator, BinaryOperatorAggregate };

package/dist/channels/binop.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"binop.d.ts","names":["BaseChannel","BinaryOperator","ValueType","UpdateType","BinaryOperatorAggregate"],"sources":["../../src/channels/binop.d.ts"],"sourcesContent":["import { BaseChannel } from \"./base.js\";\nexport type BinaryOperator<ValueType, UpdateType> = (a: ValueType, b: UpdateType) => ValueType;\n/**\n * Stores the result of applying a binary operator to the current value and each new value.\n */\nexport declare class BinaryOperatorAggregate<ValueType, UpdateType = ValueType> extends BaseChannel<ValueType, UpdateType, ValueType> {\n    lc_graph_name: string;\n    value: ValueType | undefined;\n    operator: BinaryOperator<ValueType, UpdateType>;\n    initialValueFactory?: () => ValueType;\n    constructor(operator: BinaryOperator<ValueType, UpdateType>, initialValueFactory?: () => ValueType);\n    fromCheckpoint(checkpoint?: ValueType): this;\n    update(values: UpdateType[]): boolean;\n    get(): ValueType;\n    checkpoint(): ValueType;\n    isAvailable(): boolean;\n}\n"],"mappings":";;;KACYC,4CAA4CC,cAAcC,eAAeD;;AAArF;;AAAwDA,cAInCE,uBAJmCF,CAAAA,SAAAA,EAAAA,aAIaA,SAJbA,CAAAA,SAIgCF,WAJhCE,CAI4CA,SAJ5CA,EAIuDC,UAJvDD,EAImEA,SAJnEA,CAAAA,CAAAA;eAAcC,EAAAA,MAAAA;OAAeD,EAM1EA,SAN0EA,GAAAA,SAAAA;EAAS,QAAA,EAOhFD,cAPgF,CAOjEC,SAPiE,EAOtDC,UAPsD,CAAA;EAIzEC,mBAAAA,CAAAA,EAAAA,GAAAA,GAIWF,SAJY;EAAA,WAAA,CAAA,QAAA,EAKlBD,cALkB,CAKHC,SALG,EAKQC,UALR,CAAA,EAAA,mBAAA,CAAA,EAAA,GAAA,GAKiDD,SALjD;gBAAyBA,CAAAA,UAAAA,CAAAA,EAMrCA,SANqCA,CAAAA,EAAAA,IAAAA;QAA+BA,CAAAA,MAAAA,EAOjFC,UAPiFD,EAAAA,CAAAA,EAAAA,OAAAA;KAAWC,CAAAA,CAAAA,EAQpGD,SARoGC;YAAYD,CAAAA,CAAAA,EASzGA,SATyGA;aAEhHA,CAAAA,CAAAA,EAAAA,OAAAA"}
+{"version":3,"file":"binop.d.ts","names":["BaseChannel","BinaryOperator","ValueType","UpdateType","BinaryOperatorAggregate"],"sources":["../../src/channels/binop.d.ts"],"sourcesContent":["import { BaseChannel } from \"./base.js\";\nexport type BinaryOperator<ValueType, UpdateType> = (a: ValueType, b: UpdateType) => ValueType;\n/**\n * Stores the result of applying a binary operator to the current value and each new value.\n */\nexport declare class BinaryOperatorAggregate<ValueType, UpdateType = ValueType> extends BaseChannel<ValueType, UpdateType, ValueType> {\n    lc_graph_name: string;\n    value: ValueType | undefined;\n    operator: BinaryOperator<ValueType, UpdateType>;\n    initialValueFactory?: () => ValueType;\n    constructor(operator: BinaryOperator<ValueType, UpdateType>, initialValueFactory?: () => ValueType);\n    fromCheckpoint(checkpoint?: ValueType): this;\n    update(values: UpdateType[]): boolean;\n    get(): ValueType;\n    checkpoint(): ValueType;\n    isAvailable(): boolean;\n    /**\n     * Compare this channel with another channel for equality.\n     * Two BinaryOperatorAggregate channels are equal if they have the same operator function.\n     * This follows the Python implementation which compares operator references.\n     */\n    equals(other: BaseChannel): boolean;\n}\n"],"mappings":";;;KACYC,4CAA4CC,cAAcC,eAAeD;;AAArF;;AAAwDA,cAInCE,uBAJmCF,CAAAA,SAAAA,EAAAA,aAIaA,SAJbA,CAAAA,SAIgCF,WAJhCE,CAI4CA,SAJ5CA,EAIuDC,UAJvDD,EAImEA,SAJnEA,CAAAA,CAAAA;eAAcC,EAAAA,MAAAA;OAAeD,EAM1EA,SAN0EA,GAAAA,SAAAA;EAAS,QAAA,EAOhFD,cAPgF,CAOjEC,SAPiE,EAOtDC,UAPsD,CAAA;EAIzEC,mBAAAA,CAAAA,EAAAA,GAAAA,GAIWF,SAJY;EAAA,WAAA,CAAA,QAAA,EAKlBD,cALkB,CAKHC,SALG,EAKQC,UALR,CAAA,EAAA,mBAAA,CAAA,EAAA,GAAA,GAKiDD,SALjD;gBAAyBA,CAAAA,UAAAA,CAAAA,EAMrCA,SANqCA,CAAAA,EAAAA,IAAAA;QAA+BA,CAAAA,MAAAA,EAOjFC,UAPiFD,EAAAA,CAAAA,EAAAA,OAAAA;KAAWC,CAAAA,CAAAA,EAQpGD,SARoGC;YAAYD,CAAAA,CAAAA,EASzGA,SATyGA;aAEhHA,CAAAA,CAAAA,EAAAA,OAAAA;;;;;;QAGyCC,CAAAA,KAAAA,EAWlCH,WAXkCG,CAAAA,EAAAA,OAAAA"}

package/dist/channels/binop.js

@@ -2,6 +2,9 @@ import { EmptyChannelError } from "../errors.js";
 import { BaseChannel } from "./base.js";
 
 //#region src/channels/binop.ts
+const isBinaryOperatorAggregate = (value) => {
+	return value != null && value.lc_graph_name === "BinaryOperatorAggregate";
+};
 /**
 * Stores the result of applying a binary operator to the current value and each new value.
 */
@@ -42,6 +45,16 @@ var BinaryOperatorAggregate = class BinaryOperatorAggregate extends BaseChannel
 	isAvailable() {
 		return this.value !== void 0;
 	}
+	/**
+	* Compare this channel with another channel for equality.
+	* Two BinaryOperatorAggregate channels are equal if they have the same operator function.
+	* This follows the Python implementation which compares operator references.
+	*/
+	equals(other) {
+		if (this === other) return true;
+		if (!isBinaryOperatorAggregate(other)) return false;
+		return this.operator === other.operator;
+	}
 };
 
 //#endregion

package/dist/channels/binop.js.map

@@ -1 +1 @@
-{"version":3,"file":"binop.js","names":[],"sources":["../../src/channels/binop.ts"],"sourcesContent":["import { EmptyChannelError } from \"../errors.js\";\nimport { BaseChannel } from \"./base.js\";\n\nexport type BinaryOperator<ValueType, UpdateType> = (\n  a: ValueType,\n  b: UpdateType\n) => ValueType;\n\n/**\n * Stores the result of applying a binary operator to the current value and each new value.\n */\nexport class BinaryOperatorAggregate<\n  ValueType,\n  UpdateType = ValueType\n> extends BaseChannel<ValueType, UpdateType, ValueType> {\n  lc_graph_name = \"BinaryOperatorAggregate\";\n\n  value: ValueType | undefined;\n\n  operator: BinaryOperator<ValueType, UpdateType>;\n\n  initialValueFactory?: () => ValueType;\n\n  constructor(\n    operator: BinaryOperator<ValueType, UpdateType>,\n    initialValueFactory?: () => ValueType\n  ) {\n    super();\n\n    this.operator = operator;\n    this.initialValueFactory = initialValueFactory;\n    this.value = initialValueFactory?.();\n  }\n\n  public fromCheckpoint(checkpoint?: ValueType) {\n    const empty = new BinaryOperatorAggregate(\n      this.operator,\n      this.initialValueFactory\n    );\n    if (typeof checkpoint !== \"undefined\") {\n      empty.value = checkpoint;\n    }\n    return empty as this;\n  }\n\n  public update(values: UpdateType[]): boolean {\n    let newValues = values;\n    if (!newValues.length) return false;\n\n    if (this.value === undefined) {\n      [this.value as UpdateType] = newValues;\n      newValues = newValues.slice(1);\n    }\n\n    for (const value of newValues) {\n      if (this.value !== undefined) {\n        this.value = this.operator(this.value, value);\n      }\n    }\n    return true;\n  }\n\n  public get(): ValueType {\n    if (this.value === undefined) {\n      throw new EmptyChannelError();\n    }\n    return this.value;\n  }\n\n  public checkpoint(): ValueType {\n    if (this.value === undefined) {\n      throw new EmptyChannelError();\n    }\n    return this.value;\n  }\n\n  isAvailable(): boolean {\n    return this.value !== undefined;\n  }\n}\n"],"mappings":";;;;;;;AAWA,IAAa,0BAAb,MAAa,gCAGH,YAA8C;CACtD,gBAAgB;CAEhB;CAEA;CAEA;CAEA,YACE,UACA,qBACA;AACA,SAAO;AAEP,OAAK,WAAW;AAChB,OAAK,sBAAsB;AAC3B,OAAK,QAAQ,uBAAuB;;CAGtC,AAAO,eAAe,YAAwB;EAC5C,MAAM,QAAQ,IAAI,wBAChB,KAAK,UACL,KAAK,oBACN;AACD,MAAI,OAAO,eAAe,YACxB,OAAM,QAAQ;AAEhB,SAAO;;CAGT,AAAO,OAAO,QAA+B;EAC3C,IAAI,YAAY;AAChB,MAAI,CAAC,UAAU,OAAQ,QAAO;AAE9B,MAAI,KAAK,UAAU,QAAW;AAC5B,IAAC,KAAK,SAAuB;AAC7B,eAAY,UAAU,MAAM,EAAE;;AAGhC,OAAK,MAAM,SAAS,UAClB,KAAI,KAAK,UAAU,OACjB,MAAK,QAAQ,KAAK,SAAS,KAAK,OAAO,MAAM;AAGjD,SAAO;;CAGT,AAAO,MAAiB;AACtB,MAAI,KAAK,UAAU,OACjB,OAAM,IAAI,mBAAmB;AAE/B,SAAO,KAAK;;CAGd,AAAO,aAAwB;AAC7B,MAAI,KAAK,UAAU,OACjB,OAAM,IAAI,mBAAmB;AAE/B,SAAO,KAAK;;CAGd,cAAuB;AACrB,SAAO,KAAK,UAAU"}
+{"version":3,"file":"binop.js","names":[],"sources":["../../src/channels/binop.ts"],"sourcesContent":["import { EmptyChannelError } from \"../errors.js\";\nimport { BaseChannel } from \"./base.js\";\n\nexport type BinaryOperator<ValueType, UpdateType> = (\n  a: ValueType,\n  b: UpdateType\n) => ValueType;\n\nconst isBinaryOperatorAggregate = (\n  value: BaseChannel\n): value is BinaryOperatorAggregate<unknown, unknown> => {\n  return value != null && value.lc_graph_name === \"BinaryOperatorAggregate\";\n};\n\n/**\n * Stores the result of applying a binary operator to the current value and each new value.\n */\nexport class BinaryOperatorAggregate<\n  ValueType,\n  UpdateType = ValueType\n> extends BaseChannel<ValueType, UpdateType, ValueType> {\n  lc_graph_name = \"BinaryOperatorAggregate\";\n\n  value: ValueType | undefined;\n\n  operator: BinaryOperator<ValueType, UpdateType>;\n\n  initialValueFactory?: () => ValueType;\n\n  constructor(\n    operator: BinaryOperator<ValueType, UpdateType>,\n    initialValueFactory?: () => ValueType\n  ) {\n    super();\n\n    this.operator = operator;\n    this.initialValueFactory = initialValueFactory;\n    this.value = initialValueFactory?.();\n  }\n\n  public fromCheckpoint(checkpoint?: ValueType) {\n    const empty = new BinaryOperatorAggregate(\n      this.operator,\n      this.initialValueFactory\n    );\n    if (typeof checkpoint !== \"undefined\") {\n      empty.value = checkpoint;\n    }\n    return empty as this;\n  }\n\n  public update(values: UpdateType[]): boolean {\n    let newValues = values;\n    if (!newValues.length) return false;\n\n    if (this.value === undefined) {\n      [this.value as UpdateType] = newValues;\n      newValues = newValues.slice(1);\n    }\n\n    for (const value of newValues) {\n      if (this.value !== undefined) {\n        this.value = this.operator(this.value, value);\n      }\n    }\n    return true;\n  }\n\n  public get(): ValueType {\n    if (this.value === undefined) {\n      throw new EmptyChannelError();\n    }\n    return this.value;\n  }\n\n  public checkpoint(): ValueType {\n    if (this.value === undefined) {\n      throw new EmptyChannelError();\n    }\n    return this.value;\n  }\n\n  isAvailable(): boolean {\n    return this.value !== undefined;\n  }\n\n  /**\n   * Compare this channel with another channel for equality.\n   * Two BinaryOperatorAggregate channels are equal if they have the same operator function.\n   * This follows the Python implementation which compares operator references.\n   */\n  equals(other: BaseChannel): boolean {\n    if (this === other) return true;\n    if (!isBinaryOperatorAggregate(other)) return false;\n    return this.operator === other.operator;\n  }\n}\n"],"mappings":";;;;AAQA,MAAM,6BACJ,UACuD;AACvD,QAAO,SAAS,QAAQ,MAAM,kBAAkB;;;;;AAMlD,IAAa,0BAAb,MAAa,gCAGH,YAA8C;CACtD,gBAAgB;CAEhB;CAEA;CAEA;CAEA,YACE,UACA,qBACA;AACA,SAAO;AAEP,OAAK,WAAW;AAChB,OAAK,sBAAsB;AAC3B,OAAK,QAAQ,uBAAuB;;CAGtC,AAAO,eAAe,YAAwB;EAC5C,MAAM,QAAQ,IAAI,wBAChB,KAAK,UACL,KAAK,oBACN;AACD,MAAI,OAAO,eAAe,YACxB,OAAM,QAAQ;AAEhB,SAAO;;CAGT,AAAO,OAAO,QAA+B;EAC3C,IAAI,YAAY;AAChB,MAAI,CAAC,UAAU,OAAQ,QAAO;AAE9B,MAAI,KAAK,UAAU,QAAW;AAC5B,IAAC,KAAK,SAAuB;AAC7B,eAAY,UAAU,MAAM,EAAE;;AAGhC,OAAK,MAAM,SAAS,UAClB,KAAI,KAAK,UAAU,OACjB,MAAK,QAAQ,KAAK,SAAS,KAAK,OAAO,MAAM;AAGjD,SAAO;;CAGT,AAAO,MAAiB;AACtB,MAAI,KAAK,UAAU,OACjB,OAAM,IAAI,mBAAmB;AAE/B,SAAO,KAAK;;CAGd,AAAO,aAAwB;AAC7B,MAAI,KAAK,UAAU,OACjB,OAAM,IAAI,mBAAmB;AAE/B,SAAO,KAAK;;CAGd,cAAuB;AACrB,SAAO,KAAK,UAAU;;;;;;;CAQxB,OAAO,OAA6B;AAClC,MAAI,SAAS,MAAO,QAAO;AAC3B,MAAI,CAAC,0BAA0B,MAAM,CAAE,QAAO;AAC9C,SAAO,KAAK,aAAa,MAAM"}

package/dist/channels/index.cjs

@@ -6,6 +6,7 @@ const require_ephemeral_value = require('./ephemeral_value.cjs');
 const require_named_barrier_value = require('./named_barrier_value.cjs');
 const require_any_value = require('./any_value.cjs');
 const require_dynamic_barrier_value = require('./dynamic_barrier_value.cjs');
+const require_untracked_value = require('./untracked_value.cjs');
 
 exports.AnyValue = require_any_value.AnyValue;
 exports.BaseChannel = require_base.BaseChannel;
@@ -17,5 +18,6 @@ exports.LastValueAfterFinish = require_last_value.LastValueAfterFinish;
 exports.NamedBarrierValue = require_named_barrier_value.NamedBarrierValue;
 exports.NamedBarrierValueAfterFinish = require_named_barrier_value.NamedBarrierValueAfterFinish;
 exports.Topic = require_topic.Topic;
+exports.UntrackedValueChannel = require_untracked_value.UntrackedValueChannel;
 exports.createCheckpoint = require_base.createCheckpoint;
 exports.empty = require_base.emptyChannels;

package/dist/channels/index.d.cts

@@ -6,4 +6,5 @@ import { DynamicBarrierValue, WaitForNames } from "./dynamic_barrier_value.cjs";
 import { EphemeralValue } from "./ephemeral_value.cjs";
 import { NamedBarrierValue, NamedBarrierValueAfterFinish } from "./named_barrier_value.cjs";
 import { Topic } from "./topic.cjs";
-export { AnyValue, BaseChannel, type BinaryOperator, BinaryOperatorAggregate, DynamicBarrierValue, EphemeralValue, LastValue, LastValueAfterFinish, NamedBarrierValue, NamedBarrierValueAfterFinish, Topic, type WaitForNames, createCheckpoint, emptyChannels as empty };
+import { UntrackedValueChannel } from "./untracked_value.cjs";
+export { AnyValue, BaseChannel, type BinaryOperator, BinaryOperatorAggregate, DynamicBarrierValue, EphemeralValue, LastValue, LastValueAfterFinish, NamedBarrierValue, NamedBarrierValueAfterFinish, Topic, UntrackedValueChannel, type WaitForNames, createCheckpoint, emptyChannels as empty };

package/dist/channels/index.d.ts

@@ -6,4 +6,5 @@ import { DynamicBarrierValue, WaitForNames } from "./dynamic_barrier_value.js";
 import { EphemeralValue } from "./ephemeral_value.js";
 import { NamedBarrierValue, NamedBarrierValueAfterFinish } from "./named_barrier_value.js";
 import { Topic } from "./topic.js";
-export { AnyValue, BaseChannel, type BinaryOperator, BinaryOperatorAggregate, DynamicBarrierValue, EphemeralValue, LastValue, LastValueAfterFinish, NamedBarrierValue, NamedBarrierValueAfterFinish, Topic, type WaitForNames, createCheckpoint, emptyChannels as empty };
+import { UntrackedValueChannel } from "./untracked_value.js";
+export { AnyValue, BaseChannel, type BinaryOperator, BinaryOperatorAggregate, DynamicBarrierValue, EphemeralValue, LastValue, LastValueAfterFinish, NamedBarrierValue, NamedBarrierValueAfterFinish, Topic, UntrackedValueChannel, type WaitForNames, createCheckpoint, emptyChannels as empty };

package/dist/channels/index.js

@@ -6,5 +6,6 @@ import { EphemeralValue } from "./ephemeral_value.js";
 import { NamedBarrierValue, NamedBarrierValueAfterFinish } from "./named_barrier_value.js";
 import { AnyValue } from "./any_value.js";
 import { DynamicBarrierValue } from "./dynamic_barrier_value.js";
+import { UntrackedValueChannel } from "./untracked_value.js";
 
-export { AnyValue, BaseChannel, BinaryOperatorAggregate, DynamicBarrierValue, EphemeralValue, LastValue, LastValueAfterFinish, NamedBarrierValue, NamedBarrierValueAfterFinish, Topic, createCheckpoint, emptyChannels as empty };
+export { AnyValue, BaseChannel, BinaryOperatorAggregate, DynamicBarrierValue, EphemeralValue, LastValue, LastValueAfterFinish, NamedBarrierValue, NamedBarrierValueAfterFinish, Topic, UntrackedValueChannel, createCheckpoint, emptyChannels as empty };

package/dist/channels/untracked_value.cjs

@@ -0,0 +1,83 @@
+const require_errors = require('../errors.cjs');
+const require_base = require('./base.cjs');
+
+//#region src/channels/untracked_value.ts
+const MISSING = Symbol.for("langgraph.channel.missing");
+/**
+* Stores the last value received, never checkpointed.
+*
+* This channel stores values during graph execution but does NOT persist
+* the value to checkpoints. On restoration from a checkpoint, the value
+* will be reset to empty (or the initial value if provided).
+*
+* Useful for transient state like:
+* - Database connections
+* - Temporary caches
+* - Runtime-only configuration
+*
+* @internal
+*/
+var UntrackedValueChannel = class UntrackedValueChannel extends require_base.BaseChannel {
+	lc_graph_name = "UntrackedValue";
+	/**
+	* If true, throws an error when multiple values are received in a single step.
+	* If false, stores the last value received.
+	*/
+	guard;
+	/**
+	* The current value. MISSING sentinel indicates no value has been set.
+	*/
+	_value = MISSING;
+	/**
+	* Optional factory function for the initial value.
+	*/
+	initialValueFactory;
+	constructor(options) {
+		super();
+		this.guard = options?.guard ?? true;
+		this.initialValueFactory = options?.initialValueFactory;
+		if (this.initialValueFactory) this._value = this.initialValueFactory();
+	}
+	/**
+	* Return a new channel, ignoring the checkpoint since we don't persist.
+	* The initial value (if any) is restored.
+	*/
+	fromCheckpoint(_checkpoint) {
+		return new UntrackedValueChannel({
+			guard: this.guard,
+			initialValueFactory: this.initialValueFactory
+		});
+	}
+	/**
+	* Update the channel with the given values.
+	* If guard is true, throws if more than one value is received.
+	*/
+	update(values) {
+		if (values.length === 0) return false;
+		if (values.length !== 1 && this.guard) throw new require_errors.InvalidUpdateError("UntrackedValue(guard=true) can receive only one value per step. Use guard=false if you want to store any one of multiple values.", { lc_error_code: "INVALID_CONCURRENT_GRAPH_UPDATE" });
+		this._value = values[values.length - 1];
+		return true;
+	}
+	/**
+	* Get the current value.
+	* @throws EmptyChannelError if no value has been set.
+	*/
+	get() {
+		if (this._value === MISSING) throw new require_errors.EmptyChannelError();
+		return this._value;
+	}
+	/**
+	* Always returns undefined - untracked values are never checkpointed.
+	*/
+	checkpoint() {}
+	/**
+	* Return true if a value has been set.
+	*/
+	isAvailable() {
+		return this._value !== MISSING;
+	}
+};
+
+//#endregion
+exports.UntrackedValueChannel = UntrackedValueChannel;
+//# sourceMappingURL=untracked_value.cjs.map

package/dist/channels/untracked_value.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"untracked_value.cjs","names":["BaseChannel","InvalidUpdateError","EmptyChannelError"],"sources":["../../src/channels/untracked_value.ts"],"sourcesContent":["import { EmptyChannelError, InvalidUpdateError } from \"../errors.js\";\nimport { BaseChannel } from \"./base.js\";\n\n// Sentinel value for missing/unset\nconst MISSING = Symbol.for(\"langgraph.channel.missing\");\n\n/**\n * Stores the last value received, never checkpointed.\n *\n * This channel stores values during graph execution but does NOT persist\n * the value to checkpoints. On restoration from a checkpoint, the value\n * will be reset to empty (or the initial value if provided).\n *\n * Useful for transient state like:\n * - Database connections\n * - Temporary caches\n * - Runtime-only configuration\n *\n * @internal\n */\nexport class UntrackedValueChannel<Value> extends BaseChannel<\n  Value,\n  Value,\n  undefined\n> {\n  lc_graph_name = \"UntrackedValue\";\n\n  /**\n   * If true, throws an error when multiple values are received in a single step.\n   * If false, stores the last value received.\n   */\n  guard: boolean;\n\n  /**\n   * The current value. MISSING sentinel indicates no value has been set.\n   */\n  private _value: Value | typeof MISSING = MISSING;\n\n  /**\n   * Optional factory function for the initial value.\n   */\n  private initialValueFactory?: () => Value;\n\n  constructor(options?: {\n    guard?: boolean;\n    initialValueFactory?: () => Value;\n  }) {\n    super();\n    this.guard = options?.guard ?? true;\n    this.initialValueFactory = options?.initialValueFactory;\n    if (this.initialValueFactory) {\n      this._value = this.initialValueFactory();\n    }\n  }\n\n  /**\n   * Return a new channel, ignoring the checkpoint since we don't persist.\n   * The initial value (if any) is restored.\n   */\n  fromCheckpoint(_checkpoint?: undefined): this {\n    const empty = new UntrackedValueChannel<Value>({\n      guard: this.guard,\n      initialValueFactory: this.initialValueFactory,\n    });\n    return empty as this;\n  }\n\n  /**\n   * Update the channel with the given values.\n   * If guard is true, throws if more than one value is received.\n   */\n  update(values: Value[]): boolean {\n    if (values.length === 0) {\n      return false;\n    }\n\n    if (values.length !== 1 && this.guard) {\n      throw new InvalidUpdateError(\n        \"UntrackedValue(guard=true) can receive only one value per step. \" +\n          \"Use guard=false if you want to store any one of multiple values.\",\n        { lc_error_code: \"INVALID_CONCURRENT_GRAPH_UPDATE\" }\n      );\n    }\n\n    this._value = values[values.length - 1];\n    return true;\n  }\n\n  /**\n   * Get the current value.\n   * @throws EmptyChannelError if no value has been set.\n   */\n  get(): Value {\n    if (this._value === MISSING) {\n      throw new EmptyChannelError();\n    }\n    return this._value;\n  }\n\n  /**\n   * Always returns undefined - untracked values are never checkpointed.\n   */\n  checkpoint(): undefined {\n    return undefined;\n  }\n\n  /**\n   * Return true if a value has been set.\n   */\n  isAvailable(): boolean {\n    return this._value !== MISSING;\n  }\n}\n"],"mappings":";;;;AAIA,MAAM,UAAU,OAAO,IAAI,4BAA4B;;;;;;;;;;;;;;;AAgBvD,IAAa,wBAAb,MAAa,8BAAqCA,yBAIhD;CACA,gBAAgB;;;;;CAMhB;;;;CAKA,AAAQ,SAAiC;;;;CAKzC,AAAQ;CAER,YAAY,SAGT;AACD,SAAO;AACP,OAAK,QAAQ,SAAS,SAAS;AAC/B,OAAK,sBAAsB,SAAS;AACpC,MAAI,KAAK,oBACP,MAAK,SAAS,KAAK,qBAAqB;;;;;;CAQ5C,eAAe,aAA+B;AAK5C,SAJc,IAAI,sBAA6B;GAC7C,OAAO,KAAK;GACZ,qBAAqB,KAAK;GAC3B,CAAC;;;;;;CAQJ,OAAO,QAA0B;AAC/B,MAAI,OAAO,WAAW,EACpB,QAAO;AAGT,MAAI,OAAO,WAAW,KAAK,KAAK,MAC9B,OAAM,IAAIC,kCACR,oIAEA,EAAE,eAAe,mCAAmC,CACrD;AAGH,OAAK,SAAS,OAAO,OAAO,SAAS;AACrC,SAAO;;;;;;CAOT,MAAa;AACX,MAAI,KAAK,WAAW,QAClB,OAAM,IAAIC,kCAAmB;AAE/B,SAAO,KAAK;;;;;CAMd,aAAwB;;;;CAOxB,cAAuB;AACrB,SAAO,KAAK,WAAW"}

package/dist/channels/untracked_value.d.cts

@@ -0,0 +1,64 @@
+import { BaseChannel } from "./base.cjs";
+
+//#region src/channels/untracked_value.d.ts
+
+/**
+ * Stores the last value received, never checkpointed.
+ *
+ * This channel stores values during graph execution but does NOT persist
+ * the value to checkpoints. On restoration from a checkpoint, the value
+ * will be reset to empty (or the initial value if provided).
+ *
+ * Useful for transient state like:
+ * - Database connections
+ * - Temporary caches
+ * - Runtime-only configuration
+ *
+ * @internal
+ */
+declare class UntrackedValueChannel<Value> extends BaseChannel<Value, Value, undefined> {
+  lc_graph_name: string;
+  /**
+   * If true, throws an error when multiple values are received in a single step.
+   * If false, stores the last value received.
+   */
+  guard: boolean;
+  /**
+   * The current value. MISSING sentinel indicates no value has been set.
+   */
+  private _value;
+  /**
+   * Optional factory function for the initial value.
+   */
+  private initialValueFactory?;
+  constructor(options?: {
+    guard?: boolean;
+    initialValueFactory?: () => Value;
+  });
+  /**
+   * Return a new channel, ignoring the checkpoint since we don't persist.
+   * The initial value (if any) is restored.
+   */
+  fromCheckpoint(_checkpoint?: undefined): this;
+  /**
+   * Update the channel with the given values.
+   * If guard is true, throws if more than one value is received.
+   */
+  update(values: Value[]): boolean;
+  /**
+   * Get the current value.
+   * @throws EmptyChannelError if no value has been set.
+   */
+  get(): Value;
+  /**
+   * Always returns undefined - untracked values are never checkpointed.
+   */
+  checkpoint(): undefined;
+  /**
+   * Return true if a value has been set.
+   */
+  isAvailable(): boolean;
+}
+//#endregion
+export { UntrackedValueChannel };
+//# sourceMappingURL=untracked_value.d.cts.map

package/dist/channels/untracked_value.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"untracked_value.d.cts","names":["BaseChannel","UntrackedValueChannel","Value"],"sources":["../../src/channels/untracked_value.d.ts"],"sourcesContent":["import { BaseChannel } from \"./base.js\";\n/**\n * Stores the last value received, never checkpointed.\n *\n * This channel stores values during graph execution but does NOT persist\n * the value to checkpoints. On restoration from a checkpoint, the value\n * will be reset to empty (or the initial value if provided).\n *\n * Useful for transient state like:\n * - Database connections\n * - Temporary caches\n * - Runtime-only configuration\n *\n * @internal\n */\nexport declare class UntrackedValueChannel<Value> extends BaseChannel<Value, Value, undefined> {\n    lc_graph_name: string;\n    /**\n     * If true, throws an error when multiple values are received in a single step.\n     * If false, stores the last value received.\n     */\n    guard: boolean;\n    /**\n     * The current value. MISSING sentinel indicates no value has been set.\n     */\n    private _value;\n    /**\n     * Optional factory function for the initial value.\n     */\n    private initialValueFactory?;\n    constructor(options?: {\n        guard?: boolean;\n        initialValueFactory?: () => Value;\n    });\n    /**\n     * Return a new channel, ignoring the checkpoint since we don't persist.\n     * The initial value (if any) is restored.\n     */\n    fromCheckpoint(_checkpoint?: undefined): this;\n    /**\n     * Update the channel with the given values.\n     * If guard is true, throws if more than one value is received.\n     */\n    update(values: Value[]): boolean;\n    /**\n     * Get the current value.\n     * @throws EmptyChannelError if no value has been set.\n     */\n    get(): Value;\n    /**\n     * Always returns undefined - untracked values are never checkpointed.\n     */\n    checkpoint(): undefined;\n    /**\n     * Return true if a value has been set.\n     */\n    isAvailable(): boolean;\n}\n"],"mappings":";;;;;;AAeA;;;;;;;;;;;;cAAqBC,qCAAqCD,YAAYE,OAAOA;;;;;;;;;;;;;;;;;gCAiBzCA;;;;;;;;;;;iBAWjBA;;;;;SAKRA"}

package/dist/channels/untracked_value.d.ts

@@ -0,0 +1,64 @@
+import { BaseChannel } from "./base.js";
+
+//#region src/channels/untracked_value.d.ts
+
+/**
+ * Stores the last value received, never checkpointed.
+ *
+ * This channel stores values during graph execution but does NOT persist
+ * the value to checkpoints. On restoration from a checkpoint, the value
+ * will be reset to empty (or the initial value if provided).
+ *
+ * Useful for transient state like:
+ * - Database connections
+ * - Temporary caches
+ * - Runtime-only configuration
+ *
+ * @internal
+ */
+declare class UntrackedValueChannel<Value> extends BaseChannel<Value, Value, undefined> {
+  lc_graph_name: string;
+  /**
+   * If true, throws an error when multiple values are received in a single step.
+   * If false, stores the last value received.
+   */
+  guard: boolean;
+  /**
+   * The current value. MISSING sentinel indicates no value has been set.
+   */
+  private _value;
+  /**
+   * Optional factory function for the initial value.
+   */
+  private initialValueFactory?;
+  constructor(options?: {
+    guard?: boolean;
+    initialValueFactory?: () => Value;
+  });
+  /**
+   * Return a new channel, ignoring the checkpoint since we don't persist.
+   * The initial value (if any) is restored.
+   */
+  fromCheckpoint(_checkpoint?: undefined): this;
+  /**
+   * Update the channel with the given values.
+   * If guard is true, throws if more than one value is received.
+   */
+  update(values: Value[]): boolean;
+  /**
+   * Get the current value.
+   * @throws EmptyChannelError if no value has been set.
+   */
+  get(): Value;
+  /**
+   * Always returns undefined - untracked values are never checkpointed.
+   */
+  checkpoint(): undefined;
+  /**
+   * Return true if a value has been set.
+   */
+  isAvailable(): boolean;
+}
+//#endregion
+export { UntrackedValueChannel };
+//# sourceMappingURL=untracked_value.d.ts.map

package/dist/channels/untracked_value.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"untracked_value.d.ts","names":["BaseChannel","UntrackedValueChannel","Value"],"sources":["../../src/channels/untracked_value.d.ts"],"sourcesContent":["import { BaseChannel } from \"./base.js\";\n/**\n * Stores the last value received, never checkpointed.\n *\n * This channel stores values during graph execution but does NOT persist\n * the value to checkpoints. On restoration from a checkpoint, the value\n * will be reset to empty (or the initial value if provided).\n *\n * Useful for transient state like:\n * - Database connections\n * - Temporary caches\n * - Runtime-only configuration\n *\n * @internal\n */\nexport declare class UntrackedValueChannel<Value> extends BaseChannel<Value, Value, undefined> {\n    lc_graph_name: string;\n    /**\n     * If true, throws an error when multiple values are received in a single step.\n     * If false, stores the last value received.\n     */\n    guard: boolean;\n    /**\n     * The current value. MISSING sentinel indicates no value has been set.\n     */\n    private _value;\n    /**\n     * Optional factory function for the initial value.\n     */\n    private initialValueFactory?;\n    constructor(options?: {\n        guard?: boolean;\n        initialValueFactory?: () => Value;\n    });\n    /**\n     * Return a new channel, ignoring the checkpoint since we don't persist.\n     * The initial value (if any) is restored.\n     */\n    fromCheckpoint(_checkpoint?: undefined): this;\n    /**\n     * Update the channel with the given values.\n     * If guard is true, throws if more than one value is received.\n     */\n    update(values: Value[]): boolean;\n    /**\n     * Get the current value.\n     * @throws EmptyChannelError if no value has been set.\n     */\n    get(): Value;\n    /**\n     * Always returns undefined - untracked values are never checkpointed.\n     */\n    checkpoint(): undefined;\n    /**\n     * Return true if a value has been set.\n     */\n    isAvailable(): boolean;\n}\n"],"mappings":";;;;;;AAeA;;;;;;;;;;;;cAAqBC,qCAAqCD,YAAYE,OAAOA;;;;;;;;;;;;;;;;;gCAiBzCA;;;;;;;;;;;iBAWjBA;;;;;SAKRA"}