@langchain/core 0.3.72 → 1.0.0-alpha.2

package/dist/runnables/passthrough.d.cts

@@ -0,0 +1,76 @@
+import { RunnableConfig } from "./types.cjs";
+import { Runnable, RunnableAssign, RunnableMapLike } from "./base.cjs";
+
+//#region src/runnables/passthrough.d.ts
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type RunnablePassthroughFunc<RunInput = any> = ((input: RunInput) => void) | ((input: RunInput, config?: RunnableConfig) => void) | ((input: RunInput) => Promise<void>) | ((input: RunInput, config?: RunnableConfig) => Promise<void>);
+/**
+ * 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`."
+ * );
+ * ```
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+declare class RunnablePassthrough<RunInput = any> extends Runnable<RunInput, RunInput> {
+  static lc_name(): string;
+  lc_namespace: string[];
+  lc_serializable: boolean;
+  func?: RunnablePassthroughFunc<RunInput>;
+  constructor(fields?: {
+    func?: RunnablePassthroughFunc<RunInput>;
+  });
+  invoke(input: RunInput, options?: Partial<RunnableConfig>): Promise<RunInput>;
+  transform(generator: AsyncGenerator<RunInput>, options: Partial<RunnableConfig>): AsyncGenerator<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({ model: "gpt-4o-mini" }).withConfig({ stop: ["\nSQLResult:"] }),
+   *   new StringOutputParser(),
+   * ]);
+   * const result = await sqlQueryGeneratorChain.invoke({
+   *   question: "How many employees are there?",
+   * });
+   * ```
+   */
+  static assign<RunInput extends Record<string, unknown> = Record<string, unknown>, RunOutput extends Record<string, unknown> = Record<string, unknown>>(mapping: RunnableMapLike<RunInput, RunOutput>): RunnableAssign<RunInput, RunInput & RunOutput>;
+}
+//#endregion
+export { RunnablePassthrough };
+//# sourceMappingURL=passthrough.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"passthrough.d.cts","names":["Runnable","RunnableAssign","RunnableMapLike","RunnableConfig","RunnablePassthroughFunc","RunInput","Promise","RunnablePassthrough","Partial","AsyncGenerator","Record","RunOutput"],"sources":["../../src/runnables/passthrough.d.ts"],"sourcesContent":["import { Runnable, RunnableAssign, RunnableMapLike } from \"./base.js\";\nimport { type RunnableConfig } from \"./config.js\";\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype RunnablePassthroughFunc<RunInput = any> = ((input: RunInput) => void) | ((input: RunInput, config?: RunnableConfig) => void) | ((input: RunInput) => Promise<void>) | ((input: RunInput, config?: RunnableConfig) => Promise<void>);\n/**\n * A runnable to passthrough inputs unchanged or with additional keys.\n *\n * This runnable behaves almost like the identity function, except that it\n * can be configured to add additional keys to the output, if the input is\n * an object.\n *\n * The example below demonstrates how to use `RunnablePassthrough to\n * passthrough the input from the `.invoke()`\n *\n * @example\n * ```typescript\n * const chain = RunnableSequence.from([\n *   {\n *     question: new RunnablePassthrough(),\n *     context: async () => loadContextFromStore(),\n *   },\n *   prompt,\n *   llm,\n *   outputParser,\n * ]);\n * const response = await chain.invoke(\n *   \"I can pass a single string instead of an object since I'm using `RunnablePassthrough`.\"\n * );\n * ```\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport declare class RunnablePassthrough<RunInput = any> extends Runnable<RunInput, RunInput> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    func?: RunnablePassthroughFunc<RunInput>;\n    constructor(fields?: {\n        func?: RunnablePassthroughFunc<RunInput>;\n    });\n    invoke(input: RunInput, options?: Partial<RunnableConfig>): Promise<RunInput>;\n    transform(generator: AsyncGenerator<RunInput>, options: Partial<RunnableConfig>): AsyncGenerator<RunInput>;\n    /**\n     * A runnable that assigns key-value pairs to the input.\n     *\n     * The example below shows how you could use it with an inline function.\n     *\n     * @example\n     * ```typescript\n     * const prompt =\n     *   PromptTemplate.fromTemplate(`Write a SQL query to answer the question using the following schema: {schema}\n     * Question: {question}\n     * SQL Query:`);\n     *\n     * // The `RunnablePassthrough.assign()` is used here to passthrough the input from the `.invoke()`\n     * // call (in this example it's the question), along with any inputs passed to the `.assign()` method.\n     * // In this case, we're passing the schema.\n     * const sqlQueryGeneratorChain = RunnableSequence.from([\n     *   RunnablePassthrough.assign({\n     *     schema: async () => db.getTableInfo(),\n     *   }),\n     *   prompt,\n     *   new ChatOpenAI({ model: \"gpt-4o-mini\" }).withConfig({ stop: [\"\\nSQLResult:\"] }),\n     *   new StringOutputParser(),\n     * ]);\n     * const result = await sqlQueryGeneratorChain.invoke({\n     *   question: \"How many employees are there?\",\n     * });\n     * ```\n     */\n    static assign<RunInput extends Record<string, unknown> = Record<string, unknown>, RunOutput extends Record<string, unknown> = Record<string, unknown>>(mapping: RunnableMapLike<RunInput, RunOutput>): RunnableAssign<RunInput, RunInput & RunOutput>;\n}\nexport {};\n"],"mappings":";;;;;KAGKI,mDAAmDC,8BAA8BA,mBAAmBF,oCAAoCE,aAAaC,0BAA0BD,mBAAmBF,mBAAmBG;AAFxK;;;;;;;;;;AAE+K;AA4BjO;;;;;;;;;;;;;;;;AAS4DE,cATvCD,mBASuCC,CAAAA,WAAAA,GAAAA,CAAAA,SATKR,QASLQ,CATcH,QASdG,EATwBH,QASxBG,CAAAA,CAAAA;EAAO,OAAkCH,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAQ,YAAvBI,EAAAA,MAAAA,EAAAA;EAAc,eA6BjEC,EAAAA,OAAAA;EAAM,IAAoBA,CAAAA,EAlClDN,uBAkCkDM,CAlC1BL,QAkC0BK,CAAAA;EAAM,WAAqCA,CAAAA,MAAgC,CAAhCA,EAAAA;IAA0BA,IAAAA,CAAAA,EAhCnHN,uBAgCmHM,CAhC3FL,QAgC2FK,CAAAA;EAAM,CAAA;EAAoD,MAAEC,CAAAA,KAAAA,EA9B5KN,QA8B4KM,EAAAA,OAAAA,CAAAA,EA9BxJH,OA8BwJG,CA9BhJR,cA8BgJQ,CAAAA,CAAAA,EA9B9HL,OA8B8HK,CA9BtHN,QA8BsHM,CAAAA;EAAS,SAAnCT,CAAAA,SAAAA,EA7B3IO,cA6B2IP,CA7B5HG,QA6B4HH,CAAAA,EAAAA,OAAAA,EA7BxGM,OA6BwGN,CA7BhGC,cA6BgGD,CAAAA,CAAAA,EA7B9EO,cA6B8EP,CA7B/DG,QA6B+DH,CAAAA;EAAe;;;;;AAtC1G;;;;;;;;;;;;;;;;;;;;;;;iCAsCtCQ,0BAA0BA,2CAA2CA,0BAA0BA,kCAAkCR,gBAAgBG,UAAUM,aAAaV,eAAeI,UAAUA,WAAWM"}

