@langchain/classic 1.0.0-alpha.1

package/dist/chains/llm_chain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"llm_chain.d.ts","names":["BaseLanguageModelInterface","BaseLanguageModelInput","ChainValues","Generation","BaseMessage","BasePromptValueInterface","BasePromptTemplate","BaseLLMOutputParser","CallbackManager","BaseCallbackConfig","CallbackManagerForChainRun","Callbacks","Runnable","BaseChain","ChainInputs","SerializedLLMChain","LLMType","CallOptionsIfAvailable","T","CO","LLMChainInput","Model","LLMChain","Promise"],"sources":["../../src/chains/llm_chain.d.ts"],"sourcesContent":["import { BaseLanguageModelInterface, BaseLanguageModelInput } from \"@langchain/core/language_models/base\";\nimport type { ChainValues } from \"@langchain/core/utils/types\";\nimport type { Generation } from \"@langchain/core/outputs\";\nimport type { BaseMessage } from \"@langchain/core/messages\";\nimport type { BasePromptValueInterface } from \"@langchain/core/prompt_values\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { BaseLLMOutputParser } from \"@langchain/core/output_parsers\";\nimport { CallbackManager, BaseCallbackConfig, CallbackManagerForChainRun, Callbacks } from \"@langchain/core/callbacks/manager\";\nimport { Runnable } from \"@langchain/core/runnables\";\nimport { BaseChain, ChainInputs } from \"./base.js\";\nimport { SerializedLLMChain } from \"./serde.js\";\ntype LLMType = BaseLanguageModelInterface | Runnable<BaseLanguageModelInput, string> | Runnable<BaseLanguageModelInput, BaseMessage>;\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype CallOptionsIfAvailable<T> = T extends {\n    CallOptions: infer CO;\n} ? CO : any;\n/**\n * Interface for the input parameters of the LLMChain class.\n */\nexport interface LLMChainInput<T extends string | object = string, Model extends LLMType = LLMType> extends ChainInputs {\n    /** Prompt object to use */\n    prompt: BasePromptTemplate;\n    /** LLM Wrapper to use */\n    llm: Model;\n    /** Kwargs to pass to LLM */\n    llmKwargs?: CallOptionsIfAvailable<Model>;\n    /** OutputParser to use */\n    outputParser?: BaseLLMOutputParser<T>;\n    /** Key to use for output, defaults to `text` */\n    outputKey?: string;\n}\n/**\n * Chain to run queries against LLMs.\n *\n * @example\n * ```ts\n * import { ChatPromptTemplate } from \"@langchain/core/prompts\";\n * import { ChatOpenAI } from \"@langchain/openai\";\n *\n * const prompt = ChatPromptTemplate.fromTemplate(\"Tell me a {adjective} joke\");\n * const llm = new ChatOpenAI({ model: \"gpt-4o-mini\" });\n * const chain = prompt.pipe(llm);\n *\n * const response = await chain.invoke({ adjective: \"funny\" });\n * ```\n */\nexport declare class LLMChain<T extends string | object = string, Model extends LLMType = LLMType> extends BaseChain implements LLMChainInput<T> {\n    static lc_name(): string;\n    lc_serializable: boolean;\n    prompt: BasePromptTemplate;\n    llm: Model;\n    llmKwargs?: CallOptionsIfAvailable<Model>;\n    outputKey: string;\n    outputParser?: BaseLLMOutputParser<T>;\n    get inputKeys(): string[];\n    get outputKeys(): string[];\n    constructor(fields: LLMChainInput<T, Model>);\n    private getCallKeys;\n    /** @ignore */\n    _selectMemoryInputs(values: ChainValues): ChainValues;\n    /** @ignore */\n    _getFinalOutput(generations: Generation[], promptValue: BasePromptValueInterface, runManager?: CallbackManagerForChainRun): Promise<unknown>;\n    /**\n     * Run the core logic of this chain and add to output if desired.\n     *\n     * Wraps _call and handles memory.\n     */\n    call(values: ChainValues & CallOptionsIfAvailable<Model>, config?: Callbacks | BaseCallbackConfig): Promise<ChainValues>;\n    /** @ignore */\n    _call(values: ChainValues & CallOptionsIfAvailable<Model>, runManager?: CallbackManagerForChainRun): Promise<ChainValues>;\n    /**\n     * Format prompt with values and pass to LLM\n     *\n     * @param values - keys to pass to prompt template\n     * @param callbackManager - CallbackManager to use\n     * @returns Completion from LLM.\n     *\n     * @example\n     * ```ts\n     * llm.predict({ adjective: \"funny\" })\n     * ```\n     */\n    predict(values: ChainValues & CallOptionsIfAvailable<Model>, callbackManager?: CallbackManager): Promise<T>;\n    _chainType(): \"llm\";\n    static deserialize(data: SerializedLLMChain): Promise<LLMChain>;\n    /** @deprecated */\n    serialize(): SerializedLLMChain;\n    _getNumTokens(text: string): Promise<number>;\n}\nexport {};\n"],"mappings":";;;;;;;;;;;;;KAWKgB,OAAAA,GAAUhB,6BAA6BY,SAASX,kCAAkCW,SAASX,wBAAwBG;;AADxE,KAG3Ca,sBAFO,CAAA,CAAA,CAAA,GAEqBC,CAFrB,SAAA;EAAA,WAAA,EAAA,KAAA,GAAA;CAAA,GAIRC,EAJQ,GAAGnB,GAAAA;;;;AAAyGI,UAQvGgB,aARuGhB,CAAAA,UAAAA,MAAAA,GAAAA,MAAAA,GAAAA,MAAAA,EAAAA,cAQvCY,OARuCZ,GAQ7BY,OAR6BZ,CAAAA,SAQZU,WARYV,CAAAA;EAAW;EAApC,MAAA,EAUnFE,kBAVmF;EAE1FW;EAAsB,GAAA,EAUlBI,KAVkB;EAAA;EAAO,SAE9BF,CAAAA,EAUYF,sBAVZE,CAUmCE,KAVnCF,CAAAA;EAAE;EAIWC,YAAAA,CAAAA,EAQEb,mBARW,CAQSW,CART,CAAA;EAAA;EAAA,SAAmDF,CAAAA,EAAAA,MAAAA;;;;;;;;;AAAsC;AA2BvH;;;;;;;AAKuCK,cALlBC,QAKkBD,CAAAA,UAAAA,MAAAA,GAAAA,MAAAA,GAAAA,MAAAA,EAAAA,cALyCL,OAKzCK,GALmDL,OAKnDK,CAAAA,SALoER,SAAAA,YAAqBO,aAKzFC,CALuGH,CAKvGG,CAAAA,CAAAA;EAAK,OAA5BJ,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAsB,eAECC,EAAAA,OAAAA;EAAC,MAArBX,EAJPD,kBAIOC;EAAmB,GAGAW,EAN7BG,KAM6BH;EAAC,SAAEG,CAAAA,EALzBJ,sBAKyBI,CALFA,KAKEA,CAAAA;EAAK,SAAtBD,EAAAA,MAAAA;EAAa,YAGLlB,CAAAA,EANbK,mBAMaL,CANOgB,CAMPhB,CAAAA;EAAW,IAAGA,SAAAA,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAW,IAExBC,UAAAA,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAU,WAAiBE,CAAAA,MAAAA,EALpCe,aAKoCf,CALtBa,CAKsBb,EALnBgB,KAKmBhB,CAAAA;EAAwB,QAAeK,WAAAA;EAA0B;EAAU,mBAMtHR,CAAAA,MAAAA,EAReA,WAQfA,CAAAA,EAR6BA,WAQ7BA;EAAW;EAA+B,eAA5Be,CAAAA,WAAAA,EANEd,UAMFc,EAAAA,EAAAA,WAAAA,EAN6BZ,wBAM7BY,EAAAA,UAAAA,CAAAA,EANoEP,0BAMpEO,CAAAA,EANiGM,OAMjGN,CAAAA,OAAAA,CAAAA;EAAsB;;;;;EAExB,IAA0BI,CAAAA,MAAAA,EAFtCnB,WAEsCmB,GAFxBJ,sBAEwBI,CAFDA,KAECA,CAAAA,EAAAA,MAAAA,CAAAA,EAFgBV,SAEhBU,GAF4BZ,kBAE5BY,CAAAA,EAFiDE,OAEjDF,CAFyDnB,WAEzDmB,CAAAA;EAAK;EAAN,KAAsBX,CAAAA,MAAAA,EAA1DR,WAA0DQ,GAA5CO,sBAA4CP,CAArBW,KAAqBX,CAAAA,EAAAA,UAAAA,CAAAA,EAAAA,0BAAAA,CAAAA,EAA6Ba,OAA7Bb,CAAqCR,WAArCQ,CAAAA;EAA0B;;;;;;;;;;;;EAiBnE,OACFa,CAAAA,MAAAA,EALbrB,WAKaqB,GALCN,sBAKDM,CALwBF,KAKxBE,CAAAA,EAAAA,eAAAA,CAAAA,EALkDf,eAKlDe,CAAAA,EALoEA,OAKpEA,CAL4EL,CAK5EK,CAAAA;EAAO,UAzCmEV,CAAAA,CAAAA,EAAAA,KAAAA;EAAS,OAAYO,WAAAA,CAAAA,IAAAA,EAsCnGL,kBAtCmGK,CAAAA,EAsC9EG,OAtC8EH,CAsCtEE,QAtCsEF,CAAAA;EAAa;eAwC5HL;+BACgBQ"}

