@langchain/core 1.2.0-dev-1765937705265 → 1.2.0

package/dist/runnables/passthrough.cjs

@@ -1,7 +1,6 @@
-const require_config = require('./config.cjs');
-const require_utils_stream = require('../utils/stream.cjs');
-const require_base = require('./base.cjs');
-
+const require_config = require("./config.cjs");
+const require_utils_stream = require("../utils/stream.cjs");
+const require_base = require("./base.cjs");
 //#region src/runnables/passthrough.ts
 /**
 * A runnable to passthrough inputs unchanged or with additional keys.
@@ -43,7 +42,7 @@ var RunnablePassthrough = class extends require_base.Runnable {
 	async invoke(input, options) {
 		const config = require_config.ensureConfig(options);
 		if (this.func) await this.func(input, config);
-		return this._callWithConfig((input$1) => Promise.resolve(input$1), input, config);
+		return this._callWithConfig((input) => Promise.resolve(input), input, config);
 	}
 	async *transform(generator, options) {
 		const config = require_config.ensureConfig(options);
@@ -93,7 +92,7 @@ var RunnablePassthrough = class extends require_base.Runnable {
 		return new require_base.RunnableAssign(new require_base.RunnableMap({ steps: mapping }));
 	}
 };
-
 //#endregion
 exports.RunnablePassthrough = RunnablePassthrough;
+
 //# sourceMappingURL=passthrough.cjs.map

package/dist/runnables/passthrough.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"passthrough.cjs","names":["Runnable","fields?: { func?: RunnablePassthroughFunc<RunInput> }","input: RunInput","options?: Partial<RunnableConfig>","ensureConfig","input","generator: AsyncGenerator<RunInput>","options: Partial<RunnableConfig>","finalOutput: RunInput | undefined","input: AsyncGenerator<RunInput>","concat","mapping: RunnableMapLike<RunInput, RunOutput>","RunnableAssign","RunnableMap"],"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,cAAyDA,sBAGvD;CACA,OAAO,UAAU;AACf,SAAO;CACR;CAED,eAAe,CAAC,kBAAkB,WAAY;CAE9C,kBAAkB;CAElB;CAEA,YAAYC,QAAuD;EACjE,MAAM,OAAO;AACb,MAAI,QACF,KAAK,OAAO,OAAO;CAEtB;CAED,MAAM,OACJC,OACAC,SACmB;EACnB,MAAM,SAASC,4BAAa,QAAQ;AACpC,MAAI,KAAK,MACP,MAAM,KAAK,KAAK,OAAO,OAAO;AAGhC,SAAO,KAAK,gBACV,CAACF,YAAoB,QAAQ,QAAQG,QAAM,EAC3C,OACA,OACD;CACF;CAED,OAAO,UACLC,WACAC,SAC0B;EAC1B,MAAM,SAASH,4BAAa,QAAQ;EACpC,IAAII;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,cAAcC,4BAAO,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,IAAIC,4BAAe,IAAIC,yBAAY,EAAE,OAAO,QAAS;CAC7D;AACF"}
+{"version":3,"file":"passthrough.cjs","names":["Runnable","ensureConfig","concat","RunnableAssign","RunnableMap"],"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// oxlint-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// oxlint-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            // oxlint-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,cAAyDA,aAAAA,SAGvD;CACA,OAAO,UAAU;AACf,SAAO;;CAGT,eAAe,CAAC,kBAAkB,YAAY;CAE9C,kBAAkB;CAElB;CAEA,YAAY,QAAuD;AACjE,QAAM,OAAO;AACb,MAAI,OACF,MAAK,OAAO,OAAO;;CAIvB,MAAM,OACJ,OACA,SACmB;EACnB,MAAM,SAASC,eAAAA,aAAa,QAAQ;AACpC,MAAI,KAAK,KACP,OAAM,KAAK,KAAK,OAAO,OAAO;AAGhC,SAAO,KAAK,iBACT,UAAoB,QAAQ,QAAQ,MAAM,EAC3C,OACA,OACD;;CAGH,OAAO,UACL,WACA,SAC0B;EAC1B,MAAM,SAASA,eAAAA,aAAa,QAAQ;EACpC,IAAI;EACJ,IAAI,uBAAuB;AAE3B,aAAW,MAAM,SAAS,KAAK,2BAC7B,YACC,UAAoC,OACrC,OACD,EAAE;AACD,SAAM;AACN,OAAI,qBACF,KAAI,gBAAgB,KAAA,EAClB,eAAc;OAEd,KAAI;AAEF,kBAAcC,qBAAAA,OAAO,aAAa,MAAa;WACzC;AACN,kBAAc,KAAA;AACd,2BAAuB;;;AAM/B,MAAI,KAAK,QAAQ,gBAAgB,KAAA,EAC/B,OAAM,KAAK,KAAK,aAAa,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgCxC,OAAO,OAIL,SACgD;AAChD,SAAO,IAAIC,aAAAA,eAAe,IAAIC,aAAAA,YAAY,EAAE,OAAO,SAAS,CAAC,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"passthrough.d.cts","names":["Runnable","RunnableAssign","RunnableMapLike","RunnableConfig","RunnablePassthroughFunc","RunInput","Promise","RunnablePassthrough","RunOutput","Partial","AsyncGenerator","Record"],"sources":["../../src/runnables/passthrough.d.ts"],"sourcesContent":["import { Runnable, RunnableAssign, RunnableMapLike } from \"./base.js\";\nimport { type RunnableConfig } from \"./config.js\";\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 */\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//# sourceMappingURL=passthrough.d.ts.map"],"mappings":";;;;KAEKI,mDAAmDC,8BAA8BA,mBAAmBF,oCAAoCE,aAAaC,0BAA0BD,mBAAmBF,mBAAmBG;;AADxK;;;;;;;;;AAC+K;AA2BjO;;;;;;;;;;;;;;;AAS4DG,cATvCF,mBASuCE,CAAAA,WAAAA,GAAAA,CAAAA,SATKT,QASLS,CATcJ,QASdI,EATwBJ,QASxBI,CAAAA,CAAAA;EAAyCJ,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAfK,YAAAA,EAAAA,MAAAA,EAAAA;EA6BnDC,eAAAA,EAAAA,OAAAA;EAA0BA,IAAAA,CAAAA,EAlClDP,uBAkCkDO,CAlC1BN,QAkC0BM,CAAAA;EAA2CA,WAAAA,CAAAA,MAA4EN,CAA5EM,EAAAA;IAA0BA,IAAAA,CAAAA,EAhCnHP,uBAgCmHO,CAhC3FN,QAgC2FM,CAAAA;EAAkDN,CAAAA;EAAUG,MAAAA,CAAAA,KAAAA,EA9B5KH,QA8B4KG,EAAAA,OAAAA,CAAAA,EA9BxJC,OA8BwJD,CA9BhJL,cA8BgJK,CAAAA,CAAAA,EA9B9HF,OA8B8HE,CA9BtHH,QA8BsHG,CAAAA;EAA1BN,SAAAA,CAAAA,SAAAA,EA7B3IQ,cA6B2IR,CA7B5HG,QA6B4HH,CAAAA,EAAAA,OAAAA,EA7BxGO,OA6BwGP,CA7BhGC,cA6BgGD,CAAAA,CAAAA,EA7B9EQ,cA6B8ER,CA7B/DG,QA6B+DH,CAAAA;EAAsDG;;;;;AAtCjJ;;;;;;;;;;;;;;;;;;;;;;;iCAsCtCM,0BAA0BA,2CAA2CA,0BAA0BA,kCAAkCT,gBAAgBG,UAAUG,aAAaP,eAAeI,UAAUA,WAAWG"}
+{"version":3,"file":"passthrough.d.cts","names":[],"sources":["../../src/runnables/passthrough.ts"],"mappings":";;;;KAUK,uBAAA,qBACC,KAAA,EAAO,QAAA,eACP,KAAA,EAAO,QAAA,EAAU,MAAA,GAAS,cAAA,eAC1B,KAAA,EAAO,QAAA,KAAa,OAAA,YACpB,KAAA,EAAO,QAAA,EAAU,MAAA,GAAS,cAAA,KAAmB,OAAA;;;AAPa;;;;;;;;;;;;;;;;;;;;;;;;cAoCnD,mBAAA,yBAA4C,QAAA,CACvD,QAAA,EACA,QAAA;EAAA,OAEO,OAAA,CAAA;EAIP,YAAA;EAEA,eAAA;EAEA,IAAA,GAAO,uBAAA,CAAwB,QAAA;EAE/B,WAAA,CAAY,MAAA;IAAW,IAAA,GAAO,uBAAA,CAAwB,QAAA;EAAA;EAOhD,MAAA,CACJ,KAAA,EAAO,QAAA,EACP,OAAA,GAAU,OAAA,CAAQ,cAAA,IACjB,OAAA,CAAQ,QAAA;EAaJ,SAAA,CACL,SAAA,EAAW,cAAA,CAAe,QAAA,GAC1B,OAAA,EAAS,OAAA,CAAQ,cAAA,IAChB,cAAA,CAAe,QAAA;EAtClB;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAA,OAiGO,MAAA,kBACY,MAAA,oBAA0B,MAAA,qCACzB,MAAA,oBAA0B,MAAA,kBAAA,CAE5C,OAAA,EAAS,eAAA,CAAgB,QAAA,EAAU,SAAA,IAClC,cAAA,CAAe,QAAA,EAAU,QAAA,GAAW,SAAA;AAAA"}

package/dist/runnables/passthrough.d.ts

@@ -1,5 +1,4 @@
 import { RunnableConfig } from "./types.js";
-import "./config.js";
 import { Runnable, RunnableAssign, RunnableMapLike } from "./base.js";
 
 //#region src/runnables/passthrough.d.ts

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

@@ -1 +1 @@
-{"version":3,"file":"passthrough.d.ts","names":["Runnable","RunnableAssign","RunnableMapLike","RunnableConfig","RunnablePassthroughFunc","RunInput","Promise","RunnablePassthrough","RunOutput","Partial","AsyncGenerator","Record"],"sources":["../../src/runnables/passthrough.d.ts"],"sourcesContent":["import { Runnable, RunnableAssign, RunnableMapLike } from \"./base.js\";\nimport { type RunnableConfig } from \"./config.js\";\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 */\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//# sourceMappingURL=passthrough.d.ts.map"],"mappings":";;;;;KAEKI,mDAAmDC,8BAA8BA,mBAAmBF,oCAAoCE,aAAaC,0BAA0BD,mBAAmBF,mBAAmBG;;;AADxK;;;;;;;;;AAC+K;AA2BjO;;;;;;;;;;;;;;AASoEH,cAT/CI,mBAS+CJ,CAAAA,WAAAA,GAAAA,CAAAA,SATHH,QASGG,CATME,QASNF,EATgBE,QAShBF,CAAAA,CAAAA;EAARM,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAyCJ,YAAAA,EAAAA,MAAAA,EAAAA;EAAfK,eAAAA,EAAAA,OAAAA;EA6BnDC,IAAAA,CAAAA,EAlCxBP,uBAkCwBO,CAlCAN,QAkCAM,CAAAA;EAA0BA,WAAAA,CAAAA,MAAqEA,CAArEA,EAAAA;IAA2CA,IAAAA,CAAAA,EAhCzFP,uBAgCyFO,CAhCjEN,QAgCiEM,CAAAA;EAA0BA,CAAAA;EAAkDN,MAAAA,CAAAA,KAAAA,EA9BlKA,QA8BkKA,EAAAA,OAAAA,CAAAA,EA9B9II,OA8B8IJ,CA9BtIF,cA8BsIE,CAAAA,CAAAA,EA9BpHC,OA8BoHD,CA9B5GA,QA8B4GA,CAAAA;EAAUG,SAAAA,CAAAA,SAAAA,EA7BrKE,cA6BqKF,CA7BtJH,QA6BsJG,CAAAA,EAAAA,OAAAA,EA7BlIC,OA6BkID,CA7B1HL,cA6B0HK,CAAAA,CAAAA,EA7BxGE,cA6BwGF,CA7BzFH,QA6ByFG,CAAAA;EAA1BN;;;;;;AAtC3F;;;;;;;;;;;;;;;;;;;;;;iCAsCtCS,0BAA0BA,2CAA2CA,0BAA0BA,kCAAkCT,gBAAgBG,UAAUG,aAAaP,eAAeI,UAAUA,WAAWG"}
+{"version":3,"file":"passthrough.d.ts","names":[],"sources":["../../src/runnables/passthrough.ts"],"mappings":";;;;KAUK,uBAAA,qBACC,KAAA,EAAO,QAAA,eACP,KAAA,EAAO,QAAA,EAAU,MAAA,GAAS,cAAA,eAC1B,KAAA,EAAO,QAAA,KAAa,OAAA,YACpB,KAAA,EAAO,QAAA,EAAU,MAAA,GAAS,cAAA,KAAmB,OAAA;;;AAPa;;;;;;;;;;;;;;;;;;;;;;;;cAoCnD,mBAAA,yBAA4C,QAAA,CACvD,QAAA,EACA,QAAA;EAAA,OAEO,OAAA,CAAA;EAIP,YAAA;EAEA,eAAA;EAEA,IAAA,GAAO,uBAAA,CAAwB,QAAA;EAE/B,WAAA,CAAY,MAAA;IAAW,IAAA,GAAO,uBAAA,CAAwB,QAAA;EAAA;EAOhD,MAAA,CACJ,KAAA,EAAO,QAAA,EACP,OAAA,GAAU,OAAA,CAAQ,cAAA,IACjB,OAAA,CAAQ,QAAA;EAaJ,SAAA,CACL,SAAA,EAAW,cAAA,CAAe,QAAA,GAC1B,OAAA,EAAS,OAAA,CAAQ,cAAA,IAChB,cAAA,CAAe,QAAA;EAtClB;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAA,OAiGO,MAAA,kBACY,MAAA,oBAA0B,MAAA,qCACzB,MAAA,oBAA0B,MAAA,kBAAA,CAE5C,OAAA,EAAS,eAAA,CAAgB,QAAA,EAAU,SAAA,IAClC,cAAA,CAAe,QAAA,EAAU,QAAA,GAAW,SAAA;AAAA"}