package/dist/runnables/passthrough.d.ts

@@ -1,5 +1,8 @@
+import { RunnableConfig } from "./types.js";
 import { Runnable, RunnableAssign, RunnableMapLike } from "./base.js";
-import { type RunnableConfig } from "./config.js";
+
+//#region src/runnables/passthrough.d.ts
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 type RunnablePassthroughFunc<RunInput = any> = ((input: RunInput) => void) | ((input: RunInput, config?: RunnableConfig) => void) | ((input: RunInput) => Promise<void>) | ((input: RunInput, config?: RunnableConfig) => Promise<void>);
 /**
  * A runnable to passthrough inputs unchanged or with additional keys.
@@ -27,44 +30,47 @@ type RunnablePassthroughFunc<RunInput = any> = ((input: RunInput) => void) | ((i
  * );
  * ```
  */
-export declare class RunnablePassthrough<RunInput = any> extends Runnable<RunInput, RunInput> {
-    static lc_name(): string;
-    lc_namespace: string[];
-    lc_serializable: boolean;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+declare class RunnablePassthrough<RunInput = any> extends Runnable<RunInput, RunInput> {
+  static lc_name(): string;
+  lc_namespace: string[];
+  lc_serializable: boolean;
+  func?: RunnablePassthroughFunc<RunInput>;
+  constructor(fields?: {
     func?: RunnablePassthroughFunc<RunInput>;
-    constructor(fields?: {
-        func?: RunnablePassthroughFunc<RunInput>;
-    });
-    invoke(input: RunInput, options?: Partial<RunnableConfig>): Promise<RunInput>;
-    transform(generator: AsyncGenerator<RunInput>, options: Partial<RunnableConfig>): AsyncGenerator<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({ model: "gpt-4o-mini" }).withConfig({ stop: ["\nSQLResult:"] }),
-     *   new StringOutputParser(),
-     * ]);
-     * const result = await sqlQueryGeneratorChain.invoke({
-     *   question: "How many employees are there?",
-     * });
-     * ```
-     */
-    static assign<RunInput extends Record<string, unknown> = Record<string, unknown>, RunOutput extends Record<string, unknown> = Record<string, unknown>>(mapping: RunnableMapLike<RunInput, RunOutput>): RunnableAssign<RunInput, RunInput & RunOutput>;
+  });
+  invoke(input: RunInput, options?: Partial<RunnableConfig>): Promise<RunInput>;
+  transform(generator: AsyncGenerator<RunInput>, options: Partial<RunnableConfig>): AsyncGenerator<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({ model: "gpt-4o-mini" }).withConfig({ stop: ["\nSQLResult:"] }),
+   *   new StringOutputParser(),
+   * ]);
+   * const result = await sqlQueryGeneratorChain.invoke({
+   *   question: "How many employees are there?",
+   * });
+   * ```
+   */
+  static assign<RunInput extends Record<string, unknown> = Record<string, unknown>, RunOutput extends Record<string, unknown> = Record<string, unknown>>(mapping: RunnableMapLike<RunInput, RunOutput>): RunnableAssign<RunInput, RunInput & RunOutput>;
 }
-export {};
+//#endregion
+export { RunnablePassthrough };
+//# sourceMappingURL=passthrough.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"passthrough.d.ts","names":["Runnable","RunnableAssign","RunnableMapLike","RunnableConfig","RunnablePassthroughFunc","RunInput","Promise","RunnablePassthrough","Partial","AsyncGenerator","Record","RunOutput"],"sources":["../../src/runnables/passthrough.d.ts"],"sourcesContent":["import { Runnable, RunnableAssign, RunnableMapLike } from \"./base.js\";\nimport { type RunnableConfig } from \"./config.js\";\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype RunnablePassthroughFunc<RunInput = any> = ((input: RunInput) => void) | ((input: RunInput, config?: RunnableConfig) => void) | ((input: RunInput) => Promise<void>) | ((input: RunInput, config?: RunnableConfig) => Promise<void>);\n/**\n * A runnable to passthrough inputs unchanged or with additional keys.\n *\n * This runnable behaves almost like the identity function, except that it\n * can be configured to add additional keys to the output, if the input is\n * an object.\n *\n * The example below demonstrates how to use `RunnablePassthrough to\n * passthrough the input from the `.invoke()`\n *\n * @example\n * ```typescript\n * const chain = RunnableSequence.from([\n *   {\n *     question: new RunnablePassthrough(),\n *     context: async () => loadContextFromStore(),\n *   },\n *   prompt,\n *   llm,\n *   outputParser,\n * ]);\n * const response = await chain.invoke(\n *   \"I can pass a single string instead of an object since I'm using `RunnablePassthrough`.\"\n * );\n * ```\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport declare class RunnablePassthrough<RunInput = any> extends Runnable<RunInput, RunInput> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    func?: RunnablePassthroughFunc<RunInput>;\n    constructor(fields?: {\n        func?: RunnablePassthroughFunc<RunInput>;\n    });\n    invoke(input: RunInput, options?: Partial<RunnableConfig>): Promise<RunInput>;\n    transform(generator: AsyncGenerator<RunInput>, options: Partial<RunnableConfig>): AsyncGenerator<RunInput>;\n    /**\n     * A runnable that assigns key-value pairs to the input.\n     *\n     * The example below shows how you could use it with an inline function.\n     *\n     * @example\n     * ```typescript\n     * const prompt =\n     *   PromptTemplate.fromTemplate(`Write a SQL query to answer the question using the following schema: {schema}\n     * Question: {question}\n     * SQL Query:`);\n     *\n     * // The `RunnablePassthrough.assign()` is used here to passthrough the input from the `.invoke()`\n     * // call (in this example it's the question), along with any inputs passed to the `.assign()` method.\n     * // In this case, we're passing the schema.\n     * const sqlQueryGeneratorChain = RunnableSequence.from([\n     *   RunnablePassthrough.assign({\n     *     schema: async () => db.getTableInfo(),\n     *   }),\n     *   prompt,\n     *   new ChatOpenAI({ model: \"gpt-4o-mini\" }).withConfig({ stop: [\"\\nSQLResult:\"] }),\n     *   new StringOutputParser(),\n     * ]);\n     * const result = await sqlQueryGeneratorChain.invoke({\n     *   question: \"How many employees are there?\",\n     * });\n     * ```\n     */\n    static assign<RunInput extends Record<string, unknown> = Record<string, unknown>, RunOutput extends Record<string, unknown> = Record<string, unknown>>(mapping: RunnableMapLike<RunInput, RunOutput>): RunnableAssign<RunInput, RunInput & RunOutput>;\n}\nexport {};\n"],"mappings":";;;;;KAGKI,mDAAmDC,8BAA8BA,mBAAmBF,oCAAoCE,aAAaC,0BAA0BD,mBAAmBF,mBAAmBG;AAFxK;;;;;;;;;;AAE+K;AA4BjO;;;;;;;;;;;;;;;;AAS4DE,cATvCD,mBASuCC,CAAAA,WAAAA,GAAAA,CAAAA,SATKR,QASLQ,CATcH,QASdG,EATwBH,QASxBG,CAAAA,CAAAA;EAAO,OAAkCH,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAQ,YAAvBI,EAAAA,MAAAA,EAAAA;EAAc,eA6BjEC,EAAAA,OAAAA;EAAM,IAAoBA,CAAAA,EAlClDN,uBAkCkDM,CAlC1BL,QAkC0BK,CAAAA;EAAM,WAAqCA,CAAAA,MAAgC,CAAhCA,EAAAA;IAA0BA,IAAAA,CAAAA,EAhCnHN,uBAgCmHM,CAhC3FL,QAgC2FK,CAAAA;EAAM,CAAA;EAAoD,MAAEC,CAAAA,KAAAA,EA9B5KN,QA8B4KM,EAAAA,OAAAA,CAAAA,EA9BxJH,OA8BwJG,CA9BhJR,cA8BgJQ,CAAAA,CAAAA,EA9B9HL,OA8B8HK,CA9BtHN,QA8BsHM,CAAAA;EAAS,SAAnCT,CAAAA,SAAAA,EA7B3IO,cA6B2IP,CA7B5HG,QA6B4HH,CAAAA,EAAAA,OAAAA,EA7BxGM,OA6BwGN,CA7BhGC,cA6BgGD,CAAAA,CAAAA,EA7B9EO,cA6B8EP,CA7B/DG,QA6B+DH,CAAAA;EAAe;;;;;AAtC1G;;;;;;;;;;;;;;;;;;;;;;;iCAsCtCQ,0BAA0BA,2CAA2CA,0BAA0BA,kCAAkCR,gBAAgBG,UAAUM,aAAaV,eAAeI,UAAUA,WAAWM"}

package/dist/runnables/passthrough.js

@@ -1,123 +1,99 @@
-import { concat } from "../utils/stream.js";
-import { Runnable, RunnableAssign, RunnableMap, } from "./base.js";
 import { ensureConfig } from "./config.js";
+import { concat } from "../utils/stream.js";
+import { Runnable, RunnableAssign, RunnableMap } from "./base.js";
+
+//#region src/runnables/passthrough.ts
 /**
- * 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`."
- * );
- * ```
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export class RunnablePassthrough extends Runnable {
-    static lc_name() {
-        return "RunnablePassthrough";
-    }
-    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, "func", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        if (fields) {
-            this.func = fields.func;
-        }
-    }
-    async invoke(input, options) {
-        const config = ensureConfig(options);
-        if (this.func) {
-            await this.func(input, config);
-        }
-        return this._callWithConfig((input) => Promise.resolve(input), input, config);
-    }
-    async *transform(generator, options) {
-        const config = ensureConfig(options);
-        let finalOutput;
-        let finalOutputSupported = true;
-        for await (const chunk of this._transformStreamWithConfig(generator, (input) => input, config)) {
-            yield chunk;
-            if (finalOutputSupported) {
-                if (finalOutput === undefined) {
-                    finalOutput = chunk;
-                }
-                else {
-                    try {
-                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                        finalOutput = concat(finalOutput, chunk);
-                    }
-                    catch {
-                        finalOutput = undefined;
-                        finalOutputSupported = false;
-                    }
-                }
-            }
-        }
-        if (this.func && finalOutput !== undefined) {
-            await this.func(finalOutput, config);
-        }
-    }
-    /**
-     * 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({ model: "gpt-4o-mini" }).withConfig({ stop: ["\nSQLResult:"] }),
-     *   new StringOutputParser(),
-     * ]);
-     * const result = await sqlQueryGeneratorChain.invoke({
-     *   question: "How many employees are there?",
-     * });
-     * ```
-     */
-    static assign(mapping) {
-        return new RunnableAssign(new RunnableMap({ steps: mapping }));
-    }
-}
+* 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`."
+* );
+* ```
+*/
+var RunnablePassthrough = class extends Runnable {
+	static lc_name() {
+		return "RunnablePassthrough";
+	}
+	lc_namespace = ["langchain_core", "runnables"];
+	lc_serializable = true;
+	func;
+	constructor(fields) {
+		super(fields);
+		if (fields) this.func = fields.func;
+	}
+	async invoke(input, options) {
+		const config = ensureConfig(options);
+		if (this.func) await this.func(input, config);
+		return this._callWithConfig((input$1) => Promise.resolve(input$1), input, config);
+	}
+	async *transform(generator, options) {
+		const config = ensureConfig(options);
+		let finalOutput;
+		let finalOutputSupported = true;
+		for await (const chunk of this._transformStreamWithConfig(generator, (input) => input, config)) {
+			yield chunk;
+			if (finalOutputSupported) if (finalOutput === void 0) finalOutput = chunk;
+			else try {
+				finalOutput = concat(finalOutput, chunk);
+			} catch {
+				finalOutput = void 0;
+				finalOutputSupported = false;
+			}
+		}
+		if (this.func && finalOutput !== void 0) await this.func(finalOutput, config);
+	}
+	/**
+	* 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({ model: "gpt-4o-mini" }).withConfig({ stop: ["\nSQLResult:"] }),
+	*   new StringOutputParser(),
+	* ]);
+	* const result = await sqlQueryGeneratorChain.invoke({
+	*   question: "How many employees are there?",
+	* });
+	* ```
+	*/
+	static assign(mapping) {
+		return new RunnableAssign(new RunnableMap({ steps: mapping }));
+	}
+};
+
+//#endregion
+export { RunnablePassthrough };
+//# sourceMappingURL=passthrough.js.map