package/dist/chains/llm_chain.js

@@ -0,0 +1,151 @@
+import { BaseChain } from "./base.js";
+import { NoOpOutputParser } from "../output_parsers/noop.js";
+import { BasePromptTemplate } from "@langchain/core/prompts";
+import { Runnable } from "@langchain/core/runnables";
+import { BaseLanguageModel } from "@langchain/core/language_models/base";
+
+//#region src/chains/llm_chain.ts
+function isBaseLanguageModel(llmLike) {
+	return typeof llmLike._llmType === "function";
+}
+function _getLanguageModel(llmLike) {
+	if (isBaseLanguageModel(llmLike)) return llmLike;
+	else if ("bound" in llmLike && Runnable.isRunnable(llmLike.bound)) return _getLanguageModel(llmLike.bound);
+	else if ("runnable" in llmLike && "fallbacks" in llmLike && Runnable.isRunnable(llmLike.runnable)) return _getLanguageModel(llmLike.runnable);
+	else if ("default" in llmLike && Runnable.isRunnable(llmLike.default)) return _getLanguageModel(llmLike.default);
+	else throw new Error("Unable to extract BaseLanguageModel from llmLike object.");
+}
+/**
+* Chain to run queries against LLMs.
+*
+* @example
+* ```ts
+* import { ChatPromptTemplate } from "@langchain/core/prompts";
+* import { ChatOpenAI } from "@langchain/openai";
+*
+* const prompt = ChatPromptTemplate.fromTemplate("Tell me a {adjective} joke");
+* const llm = new ChatOpenAI({ model: "gpt-4o-mini" });
+* const chain = prompt.pipe(llm);
+*
+* const response = await chain.invoke({ adjective: "funny" });
+* ```
+*/
+var LLMChain = class LLMChain extends BaseChain {
+	static lc_name() {
+		return "LLMChain";
+	}
+	lc_serializable = true;
+	prompt;
+	llm;
+	llmKwargs;
+	outputKey = "text";
+	outputParser;
+	get inputKeys() {
+		return this.prompt.inputVariables;
+	}
+	get outputKeys() {
+		return [this.outputKey];
+	}
+	constructor(fields) {
+		super(fields);
+		this.prompt = fields.prompt;
+		this.llm = fields.llm;
+		this.llmKwargs = fields.llmKwargs;
+		this.outputKey = fields.outputKey ?? this.outputKey;
+		this.outputParser = fields.outputParser ?? new NoOpOutputParser();
+		if (this.prompt.outputParser) {
+			if (fields.outputParser) throw new Error("Cannot set both outputParser and prompt.outputParser");
+			this.outputParser = this.prompt.outputParser;
+		}
+	}
+	getCallKeys() {
+		const callKeys = "callKeys" in this.llm ? this.llm.callKeys : [];
+		return callKeys;
+	}
+	/** @ignore */
+	_selectMemoryInputs(values) {
+		const valuesForMemory = super._selectMemoryInputs(values);
+		const callKeys = this.getCallKeys();
+		for (const key of callKeys) if (key in values) delete valuesForMemory[key];
+		return valuesForMemory;
+	}
+	/** @ignore */
+	async _getFinalOutput(generations, promptValue, runManager) {
+		let finalCompletion;
+		if (this.outputParser) finalCompletion = await this.outputParser.parseResultWithPrompt(generations, promptValue, runManager?.getChild());
+		else finalCompletion = generations[0].text;
+		return finalCompletion;
+	}
+	/**
+	* Run the core logic of this chain and add to output if desired.
+	*
+	* Wraps _call and handles memory.
+	*/
+	call(values, config) {
+		return super.call(values, config);
+	}
+	/** @ignore */
+	async _call(values, runManager) {
+		const valuesForPrompt = { ...values };
+		const valuesForLLM = { ...this.llmKwargs };
+		const callKeys = this.getCallKeys();
+		for (const key of callKeys) if (key in values) {
+			if (valuesForLLM) {
+				valuesForLLM[key] = values[key];
+				delete valuesForPrompt[key];
+			}
+		}
+		const promptValue = await this.prompt.formatPromptValue(valuesForPrompt);
+		if ("generatePrompt" in this.llm) {
+			const { generations } = await this.llm.generatePrompt([promptValue], valuesForLLM, runManager?.getChild());
+			return { [this.outputKey]: await this._getFinalOutput(generations[0], promptValue, runManager) };
+		}
+		const modelWithParser = this.outputParser ? this.llm.pipe(this.outputParser) : this.llm;
+		const response = await modelWithParser.invoke(promptValue, runManager?.getChild());
+		return { [this.outputKey]: response };
+	}
+	/**
+	* Format prompt with values and pass to LLM
+	*
+	* @param values - keys to pass to prompt template
+	* @param callbackManager - CallbackManager to use
+	* @returns Completion from LLM.
+	*
+	* @example
+	* ```ts
+	* llm.predict({ adjective: "funny" })
+	* ```
+	*/
+	async predict(values, callbackManager) {
+		const output = await this.call(values, callbackManager);
+		return output[this.outputKey];
+	}
+	_chainType() {
+		return "llm";
+	}
+	static async deserialize(data) {
+		const { llm, prompt } = data;
+		if (!llm) throw new Error("LLMChain must have llm");
+		if (!prompt) throw new Error("LLMChain must have prompt");
+		return new LLMChain({
+			llm: await BaseLanguageModel.deserialize(llm),
+			prompt: await BasePromptTemplate.deserialize(prompt)
+		});
+	}
+	/** @deprecated */
+	serialize() {
+		const serialize = "serialize" in this.llm ? this.llm.serialize() : void 0;
+		return {
+			_type: `${this._chainType()}_chain`,
+			llm: serialize,
+			prompt: this.prompt.serialize()
+		};
+	}
+	_getNumTokens(text) {
+		return _getLanguageModel(this.llm).getNumTokens(text);
+	}
+};
+
+//#endregion
+export { LLMChain };
+//# sourceMappingURL=llm_chain.js.map