package/dist/runnables/passthrough.js

@@ -1,7 +1,6 @@
 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.
@@ -43,7 +42,7 @@ var RunnablePassthrough = class extends Runnable {
 	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);
+		return this._callWithConfig((input) => Promise.resolve(input), input, config);
 	}
 	async *transform(generator, options) {
 		const config = ensureConfig(options);
@@ -93,7 +92,7 @@ var RunnablePassthrough = class extends Runnable {
 		return new RunnableAssign(new RunnableMap({ steps: mapping }));
 	}
 };
-
 //#endregion
 export { RunnablePassthrough };
+
 //# sourceMappingURL=passthrough.js.map

package/dist/runnables/passthrough.js.map

@@ -1 +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"}
+{"version":3,"file":"passthrough.js","names":[],"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// oxlint-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// oxlint-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            // oxlint-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;;CAGT,eAAe,CAAC,kBAAkB,YAAY;CAE9C,kBAAkB;CAElB;CAEA,YAAY,QAAuD;AACjE,QAAM,OAAO;AACb,MAAI,OACF,MAAK,OAAO,OAAO;;CAIvB,MAAM,OACJ,OACA,SACmB;EACnB,MAAM,SAAS,aAAa,QAAQ;AACpC,MAAI,KAAK,KACP,OAAM,KAAK,KAAK,OAAO,OAAO;AAGhC,SAAO,KAAK,iBACT,UAAoB,QAAQ,QAAQ,MAAM,EAC3C,OACA,OACD;;CAGH,OAAO,UACL,WACA,SAC0B;EAC1B,MAAM,SAAS,aAAa,QAAQ;EACpC,IAAI;EACJ,IAAI,uBAAuB;AAE3B,aAAW,MAAM,SAAS,KAAK,2BAC7B,YACC,UAAoC,OACrC,OACD,EAAE;AACD,SAAM;AACN,OAAI,qBACF,KAAI,gBAAgB,KAAA,EAClB,eAAc;OAEd,KAAI;AAEF,kBAAc,OAAO,aAAa,MAAa;WACzC;AACN,kBAAc,KAAA;AACd,2BAAuB;;;AAM/B,MAAI,KAAK,QAAQ,gBAAgB,KAAA,EAC/B,OAAM,KAAK,KAAK,aAAa,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgCxC,OAAO,OAIL,SACgD;AAChD,SAAO,IAAI,eAAe,IAAI,YAAY,EAAE,OAAO,SAAS,CAAC,CAAC"}

package/dist/runnables/router.cjs