package/dist/runnables/passthrough.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"passthrough.js","names":["fields?: { func?: RunnablePassthroughFunc<RunInput> }","input: RunInput","options?: Partial<RunnableConfig>","input","generator: AsyncGenerator<RunInput>","options: Partial<RunnableConfig>","finalOutput: RunInput | undefined","input: AsyncGenerator<RunInput>","mapping: RunnableMapLike<RunInput, RunOutput>"],"sources":["../../src/runnables/passthrough.ts"],"sourcesContent":["import { concat } from \"../utils/stream.js\";\nimport {\n  Runnable,\n  RunnableAssign,\n  RunnableMap,\n  RunnableMapLike,\n} from \"./base.js\";\nimport { ensureConfig, type RunnableConfig } from \"./config.js\";\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype RunnablePassthroughFunc<RunInput = any> =\n  | ((input: RunInput) => void)\n  | ((input: RunInput, config?: RunnableConfig) => void)\n  | ((input: RunInput) => Promise<void>)\n  | ((input: RunInput, config?: RunnableConfig) => Promise<void>);\n\n/**\n * A runnable to passthrough inputs unchanged or with additional keys.\n *\n * This runnable behaves almost like the identity function, except that it\n * can be configured to add additional keys to the output, if the input is\n * an object.\n *\n * The example below demonstrates how to use `RunnablePassthrough to\n * passthrough the input from the `.invoke()`\n *\n * @example\n * ```typescript\n * const chain = RunnableSequence.from([\n *   {\n *     question: new RunnablePassthrough(),\n *     context: async () => loadContextFromStore(),\n *   },\n *   prompt,\n *   llm,\n *   outputParser,\n * ]);\n * const response = await chain.invoke(\n *   \"I can pass a single string instead of an object since I'm using `RunnablePassthrough`.\"\n * );\n * ```\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport class RunnablePassthrough<RunInput = any> extends Runnable<\n  RunInput,\n  RunInput\n> {\n  static lc_name() {\n    return \"RunnablePassthrough\";\n  }\n\n  lc_namespace = [\"langchain_core\", \"runnables\"];\n\n  lc_serializable = true;\n\n  func?: RunnablePassthroughFunc<RunInput>;\n\n  constructor(fields?: { func?: RunnablePassthroughFunc<RunInput> }) {\n    super(fields);\n    if (fields) {\n      this.func = fields.func;\n    }\n  }\n\n  async invoke(\n    input: RunInput,\n    options?: Partial<RunnableConfig>\n  ): Promise<RunInput> {\n    const config = ensureConfig(options);\n    if (this.func) {\n      await this.func(input, config);\n    }\n\n    return this._callWithConfig(\n      (input: RunInput) => Promise.resolve(input),\n      input,\n      config\n    );\n  }\n\n  async *transform(\n    generator: AsyncGenerator<RunInput>,\n    options: Partial<RunnableConfig>\n  ): AsyncGenerator<RunInput> {\n    const config = ensureConfig(options);\n    let finalOutput: RunInput | undefined;\n    let finalOutputSupported = true;\n\n    for await (const chunk of this._transformStreamWithConfig(\n      generator,\n      (input: AsyncGenerator<RunInput>) => input,\n      config\n    )) {\n      yield chunk;\n      if (finalOutputSupported) {\n        if (finalOutput === undefined) {\n          finalOutput = chunk;\n        } else {\n          try {\n            // eslint-disable-next-line @typescript-eslint/no-explicit-any\n            finalOutput = concat(finalOutput, chunk as any);\n          } catch {\n            finalOutput = undefined;\n            finalOutputSupported = false;\n          }\n        }\n      }\n    }\n\n    if (this.func && finalOutput !== undefined) {\n      await this.func(finalOutput, config);\n    }\n  }\n\n  /**\n   * A runnable that assigns key-value pairs to the input.\n   *\n   * The example below shows how you could use it with an inline function.\n   *\n   * @example\n   * ```typescript\n   * const prompt =\n   *   PromptTemplate.fromTemplate(`Write a SQL query to answer the question using the following schema: {schema}\n   * Question: {question}\n   * SQL Query:`);\n   *\n   * // The `RunnablePassthrough.assign()` is used here to passthrough the input from the `.invoke()`\n   * // call (in this example it's the question), along with any inputs passed to the `.assign()` method.\n   * // In this case, we're passing the schema.\n   * const sqlQueryGeneratorChain = RunnableSequence.from([\n   *   RunnablePassthrough.assign({\n   *     schema: async () => db.getTableInfo(),\n   *   }),\n   *   prompt,\n   *   new ChatOpenAI({ model: \"gpt-4o-mini\" }).withConfig({ stop: [\"\\nSQLResult:\"] }),\n   *   new StringOutputParser(),\n   * ]);\n   * const result = await sqlQueryGeneratorChain.invoke({\n   *   question: \"How many employees are there?\",\n   * });\n   * ```\n   */\n  static assign<\n    RunInput extends Record<string, unknown> = Record<string, unknown>,\n    RunOutput extends Record<string, unknown> = Record<string, unknown>\n  >(\n    mapping: RunnableMapLike<RunInput, RunOutput>\n  ): RunnableAssign<RunInput, RunInput & RunOutput> {\n    return new RunnableAssign(new RunnableMap({ steps: mapping }));\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2CA,IAAa,sBAAb,cAAyD,SAGvD;CACA,OAAO,UAAU;AACf,SAAO;CACR;CAED,eAAe,CAAC,kBAAkB,WAAY;CAE9C,kBAAkB;CAElB;CAEA,YAAYA,QAAuD;EACjE,MAAM,OAAO;AACb,MAAI,QACF,KAAK,OAAO,OAAO;CAEtB;CAED,MAAM,OACJC,OACAC,SACmB;EACnB,MAAM,SAAS,aAAa,QAAQ;AACpC,MAAI,KAAK,MACP,MAAM,KAAK,KAAK,OAAO,OAAO;AAGhC,SAAO,KAAK,gBACV,CAACD,YAAoB,QAAQ,QAAQE,QAAM,EAC3C,OACA,OACD;CACF;CAED,OAAO,UACLC,WACAC,SAC0B;EAC1B,MAAM,SAAS,aAAa,QAAQ;EACpC,IAAIC;EACJ,IAAI,uBAAuB;AAE3B,aAAW,MAAM,SAAS,KAAK,2BAC7B,WACA,CAACC,UAAoC,OACrC,OACD,EAAE;GACD,MAAM;AACN,OAAI,qBACF,KAAI,gBAAgB,QAClB,cAAc;OAEd,KAAI;IAEF,cAAc,OAAO,aAAa,MAAa;GAChD,QAAO;IACN,cAAc;IACd,uBAAuB;GACxB;EAGN;AAED,MAAI,KAAK,QAAQ,gBAAgB,QAC/B,MAAM,KAAK,KAAK,aAAa,OAAO;CAEvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8BD,OAAO,OAILC,SACgD;AAChD,SAAO,IAAI,eAAe,IAAI,YAAY,EAAE,OAAO,QAAS;CAC7D;AACF"}