package/dist/chains/llm_chain.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"llm_chain.js","names":["llmLike: unknown","llmLike: RunnableInterface","fields: LLMChainInput<T, Model>","values: ChainValues","generations: Generation[]","promptValue: BasePromptValueInterface","runManager?: CallbackManagerForChainRun","finalCompletion: unknown","values: ChainValues & CallOptionsIfAvailable<Model>","config?: Callbacks | BaseCallbackConfig","callbackManager?: CallbackManager","data: SerializedLLMChain","text: string"],"sources":["../../src/chains/llm_chain.ts"],"sourcesContent":["import {\n  BaseLanguageModel,\n  BaseLanguageModelInterface,\n  BaseLanguageModelInput,\n} from \"@langchain/core/language_models/base\";\nimport type { ChainValues } from \"@langchain/core/utils/types\";\nimport type { Generation } from \"@langchain/core/outputs\";\nimport type { BaseMessage } from \"@langchain/core/messages\";\nimport type { BasePromptValueInterface } from \"@langchain/core/prompt_values\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport {\n  BaseLLMOutputParser,\n  BaseOutputParser,\n} from \"@langchain/core/output_parsers\";\nimport {\n  CallbackManager,\n  BaseCallbackConfig,\n  CallbackManagerForChainRun,\n  Callbacks,\n} from \"@langchain/core/callbacks/manager\";\nimport { Runnable, type RunnableInterface } from \"@langchain/core/runnables\";\nimport { BaseChain, ChainInputs } from \"./base.js\";\nimport { SerializedLLMChain } from \"./serde.js\";\nimport { NoOpOutputParser } from \"../output_parsers/noop.js\";\n\ntype LLMType =\n  | BaseLanguageModelInterface\n  | Runnable<BaseLanguageModelInput, string>\n  | Runnable<BaseLanguageModelInput, BaseMessage>;\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype CallOptionsIfAvailable<T> = T extends { CallOptions: infer CO } ? CO : any;\n/**\n * Interface for the input parameters of the LLMChain class.\n */\nexport interface LLMChainInput<\n  T extends string | object = string,\n  Model extends LLMType = LLMType\n> extends ChainInputs {\n  /** Prompt object to use */\n  prompt: BasePromptTemplate;\n  /** LLM Wrapper to use */\n  llm: Model;\n  /** Kwargs to pass to LLM */\n  llmKwargs?: CallOptionsIfAvailable<Model>;\n  /** OutputParser to use */\n  outputParser?: BaseLLMOutputParser<T>;\n  /** Key to use for output, defaults to `text` */\n  outputKey?: string;\n}\n\nfunction isBaseLanguageModel(llmLike: unknown): llmLike is BaseLanguageModel {\n  return typeof (llmLike as BaseLanguageModelInterface)._llmType === \"function\";\n}\n\nfunction _getLanguageModel(llmLike: RunnableInterface): BaseLanguageModel {\n  if (isBaseLanguageModel(llmLike)) {\n    return llmLike;\n  } else if (\"bound\" in llmLike && Runnable.isRunnable(llmLike.bound)) {\n    return _getLanguageModel(llmLike.bound);\n  } else if (\n    \"runnable\" in llmLike &&\n    \"fallbacks\" in llmLike &&\n    Runnable.isRunnable(llmLike.runnable)\n  ) {\n    return _getLanguageModel(llmLike.runnable);\n  } else if (\"default\" in llmLike && Runnable.isRunnable(llmLike.default)) {\n    return _getLanguageModel(llmLike.default);\n  } else {\n    throw new Error(\"Unable to extract BaseLanguageModel from llmLike object.\");\n  }\n}\n\n/**\n * Chain to run queries against LLMs.\n *\n * @example\n * ```ts\n * import { ChatPromptTemplate } from \"@langchain/core/prompts\";\n * import { ChatOpenAI } from \"@langchain/openai\";\n *\n * const prompt = ChatPromptTemplate.fromTemplate(\"Tell me a {adjective} joke\");\n * const llm = new ChatOpenAI({ model: \"gpt-4o-mini\" });\n * const chain = prompt.pipe(llm);\n *\n * const response = await chain.invoke({ adjective: \"funny\" });\n * ```\n */\nexport class LLMChain<\n    T extends string | object = string,\n    Model extends LLMType = LLMType\n  >\n  extends BaseChain\n  implements LLMChainInput<T>\n{\n  static lc_name() {\n    return \"LLMChain\";\n  }\n\n  lc_serializable = true;\n\n  prompt: BasePromptTemplate;\n\n  llm: Model;\n\n  llmKwargs?: CallOptionsIfAvailable<Model>;\n\n  outputKey = \"text\";\n\n  outputParser?: BaseLLMOutputParser<T>;\n\n  get inputKeys() {\n    return this.prompt.inputVariables;\n  }\n\n  get outputKeys() {\n    return [this.outputKey];\n  }\n\n  constructor(fields: LLMChainInput<T, Model>) {\n    super(fields);\n    this.prompt = fields.prompt;\n    this.llm = fields.llm;\n    this.llmKwargs = fields.llmKwargs;\n    this.outputKey = fields.outputKey ?? this.outputKey;\n    this.outputParser =\n      fields.outputParser ?? (new NoOpOutputParser() as BaseOutputParser<T>);\n    if (this.prompt.outputParser) {\n      if (fields.outputParser) {\n        throw new Error(\"Cannot set both outputParser and prompt.outputParser\");\n      }\n      this.outputParser = this.prompt.outputParser as BaseOutputParser<T>;\n    }\n  }\n\n  private getCallKeys(): string[] {\n    const callKeys = \"callKeys\" in this.llm ? this.llm.callKeys : [];\n    return callKeys;\n  }\n\n  /** @ignore */\n  _selectMemoryInputs(values: ChainValues): ChainValues {\n    const valuesForMemory = super._selectMemoryInputs(values);\n    const callKeys = this.getCallKeys();\n    for (const key of callKeys) {\n      if (key in values) {\n        delete valuesForMemory[key];\n      }\n    }\n    return valuesForMemory;\n  }\n\n  /** @ignore */\n  async _getFinalOutput(\n    generations: Generation[],\n    promptValue: BasePromptValueInterface,\n    runManager?: CallbackManagerForChainRun\n  ): Promise<unknown> {\n    let finalCompletion: unknown;\n    if (this.outputParser) {\n      finalCompletion = await this.outputParser.parseResultWithPrompt(\n        generations,\n        promptValue,\n        runManager?.getChild()\n      );\n    } else {\n      finalCompletion = generations[0].text;\n    }\n    return finalCompletion;\n  }\n\n  /**\n   * Run the core logic of this chain and add to output if desired.\n   *\n   * Wraps _call and handles memory.\n   */\n  call(\n    values: ChainValues & CallOptionsIfAvailable<Model>,\n    config?: Callbacks | BaseCallbackConfig\n  ): Promise<ChainValues> {\n    return super.call(values, config);\n  }\n\n  /** @ignore */\n  async _call(\n    values: ChainValues & CallOptionsIfAvailable<Model>,\n    runManager?: CallbackManagerForChainRun\n  ): Promise<ChainValues> {\n    const valuesForPrompt = { ...values };\n    const valuesForLLM = {\n      ...this.llmKwargs,\n    } as CallOptionsIfAvailable<Model>;\n    const callKeys = this.getCallKeys();\n    for (const key of callKeys) {\n      if (key in values) {\n        if (valuesForLLM) {\n          valuesForLLM[key as keyof CallOptionsIfAvailable<Model>] =\n            values[key];\n          delete valuesForPrompt[key];\n        }\n      }\n    }\n    const promptValue = await this.prompt.formatPromptValue(valuesForPrompt);\n    if (\"generatePrompt\" in this.llm) {\n      const { generations } = await this.llm.generatePrompt(\n        [promptValue],\n        valuesForLLM,\n        runManager?.getChild()\n      );\n      return {\n        [this.outputKey]: await this._getFinalOutput(\n          generations[0],\n          promptValue,\n          runManager\n        ),\n      };\n    }\n\n    const modelWithParser = this.outputParser\n      ? this.llm.pipe(this.outputParser)\n      : this.llm;\n    const response = await modelWithParser.invoke(\n      promptValue,\n      runManager?.getChild()\n    );\n    return {\n      [this.outputKey]: response,\n    };\n  }\n\n  /**\n   * Format prompt with values and pass to LLM\n   *\n   * @param values - keys to pass to prompt template\n   * @param callbackManager - CallbackManager to use\n   * @returns Completion from LLM.\n   *\n   * @example\n   * ```ts\n   * llm.predict({ adjective: \"funny\" })\n   * ```\n   */\n  async predict(\n    values: ChainValues & CallOptionsIfAvailable<Model>,\n    callbackManager?: CallbackManager\n  ): Promise<T> {\n    const output = await this.call(values, callbackManager);\n    return output[this.outputKey];\n  }\n\n  _chainType() {\n    return \"llm\" as const;\n  }\n\n  static async deserialize(data: SerializedLLMChain): Promise<LLMChain> {\n    const { llm, prompt } = data;\n    if (!llm) {\n      throw new Error(\"LLMChain must have llm\");\n    }\n    if (!prompt) {\n      throw new Error(\"LLMChain must have prompt\");\n    }\n\n    return new LLMChain({\n      llm: await BaseLanguageModel.deserialize(llm),\n      prompt: await BasePromptTemplate.deserialize(prompt),\n    });\n  }\n\n  /** @deprecated */\n  serialize(): SerializedLLMChain {\n    const serialize =\n      \"serialize\" in this.llm ? this.llm.serialize() : undefined;\n    return {\n      _type: `${this._chainType()}_chain`,\n      llm: serialize,\n      prompt: this.prompt.serialize(),\n    };\n  }\n\n  _getNumTokens(text: string): Promise<number> {\n    return _getLanguageModel(this.llm).getNumTokens(text);\n  }\n}\n"],"mappings":"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"}