@@ -1,6 +1,5 @@
-const require_config = require('./config.cjs');
-const require_base = require('./base.cjs');
-
+const require_config = require("./config.cjs");
+const require_base = require("./base.cjs");
 //#region src/runnables/router.ts
 /**
 * A runnable that routes to a set of runnables based on Input['key'].
@@ -49,15 +48,14 @@ var RouterRunnable = class extends require_base.Runnable {
 	async batch(inputs, options, batchOptions) {
 		const keys = inputs.map((input) => input.key);
 		const actualInputs = inputs.map((input) => input.input);
-		const missingKey = keys.find((key) => this.runnables[key] === void 0);
-		if (missingKey !== void 0) throw new Error(`One or more keys do not have a corresponding runnable.`);
+		if (keys.find((key) => this.runnables[key] === void 0) !== void 0) throw new Error(`One or more keys do not have a corresponding runnable.`);
 		const runnables = keys.map((key) => this.runnables[key]);
 		const optionsList = this._getOptionsList(options ?? {}, inputs.length);
 		const maxConcurrency = optionsList[0]?.maxConcurrency ?? batchOptions?.maxConcurrency;
 		const batchSize = maxConcurrency && maxConcurrency > 0 ? maxConcurrency : inputs.length;
 		const batchResults = [];
 		for (let i = 0; i < actualInputs.length; i += batchSize) {
-			const batchPromises = actualInputs.slice(i, i + batchSize).map((actualInput, i$1) => runnables[i$1].invoke(actualInput, optionsList[i$1]));
+			const batchPromises = actualInputs.slice(i, i + batchSize).map((actualInput, i) => runnables[i].invoke(actualInput, optionsList[i]));
 			const batchResult = await Promise.all(batchPromises);
 			batchResults.push(batchResult);
 		}
@@ -70,7 +68,7 @@ var RouterRunnable = class extends require_base.Runnable {
 		return runnable.stream(actualInput, options);
 	}
 };
-
 //#endregion
 exports.RouterRunnable = RouterRunnable;
+
 //# sourceMappingURL=router.cjs.map

package/dist/runnables/router.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"router.cjs","names":["Runnable","fields: {\n    runnables: Record<string, Runnable<RunnableInput, RunOutput>>;\n  }","input: RunInput","options?: Partial<RunnableConfig>","ensureConfig","inputs: RunInput[]","options?: Partial<RunnableConfig> | Partial<RunnableConfig>[]","batchOptions?: RunnableBatchOptions","i"],"sources":["../../src/runnables/router.ts"],"sourcesContent":["import { Runnable, type RunnableBatchOptions } from \"./base.js\";\nimport { IterableReadableStream } from \"../utils/stream.js\";\nimport { ensureConfig, type RunnableConfig } from \"./config.js\";\n\nexport type RouterInput = {\n  key: string;\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  input: any;\n};\n\n/**\n * A runnable that routes to a set of runnables based on Input['key'].\n * Returns the output of the selected runnable.\n * @example\n * ```typescript\n * import { RouterRunnable, RunnableLambda } from \"@langchain/core/runnables\";\n *\n * const router = new RouterRunnable({\n *   runnables: {\n *     toUpperCase: RunnableLambda.from((text: string) => text.toUpperCase()),\n *     reverseText: RunnableLambda.from((text: string) =>\n *       text.split(\"\").reverse().join(\"\")\n *     ),\n *   },\n * });\n *\n * // Invoke the 'reverseText' runnable\n * const result1 = router.invoke({ key: \"reverseText\", input: \"Hello World\" });\n *\n * // \"dlroW olleH\"\n *\n * // Invoke the 'toUpperCase' runnable\n * const result2 = router.invoke({ key: \"toUpperCase\", input: \"Hello World\" });\n *\n * // \"HELLO WORLD\"\n * ```\n */\nexport class RouterRunnable<\n  RunInput extends RouterInput,\n  RunnableInput,\n  RunOutput\n> extends Runnable<RunInput, RunOutput> {\n  static lc_name() {\n    return \"RouterRunnable\";\n  }\n\n  lc_namespace = [\"langchain_core\", \"runnables\"];\n\n  lc_serializable = true;\n\n  runnables: Record<string, Runnable<RunnableInput, RunOutput>>;\n\n  constructor(fields: {\n    runnables: Record<string, Runnable<RunnableInput, RunOutput>>;\n  }) {\n    super(fields);\n    this.runnables = fields.runnables;\n  }\n\n  async invoke(\n    input: RunInput,\n    options?: Partial<RunnableConfig>\n  ): Promise<RunOutput> {\n    const { key, input: actualInput } = input;\n    const runnable = this.runnables[key];\n    if (runnable === undefined) {\n      throw new Error(`No runnable associated with key \"${key}\".`);\n    }\n    return runnable.invoke(actualInput, ensureConfig(options));\n  }\n\n  async batch(\n    inputs: RunInput[],\n    options?: Partial<RunnableConfig> | Partial<RunnableConfig>[],\n    batchOptions?: RunnableBatchOptions & { returnExceptions?: false }\n  ): Promise<RunOutput[]>;\n\n  async batch(\n    inputs: RunInput[],\n    options?: Partial<RunnableConfig> | Partial<RunnableConfig>[],\n    batchOptions?: RunnableBatchOptions & { returnExceptions: true }\n  ): Promise<(RunOutput | Error)[]>;\n\n  async batch(\n    inputs: RunInput[],\n    options?: Partial<RunnableConfig> | Partial<RunnableConfig>[],\n    batchOptions?: RunnableBatchOptions\n  ): Promise<(RunOutput | Error)[]>;\n\n  async batch(\n    inputs: RunInput[],\n    options?: Partial<RunnableConfig> | Partial<RunnableConfig>[],\n    batchOptions?: RunnableBatchOptions\n  ): Promise<(RunOutput | Error)[]> {\n    const keys = inputs.map((input) => input.key);\n    const actualInputs = inputs.map((input) => input.input);\n    const missingKey = keys.find((key) => this.runnables[key] === undefined);\n    if (missingKey !== undefined) {\n      throw new Error(`One or more keys do not have a corresponding runnable.`);\n    }\n    const runnables = keys.map((key) => this.runnables[key]);\n    const optionsList = this._getOptionsList(options ?? {}, inputs.length);\n    const maxConcurrency =\n      optionsList[0]?.maxConcurrency ?? batchOptions?.maxConcurrency;\n    const batchSize =\n      maxConcurrency && maxConcurrency > 0 ? maxConcurrency : inputs.length;\n    const batchResults = [];\n    for (let i = 0; i < actualInputs.length; i += batchSize) {\n      const batchPromises = actualInputs\n        .slice(i, i + batchSize)\n        .map((actualInput, i) =>\n          runnables[i].invoke(actualInput, optionsList[i])\n        );\n      const batchResult = await Promise.all(batchPromises);\n      batchResults.push(batchResult);\n    }\n    return batchResults.flat();\n  }\n\n  async stream(\n    input: RunInput,\n    options?: Partial<RunnableConfig>\n  ): Promise<IterableReadableStream<RunOutput>> {\n    const { key, input: actualInput } = input;\n    const runnable = this.runnables[key];\n    if (runnable === undefined) {\n      throw new Error(`No runnable associated with key \"${key}\".`);\n    }\n    return runnable.stream(actualInput, options);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCA,IAAa,iBAAb,cAIUA,sBAA8B;CACtC,OAAO,UAAU;AACf,SAAO;CACR;CAED,eAAe,CAAC,kBAAkB,WAAY;CAE9C,kBAAkB;CAElB;CAEA,YAAYC,QAET;EACD,MAAM,OAAO;EACb,KAAK,YAAY,OAAO;CACzB;CAED,MAAM,OACJC,OACAC,SACoB;EACpB,MAAM,EAAE,KAAK,OAAO,aAAa,GAAG;EACpC,MAAM,WAAW,KAAK,UAAU;AAChC,MAAI,aAAa,OACf,OAAM,IAAI,MAAM,CAAC,iCAAiC,EAAE,IAAI,EAAE,CAAC;AAE7D,SAAO,SAAS,OAAO,aAAaC,4BAAa,QAAQ,CAAC;CAC3D;CAoBD,MAAM,MACJC,QACAC,SACAC,cACgC;EAChC,MAAM,OAAO,OAAO,IAAI,CAAC,UAAU,MAAM,IAAI;EAC7C,MAAM,eAAe,OAAO,IAAI,CAAC,UAAU,MAAM,MAAM;EACvD,MAAM,aAAa,KAAK,KAAK,CAAC,QAAQ,KAAK,UAAU,SAAS,OAAU;AACxE,MAAI,eAAe,OACjB,OAAM,IAAI,MAAM,CAAC,sDAAsD,CAAC;EAE1E,MAAM,YAAY,KAAK,IAAI,CAAC,QAAQ,KAAK,UAAU,KAAK;EACxD,MAAM,cAAc,KAAK,gBAAgB,WAAW,CAAE,GAAE,OAAO,OAAO;EACtE,MAAM,iBACJ,YAAY,IAAI,kBAAkB,cAAc;EAClD,MAAM,YACJ,kBAAkB,iBAAiB,IAAI,iBAAiB,OAAO;EACjE,MAAM,eAAe,CAAE;AACvB,OAAK,IAAI,IAAI,GAAG,IAAI,aAAa,QAAQ,KAAK,WAAW;GACvD,MAAM,gBAAgB,aACnB,MAAM,GAAG,IAAI,UAAU,CACvB,IAAI,CAAC,aAAaC,QACjB,UAAUA,KAAG,OAAO,aAAa,YAAYA,KAAG,CACjD;GACH,MAAM,cAAc,MAAM,QAAQ,IAAI,cAAc;GACpD,aAAa,KAAK,YAAY;EAC/B;AACD,SAAO,aAAa,MAAM;CAC3B;CAED,MAAM,OACJN,OACAC,SAC4C;EAC5C,MAAM,EAAE,KAAK,OAAO,aAAa,GAAG;EACpC,MAAM,WAAW,KAAK,UAAU;AAChC,MAAI,aAAa,OACf,OAAM,IAAI,MAAM,CAAC,iCAAiC,EAAE,IAAI,EAAE,CAAC;AAE7D,SAAO,SAAS,OAAO,aAAa,QAAQ;CAC7C;AACF"}
+{"version":3,"file":"router.cjs","names":["Runnable","ensureConfig"],"sources":["../../src/runnables/router.ts"],"sourcesContent":["import { Runnable, type RunnableBatchOptions } from \"./base.js\";\nimport { IterableReadableStream } from \"../utils/stream.js\";\nimport { ensureConfig, type RunnableConfig } from \"./config.js\";\n\nexport type RouterInput = {\n  key: string;\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n  input: any;\n};\n\n/**\n * A runnable that routes to a set of runnables based on Input['key'].\n * Returns the output of the selected runnable.\n * @example\n * ```typescript\n * import { RouterRunnable, RunnableLambda } from \"@langchain/core/runnables\";\n *\n * const router = new RouterRunnable({\n *   runnables: {\n *     toUpperCase: RunnableLambda.from((text: string) => text.toUpperCase()),\n *     reverseText: RunnableLambda.from((text: string) =>\n *       text.split(\"\").reverse().join(\"\")\n *     ),\n *   },\n * });\n *\n * // Invoke the 'reverseText' runnable\n * const result1 = router.invoke({ key: \"reverseText\", input: \"Hello World\" });\n *\n * // \"dlroW olleH\"\n *\n * // Invoke the 'toUpperCase' runnable\n * const result2 = router.invoke({ key: \"toUpperCase\", input: \"Hello World\" });\n *\n * // \"HELLO WORLD\"\n * ```\n */\nexport class RouterRunnable<\n  RunInput extends RouterInput,\n  RunnableInput,\n  RunOutput,\n> extends Runnable<RunInput, RunOutput> {\n  static lc_name() {\n    return \"RouterRunnable\";\n  }\n\n  lc_namespace = [\"langchain_core\", \"runnables\"];\n\n  lc_serializable = true;\n\n  runnables: Record<string, Runnable<RunnableInput, RunOutput>>;\n\n  constructor(fields: {\n    runnables: Record<string, Runnable<RunnableInput, RunOutput>>;\n  }) {\n    super(fields);\n    this.runnables = fields.runnables;\n  }\n\n  async invoke(\n    input: RunInput,\n    options?: Partial<RunnableConfig>\n  ): Promise<RunOutput> {\n    const { key, input: actualInput } = input;\n    const runnable = this.runnables[key];\n    if (runnable === undefined) {\n      throw new Error(`No runnable associated with key \"${key}\".`);\n    }\n    return runnable.invoke(actualInput, ensureConfig(options));\n  }\n\n  async batch(\n    inputs: RunInput[],\n    options?: Partial<RunnableConfig> | Partial<RunnableConfig>[],\n    batchOptions?: RunnableBatchOptions & { returnExceptions?: false }\n  ): Promise<RunOutput[]>;\n\n  async batch(\n    inputs: RunInput[],\n    options?: Partial<RunnableConfig> | Partial<RunnableConfig>[],\n    batchOptions?: RunnableBatchOptions & { returnExceptions: true }\n  ): Promise<(RunOutput | Error)[]>;\n\n  async batch(\n    inputs: RunInput[],\n    options?: Partial<RunnableConfig> | Partial<RunnableConfig>[],\n    batchOptions?: RunnableBatchOptions\n  ): Promise<(RunOutput | Error)[]>;\n\n  async batch(\n    inputs: RunInput[],\n    options?: Partial<RunnableConfig> | Partial<RunnableConfig>[],\n    batchOptions?: RunnableBatchOptions\n  ): Promise<(RunOutput | Error)[]> {\n    const keys = inputs.map((input) => input.key);\n    const actualInputs = inputs.map((input) => input.input);\n    const missingKey = keys.find((key) => this.runnables[key] === undefined);\n    if (missingKey !== undefined) {\n      throw new Error(`One or more keys do not have a corresponding runnable.`);\n    }\n    const runnables = keys.map((key) => this.runnables[key]);\n    const optionsList = this._getOptionsList(options ?? {}, inputs.length);\n    const maxConcurrency =\n      optionsList[0]?.maxConcurrency ?? batchOptions?.maxConcurrency;\n    const batchSize =\n      maxConcurrency && maxConcurrency > 0 ? maxConcurrency : inputs.length;\n    const batchResults = [];\n    for (let i = 0; i < actualInputs.length; i += batchSize) {\n      const batchPromises = actualInputs\n        .slice(i, i + batchSize)\n        .map((actualInput, i) =>\n          runnables[i].invoke(actualInput, optionsList[i])\n        );\n      const batchResult = await Promise.all(batchPromises);\n      batchResults.push(batchResult);\n    }\n    return batchResults.flat();\n  }\n\n  async stream(\n    input: RunInput,\n    options?: Partial<RunnableConfig>\n  ): Promise<IterableReadableStream<RunOutput>> {\n    const { key, input: actualInput } = input;\n    const runnable = this.runnables[key];\n    if (runnable === undefined) {\n      throw new Error(`No runnable associated with key \"${key}\".`);\n    }\n    return runnable.stream(actualInput, options);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCA,IAAa,iBAAb,cAIUA,aAAAA,SAA8B;CACtC,OAAO,UAAU;AACf,SAAO;;CAGT,eAAe,CAAC,kBAAkB,YAAY;CAE9C,kBAAkB;CAElB;CAEA,YAAY,QAET;AACD,QAAM,OAAO;AACb,OAAK,YAAY,OAAO;;CAG1B,MAAM,OACJ,OACA,SACoB;EACpB,MAAM,EAAE,KAAK,OAAO,gBAAgB;EACpC,MAAM,WAAW,KAAK,UAAU;AAChC,MAAI,aAAa,KAAA,EACf,OAAM,IAAI,MAAM,oCAAoC,IAAI,IAAI;AAE9D,SAAO,SAAS,OAAO,aAAaC,eAAAA,aAAa,QAAQ,CAAC;;CAqB5D,MAAM,MACJ,QACA,SACA,cACgC;EAChC,MAAM,OAAO,OAAO,KAAK,UAAU,MAAM,IAAI;EAC7C,MAAM,eAAe,OAAO,KAAK,UAAU,MAAM,MAAM;AAEvD,MADmB,KAAK,MAAM,QAAQ,KAAK,UAAU,SAAS,KAAA,EAChD,KAAK,KAAA,EACjB,OAAM,IAAI,MAAM,yDAAyD;EAE3E,MAAM,YAAY,KAAK,KAAK,QAAQ,KAAK,UAAU,KAAK;EACxD,MAAM,cAAc,KAAK,gBAAgB,WAAW,EAAE,EAAE,OAAO,OAAO;EACtE,MAAM,iBACJ,YAAY,IAAI,kBAAkB,cAAc;EAClD,MAAM,YACJ,kBAAkB,iBAAiB,IAAI,iBAAiB,OAAO;EACjE,MAAM,eAAe,EAAE;AACvB,OAAK,IAAI,IAAI,GAAG,IAAI,aAAa,QAAQ,KAAK,WAAW;GACvD,MAAM,gBAAgB,aACnB,MAAM,GAAG,IAAI,UAAU,CACvB,KAAK,aAAa,MACjB,UAAU,GAAG,OAAO,aAAa,YAAY,GAAG,CACjD;GACH,MAAM,cAAc,MAAM,QAAQ,IAAI,cAAc;AACpD,gBAAa,KAAK,YAAY;;AAEhC,SAAO,aAAa,MAAM;;CAG5B,MAAM,OACJ,OACA,SAC4C;EAC5C,MAAM,EAAE,KAAK,OAAO,gBAAgB;EACpC,MAAM,WAAW,KAAK,UAAU;AAChC,MAAI,aAAa,KAAA,EACf,OAAM,IAAI,MAAM,oCAAoC,IAAI,IAAI;AAE9D,SAAO,SAAS,OAAO,aAAa,QAAQ"}

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

@@ -1 +1 @@
-{"version":3,"file":"router.d.cts","names":["Runnable","RunnableBatchOptions","IterableReadableStream","RunnableConfig","RouterInput","RouterRunnable","RunInput","RunnableInput","RunOutput","Record","Partial","Promise","Error"],"sources":["../../src/runnables/router.d.ts"],"sourcesContent":["import { Runnable, type RunnableBatchOptions } from \"./base.js\";\nimport { IterableReadableStream } from \"../utils/stream.js\";\nimport { type RunnableConfig } from \"./config.js\";\nexport type RouterInput = {\n    key: string;\n    input: any;\n};\n/**\n * A runnable that routes to a set of runnables based on Input['key'].\n * Returns the output of the selected runnable.\n * @example\n * ```typescript\n * import { RouterRunnable, RunnableLambda } from \"@langchain/core/runnables\";\n *\n * const router = new RouterRunnable({\n *   runnables: {\n *     toUpperCase: RunnableLambda.from((text: string) => text.toUpperCase()),\n *     reverseText: RunnableLambda.from((text: string) =>\n *       text.split(\"\").reverse().join(\"\")\n *     ),\n *   },\n * });\n *\n * // Invoke the 'reverseText' runnable\n * const result1 = router.invoke({ key: \"reverseText\", input: \"Hello World\" });\n *\n * // \"dlroW olleH\"\n *\n * // Invoke the 'toUpperCase' runnable\n * const result2 = router.invoke({ key: \"toUpperCase\", input: \"Hello World\" });\n *\n * // \"HELLO WORLD\"\n * ```\n */\nexport declare class RouterRunnable<RunInput extends RouterInput, RunnableInput, RunOutput> extends Runnable<RunInput, RunOutput> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    runnables: Record<string, Runnable<RunnableInput, RunOutput>>;\n    constructor(fields: {\n        runnables: Record<string, Runnable<RunnableInput, RunOutput>>;\n    });\n    invoke(input: RunInput, options?: Partial<RunnableConfig>): Promise<RunOutput>;\n    batch(inputs: RunInput[], options?: Partial<RunnableConfig> | Partial<RunnableConfig>[], batchOptions?: RunnableBatchOptions & {\n        returnExceptions?: false;\n    }): Promise<RunOutput[]>;\n    batch(inputs: RunInput[], options?: Partial<RunnableConfig> | Partial<RunnableConfig>[], batchOptions?: RunnableBatchOptions & {\n        returnExceptions: true;\n    }): Promise<(RunOutput | Error)[]>;\n    batch(inputs: RunInput[], options?: Partial<RunnableConfig> | Partial<RunnableConfig>[], batchOptions?: RunnableBatchOptions): Promise<(RunOutput | Error)[]>;\n    stream(input: RunInput, options?: Partial<RunnableConfig>): Promise<IterableReadableStream<RunOutput>>;\n}\n//# sourceMappingURL=router.d.ts.map"],"mappings":";;;;;KAGYI,WAAAA;;EAAAA,KAAAA,EAAAA,GAAAA;AA+BZ,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAY0ED,cAZrDE,cAYqDF,CAAAA,iBAZrBC,WAYqBD,EAAAA,aAAAA,EAAAA,SAAAA,CAAAA,SAZ0BH,QAY1BG,CAZmCG,QAYnCH,EAZ6CK,SAY7CL,CAAAA,CAAAA;EAARO,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAA0CT,YAAAA,EAAAA,MAAAA,EAAAA;EAE3FO,eAAAA,EAAAA,OAAAA;EAAYI,SAAAA,EAVdH,MAUcG,CAAAA,MAAAA,EAVCZ,QAUDY,CAVUL,aAUVK,EAVyBJ,SAUzBI,CAAAA,CAAAA;EAArBD,WAAAA,CAAAA,MAAAA,EAAAA;IACUL,SAAAA,EATCG,MASDH,CAAAA,MAAAA,EATgBN,QAShBM,CATyBC,aASzBD,EATwCE,SASxCF,CAAAA,CAAAA;EAA8BH,CAAAA;EAARO,MAAAA,CAAAA,KAAAA,EAPtBJ,QAOsBI,EAAAA,OAAAA,CAAAA,EAPFA,OAOEA,CAPMP,cAONO,CAAAA,CAAAA,EAPwBC,OAOxBD,CAPgCF,SAOhCE,CAAAA;EAAkCP,KAAAA,CAAAA,MAAAA,EANxDG,QAMwDH,EAAAA,EAAAA,OAAAA,CAAAA,EANlCO,OAMkCP,CAN1BA,cAM0BA,CAAAA,GANRO,OAMQP,CANAA,cAMAA,CAAAA,EAAAA,EAAAA,YAAkCF,CAAlCE,EANkCF,oBAMlCE,GAAAA;IAARO,gBAAAA,CAAAA,EAAAA,KAAAA;EAA0CT,CAAAA,CAAAA,EAJpGU,OAIoGV,CAJ5FO,SAI4FP,EAAAA,CAAAA;EAAgCO,KAAAA,CAAAA,MAAAA,EAH1HF,QAG0HE,EAAAA,EAAAA,OAAAA,CAAAA,EAHpGE,OAGoGF,CAH5FL,cAG4FK,CAAAA,GAH1EE,OAG0EF,CAHlEL,cAGkEK,CAAAA,EAAAA,EAAAA,YAATG,CAASH,EAHhCP,oBAGgCO,GAAAA;IAAYI,gBAAAA,EAAAA,IAAAA;EAArBD,CAAAA,CAAAA,EAD3HA,OAC2HA,CAAAA,CADlHH,SACkHG,GADtGC,KACsGD,CAAAA,EAAAA,CAAAA;EACjHL,KAAAA,CAAAA,MAAAA,EADAA,QACAA,EAAAA,EAAAA,OAAAA,CAAAA,EADsBI,OACtBJ,CAD8BH,cAC9BG,CAAAA,GADgDI,OAChDJ,CADwDH,cACxDG,CAAAA,EAAAA,EAAAA,YAAAA,CAAAA,EAD0FL,oBAC1FK,CAAAA,EADiHK,OACjHL,CAAAA,CAD0HE,SAC1HF,GADsIM,KACtIN,CAAAA,EAAAA,CAAAA;EAA4BH,MAAAA,CAAAA,KAAAA,EAA5BG,QAA4BH,EAAAA,OAAAA,CAAAA,EAARO,OAAQP,CAAAA,cAAAA,CAAAA,CAAAA,EAAkBQ,OAAlBR,CAA0BD,sBAA1BC,CAAiDK,SAAjDL,CAAAA,CAAAA"}
+{"version":3,"file":"router.d.cts","names":[],"sources":["../../src/runnables/router.ts"],"mappings":";;;;;KAIY,WAAA;EACV,GAAA;EAEA,KAAA;AAAA;;;;;AA8BF;;;;;;;;;;;;;;;;;;;;;;;cAAa,cAAA,kBACM,WAAA,oCAGT,QAAA,CAAS,QAAA,EAAU,SAAA;EAAA,OACpB,OAAA,CAAA;EAIP,YAAA;EAEA,eAAA;EAEA,SAAA,EAAW,MAAA,SAAe,QAAA,CAAS,aAAA,EAAe,SAAA;EAElD,WAAA,CAAY,MAAA;IACV,SAAA,EAAW,MAAA,SAAe,QAAA,CAAS,aAAA,EAAe,SAAA;EAAA;EAM9C,MAAA,CACJ,KAAA,EAAO,QAAA,EACP,OAAA,GAAU,OAAA,CAAQ,cAAA,IACjB,OAAA,CAAQ,SAAA;EASL,KAAA,CACJ,MAAA,EAAQ,QAAA,IACR,OAAA,GAAU,OAAA,CAAQ,cAAA,IAAkB,OAAA,CAAQ,cAAA,KAC5C,YAAA,GAAe,oBAAA;IAAyB,gBAAA;EAAA,IACvC,OAAA,CAAQ,SAAA;EAEL,KAAA,CACJ,MAAA,EAAQ,QAAA,IACR,OAAA,GAAU,OAAA,CAAQ,cAAA,IAAkB,OAAA,CAAQ,cAAA,KAC5C,YAAA,GAAe,oBAAA;IAAyB,gBAAA;EAAA,IACvC,OAAA,EAAS,SAAA,GAAY,KAAA;EAElB,KAAA,CACJ,MAAA,EAAQ,QAAA,IACR,OAAA,GAAU,OAAA,CAAQ,cAAA,IAAkB,OAAA,CAAQ,cAAA,KAC5C,YAAA,GAAe,oBAAA,GACd,OAAA,EAAS,SAAA,GAAY,KAAA;EAgClB,MAAA,CACJ,KAAA,EAAO,QAAA,EACP,OAAA,GAAU,OAAA,CAAQ,cAAA,IACjB,OAAA,CAAQ,sBAAA,CAAuB,SAAA;AAAA"}

package/dist/runnables/router.d.ts

@@ -1,5 +1,4 @@
 import { RunnableBatchOptions, RunnableConfig } from "./types.js";
-import "./config.js";
 import { IterableReadableStream } from "../utils/stream.js";
 import { Runnable } from "./base.js";
 

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

@@ -1 +1 @@
-{"version":3,"file":"router.d.ts","names":["Runnable","RunnableBatchOptions","IterableReadableStream","RunnableConfig","RouterInput","RouterRunnable","RunInput","RunnableInput","RunOutput","Record","Partial","Promise","Error"],"sources":["../../src/runnables/router.d.ts"],"sourcesContent":["import { Runnable, type RunnableBatchOptions } from \"./base.js\";\nimport { IterableReadableStream } from \"../utils/stream.js\";\nimport { type RunnableConfig } from \"./config.js\";\nexport type RouterInput = {\n    key: string;\n    input: any;\n};\n/**\n * A runnable that routes to a set of runnables based on Input['key'].\n * Returns the output of the selected runnable.\n * @example\n * ```typescript\n * import { RouterRunnable, RunnableLambda } from \"@langchain/core/runnables\";\n *\n * const router = new RouterRunnable({\n *   runnables: {\n *     toUpperCase: RunnableLambda.from((text: string) => text.toUpperCase()),\n *     reverseText: RunnableLambda.from((text: string) =>\n *       text.split(\"\").reverse().join(\"\")\n *     ),\n *   },\n * });\n *\n * // Invoke the 'reverseText' runnable\n * const result1 = router.invoke({ key: \"reverseText\", input: \"Hello World\" });\n *\n * // \"dlroW olleH\"\n *\n * // Invoke the 'toUpperCase' runnable\n * const result2 = router.invoke({ key: \"toUpperCase\", input: \"Hello World\" });\n *\n * // \"HELLO WORLD\"\n * ```\n */\nexport declare class RouterRunnable<RunInput extends RouterInput, RunnableInput, RunOutput> extends Runnable<RunInput, RunOutput> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    lc_serializable: boolean;\n    runnables: Record<string, Runnable<RunnableInput, RunOutput>>;\n    constructor(fields: {\n        runnables: Record<string, Runnable<RunnableInput, RunOutput>>;\n    });\n    invoke(input: RunInput, options?: Partial<RunnableConfig>): Promise<RunOutput>;\n    batch(inputs: RunInput[], options?: Partial<RunnableConfig> | Partial<RunnableConfig>[], batchOptions?: RunnableBatchOptions & {\n        returnExceptions?: false;\n    }): Promise<RunOutput[]>;\n    batch(inputs: RunInput[], options?: Partial<RunnableConfig> | Partial<RunnableConfig>[], batchOptions?: RunnableBatchOptions & {\n        returnExceptions: true;\n    }): Promise<(RunOutput | Error)[]>;\n    batch(inputs: RunInput[], options?: Partial<RunnableConfig> | Partial<RunnableConfig>[], batchOptions?: RunnableBatchOptions): Promise<(RunOutput | Error)[]>;\n    stream(input: RunInput, options?: Partial<RunnableConfig>): Promise<IterableReadableStream<RunOutput>>;\n}\n//# sourceMappingURL=router.d.ts.map"],"mappings":";;;;;;KAGYI,WAAAA;;;AAAZ,CAAA;AA+BA;;;;;;;;;;;;;;;;;;;;;;;;;;;AAYwCM,cAZnBL,cAYmBK,CAAAA,iBAZaN,WAYbM,EAAAA,aAAAA,EAAAA,SAAAA,CAAAA,SAZ4DV,QAY5DU,CAZqEJ,QAYrEI,EAZ+EF,SAY/EE,CAAAA,CAAAA;EAAkCP,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAARO,YAAAA,EAAAA,MAAAA,EAAAA;EAA0CT,eAAAA,EAAAA,OAAAA;EAE3FO,SAAAA,EAVFC,MAUED,CAAAA,MAAAA,EAVaR,QAUbQ,CAVsBD,aAUtBC,EAVqCA,SAUrCA,CAAAA,CAAAA;EAAYI,WAAAA,CAAAA,MAAAA,EAAAA;IAArBD,SAAAA,EARWF,MAQXE,CAAAA,MAAAA,EAR0BX,QAQ1BW,CARmCJ,aAQnCI,EARkDH,SAQlDG,CAAAA,CAAAA;EACUL,CAAAA;EAA8BH,MAAAA,CAAAA,KAAAA,EAP9BG,QAO8BH,EAAAA,OAAAA,CAAAA,EAPVO,OAOUP,CAPFA,cAOEA,CAAAA,CAAAA,EAPgBQ,OAOhBR,CAPwBK,SAOxBL,CAAAA;EAARO,KAAAA,CAAAA,MAAAA,EANtBJ,QAMsBI,EAAAA,EAAAA,OAAAA,CAAAA,EANAA,OAMAA,CANQP,cAMRO,CAAAA,GAN0BA,OAM1BA,CANkCP,cAMlCO,CAAAA,EAAAA,EAAAA,YAA0BA,CAA1BA,EANoET,oBAMpES,GAAAA;IAAkCP,gBAAAA,CAAAA,EAAAA,KAAAA;EAARO,CAAAA,CAAAA,EAJ1DC,OAI0DD,CAJlDF,SAIkDE,EAAAA,CAAAA;EAA0CT,KAAAA,CAAAA,MAAAA,EAH1FK,QAG0FL,EAAAA,EAAAA,OAAAA,CAAAA,EAHpES,OAGoET,CAH5DE,cAG4DF,CAAAA,GAH1CS,OAG0CT,CAHlCE,cAGkCF,CAAAA,EAAAA,EAAAA,YAA4CW,CAA5CX,EAHAA,oBAGAA,GAAAA;IAAgCO,gBAAAA,EAAAA,IAAAA;EAAYI,CAAAA,CAAAA,EADhJD,OACgJC,CAAAA,CADvIJ,SACuII,GAD3HA,KAC2HA,CAAAA,EAAAA,CAAAA;EAArBD,KAAAA,CAAAA,MAAAA,EAAjHL,QAAiHK,EAAAA,EAAAA,OAAAA,CAAAA,EAA3FD,OAA2FC,CAAnFR,cAAmFQ,CAAAA,GAAjED,OAAiEC,CAAzDR,cAAyDQ,CAAAA,EAAAA,EAAAA,YAAAA,CAAAA,EAAvBV,oBAAuBU,CAAAA,EAAAA,OAAAA,CAAAA,CAASH,SAATG,GAAqBC,KAArBD,CAAAA,EAAAA,CAAAA;EACjHL,MAAAA,CAAAA,KAAAA,EAAAA,QAAAA,EAAAA,OAAAA,CAAAA,EAAoBI,OAApBJ,CAA4BH,cAA5BG,CAAAA,CAAAA,EAA8CK,OAA9CL,CAAsDJ,sBAAtDI,CAA6EE,SAA7EF,CAAAA,CAAAA"}
+{"version":3,"file":"router.d.ts","names":[],"sources":["../../src/runnables/router.ts"],"mappings":";;;;;KAIY,WAAA;EACV,GAAA;EAEA,KAAA;AAAA;;;;;AA8BF;;;;;;;;;;;;;;;;;;;;;;;cAAa,cAAA,kBACM,WAAA,oCAGT,QAAA,CAAS,QAAA,EAAU,SAAA;EAAA,OACpB,OAAA,CAAA;EAIP,YAAA;EAEA,eAAA;EAEA,SAAA,EAAW,MAAA,SAAe,QAAA,CAAS,aAAA,EAAe,SAAA;EAElD,WAAA,CAAY,MAAA;IACV,SAAA,EAAW,MAAA,SAAe,QAAA,CAAS,aAAA,EAAe,SAAA;EAAA;EAM9C,MAAA,CACJ,KAAA,EAAO,QAAA,EACP,OAAA,GAAU,OAAA,CAAQ,cAAA,IACjB,OAAA,CAAQ,SAAA;EASL,KAAA,CACJ,MAAA,EAAQ,QAAA,IACR,OAAA,GAAU,OAAA,CAAQ,cAAA,IAAkB,OAAA,CAAQ,cAAA,KAC5C,YAAA,GAAe,oBAAA;IAAyB,gBAAA;EAAA,IACvC,OAAA,CAAQ,SAAA;EAEL,KAAA,CACJ,MAAA,EAAQ,QAAA,IACR,OAAA,GAAU,OAAA,CAAQ,cAAA,IAAkB,OAAA,CAAQ,cAAA,KAC5C,YAAA,GAAe,oBAAA;IAAyB,gBAAA;EAAA,IACvC,OAAA,EAAS,SAAA,GAAY,KAAA;EAElB,KAAA,CACJ,MAAA,EAAQ,QAAA,IACR,OAAA,GAAU,OAAA,CAAQ,cAAA,IAAkB,OAAA,CAAQ,cAAA,KAC5C,YAAA,GAAe,oBAAA,GACd,OAAA,EAAS,SAAA,GAAY,KAAA;EAgClB,MAAA,CACJ,KAAA,EAAO,QAAA,EACP,OAAA,GAAU,OAAA,CAAQ,cAAA,IACjB,OAAA,CAAQ,sBAAA,CAAuB,SAAA;AAAA"}

package/dist/runnables/router.js

@@ -1,6 +1,5 @@
 import { ensureConfig } from "./config.js";
 import { Runnable } from "./base.js";
-
 //#region src/runnables/router.ts
 /**
 * A runnable that routes to a set of runnables based on Input['key'].
@@ -49,15 +48,14 @@ var RouterRunnable = class extends Runnable {
 	async batch(inputs, options, batchOptions) {
 		const keys = inputs.map((input) => input.key);
 		const actualInputs = inputs.map((input) => input.input);
-		const missingKey = keys.find((key) => this.runnables[key] === void 0);
-		if (missingKey !== void 0) throw new Error(`One or more keys do not have a corresponding runnable.`);
+		if (keys.find((key) => this.runnables[key] === void 0) !== void 0) throw new Error(`One or more keys do not have a corresponding runnable.`);
 		const runnables = keys.map((key) => this.runnables[key]);
 		const optionsList = this._getOptionsList(options ?? {}, inputs.length);
 		const maxConcurrency = optionsList[0]?.maxConcurrency ?? batchOptions?.maxConcurrency;
 		const batchSize = maxConcurrency && maxConcurrency > 0 ? maxConcurrency : inputs.length;
 		const batchResults = [];
 		for (let i = 0; i < actualInputs.length; i += batchSize) {
-			const batchPromises = actualInputs.slice(i, i + batchSize).map((actualInput, i$1) => runnables[i$1].invoke(actualInput, optionsList[i$1]));
+			const batchPromises = actualInputs.slice(i, i + batchSize).map((actualInput, i) => runnables[i].invoke(actualInput, optionsList[i]));
 			const batchResult = await Promise.all(batchPromises);
 			batchResults.push(batchResult);
 		}
@@ -70,7 +68,7 @@ var RouterRunnable = class extends Runnable {
 		return runnable.stream(actualInput, options);
 	}
 };
-
 //#endregion
 export { RouterRunnable };
+
 //# sourceMappingURL=router.js.map

package/dist/runnables/router.js.map

@@ -1 +1 @@
-{"version":3,"file":"router.js","names":["fields: {\n    runnables: Record<string, Runnable<RunnableInput, RunOutput>>;\n  }","input: RunInput","options?: Partial<RunnableConfig>","inputs: RunInput[]","options?: Partial<RunnableConfig> | Partial<RunnableConfig>[]","batchOptions?: RunnableBatchOptions","i"],"sources":["../../src/runnables/router.ts"],"sourcesContent":["import { Runnable, type RunnableBatchOptions } from \"./base.js\";\nimport { IterableReadableStream } from \"../utils/stream.js\";\nimport { ensureConfig, type RunnableConfig } from \"./config.js\";\n\nexport type RouterInput = {\n  key: string;\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  input: any;\n};\n\n/**\n * A runnable that routes to a set of runnables based on Input['key'].\n * Returns the output of the selected runnable.\n * @example\n * ```typescript\n * import { RouterRunnable, RunnableLambda } from \"@langchain/core/runnables\";\n *\n * const router = new RouterRunnable({\n *   runnables: {\n *     toUpperCase: RunnableLambda.from((text: string) => text.toUpperCase()),\n *     reverseText: RunnableLambda.from((text: string) =>\n *       text.split(\"\").reverse().join(\"\")\n *     ),\n *   },\n * });\n *\n * // Invoke the 'reverseText' runnable\n * const result1 = router.invoke({ key: \"reverseText\", input: \"Hello World\" });\n *\n * // \"dlroW olleH\"\n *\n * // Invoke the 'toUpperCase' runnable\n * const result2 = router.invoke({ key: \"toUpperCase\", input: \"Hello World\" });\n *\n * // \"HELLO WORLD\"\n * ```\n */\nexport class RouterRunnable<\n  RunInput extends RouterInput,\n  RunnableInput,\n  RunOutput\n> extends Runnable<RunInput, RunOutput> {\n  static lc_name() {\n    return \"RouterRunnable\";\n  }\n\n  lc_namespace = [\"langchain_core\", \"runnables\"];\n\n  lc_serializable = true;\n\n  runnables: Record<string, Runnable<RunnableInput, RunOutput>>;\n\n  constructor(fields: {\n    runnables: Record<string, Runnable<RunnableInput, RunOutput>>;\n  }) {\n    super(fields);\n    this.runnables = fields.runnables;\n  }\n\n  async invoke(\n    input: RunInput,\n    options?: Partial<RunnableConfig>\n  ): Promise<RunOutput> {\n    const { key, input: actualInput } = input;\n    const runnable = this.runnables[key];\n    if (runnable === undefined) {\n      throw new Error(`No runnable associated with key \"${key}\".`);\n    }\n    return runnable.invoke(actualInput, ensureConfig(options));\n  }\n\n  async batch(\n    inputs: RunInput[],\n    options?: Partial<RunnableConfig> | Partial<RunnableConfig>[],\n    batchOptions?: RunnableBatchOptions & { returnExceptions?: false }\n  ): Promise<RunOutput[]>;\n\n  async batch(\n    inputs: RunInput[],\n    options?: Partial<RunnableConfig> | Partial<RunnableConfig>[],\n    batchOptions?: RunnableBatchOptions & { returnExceptions: true }\n  ): Promise<(RunOutput | Error)[]>;\n\n  async batch(\n    inputs: RunInput[],\n    options?: Partial<RunnableConfig> | Partial<RunnableConfig>[],\n    batchOptions?: RunnableBatchOptions\n  ): Promise<(RunOutput | Error)[]>;\n\n  async batch(\n    inputs: RunInput[],\n    options?: Partial<RunnableConfig> | Partial<RunnableConfig>[],\n    batchOptions?: RunnableBatchOptions\n  ): Promise<(RunOutput | Error)[]> {\n    const keys = inputs.map((input) => input.key);\n    const actualInputs = inputs.map((input) => input.input);\n    const missingKey = keys.find((key) => this.runnables[key] === undefined);\n    if (missingKey !== undefined) {\n      throw new Error(`One or more keys do not have a corresponding runnable.`);\n    }\n    const runnables = keys.map((key) => this.runnables[key]);\n    const optionsList = this._getOptionsList(options ?? {}, inputs.length);\n    const maxConcurrency =\n      optionsList[0]?.maxConcurrency ?? batchOptions?.maxConcurrency;\n    const batchSize =\n      maxConcurrency && maxConcurrency > 0 ? maxConcurrency : inputs.length;\n    const batchResults = [];\n    for (let i = 0; i < actualInputs.length; i += batchSize) {\n      const batchPromises = actualInputs\n        .slice(i, i + batchSize)\n        .map((actualInput, i) =>\n          runnables[i].invoke(actualInput, optionsList[i])\n        );\n      const batchResult = await Promise.all(batchPromises);\n      batchResults.push(batchResult);\n    }\n    return batchResults.flat();\n  }\n\n  async stream(\n    input: RunInput,\n    options?: Partial<RunnableConfig>\n  ): Promise<IterableReadableStream<RunOutput>> {\n    const { key, input: actualInput } = input;\n    const runnable = this.runnables[key];\n    if (runnable === undefined) {\n      throw new Error(`No runnable associated with key \"${key}\".`);\n    }\n    return runnable.stream(actualInput, options);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCA,IAAa,iBAAb,cAIU,SAA8B;CACtC,OAAO,UAAU;AACf,SAAO;CACR;CAED,eAAe,CAAC,kBAAkB,WAAY;CAE9C,kBAAkB;CAElB;CAEA,YAAYA,QAET;EACD,MAAM,OAAO;EACb,KAAK,YAAY,OAAO;CACzB;CAED,MAAM,OACJC,OACAC,SACoB;EACpB,MAAM,EAAE,KAAK,OAAO,aAAa,GAAG;EACpC,MAAM,WAAW,KAAK,UAAU;AAChC,MAAI,aAAa,OACf,OAAM,IAAI,MAAM,CAAC,iCAAiC,EAAE,IAAI,EAAE,CAAC;AAE7D,SAAO,SAAS,OAAO,aAAa,aAAa,QAAQ,CAAC;CAC3D;CAoBD,MAAM,MACJC,QACAC,SACAC,cACgC;EAChC,MAAM,OAAO,OAAO,IAAI,CAAC,UAAU,MAAM,IAAI;EAC7C,MAAM,eAAe,OAAO,IAAI,CAAC,UAAU,MAAM,MAAM;EACvD,MAAM,aAAa,KAAK,KAAK,CAAC,QAAQ,KAAK,UAAU,SAAS,OAAU;AACxE,MAAI,eAAe,OACjB,OAAM,IAAI,MAAM,CAAC,sDAAsD,CAAC;EAE1E,MAAM,YAAY,KAAK,IAAI,CAAC,QAAQ,KAAK,UAAU,KAAK;EACxD,MAAM,cAAc,KAAK,gBAAgB,WAAW,CAAE,GAAE,OAAO,OAAO;EACtE,MAAM,iBACJ,YAAY,IAAI,kBAAkB,cAAc;EAClD,MAAM,YACJ,kBAAkB,iBAAiB,IAAI,iBAAiB,OAAO;EACjE,MAAM,eAAe,CAAE;AACvB,OAAK,IAAI,IAAI,GAAG,IAAI,aAAa,QAAQ,KAAK,WAAW;GACvD,MAAM,gBAAgB,aACnB,MAAM,GAAG,IAAI,UAAU,CACvB,IAAI,CAAC,aAAaC,QACjB,UAAUA,KAAG,OAAO,aAAa,YAAYA,KAAG,CACjD;GACH,MAAM,cAAc,MAAM,QAAQ,IAAI,cAAc;GACpD,aAAa,KAAK,YAAY;EAC/B;AACD,SAAO,aAAa,MAAM;CAC3B;CAED,MAAM,OACJL,OACAC,SAC4C;EAC5C,MAAM,EAAE,KAAK,OAAO,aAAa,GAAG;EACpC,MAAM,WAAW,KAAK,UAAU;AAChC,MAAI,aAAa,OACf,OAAM,IAAI,MAAM,CAAC,iCAAiC,EAAE,IAAI,EAAE,CAAC;AAE7D,SAAO,SAAS,OAAO,aAAa,QAAQ;CAC7C;AACF"}
+{"version":3,"file":"router.js","names":[],"sources":["../../src/runnables/router.ts"],"sourcesContent":["import { Runnable, type RunnableBatchOptions } from \"./base.js\";\nimport { IterableReadableStream } from \"../utils/stream.js\";\nimport { ensureConfig, type RunnableConfig } from \"./config.js\";\n\nexport type RouterInput = {\n  key: string;\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n  input: any;\n};\n\n/**\n * A runnable that routes to a set of runnables based on Input['key'].\n * Returns the output of the selected runnable.\n * @example\n * ```typescript\n * import { RouterRunnable, RunnableLambda } from \"@langchain/core/runnables\";\n *\n * const router = new RouterRunnable({\n *   runnables: {\n *     toUpperCase: RunnableLambda.from((text: string) => text.toUpperCase()),\n *     reverseText: RunnableLambda.from((text: string) =>\n *       text.split(\"\").reverse().join(\"\")\n *     ),\n *   },\n * });\n *\n * // Invoke the 'reverseText' runnable\n * const result1 = router.invoke({ key: \"reverseText\", input: \"Hello World\" });\n *\n * // \"dlroW olleH\"\n *\n * // Invoke the 'toUpperCase' runnable\n * const result2 = router.invoke({ key: \"toUpperCase\", input: \"Hello World\" });\n *\n * // \"HELLO WORLD\"\n * ```\n */\nexport class RouterRunnable<\n  RunInput extends RouterInput,\n  RunnableInput,\n  RunOutput,\n> extends Runnable<RunInput, RunOutput> {\n  static lc_name() {\n    return \"RouterRunnable\";\n  }\n\n  lc_namespace = [\"langchain_core\", \"runnables\"];\n\n  lc_serializable = true;\n\n  runnables: Record<string, Runnable<RunnableInput, RunOutput>>;\n\n  constructor(fields: {\n    runnables: Record<string, Runnable<RunnableInput, RunOutput>>;\n  }) {\n    super(fields);\n    this.runnables = fields.runnables;\n  }\n\n  async invoke(\n    input: RunInput,\n    options?: Partial<RunnableConfig>\n  ): Promise<RunOutput> {\n    const { key, input: actualInput } = input;\n    const runnable = this.runnables[key];\n    if (runnable === undefined) {\n      throw new Error(`No runnable associated with key \"${key}\".`);\n    }\n    return runnable.invoke(actualInput, ensureConfig(options));\n  }\n\n  async batch(\n    inputs: RunInput[],\n    options?: Partial<RunnableConfig> | Partial<RunnableConfig>[],\n    batchOptions?: RunnableBatchOptions & { returnExceptions?: false }\n  ): Promise<RunOutput[]>;\n\n  async batch(\n    inputs: RunInput[],\n    options?: Partial<RunnableConfig> | Partial<RunnableConfig>[],\n    batchOptions?: RunnableBatchOptions & { returnExceptions: true }\n  ): Promise<(RunOutput | Error)[]>;\n\n  async batch(\n    inputs: RunInput[],\n    options?: Partial<RunnableConfig> | Partial<RunnableConfig>[],\n    batchOptions?: RunnableBatchOptions\n  ): Promise<(RunOutput | Error)[]>;\n\n  async batch(\n    inputs: RunInput[],\n    options?: Partial<RunnableConfig> | Partial<RunnableConfig>[],\n    batchOptions?: RunnableBatchOptions\n  ): Promise<(RunOutput | Error)[]> {\n    const keys = inputs.map((input) => input.key);\n    const actualInputs = inputs.map((input) => input.input);\n    const missingKey = keys.find((key) => this.runnables[key] === undefined);\n    if (missingKey !== undefined) {\n      throw new Error(`One or more keys do not have a corresponding runnable.`);\n    }\n    const runnables = keys.map((key) => this.runnables[key]);\n    const optionsList = this._getOptionsList(options ?? {}, inputs.length);\n    const maxConcurrency =\n      optionsList[0]?.maxConcurrency ?? batchOptions?.maxConcurrency;\n    const batchSize =\n      maxConcurrency && maxConcurrency > 0 ? maxConcurrency : inputs.length;\n    const batchResults = [];\n    for (let i = 0; i < actualInputs.length; i += batchSize) {\n      const batchPromises = actualInputs\n        .slice(i, i + batchSize)\n        .map((actualInput, i) =>\n          runnables[i].invoke(actualInput, optionsList[i])\n        );\n      const batchResult = await Promise.all(batchPromises);\n      batchResults.push(batchResult);\n    }\n    return batchResults.flat();\n  }\n\n  async stream(\n    input: RunInput,\n    options?: Partial<RunnableConfig>\n  ): Promise<IterableReadableStream<RunOutput>> {\n    const { key, input: actualInput } = input;\n    const runnable = this.runnables[key];\n    if (runnable === undefined) {\n      throw new Error(`No runnable associated with key \"${key}\".`);\n    }\n    return runnable.stream(actualInput, options);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCA,IAAa,iBAAb,cAIU,SAA8B;CACtC,OAAO,UAAU;AACf,SAAO;;CAGT,eAAe,CAAC,kBAAkB,YAAY;CAE9C,kBAAkB;CAElB;CAEA,YAAY,QAET;AACD,QAAM,OAAO;AACb,OAAK,YAAY,OAAO;;CAG1B,MAAM,OACJ,OACA,SACoB;EACpB,MAAM,EAAE,KAAK,OAAO,gBAAgB;EACpC,MAAM,WAAW,KAAK,UAAU;AAChC,MAAI,aAAa,KAAA,EACf,OAAM,IAAI,MAAM,oCAAoC,IAAI,IAAI;AAE9D,SAAO,SAAS,OAAO,aAAa,aAAa,QAAQ,CAAC;;CAqB5D,MAAM,MACJ,QACA,SACA,cACgC;EAChC,MAAM,OAAO,OAAO,KAAK,UAAU,MAAM,IAAI;EAC7C,MAAM,eAAe,OAAO,KAAK,UAAU,MAAM,MAAM;AAEvD,MADmB,KAAK,MAAM,QAAQ,KAAK,UAAU,SAAS,KAAA,EAChD,KAAK,KAAA,EACjB,OAAM,IAAI,MAAM,yDAAyD;EAE3E,MAAM,YAAY,KAAK,KAAK,QAAQ,KAAK,UAAU,KAAK;EACxD,MAAM,cAAc,KAAK,gBAAgB,WAAW,EAAE,EAAE,OAAO,OAAO;EACtE,MAAM,iBACJ,YAAY,IAAI,kBAAkB,cAAc;EAClD,MAAM,YACJ,kBAAkB,iBAAiB,IAAI,iBAAiB,OAAO;EACjE,MAAM,eAAe,EAAE;AACvB,OAAK,IAAI,IAAI,GAAG,IAAI,aAAa,QAAQ,KAAK,WAAW;GACvD,MAAM,gBAAgB,aACnB,MAAM,GAAG,IAAI,UAAU,CACvB,KAAK,aAAa,MACjB,UAAU,GAAG,OAAO,aAAa,YAAY,GAAG,CACjD;GACH,MAAM,cAAc,MAAM,QAAQ,IAAI,cAAc;AACpD,gBAAa,KAAK,YAAY;;AAEhC,SAAO,aAAa,MAAM;;CAG5B,MAAM,OACJ,OACA,SAC4C;EAC5C,MAAM,EAAE,KAAK,OAAO,gBAAgB;EACpC,MAAM,WAAW,KAAK,UAAU;AAChC,MAAI,aAAa,KAAA,EACf,OAAM,IAAI,MAAM,oCAAoC,IAAI,IAAI;AAE9D,SAAO,SAAS,OAAO,aAAa,QAAQ"}

package/dist/runnables/types.d.cts

@@ -5,8 +5,7 @@ import { IterableReadableStreamInterface } from "../types/_internal.cjs";
 
 //#region src/runnables/types.d.ts
 type RunnableBatchOptions = {
-  /** @deprecated Pass in via the standard runnable config object instead */
-  maxConcurrency?: number;
+  /** @deprecated Pass in via the standard runnable config object instead */maxConcurrency?: number;
   returnExceptions?: boolean;
 };
 type RunnableIOSchema = {

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.cts","names":["SerializableInterface","BaseCallbackConfig","IterableReadableStreamInterface","InteropZodType","RunnableBatchOptions","RunnableIOSchema","RunnableInterface","RunInput","RunOutput","CallOptions","RunnableConfig","Partial","Promise","Error","AsyncGenerator","Edge","Node","Record","ConfigurableFieldType","AbortSignal"],"sources":["../../src/runnables/types.d.ts"],"sourcesContent":["import type { SerializableInterface } from \"../load/serializable.js\";\nimport type { BaseCallbackConfig } from \"../callbacks/manager.js\";\nimport type { IterableReadableStreamInterface } from \"../types/_internal.js\";\nimport { InteropZodType } from \"../utils/types/zod.js\";\nexport type RunnableBatchOptions = {\n    /** @deprecated Pass in via the standard runnable config object instead */\n    maxConcurrency?: number;\n    returnExceptions?: boolean;\n};\nexport type RunnableIOSchema = {\n    name?: string;\n    schema: InteropZodType;\n};\n/**\n * Base interface implemented by all runnables.\n * Used for cross-compatibility between different versions of LangChain core.\n *\n * Should not change on patch releases.\n */\nexport interface RunnableInterface<RunInput = any, RunOutput = any, CallOptions extends RunnableConfig = RunnableConfig> extends SerializableInterface {\n    lc_serializable: boolean;\n    invoke(input: RunInput, options?: Partial<CallOptions>): Promise<RunOutput>;\n    batch(inputs: RunInput[], options?: Partial<CallOptions> | Partial<CallOptions>[], batchOptions?: RunnableBatchOptions & {\n        returnExceptions?: false;\n    }): Promise<RunOutput[]>;\n    batch(inputs: RunInput[], options?: Partial<CallOptions> | Partial<CallOptions>[], batchOptions?: RunnableBatchOptions & {\n        returnExceptions: true;\n    }): Promise<(RunOutput | Error)[]>;\n    batch(inputs: RunInput[], options?: Partial<CallOptions> | Partial<CallOptions>[], batchOptions?: RunnableBatchOptions): Promise<(RunOutput | Error)[]>;\n    stream(input: RunInput, options?: Partial<CallOptions>): Promise<IterableReadableStreamInterface<RunOutput>>;\n    transform(generator: AsyncGenerator<RunInput>, options: Partial<CallOptions>): AsyncGenerator<RunOutput>;\n    getName(suffix?: string): string;\n}\nexport interface Edge {\n    source: string;\n    target: string;\n    data?: string;\n    conditional?: boolean;\n}\nexport interface Node {\n    id: string;\n    name: string;\n    data: RunnableIOSchema | RunnableInterface;\n    metadata?: Record<string, any>;\n}\nexport interface RunnableConfig<ConfigurableFieldType extends Record<string, any> = Record<string, any>> extends BaseCallbackConfig {\n    /**\n     * Runtime values for attributes previously made configurable on this Runnable,\n     * or sub-Runnables.\n     */\n    configurable?: ConfigurableFieldType;\n    /**\n     * Maximum number of times a call can recurse. If not provided, defaults to 25.\n     */\n    recursionLimit?: number;\n    /** Maximum number of parallel calls to make. */\n    maxConcurrency?: number;\n    /**\n     * Timeout for this call in milliseconds.\n     */\n    timeout?: number;\n    /**\n     * Abort signal for this call.\n     * If provided, the call will be aborted when the signal is aborted.\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal\n     */\n    signal?: AbortSignal;\n}\n//# sourceMappingURL=types.d.ts.map"],"mappings":"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"}
+{"version":3,"file":"types.d.cts","names":[],"sources":["../../src/runnables/types.ts"],"mappings":";;;;;;KAKY,oBAAA;4EAEV,cAAA;EACA,gBAAA;AAAA;AAAA,KAGU,gBAAA;EACV,IAAA;EACA,MAAA,EAAQ,cAAA;AAAA;;;;;;;UASO,iBAAA,sDAKK,cAAA,GAAiB,cAAA,UAC7B,qBAAA;EACR,eAAA;EAEA,MAAA,CAAO,KAAA,EAAO,QAAA,EAAU,OAAA,GAAU,OAAA,CAAQ,WAAA,IAAe,OAAA,CAAQ,SAAA;EAEjE,KAAA,CACE,MAAA,EAAQ,QAAA,IACR,OAAA,GAAU,OAAA,CAAQ,WAAA,IAAe,OAAA,CAAQ,WAAA,KACzC,YAAA,GAAe,oBAAA;IAAyB,gBAAA;EAAA,IACvC,OAAA,CAAQ,SAAA;EAEX,KAAA,CACE,MAAA,EAAQ,QAAA,IACR,OAAA,GAAU,OAAA,CAAQ,WAAA,IAAe,OAAA,CAAQ,WAAA,KACzC,YAAA,GAAe,oBAAA;IAAyB,gBAAA;EAAA,IACvC,OAAA,EAAS,SAAA,GAAY,KAAA;EAExB,KAAA,CACE,MAAA,EAAQ,QAAA,IACR,OAAA,GAAU,OAAA,CAAQ,WAAA,IAAe,OAAA,CAAQ,WAAA,KACzC,YAAA,GAAe,oBAAA,GACd,OAAA,EAAS,SAAA,GAAY,KAAA;EAExB,MAAA,CACE,KAAA,EAAO,QAAA,EACP,OAAA,GAAU,OAAA,CAAQ,WAAA,IACjB,OAAA,CAAQ,+BAAA,CAAgC,SAAA;EAE3C,SAAA,CACE,SAAA,EAAW,cAAA,CAAe,QAAA,GAC1B,OAAA,EAAS,OAAA,CAAQ,WAAA,IAChB,cAAA,CAAe,SAAA;EAElB,OAAA,CAAQ,MAAA;AAAA;AAAA,UAGO,IAAA;EACf,MAAA;EACA,MAAA;EACA,IAAA;EACA,WAAA;AAAA;AAAA,UAGe,IAAA;EACf,EAAA;EACA,IAAA;EACA,IAAA,EAAM,gBAAA,GAAmB,iBAAA;EAEzB,QAAA,GAAW,MAAA;AAAA;AAAA,UAGI,cAAA,+BAEe,MAAA,gBAAsB,MAAA,uBAC5C,kBAAA;EAvCL;;;;EA4CH,YAAA,GAAe,qBAAA;EAxCoB;;;EA6CnC,cAAA;EA3CG;EA8CH,cAAA;EA1CoB;;;EA+CpB,OAAA;EA9CG;;;;;EAqDH,MAAA,GAAS,WAAA;AAAA"}

package/dist/runnables/types.d.ts

@@ -5,8 +5,7 @@ import { IterableReadableStreamInterface } from "../types/_internal.js";
 
 //#region src/runnables/types.d.ts
 type RunnableBatchOptions = {
-  /** @deprecated Pass in via the standard runnable config object instead */
-  maxConcurrency?: number;
+  /** @deprecated Pass in via the standard runnable config object instead */maxConcurrency?: number;
   returnExceptions?: boolean;
 };
 type RunnableIOSchema = {

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","names":["SerializableInterface","BaseCallbackConfig","IterableReadableStreamInterface","InteropZodType","RunnableBatchOptions","RunnableIOSchema","RunnableInterface","RunInput","RunOutput","CallOptions","RunnableConfig","Partial","Promise","Error","AsyncGenerator","Edge","Node","Record","ConfigurableFieldType","AbortSignal"],"sources":["../../src/runnables/types.d.ts"],"sourcesContent":["import type { SerializableInterface } from \"../load/serializable.js\";\nimport type { BaseCallbackConfig } from \"../callbacks/manager.js\";\nimport type { IterableReadableStreamInterface } from \"../types/_internal.js\";\nimport { InteropZodType } from \"../utils/types/zod.js\";\nexport type RunnableBatchOptions = {\n    /** @deprecated Pass in via the standard runnable config object instead */\n    maxConcurrency?: number;\n    returnExceptions?: boolean;\n};\nexport type RunnableIOSchema = {\n    name?: string;\n    schema: InteropZodType;\n};\n/**\n * Base interface implemented by all runnables.\n * Used for cross-compatibility between different versions of LangChain core.\n *\n * Should not change on patch releases.\n */\nexport interface RunnableInterface<RunInput = any, RunOutput = any, CallOptions extends RunnableConfig = RunnableConfig> extends SerializableInterface {\n    lc_serializable: boolean;\n    invoke(input: RunInput, options?: Partial<CallOptions>): Promise<RunOutput>;\n    batch(inputs: RunInput[], options?: Partial<CallOptions> | Partial<CallOptions>[], batchOptions?: RunnableBatchOptions & {\n        returnExceptions?: false;\n    }): Promise<RunOutput[]>;\n    batch(inputs: RunInput[], options?: Partial<CallOptions> | Partial<CallOptions>[], batchOptions?: RunnableBatchOptions & {\n        returnExceptions: true;\n    }): Promise<(RunOutput | Error)[]>;\n    batch(inputs: RunInput[], options?: Partial<CallOptions> | Partial<CallOptions>[], batchOptions?: RunnableBatchOptions): Promise<(RunOutput | Error)[]>;\n    stream(input: RunInput, options?: Partial<CallOptions>): Promise<IterableReadableStreamInterface<RunOutput>>;\n    transform(generator: AsyncGenerator<RunInput>, options: Partial<CallOptions>): AsyncGenerator<RunOutput>;\n    getName(suffix?: string): string;\n}\nexport interface Edge {\n    source: string;\n    target: string;\n    data?: string;\n    conditional?: boolean;\n}\nexport interface Node {\n    id: string;\n    name: string;\n    data: RunnableIOSchema | RunnableInterface;\n    metadata?: Record<string, any>;\n}\nexport interface RunnableConfig<ConfigurableFieldType extends Record<string, any> = Record<string, any>> extends BaseCallbackConfig {\n    /**\n     * Runtime values for attributes previously made configurable on this Runnable,\n     * or sub-Runnables.\n     */\n    configurable?: ConfigurableFieldType;\n    /**\n     * Maximum number of times a call can recurse. If not provided, defaults to 25.\n     */\n    recursionLimit?: number;\n    /** Maximum number of parallel calls to make. */\n    maxConcurrency?: number;\n    /**\n     * Timeout for this call in milliseconds.\n     */\n    timeout?: number;\n    /**\n     * Abort signal for this call.\n     * If provided, the call will be aborted when the signal is aborted.\n     * @see https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal\n     */\n    signal?: AbortSignal;\n}\n//# sourceMappingURL=types.d.ts.map"],"mappings":"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"}
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../src/runnables/types.ts"],"mappings":";;;;;;KAKY,oBAAA;4EAEV,cAAA;EACA,gBAAA;AAAA;AAAA,KAGU,gBAAA;EACV,IAAA;EACA,MAAA,EAAQ,cAAA;AAAA;;;;;;;UASO,iBAAA,sDAKK,cAAA,GAAiB,cAAA,UAC7B,qBAAA;EACR,eAAA;EAEA,MAAA,CAAO,KAAA,EAAO,QAAA,EAAU,OAAA,GAAU,OAAA,CAAQ,WAAA,IAAe,OAAA,CAAQ,SAAA;EAEjE,KAAA,CACE,MAAA,EAAQ,QAAA,IACR,OAAA,GAAU,OAAA,CAAQ,WAAA,IAAe,OAAA,CAAQ,WAAA,KACzC,YAAA,GAAe,oBAAA;IAAyB,gBAAA;EAAA,IACvC,OAAA,CAAQ,SAAA;EAEX,KAAA,CACE,MAAA,EAAQ,QAAA,IACR,OAAA,GAAU,OAAA,CAAQ,WAAA,IAAe,OAAA,CAAQ,WAAA,KACzC,YAAA,GAAe,oBAAA;IAAyB,gBAAA;EAAA,IACvC,OAAA,EAAS,SAAA,GAAY,KAAA;EAExB,KAAA,CACE,MAAA,EAAQ,QAAA,IACR,OAAA,GAAU,OAAA,CAAQ,WAAA,IAAe,OAAA,CAAQ,WAAA,KACzC,YAAA,GAAe,oBAAA,GACd,OAAA,EAAS,SAAA,GAAY,KAAA;EAExB,MAAA,CACE,KAAA,EAAO,QAAA,EACP,OAAA,GAAU,OAAA,CAAQ,WAAA,IACjB,OAAA,CAAQ,+BAAA,CAAgC,SAAA;EAE3C,SAAA,CACE,SAAA,EAAW,cAAA,CAAe,QAAA,GAC1B,OAAA,EAAS,OAAA,CAAQ,WAAA,IAChB,cAAA,CAAe,SAAA;EAElB,OAAA,CAAQ,MAAA;AAAA;AAAA,UAGO,IAAA;EACf,MAAA;EACA,MAAA;EACA,IAAA;EACA,WAAA;AAAA;AAAA,UAGe,IAAA;EACf,EAAA;EACA,IAAA;EACA,IAAA,EAAM,gBAAA,GAAmB,iBAAA;EAEzB,QAAA,GAAW,MAAA;AAAA;AAAA,UAGI,cAAA,+BAEe,MAAA,gBAAsB,MAAA,uBAC5C,kBAAA;EAvCL;;;;EA4CH,YAAA,GAAe,qBAAA;EAxCoB;;;EA6CnC,cAAA;EA3CG;EA8CH,cAAA;EA1CoB;;;EA+CpB,OAAA;EA9CG;;;;;EAqDH,MAAA,GAAS,WAAA;AAAA"}

package/dist/runnables/utils.cjs

@@ -1,4 +1,3 @@
-
 //#region src/runnables/utils.ts
 function isRunnableInterface(thing) {
 	return thing ? thing.lc_runnable : false;
@@ -38,12 +37,11 @@ var _RootEventFilter = class {
 	}
 };
 const toBase64Url = (str) => {
-	const encoded = btoa(str);
-	return encoded.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+	return btoa(str).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
 };
-
 //#endregion
 exports._RootEventFilter = _RootEventFilter;
 exports.isRunnableInterface = isRunnableInterface;
 exports.toBase64Url = toBase64Url;
+
 //# sourceMappingURL=utils.cjs.map

package/dist/runnables/utils.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"utils.cjs","names":["thing: any","fields: {\n    includeNames?: string[];\n    includeTypes?: string[];\n    includeTags?: string[];\n    excludeNames?: string[];\n    excludeTypes?: string[];\n    excludeTags?: string[];\n  }","event: StreamEvent","rootType: string","str: string"],"sources":["../../src/runnables/utils.ts"],"sourcesContent":["import { StreamEvent } from \"../tracers/event_stream.js\";\nimport type { RunnableInterface } from \"./types.js\";\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function isRunnableInterface(thing: any): thing is RunnableInterface {\n  return thing ? thing.lc_runnable : false;\n}\n\n/**\n * Utility to filter the root event in the streamEvents implementation.\n * This is simply binding the arguments to the namespace to make save on\n * a bit of typing in the streamEvents implementation.\n *\n * TODO: Refactor and remove.\n */\nexport class _RootEventFilter {\n  includeNames?: string[];\n\n  includeTypes?: string[];\n\n  includeTags?: string[];\n\n  excludeNames?: string[];\n\n  excludeTypes?: string[];\n\n  excludeTags?: string[];\n\n  constructor(fields: {\n    includeNames?: string[];\n    includeTypes?: string[];\n    includeTags?: string[];\n    excludeNames?: string[];\n    excludeTypes?: string[];\n    excludeTags?: string[];\n  }) {\n    this.includeNames = fields.includeNames;\n    this.includeTypes = fields.includeTypes;\n    this.includeTags = fields.includeTags;\n    this.excludeNames = fields.excludeNames;\n    this.excludeTypes = fields.excludeTypes;\n    this.excludeTags = fields.excludeTags;\n  }\n\n  includeEvent(event: StreamEvent, rootType: string): boolean {\n    let include =\n      this.includeNames === undefined &&\n      this.includeTypes === undefined &&\n      this.includeTags === undefined;\n    const eventTags = event.tags ?? [];\n\n    if (this.includeNames !== undefined) {\n      include = include || this.includeNames.includes(event.name);\n    }\n    if (this.includeTypes !== undefined) {\n      include = include || this.includeTypes.includes(rootType);\n    }\n    if (this.includeTags !== undefined) {\n      include =\n        include || eventTags.some((tag) => this.includeTags?.includes(tag));\n    }\n\n    if (this.excludeNames !== undefined) {\n      include = include && !this.excludeNames.includes(event.name);\n    }\n    if (this.excludeTypes !== undefined) {\n      include = include && !this.excludeTypes.includes(rootType);\n    }\n    if (this.excludeTags !== undefined) {\n      include =\n        include && eventTags.every((tag) => !this.excludeTags?.includes(tag));\n    }\n\n    return include;\n  }\n}\n\nexport const toBase64Url = (str: string): string => {\n  // Use btoa for compatibility, assume ASCII\n  const encoded = btoa(str);\n  return encoded.replace(/\\+/g, \"-\").replace(/\\//g, \"_\").replace(/=+$/, \"\");\n};\n"],"mappings":";;AAIA,SAAgB,oBAAoBA,OAAwC;AAC1E,QAAO,QAAQ,MAAM,cAAc;AACpC;;;;;;;;AASD,IAAa,mBAAb,MAA8B;CAC5B;CAEA;CAEA;CAEA;CAEA;CAEA;CAEA,YAAYC,QAOT;EACD,KAAK,eAAe,OAAO;EAC3B,KAAK,eAAe,OAAO;EAC3B,KAAK,cAAc,OAAO;EAC1B,KAAK,eAAe,OAAO;EAC3B,KAAK,eAAe,OAAO;EAC3B,KAAK,cAAc,OAAO;CAC3B;CAED,aAAaC,OAAoBC,UAA2B;EAC1D,IAAI,UACF,KAAK,iBAAiB,UACtB,KAAK,iBAAiB,UACtB,KAAK,gBAAgB;EACvB,MAAM,YAAY,MAAM,QAAQ,CAAE;AAElC,MAAI,KAAK,iBAAiB,QACxB,UAAU,WAAW,KAAK,aAAa,SAAS,MAAM,KAAK;AAE7D,MAAI,KAAK,iBAAiB,QACxB,UAAU,WAAW,KAAK,aAAa,SAAS,SAAS;AAE3D,MAAI,KAAK,gBAAgB,QACvB,UACE,WAAW,UAAU,KAAK,CAAC,QAAQ,KAAK,aAAa,SAAS,IAAI,CAAC;AAGvE,MAAI,KAAK,iBAAiB,QACxB,UAAU,WAAW,CAAC,KAAK,aAAa,SAAS,MAAM,KAAK;AAE9D,MAAI,KAAK,iBAAiB,QACxB,UAAU,WAAW,CAAC,KAAK,aAAa,SAAS,SAAS;AAE5D,MAAI,KAAK,gBAAgB,QACvB,UACE,WAAW,UAAU,MAAM,CAAC,QAAQ,CAAC,KAAK,aAAa,SAAS,IAAI,CAAC;AAGzE,SAAO;CACR;AACF;AAED,MAAa,cAAc,CAACC,QAAwB;CAElD,MAAM,UAAU,KAAK,IAAI;AACzB,QAAO,QAAQ,QAAQ,OAAO,IAAI,CAAC,QAAQ,OAAO,IAAI,CAAC,QAAQ,OAAO,GAAG;AAC1E"}
+{"version":3,"file":"utils.cjs","names":[],"sources":["../../src/runnables/utils.ts"],"sourcesContent":["import { StreamEvent } from \"../tracers/event_stream.js\";\nimport type { RunnableInterface } from \"./types.js\";\n\n// oxlint-disable-next-line @typescript-eslint/no-explicit-any\nexport function isRunnableInterface(thing: any): thing is RunnableInterface {\n  return thing ? thing.lc_runnable : false;\n}\n\n/**\n * Utility to filter the root event in the streamEvents implementation.\n * This is simply binding the arguments to the namespace to make save on\n * a bit of typing in the streamEvents implementation.\n *\n * TODO: Refactor and remove.\n */\nexport class _RootEventFilter {\n  includeNames?: string[];\n\n  includeTypes?: string[];\n\n  includeTags?: string[];\n\n  excludeNames?: string[];\n\n  excludeTypes?: string[];\n\n  excludeTags?: string[];\n\n  constructor(fields: {\n    includeNames?: string[];\n    includeTypes?: string[];\n    includeTags?: string[];\n    excludeNames?: string[];\n    excludeTypes?: string[];\n    excludeTags?: string[];\n  }) {\n    this.includeNames = fields.includeNames;\n    this.includeTypes = fields.includeTypes;\n    this.includeTags = fields.includeTags;\n    this.excludeNames = fields.excludeNames;\n    this.excludeTypes = fields.excludeTypes;\n    this.excludeTags = fields.excludeTags;\n  }\n\n  includeEvent(event: StreamEvent, rootType: string): boolean {\n    let include =\n      this.includeNames === undefined &&\n      this.includeTypes === undefined &&\n      this.includeTags === undefined;\n    const eventTags = event.tags ?? [];\n\n    if (this.includeNames !== undefined) {\n      include = include || this.includeNames.includes(event.name);\n    }\n    if (this.includeTypes !== undefined) {\n      include = include || this.includeTypes.includes(rootType);\n    }\n    if (this.includeTags !== undefined) {\n      include =\n        include || eventTags.some((tag) => this.includeTags?.includes(tag));\n    }\n\n    if (this.excludeNames !== undefined) {\n      include = include && !this.excludeNames.includes(event.name);\n    }\n    if (this.excludeTypes !== undefined) {\n      include = include && !this.excludeTypes.includes(rootType);\n    }\n    if (this.excludeTags !== undefined) {\n      include =\n        include && eventTags.every((tag) => !this.excludeTags?.includes(tag));\n    }\n\n    return include;\n  }\n}\n\nexport const toBase64Url = (str: string): string => {\n  // Use btoa for compatibility, assume ASCII\n  const encoded = btoa(str);\n  return encoded.replace(/\\+/g, \"-\").replace(/\\//g, \"_\").replace(/=+$/, \"\");\n};\n"],"mappings":";AAIA,SAAgB,oBAAoB,OAAwC;AAC1E,QAAO,QAAQ,MAAM,cAAc;;;;;;;;;AAUrC,IAAa,mBAAb,MAA8B;CAC5B;CAEA;CAEA;CAEA;CAEA;CAEA;CAEA,YAAY,QAOT;AACD,OAAK,eAAe,OAAO;AAC3B,OAAK,eAAe,OAAO;AAC3B,OAAK,cAAc,OAAO;AAC1B,OAAK,eAAe,OAAO;AAC3B,OAAK,eAAe,OAAO;AAC3B,OAAK,cAAc,OAAO;;CAG5B,aAAa,OAAoB,UAA2B;EAC1D,IAAI,UACF,KAAK,iBAAiB,KAAA,KACtB,KAAK,iBAAiB,KAAA,KACtB,KAAK,gBAAgB,KAAA;EACvB,MAAM,YAAY,MAAM,QAAQ,EAAE;AAElC,MAAI,KAAK,iBAAiB,KAAA,EACxB,WAAU,WAAW,KAAK,aAAa,SAAS,MAAM,KAAK;AAE7D,MAAI,KAAK,iBAAiB,KAAA,EACxB,WAAU,WAAW,KAAK,aAAa,SAAS,SAAS;AAE3D,MAAI,KAAK,gBAAgB,KAAA,EACvB,WACE,WAAW,UAAU,MAAM,QAAQ,KAAK,aAAa,SAAS,IAAI,CAAC;AAGvE,MAAI,KAAK,iBAAiB,KAAA,EACxB,WAAU,WAAW,CAAC,KAAK,aAAa,SAAS,MAAM,KAAK;AAE9D,MAAI,KAAK,iBAAiB,KAAA,EACxB,WAAU,WAAW,CAAC,KAAK,aAAa,SAAS,SAAS;AAE5D,MAAI,KAAK,gBAAgB,KAAA,EACvB,WACE,WAAW,UAAU,OAAO,QAAQ,CAAC,KAAK,aAAa,SAAS,IAAI,CAAC;AAGzE,SAAO;;;AAIX,MAAa,eAAe,QAAwB;AAGlD,QADgB,KAAK,IACP,CAAC,QAAQ,OAAO,IAAI,CAAC,QAAQ,OAAO,IAAI,CAAC,QAAQ,OAAO,GAAG"}

package/dist/runnables/utils.js

@@ -37,10 +37,9 @@ var _RootEventFilter = class {
 	}
 };
 const toBase64Url = (str) => {
-	const encoded = btoa(str);
-	return encoded.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+	return btoa(str).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
 };
