@langchain/core 0.3.72 → 1.0.0-alpha.2

package/dist/runnables/branch.cjs

@@ -1,207 +1,153 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RunnableBranch = void 0;
-const base_js_1 = require("./base.cjs");
-const config_js_1 = require("./config.cjs");
-const stream_js_1 = require("../utils/stream.cjs");
+const require_config = require('./config.cjs');
+const require_utils_stream = require('../utils/stream.cjs');
+const require_base = require('./base.cjs');
+
+//#region src/runnables/branch.ts
 /**
- * Class that represents a runnable branch. The RunnableBranch is
- * initialized with an array of branches and a default branch. When invoked,
- * it evaluates the condition of each branch in order and executes the
- * corresponding branch if the condition is true. If none of the conditions
- * are true, it executes the default branch.
- * @example
- * ```typescript
- * const branch = RunnableBranch.from([
- *   [
- *     (x: { topic: string; question: string }) =>
- *       x.topic.toLowerCase().includes("anthropic"),
- *     anthropicChain,
- *   ],
- *   [
- *     (x: { topic: string; question: string }) =>
- *       x.topic.toLowerCase().includes("langchain"),
- *     langChainChain,
- *   ],
- *   generalChain,
- * ]);
- *
- * const fullChain = RunnableSequence.from([
- *   {
- *     topic: classificationChain,
- *     question: (input: { question: string }) => input.question,
- *   },
- *   branch,
- * ]);
- *
- * const result = await fullChain.invoke({
- *   question: "how do I use LangChain?",
- * });
- * ```
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-class RunnableBranch extends base_js_1.Runnable {
-    static lc_name() {
-        return "RunnableBranch";
-    }
-    constructor(fields) {
-        super(fields);
-        Object.defineProperty(this, "lc_namespace", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: ["langchain_core", "runnables"]
-        });
-        Object.defineProperty(this, "lc_serializable", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: true
-        });
-        Object.defineProperty(this, "default", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "branches", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.branches = fields.branches;
-        this.default = fields.default;
-    }
-    /**
-     * Convenience method for instantiating a RunnableBranch from
-     * RunnableLikes (objects, functions, or Runnables).
-     *
-     * Each item in the input except for the last one should be a
-     * tuple with two items. The first is a "condition" RunnableLike that
-     * returns "true" if the second RunnableLike in the tuple should run.
-     *
-     * The final item in the input should be a RunnableLike that acts as a
-     * default branch if no other branches match.
-     *
-     * @example
-     * ```ts
-     * import { RunnableBranch } from "@langchain/core/runnables";
-     *
-     * const branch = RunnableBranch.from([
-     *   [(x: number) => x > 0, (x: number) => x + 1],
-     *   [(x: number) => x < 0, (x: number) => x - 1],
-     *   (x: number) => x
-     * ]);
-     * ```
-     * @param branches An array where the every item except the last is a tuple of [condition, runnable]
-     *   pairs. The last item is a default runnable which is invoked if no other condition matches.
-     * @returns A new RunnableBranch.
-     */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    static from(branches) {
-        if (branches.length < 1) {
-            throw new Error("RunnableBranch requires at least one branch");
-        }
-        const branchLikes = branches.slice(0, -1);
-        const coercedBranches = branchLikes.map(([condition, runnable]) => [
-            (0, base_js_1._coerceToRunnable)(condition),
-            (0, base_js_1._coerceToRunnable)(runnable),
-        ]);
-        const defaultBranch = (0, base_js_1._coerceToRunnable)(branches[branches.length - 1]);
-        return new this({
-            branches: coercedBranches,
-            default: defaultBranch,
-        });
-    }
-    async _invoke(input, config, runManager) {
-        let result;
-        for (let i = 0; i < this.branches.length; i += 1) {
-            const [condition, branchRunnable] = this.branches[i];
-            const conditionValue = await condition.invoke(input, (0, config_js_1.patchConfig)(config, {
-                callbacks: runManager?.getChild(`condition:${i + 1}`),
-            }));
-            if (conditionValue) {
-                result = await branchRunnable.invoke(input, (0, config_js_1.patchConfig)(config, {
-                    callbacks: runManager?.getChild(`branch:${i + 1}`),
-                }));
-                break;
-            }
-        }
-        if (!result) {
-            result = await this.default.invoke(input, (0, config_js_1.patchConfig)(config, {
-                callbacks: runManager?.getChild("branch:default"),
-            }));
-        }
-        return result;
-    }
-    async invoke(input, config = {}) {
-        return this._callWithConfig(this._invoke, input, config);
-    }
-    async *_streamIterator(input, config) {
-        const callbackManager_ = await (0, config_js_1.getCallbackManagerForConfig)(config);
-        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), (0, base_js_1._coerceToDict)(input, "input"), config?.runId, undefined, undefined, undefined, config?.runName);
-        let finalOutput;
-        let finalOutputSupported = true;
-        let stream;
-        try {
-            for (let i = 0; i < this.branches.length; i += 1) {
-                const [condition, branchRunnable] = this.branches[i];
-                const conditionValue = await condition.invoke(input, (0, config_js_1.patchConfig)(config, {
-                    callbacks: runManager?.getChild(`condition:${i + 1}`),
-                }));
-                if (conditionValue) {
-                    stream = await branchRunnable.stream(input, (0, config_js_1.patchConfig)(config, {
-                        callbacks: runManager?.getChild(`branch:${i + 1}`),
-                    }));
-                    for await (const chunk of stream) {
-                        yield chunk;
-                        if (finalOutputSupported) {
-                            if (finalOutput === undefined) {
-                                finalOutput = chunk;
-                            }
-                            else {
-                                try {
-                                    finalOutput = (0, stream_js_1.concat)(finalOutput, chunk);
-                                }
-                                catch (e) {
-                                    finalOutput = undefined;
-                                    finalOutputSupported = false;
-                                }
-                            }
-                        }
-                    }
-                    break;
-                }
-            }
-            if (stream === undefined) {
-                stream = await this.default.stream(input, (0, config_js_1.patchConfig)(config, {
-                    callbacks: runManager?.getChild("branch:default"),
-                }));
-                for await (const chunk of stream) {
-                    yield chunk;
-                    if (finalOutputSupported) {
-                        if (finalOutput === undefined) {
-                            finalOutput = chunk;
-                        }
-                        else {
-                            try {
-                                finalOutput = (0, stream_js_1.concat)(finalOutput, chunk);
-                            }
-                            catch (e) {
-                                finalOutput = undefined;
-                                finalOutputSupported = false;
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        catch (e) {
-            await runManager?.handleChainError(e);
-            throw e;
-        }
-        await runManager?.handleChainEnd(finalOutput ?? {});
-    }
-}
+* Class that represents a runnable branch. The RunnableBranch is
+* initialized with an array of branches and a default branch. When invoked,
+* it evaluates the condition of each branch in order and executes the
+* corresponding branch if the condition is true. If none of the conditions
+* are true, it executes the default branch.
+* @example
+* ```typescript
+* const branch = RunnableBranch.from([
+*   [
+*     (x: { topic: string; question: string }) =>
+*       x.topic.toLowerCase().includes("anthropic"),
+*     anthropicChain,
+*   ],
+*   [
+*     (x: { topic: string; question: string }) =>
+*       x.topic.toLowerCase().includes("langchain"),
+*     langChainChain,
+*   ],
+*   generalChain,
+* ]);
+*
+* const fullChain = RunnableSequence.from([
+*   {
+*     topic: classificationChain,
+*     question: (input: { question: string }) => input.question,
+*   },
+*   branch,
+* ]);
+*
+* const result = await fullChain.invoke({
+*   question: "how do I use LangChain?",
+* });
+* ```
+*/
+var RunnableBranch = class extends require_base.Runnable {
+	static lc_name() {
+		return "RunnableBranch";
+	}
+	lc_namespace = ["langchain_core", "runnables"];
+	lc_serializable = true;
+	default;
+	branches;
+	constructor(fields) {
+		super(fields);
+		this.branches = fields.branches;
+		this.default = fields.default;
+	}
+	/**
+	* Convenience method for instantiating a RunnableBranch from
+	* RunnableLikes (objects, functions, or Runnables).
+	*
+	* Each item in the input except for the last one should be a
+	* tuple with two items. The first is a "condition" RunnableLike that
+	* returns "true" if the second RunnableLike in the tuple should run.
+	*
+	* The final item in the input should be a RunnableLike that acts as a
+	* default branch if no other branches match.
+	*
+	* @example
+	* ```ts
+	* import { RunnableBranch } from "@langchain/core/runnables";
+	*
+	* const branch = RunnableBranch.from([
+	*   [(x: number) => x > 0, (x: number) => x + 1],
+	*   [(x: number) => x < 0, (x: number) => x - 1],
+	*   (x: number) => x
+	* ]);
+	* ```
+	* @param branches An array where the every item except the last is a tuple of [condition, runnable]
+	*   pairs. The last item is a default runnable which is invoked if no other condition matches.
+	* @returns A new RunnableBranch.
+	*/
+	static from(branches) {
+		if (branches.length < 1) throw new Error("RunnableBranch requires at least one branch");
+		const branchLikes = branches.slice(0, -1);
+		const coercedBranches = branchLikes.map(([condition, runnable]) => [require_base._coerceToRunnable(condition), require_base._coerceToRunnable(runnable)]);
+		const defaultBranch = require_base._coerceToRunnable(branches[branches.length - 1]);
+		return new this({
+			branches: coercedBranches,
+			default: defaultBranch
+		});
+	}
+	async _invoke(input, config, runManager) {
+		let result;
+		for (let i = 0; i < this.branches.length; i += 1) {
+			const [condition, branchRunnable] = this.branches[i];
+			const conditionValue = await condition.invoke(input, require_config.patchConfig(config, { callbacks: runManager?.getChild(`condition:${i + 1}`) }));
+			if (conditionValue) {
+				result = await branchRunnable.invoke(input, require_config.patchConfig(config, { callbacks: runManager?.getChild(`branch:${i + 1}`) }));
+				break;
+			}
+		}
+		if (!result) result = await this.default.invoke(input, require_config.patchConfig(config, { callbacks: runManager?.getChild("branch:default") }));
+		return result;
+	}
+	async invoke(input, config = {}) {
+		return this._callWithConfig(this._invoke, input, config);
+	}
+	async *_streamIterator(input, config) {
+		const callbackManager_ = await require_config.getCallbackManagerForConfig(config);
+		const runManager = await callbackManager_?.handleChainStart(this.toJSON(), require_base._coerceToDict(input, "input"), config?.runId, void 0, void 0, void 0, config?.runName);
+		let finalOutput;
+		let finalOutputSupported = true;
+		let stream;
+		try {
+			for (let i = 0; i < this.branches.length; i += 1) {
+				const [condition, branchRunnable] = this.branches[i];
+				const conditionValue = await condition.invoke(input, require_config.patchConfig(config, { callbacks: runManager?.getChild(`condition:${i + 1}`) }));
+				if (conditionValue) {
+					stream = await branchRunnable.stream(input, require_config.patchConfig(config, { callbacks: runManager?.getChild(`branch:${i + 1}`) }));
+					for await (const chunk of stream) {
+						yield chunk;
+						if (finalOutputSupported) if (finalOutput === void 0) finalOutput = chunk;
+						else try {
+							finalOutput = require_utils_stream.concat(finalOutput, chunk);
+						} catch (e) {
+							finalOutput = void 0;
+							finalOutputSupported = false;
+						}
+					}
+					break;
+				}
+			}
+			if (stream === void 0) {
+				stream = await this.default.stream(input, require_config.patchConfig(config, { callbacks: runManager?.getChild("branch:default") }));
+				for await (const chunk of stream) {
+					yield chunk;
+					if (finalOutputSupported) if (finalOutput === void 0) finalOutput = chunk;
+					else try {
+						finalOutput = require_utils_stream.concat(finalOutput, chunk);
+					} catch (e) {
+						finalOutput = void 0;
+						finalOutputSupported = false;
+					}
+				}
+			}
+		} catch (e) {
+			await runManager?.handleChainError(e);
+			throw e;
+		}
+		await runManager?.handleChainEnd(finalOutput ?? {});
+	}
+};
+
+//#endregion
 exports.RunnableBranch = RunnableBranch;
+//# sourceMappingURL=branch.cjs.map

package/dist/runnables/branch.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"branch.cjs","names":["Runnable","fields: {\n    branches: Branch<RunInput, RunOutput>[];\n    default: Runnable<RunInput, RunOutput>;\n  }","branches: [\n      ...BranchLike<RunInput, RunOutput>[],\n      RunnableLike<RunInput, RunOutput>\n    ]","coercedBranches: Branch<RunInput, RunOutput>[]","_coerceToRunnable","input: RunInput","config?: Partial<RunnableConfig>","runManager?: CallbackManagerForChainRun","patchConfig","config: RunnableConfig","getCallbackManagerForConfig","_coerceToDict","concat"],"sources":["../../src/runnables/branch.ts"],"sourcesContent":["import {\n  Runnable,\n  RunnableLike,\n  _coerceToDict,\n  _coerceToRunnable,\n} from \"./base.js\";\nimport {\n  RunnableConfig,\n  getCallbackManagerForConfig,\n  patchConfig,\n} from \"./config.js\";\nimport { CallbackManagerForChainRun } from \"../callbacks/manager.js\";\nimport { concat } from \"../utils/stream.js\";\n\n/**\n * Type for a branch in the RunnableBranch. It consists of a condition\n * runnable and a branch runnable. The condition runnable is used to\n * determine whether the branch should be executed, and the branch runnable\n * is executed if the condition is true.\n */\nexport type Branch<RunInput, RunOutput> = [\n  Runnable<RunInput, boolean>,\n  Runnable<RunInput, RunOutput>\n];\n\nexport type BranchLike<RunInput, RunOutput> = [\n  RunnableLike<RunInput, boolean>,\n  RunnableLike<RunInput, RunOutput>\n];\n\n/**\n * Class that represents a runnable branch. The RunnableBranch is\n * initialized with an array of branches and a default branch. When invoked,\n * it evaluates the condition of each branch in order and executes the\n * corresponding branch if the condition is true. If none of the conditions\n * are true, it executes the default branch.\n * @example\n * ```typescript\n * const branch = RunnableBranch.from([\n *   [\n *     (x: { topic: string; question: string }) =>\n *       x.topic.toLowerCase().includes(\"anthropic\"),\n *     anthropicChain,\n *   ],\n *   [\n *     (x: { topic: string; question: string }) =>\n *       x.topic.toLowerCase().includes(\"langchain\"),\n *     langChainChain,\n *   ],\n *   generalChain,\n * ]);\n *\n * const fullChain = RunnableSequence.from([\n *   {\n *     topic: classificationChain,\n *     question: (input: { question: string }) => input.question,\n *   },\n *   branch,\n * ]);\n *\n * const result = await fullChain.invoke({\n *   question: \"how do I use LangChain?\",\n * });\n * ```\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport class RunnableBranch<RunInput = any, RunOutput = any> extends Runnable<\n  RunInput,\n  RunOutput\n> {\n  static lc_name() {\n    return \"RunnableBranch\";\n  }\n\n  lc_namespace = [\"langchain_core\", \"runnables\"];\n\n  lc_serializable = true;\n\n  default: Runnable<RunInput, RunOutput>;\n\n  branches: Branch<RunInput, RunOutput>[];\n\n  constructor(fields: {\n    branches: Branch<RunInput, RunOutput>[];\n    default: Runnable<RunInput, RunOutput>;\n  }) {\n    super(fields);\n    this.branches = fields.branches;\n    this.default = fields.default;\n  }\n\n  /**\n   * Convenience method for instantiating a RunnableBranch from\n   * RunnableLikes (objects, functions, or Runnables).\n   *\n   * Each item in the input except for the last one should be a\n   * tuple with two items. The first is a \"condition\" RunnableLike that\n   * returns \"true\" if the second RunnableLike in the tuple should run.\n   *\n   * The final item in the input should be a RunnableLike that acts as a\n   * default branch if no other branches match.\n   *\n   * @example\n   * ```ts\n   * import { RunnableBranch } from \"@langchain/core/runnables\";\n   *\n   * const branch = RunnableBranch.from([\n   *   [(x: number) => x > 0, (x: number) => x + 1],\n   *   [(x: number) => x < 0, (x: number) => x - 1],\n   *   (x: number) => x\n   * ]);\n   * ```\n   * @param branches An array where the every item except the last is a tuple of [condition, runnable]\n   *   pairs. The last item is a default runnable which is invoked if no other condition matches.\n   * @returns A new RunnableBranch.\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  static from<RunInput = any, RunOutput = any>(\n    branches: [\n      ...BranchLike<RunInput, RunOutput>[],\n      RunnableLike<RunInput, RunOutput>\n    ]\n  ) {\n    if (branches.length < 1) {\n      throw new Error(\"RunnableBranch requires at least one branch\");\n    }\n    const branchLikes = branches.slice(0, -1) as BranchLike<\n      RunInput,\n      RunOutput\n    >[];\n    const coercedBranches: Branch<RunInput, RunOutput>[] = branchLikes.map(\n      ([condition, runnable]) => [\n        _coerceToRunnable(condition),\n        _coerceToRunnable(runnable),\n      ]\n    );\n    const defaultBranch = _coerceToRunnable(\n      branches[branches.length - 1] as RunnableLike<RunInput, RunOutput>\n    );\n    return new this({\n      branches: coercedBranches,\n      default: defaultBranch,\n    });\n  }\n\n  async _invoke(\n    input: RunInput,\n    config?: Partial<RunnableConfig>,\n    runManager?: CallbackManagerForChainRun\n  ): Promise<RunOutput> {\n    let result;\n    for (let i = 0; i < this.branches.length; i += 1) {\n      const [condition, branchRunnable] = this.branches[i];\n      const conditionValue = await condition.invoke(\n        input,\n        patchConfig(config, {\n          callbacks: runManager?.getChild(`condition:${i + 1}`),\n        })\n      );\n      if (conditionValue) {\n        result = await branchRunnable.invoke(\n          input,\n          patchConfig(config, {\n            callbacks: runManager?.getChild(`branch:${i + 1}`),\n          })\n        );\n        break;\n      }\n    }\n    if (!result) {\n      result = await this.default.invoke(\n        input,\n        patchConfig(config, {\n          callbacks: runManager?.getChild(\"branch:default\"),\n        })\n      );\n    }\n    return result;\n  }\n\n  async invoke(\n    input: RunInput,\n    config: RunnableConfig = {}\n  ): Promise<RunOutput> {\n    return this._callWithConfig(this._invoke, input, config);\n  }\n\n  async *_streamIterator(input: RunInput, config?: Partial<RunnableConfig>) {\n    const callbackManager_ = await getCallbackManagerForConfig(config);\n    const runManager = await callbackManager_?.handleChainStart(\n      this.toJSON(),\n      _coerceToDict(input, \"input\"),\n      config?.runId,\n      undefined,\n      undefined,\n      undefined,\n      config?.runName\n    );\n    let finalOutput;\n    let finalOutputSupported = true;\n    let stream;\n    try {\n      for (let i = 0; i < this.branches.length; i += 1) {\n        const [condition, branchRunnable] = this.branches[i];\n        const conditionValue = await condition.invoke(\n          input,\n          patchConfig(config, {\n            callbacks: runManager?.getChild(`condition:${i + 1}`),\n          })\n        );\n        if (conditionValue) {\n          stream = await branchRunnable.stream(\n            input,\n            patchConfig(config, {\n              callbacks: runManager?.getChild(`branch:${i + 1}`),\n            })\n          );\n          for await (const chunk of stream) {\n            yield chunk;\n            if (finalOutputSupported) {\n              if (finalOutput === undefined) {\n                finalOutput = chunk;\n              } else {\n                try {\n                  finalOutput = concat(finalOutput, chunk);\n                } catch (e) {\n                  finalOutput = undefined;\n                  finalOutputSupported = false;\n                }\n              }\n            }\n          }\n          break;\n        }\n      }\n      if (stream === undefined) {\n        stream = await this.default.stream(\n          input,\n          patchConfig(config, {\n            callbacks: runManager?.getChild(\"branch:default\"),\n          })\n        );\n        for await (const chunk of stream) {\n          yield chunk;\n          if (finalOutputSupported) {\n            if (finalOutput === undefined) {\n              finalOutput = chunk;\n            } else {\n              try {\n                finalOutput = concat(finalOutput, chunk as RunOutput);\n              } catch (e) {\n                finalOutput = undefined;\n                finalOutputSupported = false;\n              }\n            }\n          }\n        }\n      }\n    } catch (e) {\n      await runManager?.handleChainError(e);\n      throw e;\n    }\n    await runManager?.handleChainEnd(finalOutput ?? {});\n  }\n}\n"],"mappings":"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"}

package/dist/runnables/branch.d.cts

@@ -0,0 +1,94 @@
+import { CallbackManagerForChainRun } from "../callbacks/manager.cjs";
+import { RunnableConfig } from "./types.cjs";
+import { Runnable, RunnableLike } from "./base.cjs";
+
+//#region src/runnables/branch.d.ts
+
+/**
+ * Type for a branch in the RunnableBranch. It consists of a condition
+ * runnable and a branch runnable. The condition runnable is used to
+ * determine whether the branch should be executed, and the branch runnable
+ * is executed if the condition is true.
+ */
+type Branch<RunInput, RunOutput> = [Runnable<RunInput, boolean>, Runnable<RunInput, RunOutput>];
+type BranchLike<RunInput, RunOutput> = [RunnableLike<RunInput, boolean>, RunnableLike<RunInput, RunOutput>];
+/**
+ * Class that represents a runnable branch. The RunnableBranch is
+ * initialized with an array of branches and a default branch. When invoked,
+ * it evaluates the condition of each branch in order and executes the
+ * corresponding branch if the condition is true. If none of the conditions
+ * are true, it executes the default branch.
+ * @example
+ * ```typescript
+ * const branch = RunnableBranch.from([
+ *   [
+ *     (x: { topic: string; question: string }) =>
+ *       x.topic.toLowerCase().includes("anthropic"),
+ *     anthropicChain,
+ *   ],
+ *   [
+ *     (x: { topic: string; question: string }) =>
+ *       x.topic.toLowerCase().includes("langchain"),
+ *     langChainChain,
+ *   ],
+ *   generalChain,
+ * ]);
+ *
+ * const fullChain = RunnableSequence.from([
+ *   {
+ *     topic: classificationChain,
+ *     question: (input: { question: string }) => input.question,
+ *   },
+ *   branch,
+ * ]);
+ *
+ * const result = await fullChain.invoke({
+ *   question: "how do I use LangChain?",
+ * });
+ * ```
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+declare class RunnableBranch<RunInput = any, RunOutput = any> extends Runnable<RunInput, RunOutput> {
+  static lc_name(): string;
+  lc_namespace: string[];
+  lc_serializable: boolean;
+  default: Runnable<RunInput, RunOutput>;
+  branches: Branch<RunInput, RunOutput>[];
+  constructor(fields: {
+    branches: Branch<RunInput, RunOutput>[];
+    default: Runnable<RunInput, RunOutput>;
+  });
+  /**
+   * Convenience method for instantiating a RunnableBranch from
+   * RunnableLikes (objects, functions, or Runnables).
+   *
+   * Each item in the input except for the last one should be a
+   * tuple with two items. The first is a "condition" RunnableLike that
+   * returns "true" if the second RunnableLike in the tuple should run.
+   *
+   * The final item in the input should be a RunnableLike that acts as a
+   * default branch if no other branches match.
+   *
+   * @example
+   * ```ts
+   * import { RunnableBranch } from "@langchain/core/runnables";
+   *
+   * const branch = RunnableBranch.from([
+   *   [(x: number) => x > 0, (x: number) => x + 1],
+   *   [(x: number) => x < 0, (x: number) => x - 1],
+   *   (x: number) => x
+   * ]);
+   * ```
+   * @param branches An array where the every item except the last is a tuple of [condition, runnable]
+   *   pairs. The last item is a default runnable which is invoked if no other condition matches.
+   * @returns A new RunnableBranch.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static from<RunInput = any, RunOutput = any>(branches: [...BranchLike<RunInput, RunOutput>[], RunnableLike<RunInput, RunOutput>]): RunnableBranch<RunInput, RunOutput>;
+  _invoke(input: RunInput, config?: Partial<RunnableConfig>, runManager?: CallbackManagerForChainRun): Promise<RunOutput>;
+  invoke(input: RunInput, config?: RunnableConfig): Promise<RunOutput>;
+  _streamIterator(input: RunInput, config?: Partial<RunnableConfig>): AsyncGenerator<Awaited<RunOutput>, void, unknown>;
+}
+//#endregion
+export { Branch, BranchLike, RunnableBranch };
+//# sourceMappingURL=branch.d.cts.map

package/dist/runnables/branch.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"branch.d.cts","names":["Runnable","RunnableLike","RunnableConfig","CallbackManagerForChainRun","Branch","RunInput","RunOutput","BranchLike","RunnableBranch","Partial","Promise","Awaited","AsyncGenerator"],"sources":["../../src/runnables/branch.d.ts"],"sourcesContent":["import { Runnable, RunnableLike } from \"./base.js\";\nimport { RunnableConfig } from \"./config.js\";\nimport { CallbackManagerForChainRun } from \"../callbacks/manager.js\";\n/**\n * Type for a branch in the RunnableBranch. It consists of a condition\n * runnable and a branch runnable. The condition runnable is used to\n * determine whether the branch should be executed, and the branch runnable\n * is executed if the condition is true.\n */\nexport type Branch<RunInput, RunOutput> = [\n    Runnable<RunInput, boolean>,\n    Runnable<RunInput, RunOutput>\n];\nexport type BranchLike<RunInput, RunOutput> = [\n    RunnableLike<RunInput, boolean>,\n    RunnableLike<RunInput, RunOutput>\n];\n/**\n * Class that represents a runnable branch. The RunnableBranch is\n * initialized with an array of branches and a default branch. When invoked,\n * it evaluates the condition of each branch in order and executes the\n * corresponding branch if the condition is true. If none of the conditions\n * are true, it executes the default branch.\n * @example\n * ```typescript\n * const branch = RunnableBranch.from([\n *   [\n *     (x: { topic: string; question: string }) =>\n *       x.topic.toLowerCase().includes(\"anthropic\"),\n *     anthropicChain,\n *   ],\n *   [\n *     (x: { topic: string; question: string }) =>\n *       x.topic.toLowerCase().includes(\"langchain\"),\n *     langChainChain,\n *   ],\n *   generalChain,\n * ]);\n *\n * const fullChain = RunnableSequence.from([\n *   {\n *     topic: classificationChain,\n *     question: (input: { question: string }) => input.question,\n *   },\n *   branch,\n * ]);\n *\n * const result = await fullChain.invoke({\n *   question: \"how do I use LangChain?\",\n * });\n * ```\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport declare class RunnableBranch<RunInput = any, RunOutput = any> extends Runnable<RunInput, RunOutput> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    default: Runnable<RunInput, RunOutput>;\n    branches: Branch<RunInput, RunOutput>[];\n    constructor(fields: {\n        branches: Branch<RunInput, RunOutput>[];\n        default: Runnable<RunInput, RunOutput>;\n    });\n    /**\n     * Convenience method for instantiating a RunnableBranch from\n     * RunnableLikes (objects, functions, or Runnables).\n     *\n     * Each item in the input except for the last one should be a\n     * tuple with two items. The first is a \"condition\" RunnableLike that\n     * returns \"true\" if the second RunnableLike in the tuple should run.\n     *\n     * The final item in the input should be a RunnableLike that acts as a\n     * default branch if no other branches match.\n     *\n     * @example\n     * ```ts\n     * import { RunnableBranch } from \"@langchain/core/runnables\";\n     *\n     * const branch = RunnableBranch.from([\n     *   [(x: number) => x > 0, (x: number) => x + 1],\n     *   [(x: number) => x < 0, (x: number) => x - 1],\n     *   (x: number) => x\n     * ]);\n     * ```\n     * @param branches An array where the every item except the last is a tuple of [condition, runnable]\n     *   pairs. The last item is a default runnable which is invoked if no other condition matches.\n     * @returns A new RunnableBranch.\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    static from<RunInput = any, RunOutput = any>(branches: [\n        ...BranchLike<RunInput, RunOutput>[],\n        RunnableLike<RunInput, RunOutput>\n    ]): RunnableBranch<RunInput, RunOutput>;\n    _invoke(input: RunInput, config?: Partial<RunnableConfig>, runManager?: CallbackManagerForChainRun): Promise<RunOutput>;\n    invoke(input: RunInput, config?: RunnableConfig): Promise<RunOutput>;\n    _streamIterator(input: RunInput, config?: Partial<RunnableConfig>): AsyncGenerator<Awaited<RunOutput>, void, unknown>;\n}\n"],"mappings":";;;;;;;;AASA;;;;AAEaK,KAFDD,MAECC,CAAAA,QAAAA,EAAAA,SAAAA,CAAAA,GAAAA,CADTL,QACmBM,CADVD,QACUC,EAAAA,OAAAA,CAAAA,EAAnBN,QAAAA,CAASK,QAATL,EAAmBM,SAAnBN,CAAAA,CAAQ;AAEAO,KAAAA,UAAU,CAAA,QAAA,EAAA,SAAA,CAAA,GAAA,CAClBN,YADkB,CACLI,QADK,EAAA,OAAA,CAAA,EAElBJ,YADaI,CACAA,QADAA,EACUC,SADVD,CAAAA,CAAQ;;;;AACT;AAsChB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCqCH,cAzChBM,cAyCgBN,CAAAA,WAAAA,GAAAA,EAAAA,YAAAA,GAAAA,CAAAA,SAzCwCF,QAyCxCE,CAzCiDG,QAyCjDH,EAzC2DI,SAyC3DJ,CAAAA,CAAAA;EAAc,OAAWI,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAS,YAAjBI,EAAAA,MAAAA,EAAAA;EAAO,eAClCL,EAAAA,OAAAA;EAAQ,OAAmBH,EAtCzCF,QAsCyCE,CAtChCG,QAsCgCH,EAtCtBI,SAsCsBJ,CAAAA;EAAc,QAAtBO,EArChCL,MAqCgCK,CArCzBJ,QAqCyBI,EArCfH,SAqCeG,CAAAA,EAAAA;EAAO,WAA0CH,CAAAA,MAAAA,EAAAA;IAARK,QAAAA,EAnCrEP,MAmCqEO,CAnC9DN,QAmC8DM,EAnCpDL,SAmCoDK,CAAAA,EAAAA;IAAfC,OAAAA,EAlCvDZ,QAkCuDY,CAlC9CP,QAkC8CO,EAlCpCN,SAkCoCM,CAAAA;EAAc,CAAA;EA1CD;;;;;;;;;;;;;;;;;;;;;;;;;;6DAqC1EL,WAAWF,UAAUC,cACxBL,aAAaI,UAAUC,cACvBE,eAAeH,UAAUC;iBACdD,mBAAmBI,QAAQP,8BAA8BC,6BAA6BO,QAAQJ;gBAC/FD,mBAAmBH,iBAAiBQ,QAAQJ;yBACnCD,mBAAmBI,QAAQP,kBAAkBU,eAAeD,QAAQL"}

package/dist/runnables/branch.d.ts

@@ -1,20 +1,17 @@
-import { Runnable, RunnableLike } from "./base.js";
-import { RunnableConfig } from "./config.js";
 import { CallbackManagerForChainRun } from "../callbacks/manager.js";
+import { RunnableConfig } from "./types.js";
+import { Runnable, RunnableLike } from "./base.js";
+
+//#region src/runnables/branch.d.ts
+
 /**
  * Type for a branch in the RunnableBranch. It consists of a condition
  * runnable and a branch runnable. The condition runnable is used to
  * determine whether the branch should be executed, and the branch runnable
  * is executed if the condition is true.
  */
-export type Branch<RunInput, RunOutput> = [
-    Runnable<RunInput, boolean>,
-    Runnable<RunInput, RunOutput>
-];
-export type BranchLike<RunInput, RunOutput> = [
-    RunnableLike<RunInput, boolean>,
-    RunnableLike<RunInput, RunOutput>
-];
+type Branch<RunInput, RunOutput> = [Runnable<RunInput, boolean>, Runnable<RunInput, RunOutput>];
+type BranchLike<RunInput, RunOutput> = [RunnableLike<RunInput, boolean>, RunnableLike<RunInput, RunOutput>];
 /**
  * Class that represents a runnable branch. The RunnableBranch is
  * initialized with an array of branches and a default branch. When invoked,
@@ -50,46 +47,48 @@ export type BranchLike<RunInput, RunOutput> = [
  * });
  * ```
  */
-export declare class RunnableBranch<RunInput = any, RunOutput = any> extends Runnable<RunInput, RunOutput> {
-    static lc_name(): string;
-    lc_namespace: string[];
-    lc_serializable: boolean;
-    default: Runnable<RunInput, RunOutput>;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+declare class RunnableBranch<RunInput = any, RunOutput = any> extends Runnable<RunInput, RunOutput> {
+  static lc_name(): string;
+  lc_namespace: string[];
+  lc_serializable: boolean;
+  default: Runnable<RunInput, RunOutput>;
+  branches: Branch<RunInput, RunOutput>[];
+  constructor(fields: {
     branches: Branch<RunInput, RunOutput>[];
-    constructor(fields: {
-        branches: Branch<RunInput, RunOutput>[];
-        default: Runnable<RunInput, RunOutput>;
-    });
-    /**
-     * Convenience method for instantiating a RunnableBranch from
-     * RunnableLikes (objects, functions, or Runnables).
-     *
-     * Each item in the input except for the last one should be a
-     * tuple with two items. The first is a "condition" RunnableLike that
-     * returns "true" if the second RunnableLike in the tuple should run.
-     *
-     * The final item in the input should be a RunnableLike that acts as a
-     * default branch if no other branches match.
-     *
-     * @example
-     * ```ts
-     * import { RunnableBranch } from "@langchain/core/runnables";
-     *
-     * const branch = RunnableBranch.from([
-     *   [(x: number) => x > 0, (x: number) => x + 1],
-     *   [(x: number) => x < 0, (x: number) => x - 1],
-     *   (x: number) => x
-     * ]);
-     * ```
-     * @param branches An array where the every item except the last is a tuple of [condition, runnable]
-     *   pairs. The last item is a default runnable which is invoked if no other condition matches.
-     * @returns A new RunnableBranch.
-     */
-    static from<RunInput = any, RunOutput = any>(branches: [
-        ...BranchLike<RunInput, RunOutput>[],
-        RunnableLike<RunInput, RunOutput>
-    ]): RunnableBranch<RunInput, RunOutput>;
-    _invoke(input: RunInput, config?: Partial<RunnableConfig>, runManager?: CallbackManagerForChainRun): Promise<RunOutput>;
-    invoke(input: RunInput, config?: RunnableConfig): Promise<RunOutput>;
-    _streamIterator(input: RunInput, config?: Partial<RunnableConfig>): AsyncGenerator<Awaited<RunOutput>, void, unknown>;
+    default: Runnable<RunInput, RunOutput>;
+  });
+  /**
+   * Convenience method for instantiating a RunnableBranch from
+   * RunnableLikes (objects, functions, or Runnables).
+   *
+   * Each item in the input except for the last one should be a
+   * tuple with two items. The first is a "condition" RunnableLike that
+   * returns "true" if the second RunnableLike in the tuple should run.
+   *
+   * The final item in the input should be a RunnableLike that acts as a
+   * default branch if no other branches match.
+   *
+   * @example
+   * ```ts
+   * import { RunnableBranch } from "@langchain/core/runnables";
+   *
+   * const branch = RunnableBranch.from([
+   *   [(x: number) => x > 0, (x: number) => x + 1],
+   *   [(x: number) => x < 0, (x: number) => x - 1],
+   *   (x: number) => x
+   * ]);
+   * ```
+   * @param branches An array where the every item except the last is a tuple of [condition, runnable]
+   *   pairs. The last item is a default runnable which is invoked if no other condition matches.
+   * @returns A new RunnableBranch.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static from<RunInput = any, RunOutput = any>(branches: [...BranchLike<RunInput, RunOutput>[], RunnableLike<RunInput, RunOutput>]): RunnableBranch<RunInput, RunOutput>;
+  _invoke(input: RunInput, config?: Partial<RunnableConfig>, runManager?: CallbackManagerForChainRun): Promise<RunOutput>;
+  invoke(input: RunInput, config?: RunnableConfig): Promise<RunOutput>;
+  _streamIterator(input: RunInput, config?: Partial<RunnableConfig>): AsyncGenerator<Awaited<RunOutput>, void, unknown>;
 }
+//#endregion
+export { Branch, BranchLike, RunnableBranch };
+//# sourceMappingURL=branch.d.ts.map

package/dist/runnables/branch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"branch.d.ts","names":["Runnable","RunnableLike","RunnableConfig","CallbackManagerForChainRun","Branch","RunInput","RunOutput","BranchLike","RunnableBranch","Partial","Promise","Awaited","AsyncGenerator"],"sources":["../../src/runnables/branch.d.ts"],"sourcesContent":["import { Runnable, RunnableLike } from \"./base.js\";\nimport { RunnableConfig } from \"./config.js\";\nimport { CallbackManagerForChainRun } from \"../callbacks/manager.js\";\n/**\n * Type for a branch in the RunnableBranch. It consists of a condition\n * runnable and a branch runnable. The condition runnable is used to\n * determine whether the branch should be executed, and the branch runnable\n * is executed if the condition is true.\n */\nexport type Branch<RunInput, RunOutput> = [\n    Runnable<RunInput, boolean>,\n    Runnable<RunInput, RunOutput>\n];\nexport type BranchLike<RunInput, RunOutput> = [\n    RunnableLike<RunInput, boolean>,\n    RunnableLike<RunInput, RunOutput>\n];\n/**\n * Class that represents a runnable branch. The RunnableBranch is\n * initialized with an array of branches and a default branch. When invoked,\n * it evaluates the condition of each branch in order and executes the\n * corresponding branch if the condition is true. If none of the conditions\n * are true, it executes the default branch.\n * @example\n * ```typescript\n * const branch = RunnableBranch.from([\n *   [\n *     (x: { topic: string; question: string }) =>\n *       x.topic.toLowerCase().includes(\"anthropic\"),\n *     anthropicChain,\n *   ],\n *   [\n *     (x: { topic: string; question: string }) =>\n *       x.topic.toLowerCase().includes(\"langchain\"),\n *     langChainChain,\n *   ],\n *   generalChain,\n * ]);\n *\n * const fullChain = RunnableSequence.from([\n *   {\n *     topic: classificationChain,\n *     question: (input: { question: string }) => input.question,\n *   },\n *   branch,\n * ]);\n *\n * const result = await fullChain.invoke({\n *   question: \"how do I use LangChain?\",\n * });\n * ```\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport declare class RunnableBranch<RunInput = any, RunOutput = any> extends Runnable<RunInput, RunOutput> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    default: Runnable<RunInput, RunOutput>;\n    branches: Branch<RunInput, RunOutput>[];\n    constructor(fields: {\n        branches: Branch<RunInput, RunOutput>[];\n        default: Runnable<RunInput, RunOutput>;\n    });\n    /**\n     * Convenience method for instantiating a RunnableBranch from\n     * RunnableLikes (objects, functions, or Runnables).\n     *\n     * Each item in the input except for the last one should be a\n     * tuple with two items. The first is a \"condition\" RunnableLike that\n     * returns \"true\" if the second RunnableLike in the tuple should run.\n     *\n     * The final item in the input should be a RunnableLike that acts as a\n     * default branch if no other branches match.\n     *\n     * @example\n     * ```ts\n     * import { RunnableBranch } from \"@langchain/core/runnables\";\n     *\n     * const branch = RunnableBranch.from([\n     *   [(x: number) => x > 0, (x: number) => x + 1],\n     *   [(x: number) => x < 0, (x: number) => x - 1],\n     *   (x: number) => x\n     * ]);\n     * ```\n     * @param branches An array where the every item except the last is a tuple of [condition, runnable]\n     *   pairs. The last item is a default runnable which is invoked if no other condition matches.\n     * @returns A new RunnableBranch.\n     */\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    static from<RunInput = any, RunOutput = any>(branches: [\n        ...BranchLike<RunInput, RunOutput>[],\n        RunnableLike<RunInput, RunOutput>\n    ]): RunnableBranch<RunInput, RunOutput>;\n    _invoke(input: RunInput, config?: Partial<RunnableConfig>, runManager?: CallbackManagerForChainRun): Promise<RunOutput>;\n    invoke(input: RunInput, config?: RunnableConfig): Promise<RunOutput>;\n    _streamIterator(input: RunInput, config?: Partial<RunnableConfig>): AsyncGenerator<Awaited<RunOutput>, void, unknown>;\n}\n"],"mappings":";;;;;;;;AASA;;;;AAEaK,KAFDD,MAECC,CAAAA,QAAAA,EAAAA,SAAAA,CAAAA,GAAAA,CADTL,QACmBM,CADVD,QACUC,EAAAA,OAAAA,CAAAA,EAAnBN,QAAAA,CAASK,QAATL,EAAmBM,SAAnBN,CAAAA,CAAQ;AAEAO,KAAAA,UAAU,CAAA,QAAA,EAAA,SAAA,CAAA,GAAA,CAClBN,YADkB,CACLI,QADK,EAAA,OAAA,CAAA,EAElBJ,YADaI,CACAA,QADAA,EACUC,SADVD,CAAAA,CAAQ;;;;AACT;AAsChB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCqCH,cAzChBM,cAyCgBN,CAAAA,WAAAA,GAAAA,EAAAA,YAAAA,GAAAA,CAAAA,SAzCwCF,QAyCxCE,CAzCiDG,QAyCjDH,EAzC2DI,SAyC3DJ,CAAAA,CAAAA;EAAc,OAAWI,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAS,YAAjBI,EAAAA,MAAAA,EAAAA;EAAO,eAClCL,EAAAA,OAAAA;EAAQ,OAAmBH,EAtCzCF,QAsCyCE,CAtChCG,QAsCgCH,EAtCtBI,SAsCsBJ,CAAAA;EAAc,QAAtBO,EArChCL,MAqCgCK,CArCzBJ,QAqCyBI,EArCfH,SAqCeG,CAAAA,EAAAA;EAAO,WAA0CH,CAAAA,MAAAA,EAAAA;IAARK,QAAAA,EAnCrEP,MAmCqEO,CAnC9DN,QAmC8DM,EAnCpDL,SAmCoDK,CAAAA,EAAAA;IAAfC,OAAAA,EAlCvDZ,QAkCuDY,CAlC9CP,QAkC8CO,EAlCpCN,SAkCoCM,CAAAA;EAAc,CAAA;EA1CD;;;;;;;;;;;;;;;;;;;;;;;;;;6DAqC1EL,WAAWF,UAAUC,cACxBL,aAAaI,UAAUC,cACvBE,eAAeH,UAAUC;iBACdD,mBAAmBI,QAAQP,8BAA8BC,6BAA6BO,QAAQJ;gBAC/FD,mBAAmBH,iBAAiBQ,QAAQJ;yBACnCD,mBAAmBI,QAAQP,kBAAkBU,eAAeD,QAAQL"}