package/dist/chains/load.cjs

@@ -0,0 +1,46 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_base = require('./base.cjs');
+const require_hub = require('../util/hub.cjs');
+const require_load = require('../util/load.cjs');
+const require_parse = require('../util/parse.cjs');
+
+//#region src/chains/load.ts
+var load_exports = {};
+require_rolldown_runtime.__export(load_exports, { loadChain: () => loadChain });
+const loadChainFromFile = async (file, path, values = {}) => {
+	const serialized = require_parse.parseFileConfig(file, path);
+	return require_base.BaseChain.deserialize(serialized, values);
+};
+/**
+* Load a chain from {@link https://github.com/hwchase17/langchain-hub | LangchainHub} or local filesystem.
+*
+* @example
+* Loading from LangchainHub:
+* ```ts
+* import { loadChain } from "@langchain/classic/chains/load";
+* const chain = await loadChain("lc://chains/hello-world/chain.json");
+* const res = await chain.call({ topic: "my favorite color" });
+* ```
+*
+* @example
+* Loading from local filesystem:
+* ```ts
+* import { loadChain } from "@langchain/classic/chains/load";
+* const chain = await loadChain("/path/to/chain.json");
+* ```
+*/
+const loadChain = async (uri, values = {}) => {
+	const hubResult = await require_hub.loadFromHub(uri, loadChainFromFile, "chains", new Set(["json", "yaml"]), values);
+	if (hubResult) return hubResult;
+	return require_load.loadFromFile(uri, loadChainFromFile, values);
+};
+
+//#endregion
+exports.loadChain = loadChain;
+Object.defineProperty(exports, 'load_exports', {
+  enumerable: true,
+  get: function () {
+    return load_exports;
+  }
+});
+//# sourceMappingURL=load.cjs.map

