langchain 0.0.195 → 0.0.196

package/dist/schema/runnable/branch.cjs

@@ -1,134 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RunnableBranch = void 0;
-const base_js_1 = require("./base.cjs");
-/**
- * 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", "runnable", "branch"]
-        });
-        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/schema/runnable";
-     *
-     * 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, this._patchConfig(config, runManager?.getChild(`condition:${i + 1}`)));
-            if (conditionValue) {
-                result = await branchRunnable.invoke(input, this._patchConfig(config, runManager?.getChild(`branch:${i + 1}`)));
-                break;
-            }
-        }
-        if (!result) {
-            result = await this.default.invoke(input, this._patchConfig(config, runManager?.getChild("default")));
-        }
-        return result;
-    }
-    async invoke(input, config = {}) {
-        return this._callWithConfig(this._invoke, input, config);
-    }
-}
-exports.RunnableBranch = RunnableBranch;
+var runnables_1 = require("langchain-core/runnables");
+Object.defineProperty(exports, "RunnableBranch", { enumerable: true, get: function () { return runnables_1.RunnableBranch; } });

package/dist/schema/runnable/branch.d.ts

@@ -1,94 +1 @@
-import { Runnable, RunnableLike } from "./base.js";
-import { RunnableConfig } from "./config.js";
-import { CallbackManagerForChainRun } from "../../callbacks/manager.js";
-/**
- * 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>
-];
-/**
- * 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?",
- * });
- * ```
- */
-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>;
-    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/schema/runnable";
-     *
-     * 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>;
-}
+export { type Branch, type BranchLike, RunnableBranch, } from "langchain-core/runnables";

package/dist/schema/runnable/branch.js