-
 //#endregion
 export { _RootEventFilter, isRunnableInterface, toBase64Url };
+
 //# sourceMappingURL=utils.js.map

package/dist/runnables/utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"utils.js","names":["thing: any","fields: {\n    includeNames?: string[];\n    includeTypes?: string[];\n    includeTags?: string[];\n    excludeNames?: string[];\n    excludeTypes?: string[];\n    excludeTags?: string[];\n  }","event: StreamEvent","rootType: string","str: string"],"sources":["../../src/runnables/utils.ts"],"sourcesContent":["import { StreamEvent } from \"../tracers/event_stream.js\";\nimport type { RunnableInterface } from \"./types.js\";\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function isRunnableInterface(thing: any): thing is RunnableInterface {\n  return thing ? thing.lc_runnable : false;\n}\n\n/**\n * Utility to filter the root event in the streamEvents implementation.\n * This is simply binding the arguments to the namespace to make save on\n * a bit of typing in the streamEvents implementation.\n *\n * TODO: Refactor and remove.\n */\nexport class _RootEventFilter {\n  includeNames?: string[];\n\n  includeTypes?: string[];\n\n  includeTags?: string[];\n\n  excludeNames?: string[];\n\n  excludeTypes?: string[];\n\n  excludeTags?: string[];\n\n  constructor(fields: {\n    includeNames?: string[];\n    includeTypes?: string[];\n    includeTags?: string[];\n    excludeNames?: string[];\n    excludeTypes?: string[];\n    excludeTags?: string[];\n  }) {\n    this.includeNames = fields.includeNames;\n    this.includeTypes = fields.includeTypes;\n    this.includeTags = fields.includeTags;\n    this.excludeNames = fields.excludeNames;\n    this.excludeTypes = fields.excludeTypes;\n    this.excludeTags = fields.excludeTags;\n  }\n\n  includeEvent(event: StreamEvent, rootType: string): boolean {\n    let include =\n      this.includeNames === undefined &&\n      this.includeTypes === undefined &&\n      this.includeTags === undefined;\n    const eventTags = event.tags ?? [];\n\n    if (this.includeNames !== undefined) {\n      include = include || this.includeNames.includes(event.name);\n    }\n    if (this.includeTypes !== undefined) {\n      include = include || this.includeTypes.includes(rootType);\n    }\n    if (this.includeTags !== undefined) {\n      include =\n        include || eventTags.some((tag) => this.includeTags?.includes(tag));\n    }\n\n    if (this.excludeNames !== undefined) {\n      include = include && !this.excludeNames.includes(event.name);\n    }\n    if (this.excludeTypes !== undefined) {\n      include = include && !this.excludeTypes.includes(rootType);\n    }\n    if (this.excludeTags !== undefined) {\n      include =\n        include && eventTags.every((tag) => !this.excludeTags?.includes(tag));\n    }\n\n    return include;\n  }\n}\n\nexport const toBase64Url = (str: string): string => {\n  // Use btoa for compatibility, assume ASCII\n  const encoded = btoa(str);\n  return encoded.replace(/\\+/g, \"-\").replace(/\\//g, \"_\").replace(/=+$/, \"\");\n};\n"],"mappings":";AAIA,SAAgB,oBAAoBA,OAAwC;AAC1E,QAAO,QAAQ,MAAM,cAAc;AACpC;;;;;;;;AASD,IAAa,mBAAb,MAA8B;CAC5B;CAEA;CAEA;CAEA;CAEA;CAEA;CAEA,YAAYC,QAOT;EACD,KAAK,eAAe,OAAO;EAC3B,KAAK,eAAe,OAAO;EAC3B,KAAK,cAAc,OAAO;EAC1B,KAAK,eAAe,OAAO;EAC3B,KAAK,eAAe,OAAO;EAC3B,KAAK,cAAc,OAAO;CAC3B;CAED,aAAaC,OAAoBC,UAA2B;EAC1D,IAAI,UACF,KAAK,iBAAiB,UACtB,KAAK,iBAAiB,UACtB,KAAK,gBAAgB;EACvB,MAAM,YAAY,MAAM,QAAQ,CAAE;AAElC,MAAI,KAAK,iBAAiB,QACxB,UAAU,WAAW,KAAK,aAAa,SAAS,MAAM,KAAK;AAE7D,MAAI,KAAK,iBAAiB,QACxB,UAAU,WAAW,KAAK,aAAa,SAAS,SAAS;AAE3D,MAAI,KAAK,gBAAgB,QACvB,UACE,WAAW,UAAU,KAAK,CAAC,QAAQ,KAAK,aAAa,SAAS,IAAI,CAAC;AAGvE,MAAI,KAAK,iBAAiB,QACxB,UAAU,WAAW,CAAC,KAAK,aAAa,SAAS,MAAM,KAAK;AAE9D,MAAI,KAAK,iBAAiB,QACxB,UAAU,WAAW,CAAC,KAAK,aAAa,SAAS,SAAS;AAE5D,MAAI,KAAK,gBAAgB,QACvB,UACE,WAAW,UAAU,MAAM,CAAC,QAAQ,CAAC,KAAK,aAAa,SAAS,IAAI,CAAC;AAGzE,SAAO;CACR;AACF;AAED,MAAa,cAAc,CAACC,QAAwB;CAElD,MAAM,UAAU,KAAK,IAAI;AACzB,QAAO,QAAQ,QAAQ,OAAO,IAAI,CAAC,QAAQ,OAAO,IAAI,CAAC,QAAQ,OAAO,GAAG;AAC1E"}
+{"version":3,"file":"utils.js","names":[],"sources":["../../src/runnables/utils.ts"],"sourcesContent":["import { StreamEvent } from \"../tracers/event_stream.js\";\nimport type { RunnableInterface } from \"./types.js\";\n\n// oxlint-disable-next-line @typescript-eslint/no-explicit-any\nexport function isRunnableInterface(thing: any): thing is RunnableInterface {\n  return thing ? thing.lc_runnable : false;\n}\n\n/**\n * Utility to filter the root event in the streamEvents implementation.\n * This is simply binding the arguments to the namespace to make save on\n * a bit of typing in the streamEvents implementation.\n *\n * TODO: Refactor and remove.\n */\nexport class _RootEventFilter {\n  includeNames?: string[];\n\n  includeTypes?: string[];\n\n  includeTags?: string[];\n\n  excludeNames?: string[];\n\n  excludeTypes?: string[];\n\n  excludeTags?: string[];\n\n  constructor(fields: {\n    includeNames?: string[];\n    includeTypes?: string[];\n    includeTags?: string[];\n    excludeNames?: string[];\n    excludeTypes?: string[];\n    excludeTags?: string[];\n  }) {\n    this.includeNames = fields.includeNames;\n    this.includeTypes = fields.includeTypes;\n    this.includeTags = fields.includeTags;\n    this.excludeNames = fields.excludeNames;\n    this.excludeTypes = fields.excludeTypes;\n    this.excludeTags = fields.excludeTags;\n  }\n\n  includeEvent(event: StreamEvent, rootType: string): boolean {\n    let include =\n      this.includeNames === undefined &&\n      this.includeTypes === undefined &&\n      this.includeTags === undefined;\n    const eventTags = event.tags ?? [];\n\n    if (this.includeNames !== undefined) {\n      include = include || this.includeNames.includes(event.name);\n    }\n    if (this.includeTypes !== undefined) {\n      include = include || this.includeTypes.includes(rootType);\n    }\n    if (this.includeTags !== undefined) {\n      include =\n        include || eventTags.some((tag) => this.includeTags?.includes(tag));\n    }\n\n    if (this.excludeNames !== undefined) {\n      include = include && !this.excludeNames.includes(event.name);\n    }\n    if (this.excludeTypes !== undefined) {\n      include = include && !this.excludeTypes.includes(rootType);\n    }\n    if (this.excludeTags !== undefined) {\n      include =\n        include && eventTags.every((tag) => !this.excludeTags?.includes(tag));\n    }\n\n    return include;\n  }\n}\n\nexport const toBase64Url = (str: string): string => {\n  // Use btoa for compatibility, assume ASCII\n  const encoded = btoa(str);\n  return encoded.replace(/\\+/g, \"-\").replace(/\\//g, \"_\").replace(/=+$/, \"\");\n};\n"],"mappings":";AAIA,SAAgB,oBAAoB,OAAwC;AAC1E,QAAO,QAAQ,MAAM,cAAc;;;;;;;;;AAUrC,IAAa,mBAAb,MAA8B;CAC5B;CAEA;CAEA;CAEA;CAEA;CAEA;CAEA,YAAY,QAOT;AACD,OAAK,eAAe,OAAO;AAC3B,OAAK,eAAe,OAAO;AAC3B,OAAK,cAAc,OAAO;AAC1B,OAAK,eAAe,OAAO;AAC3B,OAAK,eAAe,OAAO;AAC3B,OAAK,cAAc,OAAO;;CAG5B,aAAa,OAAoB,UAA2B;EAC1D,IAAI,UACF,KAAK,iBAAiB,KAAA,KACtB,KAAK,iBAAiB,KAAA,KACtB,KAAK,gBAAgB,KAAA;EACvB,MAAM,YAAY,MAAM,QAAQ,EAAE;AAElC,MAAI,KAAK,iBAAiB,KAAA,EACxB,WAAU,WAAW,KAAK,aAAa,SAAS,MAAM,KAAK;AAE7D,MAAI,KAAK,iBAAiB,KAAA,EACxB,WAAU,WAAW,KAAK,aAAa,SAAS,SAAS;AAE3D,MAAI,KAAK,gBAAgB,KAAA,EACvB,WACE,WAAW,UAAU,MAAM,QAAQ,KAAK,aAAa,SAAS,IAAI,CAAC;AAGvE,MAAI,KAAK,iBAAiB,KAAA,EACxB,WAAU,WAAW,CAAC,KAAK,aAAa,SAAS,MAAM,KAAK;AAE9D,MAAI,KAAK,iBAAiB,KAAA,EACxB,WAAU,WAAW,CAAC,KAAK,aAAa,SAAS,SAAS;AAE5D,MAAI,KAAK,gBAAgB,KAAA,EACvB,WACE,WAAW,UAAU,OAAO,QAAQ,CAAC,KAAK,aAAa,SAAS,IAAI,CAAC;AAGzE,SAAO;;;AAIX,MAAa,eAAe,QAAwB;AAGlD,QADgB,KAAK,IACP,CAAC,QAAQ,OAAO,IAAI,CAAC,QAAQ,OAAO,IAAI,CAAC,QAAQ,OAAO,GAAG"}