package/dist/chains/load.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"load.cjs","names":["loadChainFromFile: FileLoader<BaseChain>","file: string","path: string","values: LoadValues","parseFileConfig","BaseChain","uri: string","loadFromHub","loadFromFile"],"sources":["../../src/chains/load.ts"],"sourcesContent":["import { BaseChain } from \"./base.js\";\nimport { loadFromHub } from \"../util/hub.js\";\nimport { FileLoader, LoadValues, loadFromFile } from \"../util/load.js\";\nimport { parseFileConfig } from \"../util/parse.js\";\n\nconst loadChainFromFile: FileLoader<BaseChain> = async (\n  file: string,\n  path: string,\n  values: LoadValues = {}\n) => {\n  const serialized = parseFileConfig(file, path);\n  return BaseChain.deserialize(serialized, values);\n};\n\n/**\n * Load a chain from {@link https://github.com/hwchase17/langchain-hub | LangchainHub} or local filesystem.\n *\n * @example\n * Loading from LangchainHub:\n * ```ts\n * import { loadChain } from \"@langchain/classic/chains/load\";\n * const chain = await loadChain(\"lc://chains/hello-world/chain.json\");\n * const res = await chain.call({ topic: \"my favorite color\" });\n * ```\n *\n * @example\n * Loading from local filesystem:\n * ```ts\n * import { loadChain } from \"@langchain/classic/chains/load\";\n * const chain = await loadChain(\"/path/to/chain.json\");\n * ```\n */\nexport const loadChain = async (\n  uri: string,\n  values: LoadValues = {}\n): Promise<BaseChain> => {\n  const hubResult = await loadFromHub(\n    uri,\n    loadChainFromFile,\n    \"chains\",\n    new Set([\"json\", \"yaml\"]),\n    values\n  );\n  if (hubResult) {\n    return hubResult;\n  }\n\n  return loadFromFile(uri, loadChainFromFile, values);\n};\n"],"mappings":";;;;;;;;;AAKA,MAAMA,oBAA2C,OAC/CC,MACAC,MACAC,SAAqB,CAAE,MACpB;CACH,MAAM,aAAaC,8BAAgB,MAAM,KAAK;AAC9C,QAAOC,uBAAU,YAAY,YAAY,OAAO;AACjD;;;;;;;;;;;;;;;;;;;AAoBD,MAAa,YAAY,OACvBC,KACAH,SAAqB,CAAE,MACA;CACvB,MAAM,YAAY,MAAMI,wBACtB,KACA,mBACA,UACA,IAAI,IAAI,CAAC,QAAQ,MAAO,IACxB,OACD;AACD,KAAI,UACF,QAAO;AAGT,QAAOC,0BAAa,KAAK,mBAAmB,OAAO;AACpD"}

package/dist/chains/load.d.cts

@@ -0,0 +1,28 @@
+import { BaseChain } from "./base.cjs";
+import { ChainValues } from "../langchain-core/dist/utils/types/index.cjs";
+import { LoadValues } from "../util/load.cjs";
+
+//#region src/chains/load.d.ts
+
+/**
+ * Load a chain from {@link https://github.com/hwchase17/langchain-hub | LangchainHub} or local filesystem.
+ *
+ * @example
+ * Loading from LangchainHub:
+ * ```ts
+ * import { loadChain } from "@langchain/classic/chains/load";
+ * const chain = await loadChain("lc://chains/hello-world/chain.json");
+ * const res = await chain.call({ topic: "my favorite color" });
+ * ```
+ *
+ * @example
+ * Loading from local filesystem:
+ * ```ts
+ * import { loadChain } from "@langchain/classic/chains/load";
+ * const chain = await loadChain("/path/to/chain.json");
+ * ```
+ */
+declare const loadChain: (uri: string, values?: LoadValues) => Promise<BaseChain<ChainValues, ChainValues>>;
+//#endregion
+export { loadChain };
+//# sourceMappingURL=load.d.cts.map

package/dist/chains/load.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load.d.cts","names":["BaseChain","LoadValues","loadChain","_________langchain_core_dist_utils_types_index_js0","ChainValues","Promise"],"sources":["../../src/chains/load.d.ts"],"sourcesContent":["import { BaseChain } from \"./base.js\";\nimport { LoadValues } from \"../util/load.js\";\n/**\n * Load a chain from {@link https://github.com/hwchase17/langchain-hub | LangchainHub} or local filesystem.\n *\n * @example\n * Loading from LangchainHub:\n * ```ts\n * import { loadChain } from \"@langchain/classic/chains/load\";\n * const chain = await loadChain(\"lc://chains/hello-world/chain.json\");\n * const res = await chain.call({ topic: \"my favorite color\" });\n * ```\n *\n * @example\n * Loading from local filesystem:\n * ```ts\n * import { loadChain } from \"@langchain/classic/chains/load\";\n * const chain = await loadChain(\"/path/to/chain.json\");\n * ```\n */\nexport declare const loadChain: (uri: string, values?: LoadValues) => Promise<BaseChain<import(\"../../../langchain-core/dist/utils/types/index.js\").ChainValues, import(\"../../../langchain-core/dist/utils/types/index.js\").ChainValues>>;\n"],"mappings":";;;;;;;;;AAoBA;;;;;;;AAA6E;;;;;;;;cAAxDE,kCAAkCD,eAAeI,QAAQL,UAAb,WAAA,EAA8F,WAAA"}

package/dist/chains/load.d.ts

@@ -0,0 +1,28 @@
+import { BaseChain } from "./base.js";
+import { ChainValues } from "../libs/langchain-core/dist/utils/types/index.js";
+import { LoadValues } from "../util/load.js";
+
+//#region src/chains/load.d.ts
+
+/**
+ * Load a chain from {@link https://github.com/hwchase17/langchain-hub | LangchainHub} or local filesystem.
+ *
+ * @example
+ * Loading from LangchainHub:
+ * ```ts
+ * import { loadChain } from "@langchain/classic/chains/load";
+ * const chain = await loadChain("lc://chains/hello-world/chain.json");
+ * const res = await chain.call({ topic: "my favorite color" });
+ * ```
+ *
+ * @example
+ * Loading from local filesystem:
+ * ```ts
+ * import { loadChain } from "@langchain/classic/chains/load";
+ * const chain = await loadChain("/path/to/chain.json");
+ * ```
+ */
+declare const loadChain: (uri: string, values?: LoadValues) => Promise<BaseChain<ChainValues, ChainValues>>;
+//#endregion
+export { loadChain };
+//# sourceMappingURL=load.d.ts.map