@@ -1,130 +1 @@
-import { Runnable, _coerceToRunnable } from "./base.js";
-/**
- * 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
-export class RunnableBranch extends Runnable {
-    static lc_name() {
-        return "RunnableBranch";
-    }
-    constructor(fields) {
-        super(fields);
-        Object.defineProperty(this, "lc_namespace", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: ["langchain", "runnable", "branch"]
-        });
-        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/schema/runnable";
-     *
-     * 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]) => [
-            _coerceToRunnable(condition),
-            _coerceToRunnable(runnable),
-        ]);
-        const defaultBranch = _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, this._patchConfig(config, runManager?.getChild(`condition:${i + 1}`)));
-            if (conditionValue) {
-                result = await branchRunnable.invoke(input, this._patchConfig(config, runManager?.getChild(`branch:${i + 1}`)));
-                break;
-            }
-        }
-        if (!result) {
-            result = await this.default.invoke(input, this._patchConfig(config, runManager?.getChild("default")));
-        }
-        return result;
-    }
-    async invoke(input, config = {}) {
-        return this._callWithConfig(this._invoke, input, config);
-    }
-}
+export { RunnableBranch, } from "langchain-core/runnables";

package/dist/schema/runnable/config.cjs

@@ -1,8 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getCallbackMangerForConfig = void 0;
-const manager_js_1 = require("../../callbacks/manager.cjs");
-async function getCallbackMangerForConfig(config) {
-    return manager_js_1.CallbackManager.configure(config?.callbacks, undefined, config?.tags, undefined, config?.metadata);
-}
-exports.getCallbackMangerForConfig = getCallbackMangerForConfig;

package/dist/schema/runnable/config.d.ts

@@ -1,3 +1 @@
-import { BaseCallbackConfig, CallbackManager } from "../../callbacks/manager.js";
-export type RunnableConfig = BaseCallbackConfig;
-export declare function getCallbackMangerForConfig(config?: RunnableConfig): Promise<CallbackManager | undefined>;
+export { getCallbackMangerForConfig, RunnableConfig, } from "langchain-core/runnables";

package/dist/schema/runnable/config.js

@@ -1,4 +1 @@
-import { CallbackManager, } from "../../callbacks/manager.js";
-export async function getCallbackMangerForConfig(config) {
-    return CallbackManager.configure(config?.callbacks, undefined, config?.tags, undefined, config?.metadata);
-}
+export {};

package/dist/schema/runnable/index.cjs

@@ -1,18 +1,17 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RunnableBranch = exports.RouterRunnable = exports.RunnablePassthrough = exports.RunnableWithFallbacks = exports.RunnableLambda = exports.RunnableMap = exports.RunnableSequence = exports.RunnableRetry = exports.RunnableEach = exports.RunnableBinding = exports.Runnable = void 0;
-var base_js_1 = require("./base.cjs");
-Object.defineProperty(exports, "Runnable", { enumerable: true, get: function () { return base_js_1.Runnable; } });
-Object.defineProperty(exports, "RunnableBinding", { enumerable: true, get: function () { return base_js_1.RunnableBinding; } });
-Object.defineProperty(exports, "RunnableEach", { enumerable: true, get: function () { return base_js_1.RunnableEach; } });
-Object.defineProperty(exports, "RunnableRetry", { enumerable: true, get: function () { return base_js_1.RunnableRetry; } });
-Object.defineProperty(exports, "RunnableSequence", { enumerable: true, get: function () { return base_js_1.RunnableSequence; } });
-Object.defineProperty(exports, "RunnableMap", { enumerable: true, get: function () { return base_js_1.RunnableMap; } });
-Object.defineProperty(exports, "RunnableLambda", { enumerable: true, get: function () { return base_js_1.RunnableLambda; } });
-Object.defineProperty(exports, "RunnableWithFallbacks", { enumerable: true, get: function () { return base_js_1.RunnableWithFallbacks; } });
-var passthrough_js_1 = require("./passthrough.cjs");
-Object.defineProperty(exports, "RunnablePassthrough", { enumerable: true, get: function () { return passthrough_js_1.RunnablePassthrough; } });
-var router_js_1 = require("./router.cjs");
-Object.defineProperty(exports, "RouterRunnable", { enumerable: true, get: function () { return router_js_1.RouterRunnable; } });
-var branch_js_1 = require("./branch.cjs");
-Object.defineProperty(exports, "RunnableBranch", { enumerable: true, get: function () { return branch_js_1.RunnableBranch; } });
+__exportStar(require("langchain-core/runnables"), exports);

package/dist/schema/runnable/index.d.ts

@@ -1,5 +1 @@
-export { type RunnableFunc, type RunnableLike, type RunnableBatchOptions, type RunnableRetryFailedAttemptHandler, Runnable, type RunnableBindingArgs, RunnableBinding, RunnableEach, RunnableRetry, RunnableSequence, RunnableMap, RunnableLambda, RunnableWithFallbacks, } from "./base.js";
-export type { RunnableConfig } from "./config.js";
-export { RunnablePassthrough } from "./passthrough.js";
-export { RouterRunnable } from "./router.js";
-export { RunnableBranch, type Branch, type BranchLike } from "./branch.js";
+export * from "langchain-core/runnables";

package/dist/schema/runnable/index.js

@@ -1,4 +1 @@
-export { Runnable, RunnableBinding, RunnableEach, RunnableRetry, RunnableSequence, RunnableMap, RunnableLambda, RunnableWithFallbacks, } from "./base.js";
-export { RunnablePassthrough } from "./passthrough.js";
-export { RouterRunnable } from "./router.js";
-export { RunnableBranch } from "./branch.js";
+export * from "langchain-core/runnables";

package/dist/schema/runnable/passthrough.cjs

@@ -1,116 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RunnablePassthrough = exports.RunnableAssign = void 0;
-const base_js_1 = require("./base.cjs");
-/**
- * A runnable that assigns key-value pairs to inputs of type `Record<string, unknown>`.
- */
-class RunnableAssign extends base_js_1.Runnable {
-    constructor(mapper) {
-        super();
-        Object.defineProperty(this, "lc_namespace", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: ["langchain", "schema", "runnable"]
-        });
-        Object.defineProperty(this, "mapper", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.mapper = mapper;
-    }
-    async invoke(input, options) {
-        const mapperResult = await this.mapper.invoke(input, options);
-        return {
-            ...input,
-            ...mapperResult,
-        };
-    }
-}
-exports.RunnableAssign = RunnableAssign;
-/**
- * A runnable to passthrough inputs unchanged or with additional keys.
- *
- * This runnable behaves almost like the identity function, except that it
- * can be configured to add additional keys to the output, if the input is
- * an object.
- *
- * The example below demonstrates how to use `RunnablePassthrough to
- * passthrough the input from the `.invoke()`
- *
- * @example
- * ```typescript
- * const chain = RunnableSequence.from([
- *   {
- *     question: new RunnablePassthrough(),
- *     context: async () => loadContextFromStore(),
- *   },
- *   prompt,
- *   llm,
- *   outputParser,
- * ]);
- * const response = await chain.invoke(
- *   "I can pass a single string instead of an object since I'm using `RunnablePassthrough`."
- * );
- * ```
- */
-class RunnablePassthrough extends base_js_1.Runnable {
-    constructor() {
-        super(...arguments);
-        Object.defineProperty(this, "lc_namespace", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: ["langchain", "schema", "runnable"]
-        });
-        Object.defineProperty(this, "lc_serializable", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: true
-        });
-    }
-    static lc_name() {
-        return "RunnablePassthrough";
-    }
-    async invoke(input, options) {
-        return this._callWithConfig((input) => Promise.resolve(input), input, options);
-    }
-    /**
-     * A runnable that assigns key-value pairs to the input.
-     *
-     * The example below shows how you could use it with an inline function.
-     *
-     * @example
-     * ```typescript
-     * const prompt =
-     *   PromptTemplate.fromTemplate(`Write a SQL query to answer the question using the following schema: {schema}
-     * Question: {question}
-     * SQL Query:`);
-     *
-     * // The `RunnablePassthrough.assign()` is used here to passthrough the input from the `.invoke()`
-     * // call (in this example it's the question), along with any inputs passed to the `.assign()` method.
-     * // In this case, we're passing the schema.
-     * const sqlQueryGeneratorChain = RunnableSequence.from([
-     *   RunnablePassthrough.assign({
-     *     schema: async () => db.getTableInfo(),
-     *   }),
-     *   prompt,
-     *   new ChatOpenAI({}).bind({ stop: ["\nSQLResult:"] }),
-     *   new StringOutputParser(),
-     * ]);
-     * const result = await sqlQueryGeneratorChain.invoke({
-     *   question: "How many employees are there?",
-     * });
-     * ```
-     */
-    static assign(
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    mapping) {
-        return new RunnableAssign(new base_js_1.RunnableMap({ steps: mapping }));
-    }
-}
-exports.RunnablePassthrough = RunnablePassthrough;
+var runnables_1 = require("langchain-core/runnables");
+Object.defineProperty(exports, "RunnableAssign", { enumerable: true, get: function () { return runnables_1.RunnableAssign; } });
+Object.defineProperty(exports, "RunnablePassthrough", { enumerable: true, get: function () { return runnables_1.RunnablePassthrough; } });