package/dist/runnables/wrappers.cjs

@@ -1,5 +1,4 @@
-const require_utils_stream = require('../utils/stream.cjs');
-
+const require_utils_stream = require("../utils/stream.cjs");
 //#region src/runnables/wrappers.ts
 function convertToHttpEventStream(stream) {
 	const encoder = new TextEncoder();
@@ -10,7 +9,7 @@ function convertToHttpEventStream(stream) {
 	} });
 	return require_utils_stream.IterableReadableStream.fromReadableStream(finalStream);
 }
-
 //#endregion
 exports.convertToHttpEventStream = convertToHttpEventStream;
+
 //# sourceMappingURL=wrappers.cjs.map

package/dist/runnables/wrappers.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"wrappers.cjs","names":["stream: AsyncGenerator","IterableReadableStream"],"sources":["../../src/runnables/wrappers.ts"],"sourcesContent":["import { IterableReadableStream } from \"../utils/stream.js\";\n\nexport function convertToHttpEventStream(stream: AsyncGenerator) {\n  const encoder = new TextEncoder();\n  const finalStream = new ReadableStream<Uint8Array>({\n    async start(controller) {\n      for await (const chunk of stream) {\n        controller.enqueue(\n          encoder.encode(`event: data\\ndata: ${JSON.stringify(chunk)}\\n\\n`)\n        );\n      }\n      controller.enqueue(encoder.encode(\"event: end\\n\\n\"));\n      controller.close();\n    },\n  });\n  return IterableReadableStream.fromReadableStream(finalStream);\n}\n"],"mappings":";;;AAEA,SAAgB,yBAAyBA,QAAwB;CAC/D,MAAM,UAAU,IAAI;CACpB,MAAM,cAAc,IAAI,eAA2B,EACjD,MAAM,MAAM,YAAY;AACtB,aAAW,MAAM,SAAS,QACxB,WAAW,QACT,QAAQ,OAAO,CAAC,mBAAmB,EAAE,KAAK,UAAU,MAAM,CAAC,IAAI,CAAC,CAAC,CAClE;EAEH,WAAW,QAAQ,QAAQ,OAAO,iBAAiB,CAAC;EACpD,WAAW,OAAO;CACnB,EACF;AACD,QAAOC,4CAAuB,mBAAmB,YAAY;AAC9D"}
+{"version":3,"file":"wrappers.cjs","names":["IterableReadableStream"],"sources":["../../src/runnables/wrappers.ts"],"sourcesContent":["import { IterableReadableStream } from \"../utils/stream.js\";\n\nexport function convertToHttpEventStream(stream: AsyncGenerator) {\n  const encoder = new TextEncoder();\n  const finalStream = new ReadableStream<Uint8Array>({\n    async start(controller) {\n      for await (const chunk of stream) {\n        controller.enqueue(\n          encoder.encode(`event: data\\ndata: ${JSON.stringify(chunk)}\\n\\n`)\n        );\n      }\n      controller.enqueue(encoder.encode(\"event: end\\n\\n\"));\n      controller.close();\n    },\n  });\n  return IterableReadableStream.fromReadableStream(finalStream);\n}\n"],"mappings":";;AAEA,SAAgB,yBAAyB,QAAwB;CAC/D,MAAM,UAAU,IAAI,aAAa;CACjC,MAAM,cAAc,IAAI,eAA2B,EACjD,MAAM,MAAM,YAAY;AACtB,aAAW,MAAM,SAAS,OACxB,YAAW,QACT,QAAQ,OAAO,sBAAsB,KAAK,UAAU,MAAM,CAAC,MAAM,CAClE;AAEH,aAAW,QAAQ,QAAQ,OAAO,iBAAiB,CAAC;AACpD,aAAW,OAAO;IAErB,CAAC;AACF,QAAOA,qBAAAA,uBAAuB,mBAAmB,YAAY"}