package/dist/chains/load.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load.d.ts","names":["BaseChain","LoadValues","loadChain","_________langchain_core_dist_utils_types_index_js0","ChainValues","Promise"],"sources":["../../src/chains/load.d.ts"],"sourcesContent":["import { BaseChain } from \"./base.js\";\nimport { LoadValues } from \"../util/load.js\";\n/**\n * Load a chain from {@link https://github.com/hwchase17/langchain-hub | LangchainHub} or local filesystem.\n *\n * @example\n * Loading from LangchainHub:\n * ```ts\n * import { loadChain } from \"@langchain/classic/chains/load\";\n * const chain = await loadChain(\"lc://chains/hello-world/chain.json\");\n * const res = await chain.call({ topic: \"my favorite color\" });\n * ```\n *\n * @example\n * Loading from local filesystem:\n * ```ts\n * import { loadChain } from \"@langchain/classic/chains/load\";\n * const chain = await loadChain(\"/path/to/chain.json\");\n * ```\n */\nexport declare const loadChain: (uri: string, values?: LoadValues) => Promise<BaseChain<import(\"../../../langchain-core/dist/utils/types/index.js\").ChainValues, import(\"../../../langchain-core/dist/utils/types/index.js\").ChainValues>>;\n"],"mappings":";;;;;;;;;AAoBA;;;;;;;AAA6E;;;;;;;;cAAxDE,kCAAkCD,eAAeI,QAAQL,UAAb,WAAA,EAA8F,WAAA"}

package/dist/chains/load.js

@@ -0,0 +1,40 @@
+import { __export } from "../_virtual/rolldown_runtime.js";
+import { BaseChain } from "./base.js";
+import { loadFromHub } from "../util/hub.js";
+import { loadFromFile } from "../util/load.js";
+import { parseFileConfig } from "../util/parse.js";
+
+//#region src/chains/load.ts
+var load_exports = {};
+__export(load_exports, { loadChain: () => loadChain });
+const loadChainFromFile = async (file, path, values = {}) => {
+	const serialized = parseFileConfig(file, path);
+	return BaseChain.deserialize(serialized, values);
+};
+/**
+* Load a chain from {@link https://github.com/hwchase17/langchain-hub | LangchainHub} or local filesystem.
+*
+* @example
+* Loading from LangchainHub:
+* ```ts
+* import { loadChain } from "@langchain/classic/chains/load";
+* const chain = await loadChain("lc://chains/hello-world/chain.json");
+* const res = await chain.call({ topic: "my favorite color" });
+* ```
+*
+* @example
+* Loading from local filesystem:
+* ```ts
+* import { loadChain } from "@langchain/classic/chains/load";
+* const chain = await loadChain("/path/to/chain.json");
+* ```
+*/
+const loadChain = async (uri, values = {}) => {
+	const hubResult = await loadFromHub(uri, loadChainFromFile, "chains", new Set(["json", "yaml"]), values);
+	if (hubResult) return hubResult;
+	return loadFromFile(uri, loadChainFromFile, values);
+};
+
+//#endregion
+export { loadChain, load_exports };
+//# sourceMappingURL=load.js.map

package/dist/chains/load.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"load.js","names":["loadChainFromFile: FileLoader<BaseChain>","file: string","path: string","values: LoadValues","uri: string"],"sources":["../../src/chains/load.ts"],"sourcesContent":["import { BaseChain } from \"./base.js\";\nimport { loadFromHub } from \"../util/hub.js\";\nimport { FileLoader, LoadValues, loadFromFile } from \"../util/load.js\";\nimport { parseFileConfig } from \"../util/parse.js\";\n\nconst loadChainFromFile: FileLoader<BaseChain> = async (\n  file: string,\n  path: string,\n  values: LoadValues = {}\n) => {\n  const serialized = parseFileConfig(file, path);\n  return BaseChain.deserialize(serialized, values);\n};\n\n/**\n * Load a chain from {@link https://github.com/hwchase17/langchain-hub | LangchainHub} or local filesystem.\n *\n * @example\n * Loading from LangchainHub:\n * ```ts\n * import { loadChain } from \"@langchain/classic/chains/load\";\n * const chain = await loadChain(\"lc://chains/hello-world/chain.json\");\n * const res = await chain.call({ topic: \"my favorite color\" });\n * ```\n *\n * @example\n * Loading from local filesystem:\n * ```ts\n * import { loadChain } from \"@langchain/classic/chains/load\";\n * const chain = await loadChain(\"/path/to/chain.json\");\n * ```\n */\nexport const loadChain = async (\n  uri: string,\n  values: LoadValues = {}\n): Promise<BaseChain> => {\n  const hubResult = await loadFromHub(\n    uri,\n    loadChainFromFile,\n    \"chains\",\n    new Set([\"json\", \"yaml\"]),\n    values\n  );\n  if (hubResult) {\n    return hubResult;\n  }\n\n  return loadFromFile(uri, loadChainFromFile, values);\n};\n"],"mappings":";;;;;;;;;AAKA,MAAMA,oBAA2C,OAC/CC,MACAC,MACAC,SAAqB,CAAE,MACpB;CACH,MAAM,aAAa,gBAAgB,MAAM,KAAK;AAC9C,QAAO,UAAU,YAAY,YAAY,OAAO;AACjD;;;;;;;;;;;;;;;;;;;AAoBD,MAAa,YAAY,OACvBC,KACAD,SAAqB,CAAE,MACA;CACvB,MAAM,YAAY,MAAM,YACtB,KACA,mBACA,UACA,IAAI,IAAI,CAAC,QAAQ,MAAO,IACxB,OACD;AACD,KAAI,UACF,QAAO;AAGT,QAAO,aAAa,KAAK,mBAAmB,OAAO;AACpD"}

package/dist/chains/openai_functions/base.cjs