package/dist/schema/runnable/passthrough.d.ts

@@ -1,72 +1 @@
-import { Runnable, RunnableLike, RunnableMap } from "./base.js";
-import type { RunnableConfig } from "./config.js";
-/**
- * A runnable that assigns key-value pairs to inputs of type `Record<string, unknown>`.
- */
-export declare class RunnableAssign<RunInput extends Record<string, any> = any, RunOutput extends Record<string, any> = any, CallOptions extends RunnableConfig = RunnableConfig> extends Runnable<RunInput, RunOutput> {
-    lc_namespace: string[];
-    mapper: RunnableMap<RunInput>;
-    constructor(mapper: RunnableMap<RunInput>);
-    invoke(input: RunInput, options?: Partial<CallOptions>): Promise<RunOutput>;
-}
-/**
- * A runnable to passthrough inputs unchanged or with additional keys.
- *
- * This runnable behaves almost like the identity function, except that it
- * can be configured to add additional keys to the output, if the input is
- * an object.
- *
- * The example below demonstrates how to use `RunnablePassthrough to
- * passthrough the input from the `.invoke()`
- *
- * @example
- * ```typescript
- * const chain = RunnableSequence.from([
- *   {
- *     question: new RunnablePassthrough(),
- *     context: async () => loadContextFromStore(),
- *   },
- *   prompt,
- *   llm,
- *   outputParser,
- * ]);
- * const response = await chain.invoke(
- *   "I can pass a single string instead of an object since I'm using `RunnablePassthrough`."
- * );
- * ```
- */
-export declare class RunnablePassthrough<RunInput> extends Runnable<RunInput, RunInput> {
-    static lc_name(): string;
-    lc_namespace: string[];
-    lc_serializable: boolean;
-    invoke(input: RunInput, options?: Partial<RunnableConfig>): Promise<RunInput>;
-    /**
-     * A runnable that assigns key-value pairs to the input.
-     *
-     * The example below shows how you could use it with an inline function.
-     *
-     * @example
-     * ```typescript
-     * const prompt =
-     *   PromptTemplate.fromTemplate(`Write a SQL query to answer the question using the following schema: {schema}
-     * Question: {question}
-     * SQL Query:`);
-     *
-     * // The `RunnablePassthrough.assign()` is used here to passthrough the input from the `.invoke()`
-     * // call (in this example it's the question), along with any inputs passed to the `.assign()` method.
-     * // In this case, we're passing the schema.
-     * const sqlQueryGeneratorChain = RunnableSequence.from([
-     *   RunnablePassthrough.assign({
-     *     schema: async () => db.getTableInfo(),
-     *   }),
-     *   prompt,
-     *   new ChatOpenAI({}).bind({ stop: ["\nSQLResult:"] }),
-     *   new StringOutputParser(),
-     * ]);
-     * const result = await sqlQueryGeneratorChain.invoke({
-     *   question: "How many employees are there?",
-     * });
-     * ```
-     */
-    static assign(mapping: Record<string, RunnableLike<Record<string, unknown>, any>>): RunnableAssign<Record<string, unknown>, Record<string, unknown>>;
-}
+export { RunnableAssign, RunnablePassthrough } from "langchain-core/runnables";