package/dist/runnables/wrappers.js

@@ -1,5 +1,4 @@
 import { IterableReadableStream } from "../utils/stream.js";
-
 //#region src/runnables/wrappers.ts
 function convertToHttpEventStream(stream) {
 	const encoder = new TextEncoder();
@@ -10,7 +9,7 @@ function convertToHttpEventStream(stream) {
 	} });
 	return IterableReadableStream.fromReadableStream(finalStream);
 }
-
 //#endregion
 export { convertToHttpEventStream };
+
 //# sourceMappingURL=wrappers.js.map

package/dist/runnables/wrappers.js.map

@@ -1 +1 @@
-{"version":3,"file":"wrappers.js","names":["stream: AsyncGenerator"],"sources":["../../src/runnables/wrappers.ts"],"sourcesContent":["import { IterableReadableStream } from \"../utils/stream.js\";\n\nexport function convertToHttpEventStream(stream: AsyncGenerator) {\n  const encoder = new TextEncoder();\n  const finalStream = new ReadableStream<Uint8Array>({\n    async start(controller) {\n      for await (const chunk of stream) {\n        controller.enqueue(\n          encoder.encode(`event: data\\ndata: ${JSON.stringify(chunk)}\\n\\n`)\n        );\n      }\n      controller.enqueue(encoder.encode(\"event: end\\n\\n\"));\n      controller.close();\n    },\n  });\n  return IterableReadableStream.fromReadableStream(finalStream);\n}\n"],"mappings":";;;AAEA,SAAgB,yBAAyBA,QAAwB;CAC/D,MAAM,UAAU,IAAI;CACpB,MAAM,cAAc,IAAI,eAA2B,EACjD,MAAM,MAAM,YAAY;AACtB,aAAW,MAAM,SAAS,QACxB,WAAW,QACT,QAAQ,OAAO,CAAC,mBAAmB,EAAE,KAAK,UAAU,MAAM,CAAC,IAAI,CAAC,CAAC,CAClE;EAEH,WAAW,QAAQ,QAAQ,OAAO,iBAAiB,CAAC;EACpD,WAAW,OAAO;CACnB,EACF;AACD,QAAO,uBAAuB,mBAAmB,YAAY;AAC9D"}
+{"version":3,"file":"wrappers.js","names":[],"sources":["../../src/runnables/wrappers.ts"],"sourcesContent":["import { IterableReadableStream } from \"../utils/stream.js\";\n\nexport function convertToHttpEventStream(stream: AsyncGenerator) {\n  const encoder = new TextEncoder();\n  const finalStream = new ReadableStream<Uint8Array>({\n    async start(controller) {\n      for await (const chunk of stream) {\n        controller.enqueue(\n          encoder.encode(`event: data\\ndata: ${JSON.stringify(chunk)}\\n\\n`)\n        );\n      }\n      controller.enqueue(encoder.encode(\"event: end\\n\\n\"));\n      controller.close();\n    },\n  });\n  return IterableReadableStream.fromReadableStream(finalStream);\n}\n"],"mappings":";;AAEA,SAAgB,yBAAyB,QAAwB;CAC/D,MAAM,UAAU,IAAI,aAAa;CACjC,MAAM,cAAc,IAAI,eAA2B,EACjD,MAAM,MAAM,YAAY;AACtB,aAAW,MAAM,SAAS,OACxB,YAAW,QACT,QAAQ,OAAO,sBAAsB,KAAK,UAAU,MAAM,CAAC,MAAM,CAClE;AAEH,aAAW,QAAQ,QAAQ,OAAO,iBAAiB,CAAC;AACpD,aAAW,OAAO;IAErB,CAAC;AACF,QAAO,uBAAuB,mBAAmB,YAAY"}