@@ -0,0 +1,139 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_openai_functions = require('../../output_parsers/openai_functions.cjs');
+const __langchain_core_utils_types = require_rolldown_runtime.__toESM(require("@langchain/core/utils/types"));
+const __langchain_core_utils_json_schema = require_rolldown_runtime.__toESM(require("@langchain/core/utils/json_schema"));
+
+//#region src/chains/openai_functions/base.ts
+/**
+* Creates a runnable sequence that calls OpenAI functions.
+* @param config - The parameters required to create the runnable.
+* @returns A runnable sequence that will pass the given functions to the model when run.
+*
+* @example
+* ```typescript
+* const openAIFunction = {
+*   name: "get_person_details",
+*   description: "Get details about a person",
+*   parameters: {
+*     title: "Person",
+*     description: "Identifying information about a person.",
+*     type: "object",
+*     properties: {
+*       name: { title: "Name", description: "The person's name", type: "string" },
+*       age: { title: "Age", description: "The person's age", type: "integer" },
+*       fav_food: {
+*         title: "Fav Food",
+*         description: "The person's favorite food",
+*         type: "string",
+*       },
+*     },
+*     required: ["name", "age"],
+*   },
+* };
+*
+* const model = new ChatOpenAI();
+* const prompt = ChatPromptTemplate.fromMessages([
+*   ["human", "Human description: {description}"],
+* ]);
+* const outputParser = new JsonOutputFunctionsParser();
+*
+* const runnable = createOpenAIFnRunnable({
+*   functions: [openAIFunction],
+*   llm: model,
+*   prompt,
+*   enforceSingleFunctionUsage: true, // Default is true
+*   outputParser
+* });
+* const response = await runnable.invoke({
+*   description:
+*     "My name's John Doe and I'm 30 years old. My favorite kind of food are chocolate chip cookies.",
+* });
+*
+* console.log(response);
+*
+* // { name: 'John Doe', age: 30, fav_food: 'chocolate chip cookies' }
+* ```
+*/
+function createOpenAIFnRunnable(config) {
+	const { functions, llm, prompt, enforceSingleFunctionUsage = true, outputParser = new require_openai_functions.JsonOutputFunctionsParser() } = config;
+	const llmKwargs = { functions };
+	if (functions.length === 1 && enforceSingleFunctionUsage) llmKwargs.function_call = { name: functions[0].name };
+	const llmWithKwargs = llm.withConfig(llmKwargs);
+	return prompt.pipe(llmWithKwargs).pipe(outputParser);
+}
+/**
+* @deprecated Prefer the `.withStructuredOutput` method on chat model classes.
+*
+* Create a runnable that uses an OpenAI function to get a structured output.
+* @param config Params required to create the runnable.
+* @returns A runnable sequence that will pass the given function to the model when run.
+*
+* @example
+* ```typescript
+* import { createStructuredOutputRunnable } from "@langchain/classic/chains/openai_functions";
+* import { ChatOpenAI } from "@langchain/openai";
+* import { ChatPromptTemplate } from "@langchain/core/prompts";
+* import { JsonOutputFunctionsParser } from "@langchain/classic/output_parsers";
+*
+* const jsonSchema = {
+*   title: "Person",
+*   description: "Identifying information about a person.",
+*   type: "object",
+*   properties: {
+*     name: { title: "Name", description: "The person's name", type: "string" },
+*     age: { title: "Age", description: "The person's age", type: "integer" },
+*     fav_food: {
+*       title: "Fav Food",
+*       description: "The person's favorite food",
+*       type: "string",
+*     },
+*   },
+*   required: ["name", "age"],
+* };
+*
+* const model = new ChatOpenAI({ model: "gpt-4o-mini" });
+* const prompt = ChatPromptTemplate.fromMessages([
+*   ["human", "Human description: {description}"],
+* ]);
+*
+* const outputParser = new JsonOutputFunctionsParser();
+*
+* // Also works with Zod schema
+* const runnable = createStructuredOutputRunnable({
+*   outputSchema: jsonSchema,
+*   llm: model,
+*   prompt,
+*   outputParser
+* });
+*
+* const response = await runnable.invoke({
+*   description:
+*     "My name's John Doe and I'm 30 years old. My favorite kind of food are chocolate chip cookies.",
+* });
+*
+* console.log(response);
+*
+* // { name: 'John Doe', age: 30, fav_food: 'chocolate chip cookies' }
+* ```
+*/
+function createStructuredOutputRunnable(config) {
+	const { outputSchema, llm, prompt, outputParser } = config;
+	const jsonSchema = (0, __langchain_core_utils_types.isInteropZodSchema)(outputSchema) ? (0, __langchain_core_utils_json_schema.toJsonSchema)(outputSchema) : outputSchema;
+	const oaiFunction = {
+		name: "outputFormatter",
+		description: "Output formatter. Should always be used to format your response to the user",
+		parameters: jsonSchema
+	};
+	return createOpenAIFnRunnable({
+		functions: [oaiFunction],
+		llm,
+		prompt,
+		enforceSingleFunctionUsage: true,
+		outputParser
+	});
+}
+
+//#endregion
+exports.createOpenAIFnRunnable = createOpenAIFnRunnable;
+exports.createStructuredOutputRunnable = createStructuredOutputRunnable;
+//# sourceMappingURL=base.cjs.map

package/dist/chains/openai_functions/base.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.cjs","names":["config: CreateOpenAIFnRunnableConfig<RunInput, RunOutput>","JsonOutputFunctionsParser","llmKwargs: BaseFunctionCallOptions","config: CreateStructuredOutputRunnableConfig<RunInput, RunOutput>","oaiFunction: FunctionDefinition"],"sources":["../../../src/chains/openai_functions/base.ts"],"sourcesContent":["import type { BaseOutputParser } from \"@langchain/core/output_parsers\";\nimport type { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport type { Runnable, RunnableInterface } from \"@langchain/core/runnables\";\nimport type {\n  BaseFunctionCallOptions,\n  BaseLanguageModelInput,\n  FunctionDefinition,\n} from \"@langchain/core/language_models/base\";\nimport {\n  isInteropZodSchema,\n  type InputValues,\n  InteropZodObject,\n} from \"@langchain/core/utils/types\";\nimport type { BaseMessage } from \"@langchain/core/messages\";\nimport {\n  toJsonSchema,\n  type JsonSchema7Type,\n} from \"@langchain/core/utils/json_schema\";\nimport { JsonOutputFunctionsParser } from \"../../output_parsers/openai_functions.js\";\n\n/**\n * Configuration params for the createOpenAIFnRunnable method.\n */\nexport type CreateOpenAIFnRunnableConfig<\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  RunInput extends Record<string, any>,\n  RunOutput\n> = {\n  functions: FunctionDefinition[];\n  /** Language model to use, assumed to support the OpenAI function-calling API. */\n  llm: RunnableInterface<\n    BaseLanguageModelInput,\n    BaseMessage,\n    BaseFunctionCallOptions\n  >;\n  /** BasePromptTemplate to pass to the model. */\n  prompt: BasePromptTemplate<InputValues<Extract<keyof RunInput, string>>>;\n  /**\n   * Only used if a single function is passed in. If `true`, then the model will be\n   * forced to use the given function. If `false`, then the model will be given the\n   * option to use the given function or not.\n   */\n  enforceSingleFunctionUsage?: boolean;\n  /**\n   * BaseLLMOutputParser to use for parsing model outputs.\n   * By default will be inferred from the function types.\n   */\n  outputParser?: BaseOutputParser<RunOutput>;\n};\n\n/**\n * Creates a runnable sequence that calls OpenAI functions.\n * @param config - The parameters required to create the runnable.\n * @returns A runnable sequence that will pass the given functions to the model when run.\n *\n * @example\n * ```typescript\n * const openAIFunction = {\n *   name: \"get_person_details\",\n *   description: \"Get details about a person\",\n *   parameters: {\n *     title: \"Person\",\n *     description: \"Identifying information about a person.\",\n *     type: \"object\",\n *     properties: {\n *       name: { title: \"Name\", description: \"The person's name\", type: \"string\" },\n *       age: { title: \"Age\", description: \"The person's age\", type: \"integer\" },\n *       fav_food: {\n *         title: \"Fav Food\",\n *         description: \"The person's favorite food\",\n *         type: \"string\",\n *       },\n *     },\n *     required: [\"name\", \"age\"],\n *   },\n * };\n *\n * const model = new ChatOpenAI();\n * const prompt = ChatPromptTemplate.fromMessages([\n *   [\"human\", \"Human description: {description}\"],\n * ]);\n * const outputParser = new JsonOutputFunctionsParser();\n *\n * const runnable = createOpenAIFnRunnable({\n *   functions: [openAIFunction],\n *   llm: model,\n *   prompt,\n *   enforceSingleFunctionUsage: true, // Default is true\n *   outputParser\n * });\n * const response = await runnable.invoke({\n *   description:\n *     \"My name's John Doe and I'm 30 years old. My favorite kind of food are chocolate chip cookies.\",\n * });\n *\n * console.log(response);\n *\n * // { name: 'John Doe', age: 30, fav_food: 'chocolate chip cookies' }\n * ```\n */\nexport function createOpenAIFnRunnable<\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  RunInput extends Record<string, any> = Record<string, any>,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  RunOutput extends Record<string, any> = Record<string, any>\n>(\n  config: CreateOpenAIFnRunnableConfig<RunInput, RunOutput>\n): Runnable<RunInput, RunOutput> {\n  const {\n    functions,\n    llm,\n    prompt,\n    enforceSingleFunctionUsage = true,\n    outputParser = new JsonOutputFunctionsParser<RunOutput>(),\n  } = config;\n  const llmKwargs: BaseFunctionCallOptions = {\n    functions,\n  };\n\n  if (functions.length === 1 && enforceSingleFunctionUsage) {\n    llmKwargs.function_call = {\n      name: functions[0].name,\n    };\n  }\n\n  const llmWithKwargs = (llm as Runnable).withConfig(llmKwargs);\n  return prompt.pipe(llmWithKwargs).pipe(outputParser);\n}\n\n/**\n * Configuration params for the createStructuredOutputRunnable method.\n */\nexport type CreateStructuredOutputRunnableConfig<\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  RunInput extends Record<string, any>,\n  RunOutput\n> = {\n  /**\n   * Schema to output. Must be either valid JSONSchema or a Zod schema.\n   */\n  outputSchema: InteropZodObject | JsonSchema7Type;\n  /**\n   * Language model to use, assumed to support the OpenAI function-calling API.\n   */\n  llm: RunnableInterface<\n    BaseLanguageModelInput,\n    BaseMessage,\n    BaseFunctionCallOptions\n  >;\n  /** BasePromptTemplate to pass to the model. */\n  prompt: BasePromptTemplate<InputValues<Extract<keyof RunInput, string>>>;\n  /**\n   * BaseLLMOutputParser to use for parsing model outputs.\n   */\n  outputParser?: BaseOutputParser<RunOutput>;\n};\n\n/**\n * @deprecated Prefer the `.withStructuredOutput` method on chat model classes.\n *\n * Create a runnable that uses an OpenAI function to get a structured output.\n * @param config Params required to create the runnable.\n * @returns A runnable sequence that will pass the given function to the model when run.\n *\n * @example\n * ```typescript\n * import { createStructuredOutputRunnable } from \"@langchain/classic/chains/openai_functions\";\n * import { ChatOpenAI } from \"@langchain/openai\";\n * import { ChatPromptTemplate } from \"@langchain/core/prompts\";\n * import { JsonOutputFunctionsParser } from \"@langchain/classic/output_parsers\";\n *\n * const jsonSchema = {\n *   title: \"Person\",\n *   description: \"Identifying information about a person.\",\n *   type: \"object\",\n *   properties: {\n *     name: { title: \"Name\", description: \"The person's name\", type: \"string\" },\n *     age: { title: \"Age\", description: \"The person's age\", type: \"integer\" },\n *     fav_food: {\n *       title: \"Fav Food\",\n *       description: \"The person's favorite food\",\n *       type: \"string\",\n *     },\n *   },\n *   required: [\"name\", \"age\"],\n * };\n *\n * const model = new ChatOpenAI({ model: \"gpt-4o-mini\" });\n * const prompt = ChatPromptTemplate.fromMessages([\n *   [\"human\", \"Human description: {description}\"],\n * ]);\n *\n * const outputParser = new JsonOutputFunctionsParser();\n *\n * // Also works with Zod schema\n * const runnable = createStructuredOutputRunnable({\n *   outputSchema: jsonSchema,\n *   llm: model,\n *   prompt,\n *   outputParser\n * });\n *\n * const response = await runnable.invoke({\n *   description:\n *     \"My name's John Doe and I'm 30 years old. My favorite kind of food are chocolate chip cookies.\",\n * });\n *\n * console.log(response);\n *\n * // { name: 'John Doe', age: 30, fav_food: 'chocolate chip cookies' }\n * ```\n */\nexport function createStructuredOutputRunnable<\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  RunInput extends Record<string, any> = Record<string, any>,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  RunOutput extends Record<string, any> = Record<string, any>\n>(\n  config: CreateStructuredOutputRunnableConfig<RunInput, RunOutput>\n): Runnable<RunInput, RunOutput> {\n  const { outputSchema, llm, prompt, outputParser } = config;\n  const jsonSchema = isInteropZodSchema(outputSchema)\n    ? toJsonSchema(outputSchema)\n    : outputSchema;\n  const oaiFunction: FunctionDefinition = {\n    name: \"outputFormatter\",\n    description:\n      \"Output formatter. Should always be used to format your response to the user\",\n    parameters: jsonSchema,\n  };\n\n  return createOpenAIFnRunnable({\n    functions: [oaiFunction],\n    llm,\n    prompt,\n    enforceSingleFunctionUsage: true,\n    outputParser,\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoGA,SAAgB,uBAMdA,QAC+B;CAC/B,MAAM,EACJ,WACA,KACA,QACA,6BAA6B,MAC7B,eAAe,IAAIC,sDACpB,GAAG;CACJ,MAAMC,YAAqC,EACzC,UACD;AAED,KAAI,UAAU,WAAW,KAAK,4BAC5B,UAAU,gBAAgB,EACxB,MAAM,UAAU,GAAG,KACpB;CAGH,MAAM,gBAAiB,IAAiB,WAAW,UAAU;AAC7D,QAAO,OAAO,KAAK,cAAc,CAAC,KAAK,aAAa;AACrD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqFD,SAAgB,+BAMdC,QAC+B;CAC/B,MAAM,EAAE,cAAc,KAAK,QAAQ,cAAc,GAAG;CACpD,MAAM,kEAAgC,aAAa,wDAClC,aAAa,GAC1B;CACJ,MAAMC,cAAkC;EACtC,MAAM;EACN,aACE;EACF,YAAY;CACb;AAED,QAAO,uBAAuB;EAC5B,WAAW,CAAC,WAAY;EACxB;EACA;EACA,4BAA4B;EAC5B;CACD,EAAC;AACH"}