@langchain/classic 1.0.9 → 1.0.10

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @langchain/classic
 
+## 1.0.10
+
+### Patch Changes
+
+- Updated dependencies [[`a7c6ec5`](https://github.com/langchain-ai/langchainjs/commit/a7c6ec51ab9baa186ab5ebf815599c08f5c7e8ab), [`04923f9`](https://github.com/langchain-ai/langchainjs/commit/04923f9835e5b3677c180b601ae8f3e7d8be0236), [`e16c218`](https://github.com/langchain-ai/langchainjs/commit/e16c218b81980a1c576af5192342019975bb95b9)]:
+  - @langchain/openai@1.2.3
+  - @langchain/textsplitters@1.0.1
+
 ## 1.0.9
 
 ### Patch Changes

package/dist/agents/chat/outputParser.d.ts

@@ -51,12 +51,12 @@ declare class ChatAgentOutputParser extends AgentActionOutputParser {
    * @returns An object that satisfies the AgentFinish interface or an object with the tool, toolInput, and log.
    */
   parse(text: string): Promise<{
-    tool?: undefined;
-    toolInput?: undefined;
     returnValues: {
       output: string;
     };
     log: string;
+    tool?: undefined;
+    toolInput?: undefined;
   } | {
     returnValues?: undefined;
     tool: any;

package/dist/agents/chat/outputParser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"outputParser.d.ts","names":["AgentActionOutputParser","FINAL_ANSWER_ACTION","ChatAgentOutputParser","Promise"],"sources":["../../../src/agents/chat/outputParser.d.ts"],"sourcesContent":["import { AgentActionOutputParser } from \"../types.js\";\nexport declare const FINAL_ANSWER_ACTION = \"Final Answer:\";\n/**\n * A class that extends the AgentActionOutputParser to parse the output of\n * the ChatAgent in LangChain. It checks if the output text contains the\n * final answer action or a JSON response, and parses it accordingly.\n * @example\n * ```typescript\n * const prompt = ChatPromptTemplate.fromMessages([\n *   [\n *     \"ai\",\n *     `{PREFIX}\n * {FORMAT_INSTRUCTIONS}\n * {SUFFIX}`,\n *   ],\n *   [\"human\", \"Question: {input}\"],\n * ]);\n * const runnableAgent = RunnableSequence.from([\n *   {\n *     input: (i: { input: string; steps: AgentStep[] }) => i.input,\n *     agent_scratchpad: (i: { input: string; steps: AgentStep[] }) =>\n *       formatLogToString(i.steps),\n *   },\n *   prompt,\n *   new OpenAI({ temperature: 0 }),\n *   new ChatAgentOutputParser(),\n * ]);\n *\n * const executor = AgentExecutor.fromAgentAndTools({\n *   agent: runnableAgent,\n *   tools: [new SerpAPI(), new Calculator()],\n * });\n *\n * const result = await executor.invoke({\n *   input:\n *     \"Who is Olivia Wilde's boyfriend? What is his current age raised to the 0.23 power?\",\n * });\n * ```\n */\nexport declare class ChatAgentOutputParser extends AgentActionOutputParser {\n    lc_namespace: string[];\n    /**\n     * Parses the output text from the MRKL chain into an agent action or\n     * agent finish. If the text contains the final answer action or does not\n     * contain an action, it returns an AgentFinish with the output and log.\n     * If the text contains a JSON response, it returns the tool, toolInput,\n     * and log.\n     * @param text The output text from the MRKL chain.\n     * @returns An object that satisfies the AgentFinish interface or an object with the tool, toolInput, and log.\n     */\n    parse(text: string): Promise<{\n        tool?: undefined;\n        toolInput?: undefined;\n        returnValues: {\n            output: string;\n        };\n        log: string;\n    } | {\n        returnValues?: undefined;\n        tool: any;\n        toolInput: any;\n        log: string;\n    }>;\n    /**\n     * Returns the format instructions used in the output parser for the\n     * ChatAgent class.\n     * @returns The format instructions as a string.\n     */\n    getFormatInstructions(): string;\n}\n//# sourceMappingURL=outputParser.d.ts.map"],"mappings":";;;;;AAuCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAqBE,qBAAAA,SAA8BF,uBAAuB;;;;;;;;;;;uBAWjDG"}
+{"version":3,"file":"outputParser.d.ts","names":["AgentActionOutputParser","FINAL_ANSWER_ACTION","ChatAgentOutputParser","Promise"],"sources":["../../../src/agents/chat/outputParser.d.ts"],"sourcesContent":["import { AgentActionOutputParser } from \"../types.js\";\nexport declare const FINAL_ANSWER_ACTION = \"Final Answer:\";\n/**\n * A class that extends the AgentActionOutputParser to parse the output of\n * the ChatAgent in LangChain. It checks if the output text contains the\n * final answer action or a JSON response, and parses it accordingly.\n * @example\n * ```typescript\n * const prompt = ChatPromptTemplate.fromMessages([\n *   [\n *     \"ai\",\n *     `{PREFIX}\n * {FORMAT_INSTRUCTIONS}\n * {SUFFIX}`,\n *   ],\n *   [\"human\", \"Question: {input}\"],\n * ]);\n * const runnableAgent = RunnableSequence.from([\n *   {\n *     input: (i: { input: string; steps: AgentStep[] }) => i.input,\n *     agent_scratchpad: (i: { input: string; steps: AgentStep[] }) =>\n *       formatLogToString(i.steps),\n *   },\n *   prompt,\n *   new OpenAI({ temperature: 0 }),\n *   new ChatAgentOutputParser(),\n * ]);\n *\n * const executor = AgentExecutor.fromAgentAndTools({\n *   agent: runnableAgent,\n *   tools: [new SerpAPI(), new Calculator()],\n * });\n *\n * const result = await executor.invoke({\n *   input:\n *     \"Who is Olivia Wilde's boyfriend? What is his current age raised to the 0.23 power?\",\n * });\n * ```\n */\nexport declare class ChatAgentOutputParser extends AgentActionOutputParser {\n    lc_namespace: string[];\n    /**\n     * Parses the output text from the MRKL chain into an agent action or\n     * agent finish. If the text contains the final answer action or does not\n     * contain an action, it returns an AgentFinish with the output and log.\n     * If the text contains a JSON response, it returns the tool, toolInput,\n     * and log.\n     * @param text The output text from the MRKL chain.\n     * @returns An object that satisfies the AgentFinish interface or an object with the tool, toolInput, and log.\n     */\n    parse(text: string): Promise<{\n        returnValues: {\n            output: string;\n        };\n        log: string;\n        tool?: undefined;\n        toolInput?: undefined;\n    } | {\n        returnValues?: undefined;\n        tool: any;\n        toolInput: any;\n        log: string;\n    }>;\n    /**\n     * Returns the format instructions used in the output parser for the\n     * ChatAgent class.\n     * @returns The format instructions as a string.\n     */\n    getFormatInstructions(): string;\n}\n//# sourceMappingURL=outputParser.d.ts.map"],"mappings":";;;;;AAuCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAqBE,qBAAAA,SAA8BF,uBAAuB;;;;;;;;;;;uBAWjDG"}

package/dist/agents/mrkl/outputParser.d.cts

@@ -25,10 +25,10 @@ declare class ZeroShotAgentOutputParser extends AgentActionOutputParser {
     tool?: undefined;
     toolInput?: undefined;
   } | {
+    returnValues?: undefined;
     tool: string;
     toolInput: string;
     log: string;
-    returnValues?: undefined;
   }>;
   /**
    * Returns the format instructions for parsing the output of an agent

package/dist/agents/mrkl/outputParser.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"outputParser.d.cts","names":["OutputParserArgs","AgentActionOutputParser","FINAL_ANSWER_ACTION","ZeroShotAgentOutputParser","Promise"],"sources":["../../../src/agents/mrkl/outputParser.d.ts"],"sourcesContent":["import { OutputParserArgs } from \"../agent.js\";\nimport { AgentActionOutputParser } from \"../types.js\";\nexport declare const FINAL_ANSWER_ACTION = \"Final Answer:\";\n/**\n * A class that extends `AgentActionOutputParser` to provide a custom\n * implementation for parsing the output of a ZeroShotAgent action.\n */\nexport declare class ZeroShotAgentOutputParser extends AgentActionOutputParser {\n    lc_namespace: string[];\n    finishToolName: string;\n    constructor(fields?: OutputParserArgs);\n    /**\n     * Parses the text output of an agent action, extracting the tool, tool\n     * input, and output.\n     * @param text The text output of an agent action.\n     * @returns An object containing the tool, tool input, and output extracted from the text, along with the original text as a log.\n     */\n    parse(text: string): Promise<{\n        returnValues: {\n            output: string;\n        };\n        log: string;\n        tool?: undefined;\n        toolInput?: undefined;\n    } | {\n        tool: string;\n        toolInput: string;\n        log: string;\n        returnValues?: undefined;\n    }>;\n    /**\n     * Returns the format instructions for parsing the output of an agent\n     * action in the style of the ZeroShotAgent.\n     * @returns The format instructions for parsing the output.\n     */\n    getFormatInstructions(): string;\n}\n//# sourceMappingURL=outputParser.d.ts.map"],"mappings":";;;;;;AAOA;;;AAAuDC,cAAlCE,yBAAAA,SAAkCF,uBAAAA,CAAAA;EAAuB,YAAA,EAAA,MAAA,EAAA;;uBAGrDD;;;;;;;uBAOAI"}
+{"version":3,"file":"outputParser.d.cts","names":["OutputParserArgs","AgentActionOutputParser","FINAL_ANSWER_ACTION","ZeroShotAgentOutputParser","Promise"],"sources":["../../../src/agents/mrkl/outputParser.d.ts"],"sourcesContent":["import { OutputParserArgs } from \"../agent.js\";\nimport { AgentActionOutputParser } from \"../types.js\";\nexport declare const FINAL_ANSWER_ACTION = \"Final Answer:\";\n/**\n * A class that extends `AgentActionOutputParser` to provide a custom\n * implementation for parsing the output of a ZeroShotAgent action.\n */\nexport declare class ZeroShotAgentOutputParser extends AgentActionOutputParser {\n    lc_namespace: string[];\n    finishToolName: string;\n    constructor(fields?: OutputParserArgs);\n    /**\n     * Parses the text output of an agent action, extracting the tool, tool\n     * input, and output.\n     * @param text The text output of an agent action.\n     * @returns An object containing the tool, tool input, and output extracted from the text, along with the original text as a log.\n     */\n    parse(text: string): Promise<{\n        returnValues: {\n            output: string;\n        };\n        log: string;\n        tool?: undefined;\n        toolInput?: undefined;\n    } | {\n        returnValues?: undefined;\n        tool: string;\n        toolInput: string;\n        log: string;\n    }>;\n    /**\n     * Returns the format instructions for parsing the output of an agent\n     * action in the style of the ZeroShotAgent.\n     * @returns The format instructions for parsing the output.\n     */\n    getFormatInstructions(): string;\n}\n//# sourceMappingURL=outputParser.d.ts.map"],"mappings":";;;;;;AAOA;;;AAAuDC,cAAlCE,yBAAAA,SAAkCF,uBAAAA,CAAAA;EAAuB,YAAA,EAAA,MAAA,EAAA;;uBAGrDD;;;;;;;uBAOAI"}

package/dist/agents/mrkl/outputParser.d.ts

@@ -25,10 +25,10 @@ declare class ZeroShotAgentOutputParser extends AgentActionOutputParser {
     tool?: undefined;
     toolInput?: undefined;
   } | {
-    returnValues?: undefined;
     tool: string;
     toolInput: string;
     log: string;
+    returnValues?: undefined;
   }>;
   /**
    * Returns the format instructions for parsing the output of an agent

package/dist/agents/mrkl/outputParser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"outputParser.d.ts","names":["OutputParserArgs","AgentActionOutputParser","FINAL_ANSWER_ACTION","ZeroShotAgentOutputParser","Promise"],"sources":["../../../src/agents/mrkl/outputParser.d.ts"],"sourcesContent":["import { OutputParserArgs } from \"../agent.js\";\nimport { AgentActionOutputParser } from \"../types.js\";\nexport declare const FINAL_ANSWER_ACTION = \"Final Answer:\";\n/**\n * A class that extends `AgentActionOutputParser` to provide a custom\n * implementation for parsing the output of a ZeroShotAgent action.\n */\nexport declare class ZeroShotAgentOutputParser extends AgentActionOutputParser {\n    lc_namespace: string[];\n    finishToolName: string;\n    constructor(fields?: OutputParserArgs);\n    /**\n     * Parses the text output of an agent action, extracting the tool, tool\n     * input, and output.\n     * @param text The text output of an agent action.\n     * @returns An object containing the tool, tool input, and output extracted from the text, along with the original text as a log.\n     */\n    parse(text: string): Promise<{\n        returnValues: {\n            output: string;\n        };\n        log: string;\n        tool?: undefined;\n        toolInput?: undefined;\n    } | {\n        returnValues?: undefined;\n        tool: string;\n        toolInput: string;\n        log: string;\n    }>;\n    /**\n     * Returns the format instructions for parsing the output of an agent\n     * action in the style of the ZeroShotAgent.\n     * @returns The format instructions for parsing the output.\n     */\n    getFormatInstructions(): string;\n}\n//# sourceMappingURL=outputParser.d.ts.map"],"mappings":";;;;;;AAOA;;;AAAuDC,cAAlCE,yBAAAA,SAAkCF,uBAAAA,CAAAA;EAAuB,YAAA,EAAA,MAAA,EAAA;;uBAGrDD;;;;;;;uBAOAI"}
+{"version":3,"file":"outputParser.d.ts","names":["OutputParserArgs","AgentActionOutputParser","FINAL_ANSWER_ACTION","ZeroShotAgentOutputParser","Promise"],"sources":["../../../src/agents/mrkl/outputParser.d.ts"],"sourcesContent":["import { OutputParserArgs } from \"../agent.js\";\nimport { AgentActionOutputParser } from \"../types.js\";\nexport declare const FINAL_ANSWER_ACTION = \"Final Answer:\";\n/**\n * A class that extends `AgentActionOutputParser` to provide a custom\n * implementation for parsing the output of a ZeroShotAgent action.\n */\nexport declare class ZeroShotAgentOutputParser extends AgentActionOutputParser {\n    lc_namespace: string[];\n    finishToolName: string;\n    constructor(fields?: OutputParserArgs);\n    /**\n     * Parses the text output of an agent action, extracting the tool, tool\n     * input, and output.\n     * @param text The text output of an agent action.\n     * @returns An object containing the tool, tool input, and output extracted from the text, along with the original text as a log.\n     */\n    parse(text: string): Promise<{\n        returnValues: {\n            output: string;\n        };\n        log: string;\n        tool?: undefined;\n        toolInput?: undefined;\n    } | {\n        tool: string;\n        toolInput: string;\n        log: string;\n        returnValues?: undefined;\n    }>;\n    /**\n     * Returns the format instructions for parsing the output of an agent\n     * action in the style of the ZeroShotAgent.\n     * @returns The format instructions for parsing the output.\n     */\n    getFormatInstructions(): string;\n}\n//# sourceMappingURL=outputParser.d.ts.map"],"mappings":";;;;;;AAOA;;;AAAuDC,cAAlCE,yBAAAA,SAAkCF,uBAAAA,CAAAA;EAAuB,YAAA,EAAA,MAAA,EAAA;;uBAGrDD;;;;;;;uBAOAI"}

package/dist/agents/openai_tools/index.d.cts

@@ -1,7 +1,7 @@
 import { ToolsAgentStep } from "../tool_calling/output_parser.cjs";
 import { AgentRunnableSequence } from "../agent.cjs";
 import { OpenAIToolsAgentOutputParser } from "./output_parser.cjs";
-import * as _langchain_core_agents3 from "@langchain/core/agents";
+import * as _langchain_core_agents1 from "@langchain/core/agents";
 import { ChatPromptTemplate } from "@langchain/core/prompts";
 import { ToolDefinition } from "@langchain/core/language_models/base";
 import { StructuredToolInterface } from "@langchain/core/tools";
@@ -94,7 +94,7 @@ declare function createOpenAIToolsAgent({
   streamRunnable
 }: CreateOpenAIToolsAgentParams): Promise<AgentRunnableSequence<{
   steps: ToolsAgentStep[];
-}, _langchain_core_agents3.AgentFinish | _langchain_core_agents3.AgentAction[]>>;
+}, _langchain_core_agents1.AgentFinish | _langchain_core_agents1.AgentAction[]>>;
 //#endregion
 export { CreateOpenAIToolsAgentParams, createOpenAIToolsAgent };
 //# sourceMappingURL=index.d.cts.map

package/dist/agents/openai_tools/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":["StructuredToolInterface","BaseChatModel","BaseChatModelCallOptions","ChatPromptTemplate","OpenAIClient","ToolDefinition","OpenAIToolsAgentOutputParser","ToolsAgentStep","AgentRunnableSequence","CreateOpenAIToolsAgentParams","ChatCompletionTool","createOpenAIToolsAgent","llm","tools","prompt","streamRunnable","_langchain_core_agents3","AgentFinish","AgentAction","Promise"],"sources":["../../../src/agents/openai_tools/index.d.ts"],"sourcesContent":["import type { StructuredToolInterface } from \"@langchain/core/tools\";\nimport type { BaseChatModel, BaseChatModelCallOptions } from \"@langchain/core/language_models/chat_models\";\nimport { ChatPromptTemplate } from \"@langchain/core/prompts\";\nimport { OpenAIClient } from \"@langchain/openai\";\nimport { ToolDefinition } from \"@langchain/core/language_models/base\";\nimport { OpenAIToolsAgentOutputParser, type ToolsAgentStep } from \"./output_parser.js\";\nimport { AgentRunnableSequence } from \"../agent.js\";\nexport { OpenAIToolsAgentOutputParser, type ToolsAgentStep };\n/**\n * Params used by the createOpenAIToolsAgent function.\n */\nexport type CreateOpenAIToolsAgentParams = {\n    /**\n     * LLM to use as the agent. Should work with OpenAI tool calling,\n     * so must either be an OpenAI model that supports that or a wrapper of\n     * a different model that adds in equivalent support.\n     */\n    llm: BaseChatModel<BaseChatModelCallOptions & {\n        tools?: StructuredToolInterface[] | OpenAIClient.ChatCompletionTool[] | any[];\n    }>;\n    /** Tools this agent has access to. */\n    tools: StructuredToolInterface[] | ToolDefinition[];\n    /** The prompt to use, must have an input key of `agent_scratchpad`. */\n    prompt: ChatPromptTemplate;\n    /**\n     * Whether to invoke the underlying model in streaming mode,\n     * allowing streaming of intermediate steps. Defaults to true.\n     */\n    streamRunnable?: boolean;\n};\n/**\n * Create an agent that uses OpenAI-style tool calling.\n * @param params Params required to create the agent. Includes an LLM, tools, and prompt.\n * @returns A runnable sequence representing an agent. It takes as input all the same input\n *     variables as the prompt passed in does. It returns as output either an\n *     AgentAction or AgentFinish.\n *\n * @example\n * ```typescript\n * import { AgentExecutor, createOpenAIToolsAgent } from \"langchain/agents\";\n * import { pull } from \"langchain/hub\";\n * import type { ChatPromptTemplate } from \"@langchain/core/prompts\";\n * import { AIMessage, HumanMessage } from \"@langchain/core/messages\";\n *\n * import { ChatOpenAI } from \"@langchain/openai\";\n *\n * // Define the tools the agent will have access to.\n * const tools = [...];\n *\n * // Get the prompt to use - you can modify this!\n * // If you want to see the prompt in full, you can at:\n * // https://smith.langchain.com/hub/hwchase17/openai-tools-agent\n * const prompt = await pull<ChatPromptTemplate>(\n *   \"hwchase17/openai-tools-agent\"\n * );\n *\n * const llm = new ChatOpenAI({\n *   temperature: 0,\n *   model: \"gpt-3.5-turbo-1106\",\n * });\n *\n * const agent = await createOpenAIToolsAgent({\n *   llm,\n *   tools,\n *   prompt,\n * });\n *\n * const agentExecutor = new AgentExecutor({\n *   agent,\n *   tools,\n * });\n *\n * const result = await agentExecutor.invoke({\n *   input: \"what is LangChain?\",\n * });\n *\n * // With chat history\n * const result2 = await agentExecutor.invoke({\n *   input: \"what's my name?\",\n *   chat_history: [\n *     new HumanMessage(\"hi! my name is cob\"),\n *     new AIMessage(\"Hello Cob! How can I assist you today?\"),\n *   ],\n * });\n * ```\n */\nexport declare function createOpenAIToolsAgent({ llm, tools, prompt, streamRunnable }: CreateOpenAIToolsAgentParams): Promise<AgentRunnableSequence<{\n    steps: ToolsAgentStep[];\n}, import(\"@langchain/core/agents\").AgentFinish | import(\"@langchain/core/agents\").AgentAction[]>>;\n//# sourceMappingURL=index.d.ts.map"],"mappings":";;;;;;;;;;;;;;AAWYS,KAAAA,4BAAAA,GAA4B;EAMjBP;;;;;EAIgBG,GAAAA,EAJ9BJ,aAI8BI,CAJhBH,wBAIgBG,GAAAA;IAE3BF,KAAAA,CAAAA,EALIH,uBAKJG,EAAAA,GALgCC,YAAAA,CAAaM,kBAK7CP,EAAAA,GAAAA,GAAAA,EAAAA;EAAkB,CAAA,CAAA;EA+DNQ;EAAyBC,KAAAA,EAjEtCZ,uBAiEsCY,EAAAA,GAjEVP,cAiEUO,EAAAA;EAAKC;EAAOC,MAAAA,EA/DjDX,kBA+DiDW;EAAQC;;;;EAEtBC,cAAAA,CAAAA,EAAAA,OAAoCE;CAF2CV;;AAAD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAArGG,sBAAAA;;;;;GAA+DF,+BAA+BU,QAAQX;SACnHD;GAAcS,uBAAAA,CACWC,WAAAA,GAAWD,uBAAAA,CAAoCE,WAAAA"}
+{"version":3,"file":"index.d.cts","names":["StructuredToolInterface","BaseChatModel","BaseChatModelCallOptions","ChatPromptTemplate","OpenAIClient","ToolDefinition","OpenAIToolsAgentOutputParser","ToolsAgentStep","AgentRunnableSequence","CreateOpenAIToolsAgentParams","ChatCompletionTool","createOpenAIToolsAgent","llm","tools","prompt","streamRunnable","_langchain_core_agents1","AgentFinish","AgentAction","Promise"],"sources":["../../../src/agents/openai_tools/index.d.ts"],"sourcesContent":["import type { StructuredToolInterface } from \"@langchain/core/tools\";\nimport type { BaseChatModel, BaseChatModelCallOptions } from \"@langchain/core/language_models/chat_models\";\nimport { ChatPromptTemplate } from \"@langchain/core/prompts\";\nimport { OpenAIClient } from \"@langchain/openai\";\nimport { ToolDefinition } from \"@langchain/core/language_models/base\";\nimport { OpenAIToolsAgentOutputParser, type ToolsAgentStep } from \"./output_parser.js\";\nimport { AgentRunnableSequence } from \"../agent.js\";\nexport { OpenAIToolsAgentOutputParser, type ToolsAgentStep };\n/**\n * Params used by the createOpenAIToolsAgent function.\n */\nexport type CreateOpenAIToolsAgentParams = {\n    /**\n     * LLM to use as the agent. Should work with OpenAI tool calling,\n     * so must either be an OpenAI model that supports that or a wrapper of\n     * a different model that adds in equivalent support.\n     */\n    llm: BaseChatModel<BaseChatModelCallOptions & {\n        tools?: StructuredToolInterface[] | OpenAIClient.ChatCompletionTool[] | any[];\n    }>;\n    /** Tools this agent has access to. */\n    tools: StructuredToolInterface[] | ToolDefinition[];\n    /** The prompt to use, must have an input key of `agent_scratchpad`. */\n    prompt: ChatPromptTemplate;\n    /**\n     * Whether to invoke the underlying model in streaming mode,\n     * allowing streaming of intermediate steps. Defaults to true.\n     */\n    streamRunnable?: boolean;\n};\n/**\n * Create an agent that uses OpenAI-style tool calling.\n * @param params Params required to create the agent. Includes an LLM, tools, and prompt.\n * @returns A runnable sequence representing an agent. It takes as input all the same input\n *     variables as the prompt passed in does. It returns as output either an\n *     AgentAction or AgentFinish.\n *\n * @example\n * ```typescript\n * import { AgentExecutor, createOpenAIToolsAgent } from \"langchain/agents\";\n * import { pull } from \"langchain/hub\";\n * import type { ChatPromptTemplate } from \"@langchain/core/prompts\";\n * import { AIMessage, HumanMessage } from \"@langchain/core/messages\";\n *\n * import { ChatOpenAI } from \"@langchain/openai\";\n *\n * // Define the tools the agent will have access to.\n * const tools = [...];\n *\n * // Get the prompt to use - you can modify this!\n * // If you want to see the prompt in full, you can at:\n * // https://smith.langchain.com/hub/hwchase17/openai-tools-agent\n * const prompt = await pull<ChatPromptTemplate>(\n *   \"hwchase17/openai-tools-agent\"\n * );\n *\n * const llm = new ChatOpenAI({\n *   temperature: 0,\n *   model: \"gpt-3.5-turbo-1106\",\n * });\n *\n * const agent = await createOpenAIToolsAgent({\n *   llm,\n *   tools,\n *   prompt,\n * });\n *\n * const agentExecutor = new AgentExecutor({\n *   agent,\n *   tools,\n * });\n *\n * const result = await agentExecutor.invoke({\n *   input: \"what is LangChain?\",\n * });\n *\n * // With chat history\n * const result2 = await agentExecutor.invoke({\n *   input: \"what's my name?\",\n *   chat_history: [\n *     new HumanMessage(\"hi! my name is cob\"),\n *     new AIMessage(\"Hello Cob! How can I assist you today?\"),\n *   ],\n * });\n * ```\n */\nexport declare function createOpenAIToolsAgent({ llm, tools, prompt, streamRunnable }: CreateOpenAIToolsAgentParams): Promise<AgentRunnableSequence<{\n    steps: ToolsAgentStep[];\n}, import(\"@langchain/core/agents\").AgentFinish | import(\"@langchain/core/agents\").AgentAction[]>>;\n//# sourceMappingURL=index.d.ts.map"],"mappings":";;;;;;;;;;;;;;AAWYS,KAAAA,4BAAAA,GAA4B;EAMjBP;;;;;EAIgBG,GAAAA,EAJ9BJ,aAI8BI,CAJhBH,wBAIgBG,GAAAA;IAE3BF,KAAAA,CAAAA,EALIH,uBAKJG,EAAAA,GALgCC,YAAAA,CAAaM,kBAK7CP,EAAAA,GAAAA,GAAAA,EAAAA;EAAkB,CAAA,CAAA;EA+DNQ;EAAyBC,KAAAA,EAjEtCZ,uBAiEsCY,EAAAA,GAjEVP,cAiEUO,EAAAA;EAAKC;EAAOC,MAAAA,EA/DjDX,kBA+DiDW;EAAQC;;;;EAEtBC,cAAAA,CAAAA,EAAAA,OAAoCE;CAF2CV;;AAAD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAArGG,sBAAAA;;;;;GAA+DF,+BAA+BU,QAAQX;SACnHD;GAAcS,uBAAAA,CACWC,WAAAA,GAAWD,uBAAAA,CAAoCE,WAAAA"}

package/dist/agents/openai_tools/index.d.ts

@@ -6,7 +6,7 @@ import { StructuredToolInterface } from "@langchain/core/tools";
 import { ToolDefinition } from "@langchain/core/language_models/base";
 import { OpenAIClient } from "@langchain/openai";
 import { BaseChatModel, BaseChatModelCallOptions } from "@langchain/core/language_models/chat_models";
-import * as _langchain_core_agents1 from "@langchain/core/agents";
+import * as _langchain_core_agents3 from "@langchain/core/agents";
 
 //#region src/agents/openai_tools/index.d.ts
 /**
@@ -94,7 +94,7 @@ declare function createOpenAIToolsAgent({
   streamRunnable
 }: CreateOpenAIToolsAgentParams): Promise<AgentRunnableSequence<{
   steps: ToolsAgentStep[];
-}, _langchain_core_agents1.AgentFinish | _langchain_core_agents1.AgentAction[]>>;
+}, _langchain_core_agents3.AgentFinish | _langchain_core_agents3.AgentAction[]>>;
 //#endregion
 export { CreateOpenAIToolsAgentParams, createOpenAIToolsAgent };
 //# sourceMappingURL=index.d.ts.map

package/dist/agents/openai_tools/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":["StructuredToolInterface","BaseChatModel","BaseChatModelCallOptions","ChatPromptTemplate","OpenAIClient","ToolDefinition","OpenAIToolsAgentOutputParser","ToolsAgentStep","AgentRunnableSequence","CreateOpenAIToolsAgentParams","ChatCompletionTool","createOpenAIToolsAgent","llm","tools","prompt","streamRunnable","_langchain_core_agents1","AgentFinish","AgentAction","Promise"],"sources":["../../../src/agents/openai_tools/index.d.ts"],"sourcesContent":["import type { StructuredToolInterface } from \"@langchain/core/tools\";\nimport type { BaseChatModel, BaseChatModelCallOptions } from \"@langchain/core/language_models/chat_models\";\nimport { ChatPromptTemplate } from \"@langchain/core/prompts\";\nimport { OpenAIClient } from \"@langchain/openai\";\nimport { ToolDefinition } from \"@langchain/core/language_models/base\";\nimport { OpenAIToolsAgentOutputParser, type ToolsAgentStep } from \"./output_parser.js\";\nimport { AgentRunnableSequence } from \"../agent.js\";\nexport { OpenAIToolsAgentOutputParser, type ToolsAgentStep };\n/**\n * Params used by the createOpenAIToolsAgent function.\n */\nexport type CreateOpenAIToolsAgentParams = {\n    /**\n     * LLM to use as the agent. Should work with OpenAI tool calling,\n     * so must either be an OpenAI model that supports that or a wrapper of\n     * a different model that adds in equivalent support.\n     */\n    llm: BaseChatModel<BaseChatModelCallOptions & {\n        tools?: StructuredToolInterface[] | OpenAIClient.ChatCompletionTool[] | any[];\n    }>;\n    /** Tools this agent has access to. */\n    tools: StructuredToolInterface[] | ToolDefinition[];\n    /** The prompt to use, must have an input key of `agent_scratchpad`. */\n    prompt: ChatPromptTemplate;\n    /**\n     * Whether to invoke the underlying model in streaming mode,\n     * allowing streaming of intermediate steps. Defaults to true.\n     */\n    streamRunnable?: boolean;\n};\n/**\n * Create an agent that uses OpenAI-style tool calling.\n * @param params Params required to create the agent. Includes an LLM, tools, and prompt.\n * @returns A runnable sequence representing an agent. It takes as input all the same input\n *     variables as the prompt passed in does. It returns as output either an\n *     AgentAction or AgentFinish.\n *\n * @example\n * ```typescript\n * import { AgentExecutor, createOpenAIToolsAgent } from \"langchain/agents\";\n * import { pull } from \"langchain/hub\";\n * import type { ChatPromptTemplate } from \"@langchain/core/prompts\";\n * import { AIMessage, HumanMessage } from \"@langchain/core/messages\";\n *\n * import { ChatOpenAI } from \"@langchain/openai\";\n *\n * // Define the tools the agent will have access to.\n * const tools = [...];\n *\n * // Get the prompt to use - you can modify this!\n * // If you want to see the prompt in full, you can at:\n * // https://smith.langchain.com/hub/hwchase17/openai-tools-agent\n * const prompt = await pull<ChatPromptTemplate>(\n *   \"hwchase17/openai-tools-agent\"\n * );\n *\n * const llm = new ChatOpenAI({\n *   temperature: 0,\n *   model: \"gpt-3.5-turbo-1106\",\n * });\n *\n * const agent = await createOpenAIToolsAgent({\n *   llm,\n *   tools,\n *   prompt,\n * });\n *\n * const agentExecutor = new AgentExecutor({\n *   agent,\n *   tools,\n * });\n *\n * const result = await agentExecutor.invoke({\n *   input: \"what is LangChain?\",\n * });\n *\n * // With chat history\n * const result2 = await agentExecutor.invoke({\n *   input: \"what's my name?\",\n *   chat_history: [\n *     new HumanMessage(\"hi! my name is cob\"),\n *     new AIMessage(\"Hello Cob! How can I assist you today?\"),\n *   ],\n * });\n * ```\n */\nexport declare function createOpenAIToolsAgent({ llm, tools, prompt, streamRunnable }: CreateOpenAIToolsAgentParams): Promise<AgentRunnableSequence<{\n    steps: ToolsAgentStep[];\n}, import(\"@langchain/core/agents\").AgentFinish | import(\"@langchain/core/agents\").AgentAction[]>>;\n//# sourceMappingURL=index.d.ts.map"],"mappings":";;;;;;;;;;;;;;AAWYS,KAAAA,4BAAAA,GAA4B;EAMjBP;;;;;EAIgBG,GAAAA,EAJ9BJ,aAI8BI,CAJhBH,wBAIgBG,GAAAA;IAE3BF,KAAAA,CAAAA,EALIH,uBAKJG,EAAAA,GALgCC,YAAAA,CAAaM,kBAK7CP,EAAAA,GAAAA,GAAAA,EAAAA;EAAkB,CAAA,CAAA;EA+DNQ;EAAyBC,KAAAA,EAjEtCZ,uBAiEsCY,EAAAA,GAjEVP,cAiEUO,EAAAA;EAAKC;EAAOC,MAAAA,EA/DjDX,kBA+DiDW;EAAQC;;;;EAEtBC,cAAAA,CAAAA,EAAAA,OAAoCE;CAF2CV;;AAAD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAArGG,sBAAAA;;;;;GAA+DF,+BAA+BU,QAAQX;SACnHD;GAAcS,uBAAAA,CACWC,WAAAA,GAAWD,uBAAAA,CAAoCE,WAAAA"}
+{"version":3,"file":"index.d.ts","names":["StructuredToolInterface","BaseChatModel","BaseChatModelCallOptions","ChatPromptTemplate","OpenAIClient","ToolDefinition","OpenAIToolsAgentOutputParser","ToolsAgentStep","AgentRunnableSequence","CreateOpenAIToolsAgentParams","ChatCompletionTool","createOpenAIToolsAgent","llm","tools","prompt","streamRunnable","_langchain_core_agents3","AgentFinish","AgentAction","Promise"],"sources":["../../../src/agents/openai_tools/index.d.ts"],"sourcesContent":["import type { StructuredToolInterface } from \"@langchain/core/tools\";\nimport type { BaseChatModel, BaseChatModelCallOptions } from \"@langchain/core/language_models/chat_models\";\nimport { ChatPromptTemplate } from \"@langchain/core/prompts\";\nimport { OpenAIClient } from \"@langchain/openai\";\nimport { ToolDefinition } from \"@langchain/core/language_models/base\";\nimport { OpenAIToolsAgentOutputParser, type ToolsAgentStep } from \"./output_parser.js\";\nimport { AgentRunnableSequence } from \"../agent.js\";\nexport { OpenAIToolsAgentOutputParser, type ToolsAgentStep };\n/**\n * Params used by the createOpenAIToolsAgent function.\n */\nexport type CreateOpenAIToolsAgentParams = {\n    /**\n     * LLM to use as the agent. Should work with OpenAI tool calling,\n     * so must either be an OpenAI model that supports that or a wrapper of\n     * a different model that adds in equivalent support.\n     */\n    llm: BaseChatModel<BaseChatModelCallOptions & {\n        tools?: StructuredToolInterface[] | OpenAIClient.ChatCompletionTool[] | any[];\n    }>;\n    /** Tools this agent has access to. */\n    tools: StructuredToolInterface[] | ToolDefinition[];\n    /** The prompt to use, must have an input key of `agent_scratchpad`. */\n    prompt: ChatPromptTemplate;\n    /**\n     * Whether to invoke the underlying model in streaming mode,\n     * allowing streaming of intermediate steps. Defaults to true.\n     */\n    streamRunnable?: boolean;\n};\n/**\n * Create an agent that uses OpenAI-style tool calling.\n * @param params Params required to create the agent. Includes an LLM, tools, and prompt.\n * @returns A runnable sequence representing an agent. It takes as input all the same input\n *     variables as the prompt passed in does. It returns as output either an\n *     AgentAction or AgentFinish.\n *\n * @example\n * ```typescript\n * import { AgentExecutor, createOpenAIToolsAgent } from \"langchain/agents\";\n * import { pull } from \"langchain/hub\";\n * import type { ChatPromptTemplate } from \"@langchain/core/prompts\";\n * import { AIMessage, HumanMessage } from \"@langchain/core/messages\";\n *\n * import { ChatOpenAI } from \"@langchain/openai\";\n *\n * // Define the tools the agent will have access to.\n * const tools = [...];\n *\n * // Get the prompt to use - you can modify this!\n * // If you want to see the prompt in full, you can at:\n * // https://smith.langchain.com/hub/hwchase17/openai-tools-agent\n * const prompt = await pull<ChatPromptTemplate>(\n *   \"hwchase17/openai-tools-agent\"\n * );\n *\n * const llm = new ChatOpenAI({\n *   temperature: 0,\n *   model: \"gpt-3.5-turbo-1106\",\n * });\n *\n * const agent = await createOpenAIToolsAgent({\n *   llm,\n *   tools,\n *   prompt,\n * });\n *\n * const agentExecutor = new AgentExecutor({\n *   agent,\n *   tools,\n * });\n *\n * const result = await agentExecutor.invoke({\n *   input: \"what is LangChain?\",\n * });\n *\n * // With chat history\n * const result2 = await agentExecutor.invoke({\n *   input: \"what's my name?\",\n *   chat_history: [\n *     new HumanMessage(\"hi! my name is cob\"),\n *     new AIMessage(\"Hello Cob! How can I assist you today?\"),\n *   ],\n * });\n * ```\n */\nexport declare function createOpenAIToolsAgent({ llm, tools, prompt, streamRunnable }: CreateOpenAIToolsAgentParams): Promise<AgentRunnableSequence<{\n    steps: ToolsAgentStep[];\n}, import(\"@langchain/core/agents\").AgentFinish | import(\"@langchain/core/agents\").AgentAction[]>>;\n//# sourceMappingURL=index.d.ts.map"],"mappings":";;;;;;;;;;;;;;AAWYS,KAAAA,4BAAAA,GAA4B;EAMjBP;;;;;EAIgBG,GAAAA,EAJ9BJ,aAI8BI,CAJhBH,wBAIgBG,GAAAA;IAE3BF,KAAAA,CAAAA,EALIH,uBAKJG,EAAAA,GALgCC,YAAAA,CAAaM,kBAK7CP,EAAAA,GAAAA,GAAAA,EAAAA;EAAkB,CAAA,CAAA;EA+DNQ;EAAyBC,KAAAA,EAjEtCZ,uBAiEsCY,EAAAA,GAjEVP,cAiEUO,EAAAA;EAAKC;EAAOC,MAAAA,EA/DjDX,kBA+DiDW;EAAQC;;;;EAEtBC,cAAAA,CAAAA,EAAAA,OAAoCE;CAF2CV;;AAAD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAArGG,sBAAAA;;;;;GAA+DF,+BAA+BU,QAAQX;SACnHD;GAAcS,uBAAAA,CACWC,WAAAA,GAAWD,uBAAAA,CAAoCE,WAAAA"}

package/dist/agents/react/index.d.cts

@@ -1,5 +1,5 @@
 import { AgentRunnableSequence } from "../agent.cjs";
-import * as _langchain_core_agents0 from "@langchain/core/agents";
+import * as _langchain_core_agents5 from "@langchain/core/agents";
 import { AgentStep } from "@langchain/core/agents";
 import { BasePromptTemplate } from "@langchain/core/prompts";
 import { BaseLanguageModelInterface } from "@langchain/core/language_models/base";
@@ -75,7 +75,7 @@ declare function createReactAgent({
   streamRunnable
 }: CreateReactAgentParams): Promise<AgentRunnableSequence<{
   steps: AgentStep[];
-}, _langchain_core_agents0.AgentAction | _langchain_core_agents0.AgentFinish>>;
+}, _langchain_core_agents5.AgentAction | _langchain_core_agents5.AgentFinish>>;
 //#endregion
 export { CreateReactAgentParams, createReactAgent };
 //# sourceMappingURL=index.d.cts.map

package/dist/agents/react/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":["ToolInterface","BasePromptTemplate","BaseLanguageModelInterface","AgentStep","AgentRunnableSequence","CreateReactAgentParams","createReactAgent","llm","tools","prompt","streamRunnable","_langchain_core_agents0","AgentAction","AgentFinish","Promise"],"sources":["../../../src/agents/react/index.d.ts"],"sourcesContent":["import type { ToolInterface } from \"@langchain/core/tools\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { AgentStep } from \"@langchain/core/agents\";\nimport { AgentRunnableSequence } from \"../agent.js\";\n/**\n * Params used by the createXmlAgent function.\n */\nexport type CreateReactAgentParams = {\n    /** LLM to use for the agent. */\n    llm: BaseLanguageModelInterface;\n    /** Tools this agent has access to. */\n    tools: ToolInterface[];\n    /**\n     * The prompt to use. Must have input keys for\n     * `tools`, `tool_names`, and `agent_scratchpad`.\n     */\n    prompt: BasePromptTemplate;\n    /**\n     * Whether to invoke the underlying model in streaming mode,\n     * allowing streaming of intermediate steps. Defaults to true.\n     */\n    streamRunnable?: boolean;\n};\n/**\n * Create an agent that uses ReAct prompting.\n * @param params Params required to create the agent. Includes an LLM, tools, and prompt.\n * @returns A runnable sequence representing an agent. It takes as input all the same input\n *     variables as the prompt passed in does. It returns as output either an\n *     AgentAction or AgentFinish.\n *\n * @example\n * ```typescript\n * import { AgentExecutor, createReactAgent } from \"langchain/agents\";\n * import { pull } from \"langchain/hub\";\n * import type { PromptTemplate } from \"@langchain/core/prompts\";\n *\n * import { OpenAI } from \"@langchain/openai\";\n *\n * // Define the tools the agent will have access to.\n * const tools = [...];\n *\n * // Get the prompt to use - you can modify this!\n * // If you want to see the prompt in full, you can at:\n * // https://smith.langchain.com/hub/hwchase17/react\n * const prompt = await pull<PromptTemplate>(\"hwchase17/react\");\n *\n * const llm = new OpenAI({\n *   temperature: 0,\n * });\n *\n * const agent = await createReactAgent({\n *   llm,\n *   tools,\n *   prompt,\n * });\n *\n * const agentExecutor = new AgentExecutor({\n *   agent,\n *   tools,\n * });\n *\n * const result = await agentExecutor.invoke({\n *   input: \"what is LangChain?\",\n * });\n * ```\n */\nexport declare function createReactAgent({ llm, tools, prompt, streamRunnable }: CreateReactAgentParams): Promise<AgentRunnableSequence<{\n    steps: AgentStep[];\n}, import(\"@langchain/core/agents\").AgentAction | import(\"@langchain/core/agents\").AgentFinish>>;\n//# sourceMappingURL=index.d.ts.map"],"mappings":";;;;;;;;;;;AAQYK,KAAAA,sBAAAA,GAAsB;EAEzBH;EAEEF,GAAAA,EAFFE,0BAEEF;EAKCC;EAAkB,KAAA,EALnBD,aAKmB,EAAA;EAkDNM;;;;EAAuCI,MAAAA,EAlDnDT,kBAkDmDS;EAAkBL;;;;EAAiCD,cAAAA,CAAAA,EAAAA,OAAAA;CAARU;AAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAzFR,gBAAAA;;;;;GAAyDD,yBAAyBS,QAAQV;SACvGD;GAASQ,uBAAAA,CACgBC,WAAAA,GAAWD,uBAAAA,CAAoCE"}
+{"version":3,"file":"index.d.cts","names":["ToolInterface","BasePromptTemplate","BaseLanguageModelInterface","AgentStep","AgentRunnableSequence","CreateReactAgentParams","createReactAgent","llm","tools","prompt","streamRunnable","_langchain_core_agents5","AgentAction","AgentFinish","Promise"],"sources":["../../../src/agents/react/index.d.ts"],"sourcesContent":["import type { ToolInterface } from \"@langchain/core/tools\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { AgentStep } from \"@langchain/core/agents\";\nimport { AgentRunnableSequence } from \"../agent.js\";\n/**\n * Params used by the createXmlAgent function.\n */\nexport type CreateReactAgentParams = {\n    /** LLM to use for the agent. */\n    llm: BaseLanguageModelInterface;\n    /** Tools this agent has access to. */\n    tools: ToolInterface[];\n    /**\n     * The prompt to use. Must have input keys for\n     * `tools`, `tool_names`, and `agent_scratchpad`.\n     */\n    prompt: BasePromptTemplate;\n    /**\n     * Whether to invoke the underlying model in streaming mode,\n     * allowing streaming of intermediate steps. Defaults to true.\n     */\n    streamRunnable?: boolean;\n};\n/**\n * Create an agent that uses ReAct prompting.\n * @param params Params required to create the agent. Includes an LLM, tools, and prompt.\n * @returns A runnable sequence representing an agent. It takes as input all the same input\n *     variables as the prompt passed in does. It returns as output either an\n *     AgentAction or AgentFinish.\n *\n * @example\n * ```typescript\n * import { AgentExecutor, createReactAgent } from \"langchain/agents\";\n * import { pull } from \"langchain/hub\";\n * import type { PromptTemplate } from \"@langchain/core/prompts\";\n *\n * import { OpenAI } from \"@langchain/openai\";\n *\n * // Define the tools the agent will have access to.\n * const tools = [...];\n *\n * // Get the prompt to use - you can modify this!\n * // If you want to see the prompt in full, you can at:\n * // https://smith.langchain.com/hub/hwchase17/react\n * const prompt = await pull<PromptTemplate>(\"hwchase17/react\");\n *\n * const llm = new OpenAI({\n *   temperature: 0,\n * });\n *\n * const agent = await createReactAgent({\n *   llm,\n *   tools,\n *   prompt,\n * });\n *\n * const agentExecutor = new AgentExecutor({\n *   agent,\n *   tools,\n * });\n *\n * const result = await agentExecutor.invoke({\n *   input: \"what is LangChain?\",\n * });\n * ```\n */\nexport declare function createReactAgent({ llm, tools, prompt, streamRunnable }: CreateReactAgentParams): Promise<AgentRunnableSequence<{\n    steps: AgentStep[];\n}, import(\"@langchain/core/agents\").AgentAction | import(\"@langchain/core/agents\").AgentFinish>>;\n//# sourceMappingURL=index.d.ts.map"],"mappings":";;;;;;;;;;;AAQYK,KAAAA,sBAAAA,GAAsB;EAEzBH;EAEEF,GAAAA,EAFFE,0BAEEF;EAKCC;EAAkB,KAAA,EALnBD,aAKmB,EAAA;EAkDNM;;;;EAAuCI,MAAAA,EAlDnDT,kBAkDmDS;EAAkBL;;;;EAAiCD,cAAAA,CAAAA,EAAAA,OAAAA;CAARU;AAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAzFR,gBAAAA;;;;;GAAyDD,yBAAyBS,QAAQV;SACvGD;GAASQ,uBAAAA,CACgBC,WAAAA,GAAWD,uBAAAA,CAAoCE"}

package/dist/agents/structured_chat/index.d.cts

@@ -2,7 +2,7 @@ import { AgentInput } from "../types.cjs";
 import { Agent, AgentArgs, AgentRunnableSequence, OutputParserArgs } from "../agent.cjs";
 import { Optional } from "../../types/type-utils.cjs";
 import { StructuredChatOutputParserWithRetries } from "./outputParser.cjs";
-import * as _langchain_core_agents1 from "@langchain/core/agents";
+import * as _langchain_core_agents0 from "@langchain/core/agents";
 import { AgentStep } from "@langchain/core/agents";
 import { BaseMessagePromptTemplate, BasePromptTemplate, ChatPromptTemplate } from "@langchain/core/prompts";
 import { BaseLanguageModelInterface, ToolDefinition } from "@langchain/core/language_models/base";
@@ -176,7 +176,7 @@ declare function createStructuredChatAgent({
   streamRunnable
 }: CreateStructuredChatAgentParams): Promise<AgentRunnableSequence<{
   steps: AgentStep[];
-}, _langchain_core_agents1.AgentAction | _langchain_core_agents1.AgentFinish>>;
+}, _langchain_core_agents0.AgentAction | _langchain_core_agents0.AgentFinish>>;
 //#endregion
 export { CreateStructuredChatAgentParams, StructuredChatAgent, StructuredChatAgentInput, StructuredChatCreatePromptArgs, createStructuredChatAgent };
 //# sourceMappingURL=index.d.cts.map

package/dist/agents/structured_chat/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":["StructuredToolInterface","BaseLanguageModelInterface","ToolDefinition","BasePromptTemplate","BaseMessagePromptTemplate","ChatPromptTemplate","AgentStep","Optional","Agent","AgentArgs","AgentRunnableSequence","OutputParserArgs","AgentInput","StructuredChatOutputParserWithRetries","StructuredChatCreatePromptArgs","StructuredChatAgentInput","StructuredChatAgent","Promise","CreateStructuredChatAgentParams","createStructuredChatAgent","llm","tools","prompt","streamRunnable","_langchain_core_agents1","AgentAction","AgentFinish"],"sources":["../../../src/agents/structured_chat/index.d.ts"],"sourcesContent":["import type { StructuredToolInterface } from \"@langchain/core/tools\";\nimport { type BaseLanguageModelInterface, type ToolDefinition } from \"@langchain/core/language_models/base\";\nimport type { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { BaseMessagePromptTemplate, ChatPromptTemplate } from \"@langchain/core/prompts\";\nimport { AgentStep } from \"@langchain/core/agents\";\nimport { Optional } from \"../../types/type-utils.js\";\nimport { Agent, AgentArgs, AgentRunnableSequence, OutputParserArgs } from \"../agent.js\";\nimport { AgentInput } from \"../types.js\";\nimport { StructuredChatOutputParserWithRetries } from \"./outputParser.js\";\n/**\n * Interface for arguments used to create a prompt for a\n * StructuredChatAgent.\n */\nexport interface StructuredChatCreatePromptArgs {\n    /** String to put after the list of tools. */\n    suffix?: string;\n    /** String to put before the list of tools. */\n    prefix?: string;\n    /** String to use directly as the human message template. */\n    humanMessageTemplate?: string;\n    /** List of input variables the final prompt will expect. */\n    inputVariables?: string[];\n    /** List of historical prompts from memory.  */\n    memoryPrompts?: BaseMessagePromptTemplate[];\n}\n/**\n * Type for input data for creating a StructuredChatAgent, with the\n * 'outputParser' property made optional.\n */\nexport type StructuredChatAgentInput = Optional<AgentInput, \"outputParser\">;\n/**\n * Agent that interoperates with Structured Tools using React logic.\n * @augments Agent\n */\nexport declare class StructuredChatAgent extends Agent {\n    static lc_name(): string;\n    lc_namespace: string[];\n    constructor(input: StructuredChatAgentInput);\n    _agentType(): \"structured-chat-zero-shot-react-description\";\n    observationPrefix(): string;\n    llmPrefix(): string;\n    _stop(): string[];\n    /**\n     * Validates that all provided tools have a description. Throws an error\n     * if any tool lacks a description.\n     * @param tools Array of StructuredTool instances to validate.\n     */\n    static validateTools(tools: StructuredToolInterface[]): void;\n    /**\n     * Returns a default output parser for the StructuredChatAgent. If an LLM\n     * is provided, it creates an output parser with retry logic from the LLM.\n     * @param fields Optional fields to customize the output parser. Can include an LLM and a list of tool names.\n     * @returns An instance of StructuredChatOutputParserWithRetries.\n     */\n    static getDefaultOutputParser(fields?: OutputParserArgs & {\n        toolNames: string[];\n    }): StructuredChatOutputParserWithRetries;\n    /**\n     * Constructs the agent's scratchpad from a list of steps. If the agent's\n     * scratchpad is not empty, it prepends a message indicating that the\n     * agent has not seen any previous work.\n     * @param steps Array of AgentStep instances to construct the scratchpad from.\n     * @returns A Promise that resolves to a string representing the agent's scratchpad.\n     */\n    constructScratchPad(steps: AgentStep[]): Promise<string>;\n    /**\n     * Creates a string representation of the schemas of the provided tools.\n     * @param tools Array of StructuredTool instances to create the schemas string from.\n     * @returns A string representing the schemas of the provided tools.\n     */\n    static createToolSchemasString(tools: StructuredToolInterface[]): string;\n    /**\n     * Create prompt in the style of the agent.\n     *\n     * @param tools - List of tools the agent will have access to, used to format the prompt.\n     * @param args - Arguments to create the prompt with.\n     * @param args.suffix - String to put after the list of tools.\n     * @param args.prefix - String to put before the list of tools.\n     * @param args.inputVariables List of input variables the final prompt will expect.\n     * @param args.memoryPrompts List of historical prompts from memory.\n     */\n    static createPrompt(tools: StructuredToolInterface[], args?: StructuredChatCreatePromptArgs): ChatPromptTemplate<any, any>;\n    /**\n     * Creates a StructuredChatAgent from an LLM and a list of tools.\n     * Validates the tools, creates a prompt, and sets up an LLM chain for the\n     * agent.\n     * @param llm BaseLanguageModel instance to create the agent from.\n     * @param tools Array of StructuredTool instances to create the agent from.\n     * @param args Optional arguments to customize the creation of the agent. Can include arguments for creating the prompt and AgentArgs.\n     * @returns A new instance of StructuredChatAgent.\n     */\n    static fromLLMAndTools(llm: BaseLanguageModelInterface, tools: StructuredToolInterface[], args?: StructuredChatCreatePromptArgs & AgentArgs): StructuredChatAgent;\n}\n/**\n * Params used by the createStructuredChatAgent function.\n */\nexport type CreateStructuredChatAgentParams = {\n    /** LLM to use as the agent. */\n    llm: BaseLanguageModelInterface;\n    /** Tools this agent has access to. */\n    tools: (StructuredToolInterface | ToolDefinition)[];\n    /**\n     * The prompt to use. Must have input keys for\n     * `tools`, `tool_names`, and `agent_scratchpad`.\n     */\n    prompt: BasePromptTemplate;\n    /**\n     * Whether to invoke the underlying model in streaming mode,\n     * allowing streaming of intermediate steps. Defaults to true.\n     */\n    streamRunnable?: boolean;\n};\n/**\n * Create an agent aimed at supporting tools with multiple inputs.\n * @param params Params required to create the agent. Includes an LLM, tools, and prompt.\n * @returns A runnable sequence representing an agent. It takes as input all the same input\n *     variables as the prompt passed in does. It returns as output either an\n *     AgentAction or AgentFinish.\n *\n * @example\n * ```typescript\n * import { AgentExecutor, createStructuredChatAgent } from \"langchain/agents\";\n * import { pull } from \"langchain/hub\";\n * import type { ChatPromptTemplate } from \"@langchain/core/prompts\";\n * import { AIMessage, HumanMessage } from \"@langchain/core/messages\";\n *\n * import { ChatOpenAI } from \"@langchain/openai\";\n *\n * // Define the tools the agent will have access to.\n * const tools = [...];\n *\n * // Get the prompt to use - you can modify this!\n * // If you want to see the prompt in full, you can at:\n * // https://smith.langchain.com/hub/hwchase17/structured-chat-agent\n * const prompt = await pull<ChatPromptTemplate>(\n *   \"hwchase17/structured-chat-agent\"\n * );\n *\n * const llm = new ChatOpenAI({\n *   temperature: 0,\n *   model: \"gpt-3.5-turbo-1106\",\n * });\n *\n * const agent = await createStructuredChatAgent({\n *   llm,\n *   tools,\n *   prompt,\n * });\n *\n * const agentExecutor = new AgentExecutor({\n *   agent,\n *   tools,\n * });\n *\n * const result = await agentExecutor.invoke({\n *   input: \"what is LangChain?\",\n * });\n *\n * // With chat history\n * const result2 = await agentExecutor.invoke({\n *   input: \"what's my name?\",\n *   chat_history: [\n *     new HumanMessage(\"hi! my name is cob\"),\n *     new AIMessage(\"Hello Cob! How can I assist you today?\"),\n *   ],\n * });\n * ```\n */\nexport declare function createStructuredChatAgent({ llm, tools, prompt, streamRunnable }: CreateStructuredChatAgentParams): Promise<AgentRunnableSequence<{\n    steps: AgentStep[];\n}, import(\"@langchain/core/agents\").AgentAction | import(\"@langchain/core/agents\").AgentFinish>>;\n//# sourceMappingURL=index.d.ts.map"],"mappings":";;;;;;;;;;;;;;AAaA;AAgBA;AAKqBgB,UArBJF,8BAAAA,CAqBuB;EAGjBC;EAUSf,MAAAA,CAAAA,EAAAA,MAAAA;EAOWW;EAEnCE,MAAAA,CAAAA,EAAAA,MAAAA;EAQuBP;EAAcW,oBAAAA,CAAAA,EAAAA,MAAAA;EAMHjB;EAWXA,cAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAkCc;EAAiCT,aAAAA,CAAAA,EA1D9ED,yBA0D8EC,EAAAA;;;;;;AA/CjDG,KALrCO,wBAAAA,GAA2BR,QAKUC,CALDI,UAKCJ,EAAAA,cAAAA,CAAAA;AAAK;AA8DtD;;;AAIsCN,cAlEjBc,mBAAAA,SAA4BR,KAAAA,CAkEXN;EAK1BC,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAkB,YAAA,EAAA,MAAA,EAAA;EA+DNgB,WAAAA,CAAAA,KAAAA,EAnIDJ,wBAmI0B;EAAGK,UAAAA,CAAAA,CAAAA,EAAAA,6CAAAA;EAAKC,iBAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAOC,SAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAQC,KAAAA,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAkBL;;;;;EAAkCD,OAAAA,aAAAA,CAAAA,KAAAA,EAzH5FjB,uBAyH4FiB,EAAAA,CAAAA,EAAAA,IAAAA;EAAO;;;;;;yCAlHxFN;;MAEnCE;;;;;;;;6BAQuBP,cAAcW;;;;;;wCAMHjB;;;;;;;;;;;6BAWXA,kCAAkCc,iCAAiCT;;;;;;;;;;8BAUlEJ,mCAAmCD,kCAAkCc,iCAAiCL,YAAYO;;;;;KAKtIE,+BAAAA;;OAEHjB;;UAEGD,0BAA0BE;;;;;UAK1BC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+DYgB,yBAAAA;;;;;GAAkED,kCAAkCD,QAAQP;SACzHJ;GAASkB,uBAAAA,CACgBC,WAAAA,GAAWD,uBAAAA,CAAoCE"}
+{"version":3,"file":"index.d.cts","names":["StructuredToolInterface","BaseLanguageModelInterface","ToolDefinition","BasePromptTemplate","BaseMessagePromptTemplate","ChatPromptTemplate","AgentStep","Optional","Agent","AgentArgs","AgentRunnableSequence","OutputParserArgs","AgentInput","StructuredChatOutputParserWithRetries","StructuredChatCreatePromptArgs","StructuredChatAgentInput","StructuredChatAgent","Promise","CreateStructuredChatAgentParams","createStructuredChatAgent","llm","tools","prompt","streamRunnable","_langchain_core_agents0","AgentAction","AgentFinish"],"sources":["../../../src/agents/structured_chat/index.d.ts"],"sourcesContent":["import type { StructuredToolInterface } from \"@langchain/core/tools\";\nimport { type BaseLanguageModelInterface, type ToolDefinition } from \"@langchain/core/language_models/base\";\nimport type { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { BaseMessagePromptTemplate, ChatPromptTemplate } from \"@langchain/core/prompts\";\nimport { AgentStep } from \"@langchain/core/agents\";\nimport { Optional } from \"../../types/type-utils.js\";\nimport { Agent, AgentArgs, AgentRunnableSequence, OutputParserArgs } from \"../agent.js\";\nimport { AgentInput } from \"../types.js\";\nimport { StructuredChatOutputParserWithRetries } from \"./outputParser.js\";\n/**\n * Interface for arguments used to create a prompt for a\n * StructuredChatAgent.\n */\nexport interface StructuredChatCreatePromptArgs {\n    /** String to put after the list of tools. */\n    suffix?: string;\n    /** String to put before the list of tools. */\n    prefix?: string;\n    /** String to use directly as the human message template. */\n    humanMessageTemplate?: string;\n    /** List of input variables the final prompt will expect. */\n    inputVariables?: string[];\n    /** List of historical prompts from memory.  */\n    memoryPrompts?: BaseMessagePromptTemplate[];\n}\n/**\n * Type for input data for creating a StructuredChatAgent, with the\n * 'outputParser' property made optional.\n */\nexport type StructuredChatAgentInput = Optional<AgentInput, \"outputParser\">;\n/**\n * Agent that interoperates with Structured Tools using React logic.\n * @augments Agent\n */\nexport declare class StructuredChatAgent extends Agent {\n    static lc_name(): string;\n    lc_namespace: string[];\n    constructor(input: StructuredChatAgentInput);\n    _agentType(): \"structured-chat-zero-shot-react-description\";\n    observationPrefix(): string;\n    llmPrefix(): string;\n    _stop(): string[];\n    /**\n     * Validates that all provided tools have a description. Throws an error\n     * if any tool lacks a description.\n     * @param tools Array of StructuredTool instances to validate.\n     */\n    static validateTools(tools: StructuredToolInterface[]): void;\n    /**\n     * Returns a default output parser for the StructuredChatAgent. If an LLM\n     * is provided, it creates an output parser with retry logic from the LLM.\n     * @param fields Optional fields to customize the output parser. Can include an LLM and a list of tool names.\n     * @returns An instance of StructuredChatOutputParserWithRetries.\n     */\n    static getDefaultOutputParser(fields?: OutputParserArgs & {\n        toolNames: string[];\n    }): StructuredChatOutputParserWithRetries;\n    /**\n     * Constructs the agent's scratchpad from a list of steps. If the agent's\n     * scratchpad is not empty, it prepends a message indicating that the\n     * agent has not seen any previous work.\n     * @param steps Array of AgentStep instances to construct the scratchpad from.\n     * @returns A Promise that resolves to a string representing the agent's scratchpad.\n     */\n    constructScratchPad(steps: AgentStep[]): Promise<string>;\n    /**\n     * Creates a string representation of the schemas of the provided tools.\n     * @param tools Array of StructuredTool instances to create the schemas string from.\n     * @returns A string representing the schemas of the provided tools.\n     */\n    static createToolSchemasString(tools: StructuredToolInterface[]): string;\n    /**\n     * Create prompt in the style of the agent.\n     *\n     * @param tools - List of tools the agent will have access to, used to format the prompt.\n     * @param args - Arguments to create the prompt with.\n     * @param args.suffix - String to put after the list of tools.\n     * @param args.prefix - String to put before the list of tools.\n     * @param args.inputVariables List of input variables the final prompt will expect.\n     * @param args.memoryPrompts List of historical prompts from memory.\n     */\n    static createPrompt(tools: StructuredToolInterface[], args?: StructuredChatCreatePromptArgs): ChatPromptTemplate<any, any>;\n    /**\n     * Creates a StructuredChatAgent from an LLM and a list of tools.\n     * Validates the tools, creates a prompt, and sets up an LLM chain for the\n     * agent.\n     * @param llm BaseLanguageModel instance to create the agent from.\n     * @param tools Array of StructuredTool instances to create the agent from.\n     * @param args Optional arguments to customize the creation of the agent. Can include arguments for creating the prompt and AgentArgs.\n     * @returns A new instance of StructuredChatAgent.\n     */\n    static fromLLMAndTools(llm: BaseLanguageModelInterface, tools: StructuredToolInterface[], args?: StructuredChatCreatePromptArgs & AgentArgs): StructuredChatAgent;\n}\n/**\n * Params used by the createStructuredChatAgent function.\n */\nexport type CreateStructuredChatAgentParams = {\n    /** LLM to use as the agent. */\n    llm: BaseLanguageModelInterface;\n    /** Tools this agent has access to. */\n    tools: (StructuredToolInterface | ToolDefinition)[];\n    /**\n     * The prompt to use. Must have input keys for\n     * `tools`, `tool_names`, and `agent_scratchpad`.\n     */\n    prompt: BasePromptTemplate;\n    /**\n     * Whether to invoke the underlying model in streaming mode,\n     * allowing streaming of intermediate steps. Defaults to true.\n     */\n    streamRunnable?: boolean;\n};\n/**\n * Create an agent aimed at supporting tools with multiple inputs.\n * @param params Params required to create the agent. Includes an LLM, tools, and prompt.\n * @returns A runnable sequence representing an agent. It takes as input all the same input\n *     variables as the prompt passed in does. It returns as output either an\n *     AgentAction or AgentFinish.\n *\n * @example\n * ```typescript\n * import { AgentExecutor, createStructuredChatAgent } from \"langchain/agents\";\n * import { pull } from \"langchain/hub\";\n * import type { ChatPromptTemplate } from \"@langchain/core/prompts\";\n * import { AIMessage, HumanMessage } from \"@langchain/core/messages\";\n *\n * import { ChatOpenAI } from \"@langchain/openai\";\n *\n * // Define the tools the agent will have access to.\n * const tools = [...];\n *\n * // Get the prompt to use - you can modify this!\n * // If you want to see the prompt in full, you can at:\n * // https://smith.langchain.com/hub/hwchase17/structured-chat-agent\n * const prompt = await pull<ChatPromptTemplate>(\n *   \"hwchase17/structured-chat-agent\"\n * );\n *\n * const llm = new ChatOpenAI({\n *   temperature: 0,\n *   model: \"gpt-3.5-turbo-1106\",\n * });\n *\n * const agent = await createStructuredChatAgent({\n *   llm,\n *   tools,\n *   prompt,\n * });\n *\n * const agentExecutor = new AgentExecutor({\n *   agent,\n *   tools,\n * });\n *\n * const result = await agentExecutor.invoke({\n *   input: \"what is LangChain?\",\n * });\n *\n * // With chat history\n * const result2 = await agentExecutor.invoke({\n *   input: \"what's my name?\",\n *   chat_history: [\n *     new HumanMessage(\"hi! my name is cob\"),\n *     new AIMessage(\"Hello Cob! How can I assist you today?\"),\n *   ],\n * });\n * ```\n */\nexport declare function createStructuredChatAgent({ llm, tools, prompt, streamRunnable }: CreateStructuredChatAgentParams): Promise<AgentRunnableSequence<{\n    steps: AgentStep[];\n}, import(\"@langchain/core/agents\").AgentAction | import(\"@langchain/core/agents\").AgentFinish>>;\n//# sourceMappingURL=index.d.ts.map"],"mappings":";;;;;;;;;;;;;;AAaA;AAgBA;AAKqBgB,UArBJF,8BAAAA,CAqBuB;EAGjBC;EAUSf,MAAAA,CAAAA,EAAAA,MAAAA;EAOWW;EAEnCE,MAAAA,CAAAA,EAAAA,MAAAA;EAQuBP;EAAcW,oBAAAA,CAAAA,EAAAA,MAAAA;EAMHjB;EAWXA,cAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAkCc;EAAiCT,aAAAA,CAAAA,EA1D9ED,yBA0D8EC,EAAAA;;;;;;AA/CjDG,KALrCO,wBAAAA,GAA2BR,QAKUC,CALDI,UAKCJ,EAAAA,cAAAA,CAAAA;AAAK;AA8DtD;;;AAIsCN,cAlEjBc,mBAAAA,SAA4BR,KAAAA,CAkEXN;EAK1BC,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAkB,YAAA,EAAA,MAAA,EAAA;EA+DNgB,WAAAA,CAAAA,KAAAA,EAnIDJ,wBAmI0B;EAAGK,UAAAA,CAAAA,CAAAA,EAAAA,6CAAAA;EAAKC,iBAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAOC,SAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAQC,KAAAA,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAkBL;;;;;EAAkCD,OAAAA,aAAAA,CAAAA,KAAAA,EAzH5FjB,uBAyH4FiB,EAAAA,CAAAA,EAAAA,IAAAA;EAAO;;;;;;yCAlHxFN;;MAEnCE;;;;;;;;6BAQuBP,cAAcW;;;;;;wCAMHjB;;;;;;;;;;;6BAWXA,kCAAkCc,iCAAiCT;;;;;;;;;;8BAUlEJ,mCAAmCD,kCAAkCc,iCAAiCL,YAAYO;;;;;KAKtIE,+BAAAA;;OAEHjB;;UAEGD,0BAA0BE;;;;;UAK1BC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+DYgB,yBAAAA;;;;;GAAkED,kCAAkCD,QAAQP;SACzHJ;GAASkB,uBAAAA,CACgBC,WAAAA,GAAWD,uBAAAA,CAAoCE"}

package/dist/agents/structured_chat/index.d.ts

@@ -5,7 +5,7 @@ import { StructuredChatOutputParserWithRetries } from "./outputParser.js";
 import { BaseMessagePromptTemplate, BasePromptTemplate, ChatPromptTemplate } from "@langchain/core/prompts";
 import { StructuredToolInterface } from "@langchain/core/tools";
 import { BaseLanguageModelInterface, ToolDefinition } from "@langchain/core/language_models/base";
-import * as _langchain_core_agents5 from "@langchain/core/agents";
+import * as _langchain_core_agents1 from "@langchain/core/agents";
 import { AgentStep } from "@langchain/core/agents";
 
 //#region src/agents/structured_chat/index.d.ts
@@ -176,7 +176,7 @@ declare function createStructuredChatAgent({
   streamRunnable
 }: CreateStructuredChatAgentParams): Promise<AgentRunnableSequence<{
   steps: AgentStep[];
-}, _langchain_core_agents5.AgentAction | _langchain_core_agents5.AgentFinish>>;
+}, _langchain_core_agents1.AgentAction | _langchain_core_agents1.AgentFinish>>;
 //#endregion
 export { CreateStructuredChatAgentParams, StructuredChatAgent, StructuredChatAgentInput, StructuredChatCreatePromptArgs, createStructuredChatAgent };
 //# sourceMappingURL=index.d.ts.map

package/dist/agents/structured_chat/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":["StructuredToolInterface","BaseLanguageModelInterface","ToolDefinition","BasePromptTemplate","BaseMessagePromptTemplate","ChatPromptTemplate","AgentStep","Optional","Agent","AgentArgs","AgentRunnableSequence","OutputParserArgs","AgentInput","StructuredChatOutputParserWithRetries","StructuredChatCreatePromptArgs","StructuredChatAgentInput","StructuredChatAgent","Promise","CreateStructuredChatAgentParams","createStructuredChatAgent","llm","tools","prompt","streamRunnable","_langchain_core_agents5","AgentAction","AgentFinish"],"sources":["../../../src/agents/structured_chat/index.d.ts"],"sourcesContent":["import type { StructuredToolInterface } from \"@langchain/core/tools\";\nimport { type BaseLanguageModelInterface, type ToolDefinition } from \"@langchain/core/language_models/base\";\nimport type { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { BaseMessagePromptTemplate, ChatPromptTemplate } from \"@langchain/core/prompts\";\nimport { AgentStep } from \"@langchain/core/agents\";\nimport { Optional } from \"../../types/type-utils.js\";\nimport { Agent, AgentArgs, AgentRunnableSequence, OutputParserArgs } from \"../agent.js\";\nimport { AgentInput } from \"../types.js\";\nimport { StructuredChatOutputParserWithRetries } from \"./outputParser.js\";\n/**\n * Interface for arguments used to create a prompt for a\n * StructuredChatAgent.\n */\nexport interface StructuredChatCreatePromptArgs {\n    /** String to put after the list of tools. */\n    suffix?: string;\n    /** String to put before the list of tools. */\n    prefix?: string;\n    /** String to use directly as the human message template. */\n    humanMessageTemplate?: string;\n    /** List of input variables the final prompt will expect. */\n    inputVariables?: string[];\n    /** List of historical prompts from memory.  */\n    memoryPrompts?: BaseMessagePromptTemplate[];\n}\n/**\n * Type for input data for creating a StructuredChatAgent, with the\n * 'outputParser' property made optional.\n */\nexport type StructuredChatAgentInput = Optional<AgentInput, \"outputParser\">;\n/**\n * Agent that interoperates with Structured Tools using React logic.\n * @augments Agent\n */\nexport declare class StructuredChatAgent extends Agent {\n    static lc_name(): string;\n    lc_namespace: string[];\n    constructor(input: StructuredChatAgentInput);\n    _agentType(): \"structured-chat-zero-shot-react-description\";\n    observationPrefix(): string;\n    llmPrefix(): string;\n    _stop(): string[];\n    /**\n     * Validates that all provided tools have a description. Throws an error\n     * if any tool lacks a description.\n     * @param tools Array of StructuredTool instances to validate.\n     */\n    static validateTools(tools: StructuredToolInterface[]): void;\n    /**\n     * Returns a default output parser for the StructuredChatAgent. If an LLM\n     * is provided, it creates an output parser with retry logic from the LLM.\n     * @param fields Optional fields to customize the output parser. Can include an LLM and a list of tool names.\n     * @returns An instance of StructuredChatOutputParserWithRetries.\n     */\n    static getDefaultOutputParser(fields?: OutputParserArgs & {\n        toolNames: string[];\n    }): StructuredChatOutputParserWithRetries;\n    /**\n     * Constructs the agent's scratchpad from a list of steps. If the agent's\n     * scratchpad is not empty, it prepends a message indicating that the\n     * agent has not seen any previous work.\n     * @param steps Array of AgentStep instances to construct the scratchpad from.\n     * @returns A Promise that resolves to a string representing the agent's scratchpad.\n     */\n    constructScratchPad(steps: AgentStep[]): Promise<string>;\n    /**\n     * Creates a string representation of the schemas of the provided tools.\n     * @param tools Array of StructuredTool instances to create the schemas string from.\n     * @returns A string representing the schemas of the provided tools.\n     */\n    static createToolSchemasString(tools: StructuredToolInterface[]): string;\n    /**\n     * Create prompt in the style of the agent.\n     *\n     * @param tools - List of tools the agent will have access to, used to format the prompt.\n     * @param args - Arguments to create the prompt with.\n     * @param args.suffix - String to put after the list of tools.\n     * @param args.prefix - String to put before the list of tools.\n     * @param args.inputVariables List of input variables the final prompt will expect.\n     * @param args.memoryPrompts List of historical prompts from memory.\n     */\n    static createPrompt(tools: StructuredToolInterface[], args?: StructuredChatCreatePromptArgs): ChatPromptTemplate<any, any>;\n    /**\n     * Creates a StructuredChatAgent from an LLM and a list of tools.\n     * Validates the tools, creates a prompt, and sets up an LLM chain for the\n     * agent.\n     * @param llm BaseLanguageModel instance to create the agent from.\n     * @param tools Array of StructuredTool instances to create the agent from.\n     * @param args Optional arguments to customize the creation of the agent. Can include arguments for creating the prompt and AgentArgs.\n     * @returns A new instance of StructuredChatAgent.\n     */\n    static fromLLMAndTools(llm: BaseLanguageModelInterface, tools: StructuredToolInterface[], args?: StructuredChatCreatePromptArgs & AgentArgs): StructuredChatAgent;\n}\n/**\n * Params used by the createStructuredChatAgent function.\n */\nexport type CreateStructuredChatAgentParams = {\n    /** LLM to use as the agent. */\n    llm: BaseLanguageModelInterface;\n    /** Tools this agent has access to. */\n    tools: (StructuredToolInterface | ToolDefinition)[];\n    /**\n     * The prompt to use. Must have input keys for\n     * `tools`, `tool_names`, and `agent_scratchpad`.\n     */\n    prompt: BasePromptTemplate;\n    /**\n     * Whether to invoke the underlying model in streaming mode,\n     * allowing streaming of intermediate steps. Defaults to true.\n     */\n    streamRunnable?: boolean;\n};\n/**\n * Create an agent aimed at supporting tools with multiple inputs.\n * @param params Params required to create the agent. Includes an LLM, tools, and prompt.\n * @returns A runnable sequence representing an agent. It takes as input all the same input\n *     variables as the prompt passed in does. It returns as output either an\n *     AgentAction or AgentFinish.\n *\n * @example\n * ```typescript\n * import { AgentExecutor, createStructuredChatAgent } from \"langchain/agents\";\n * import { pull } from \"langchain/hub\";\n * import type { ChatPromptTemplate } from \"@langchain/core/prompts\";\n * import { AIMessage, HumanMessage } from \"@langchain/core/messages\";\n *\n * import { ChatOpenAI } from \"@langchain/openai\";\n *\n * // Define the tools the agent will have access to.\n * const tools = [...];\n *\n * // Get the prompt to use - you can modify this!\n * // If you want to see the prompt in full, you can at:\n * // https://smith.langchain.com/hub/hwchase17/structured-chat-agent\n * const prompt = await pull<ChatPromptTemplate>(\n *   \"hwchase17/structured-chat-agent\"\n * );\n *\n * const llm = new ChatOpenAI({\n *   temperature: 0,\n *   model: \"gpt-3.5-turbo-1106\",\n * });\n *\n * const agent = await createStructuredChatAgent({\n *   llm,\n *   tools,\n *   prompt,\n * });\n *\n * const agentExecutor = new AgentExecutor({\n *   agent,\n *   tools,\n * });\n *\n * const result = await agentExecutor.invoke({\n *   input: \"what is LangChain?\",\n * });\n *\n * // With chat history\n * const result2 = await agentExecutor.invoke({\n *   input: \"what's my name?\",\n *   chat_history: [\n *     new HumanMessage(\"hi! my name is cob\"),\n *     new AIMessage(\"Hello Cob! How can I assist you today?\"),\n *   ],\n * });\n * ```\n */\nexport declare function createStructuredChatAgent({ llm, tools, prompt, streamRunnable }: CreateStructuredChatAgentParams): Promise<AgentRunnableSequence<{\n    steps: AgentStep[];\n}, import(\"@langchain/core/agents\").AgentAction | import(\"@langchain/core/agents\").AgentFinish>>;\n//# sourceMappingURL=index.d.ts.map"],"mappings":";;;;;;;;;;;;;;AAaA;AAgBA;AAKqBgB,UArBJF,8BAAAA,CAqBuB;EAGjBC;EAUSf,MAAAA,CAAAA,EAAAA,MAAAA;EAOWW;EAEnCE,MAAAA,CAAAA,EAAAA,MAAAA;EAQuBP;EAAcW,oBAAAA,CAAAA,EAAAA,MAAAA;EAMHjB;EAWXA,cAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAkCc;EAAiCT,aAAAA,CAAAA,EA1D9ED,yBA0D8EC,EAAAA;;;;;;AA/CjDG,KALrCO,wBAAAA,GAA2BR,QAKUC,CALDI,UAKCJ,EAAAA,cAAAA,CAAAA;AAAK;AA8DtD;;;AAIsCN,cAlEjBc,mBAAAA,SAA4BR,KAAAA,CAkEXN;EAK1BC,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAkB,YAAA,EAAA,MAAA,EAAA;EA+DNgB,WAAAA,CAAAA,KAAAA,EAnIDJ,wBAmI0B;EAAGK,UAAAA,CAAAA,CAAAA,EAAAA,6CAAAA;EAAKC,iBAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAOC,SAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAQC,KAAAA,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAkBL;;;;;EAAkCD,OAAAA,aAAAA,CAAAA,KAAAA,EAzH5FjB,uBAyH4FiB,EAAAA,CAAAA,EAAAA,IAAAA;EAAO;;;;;;yCAlHxFN;;MAEnCE;;;;;;;;6BAQuBP,cAAcW;;;;;;wCAMHjB;;;;;;;;;;;6BAWXA,kCAAkCc,iCAAiCT;;;;;;;;;;8BAUlEJ,mCAAmCD,kCAAkCc,iCAAiCL,YAAYO;;;;;KAKtIE,+BAAAA;;OAEHjB;;UAEGD,0BAA0BE;;;;;UAK1BC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+DYgB,yBAAAA;;;;;GAAkED,kCAAkCD,QAAQP;SACzHJ;GAASkB,uBAAAA,CACgBC,WAAAA,GAAWD,uBAAAA,CAAoCE"}
+{"version":3,"file":"index.d.ts","names":["StructuredToolInterface","BaseLanguageModelInterface","ToolDefinition","BasePromptTemplate","BaseMessagePromptTemplate","ChatPromptTemplate","AgentStep","Optional","Agent","AgentArgs","AgentRunnableSequence","OutputParserArgs","AgentInput","StructuredChatOutputParserWithRetries","StructuredChatCreatePromptArgs","StructuredChatAgentInput","StructuredChatAgent","Promise","CreateStructuredChatAgentParams","createStructuredChatAgent","llm","tools","prompt","streamRunnable","_langchain_core_agents1","AgentAction","AgentFinish"],"sources":["../../../src/agents/structured_chat/index.d.ts"],"sourcesContent":["import type { StructuredToolInterface } from \"@langchain/core/tools\";\nimport { type BaseLanguageModelInterface, type ToolDefinition } from \"@langchain/core/language_models/base\";\nimport type { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { BaseMessagePromptTemplate, ChatPromptTemplate } from \"@langchain/core/prompts\";\nimport { AgentStep } from \"@langchain/core/agents\";\nimport { Optional } from \"../../types/type-utils.js\";\nimport { Agent, AgentArgs, AgentRunnableSequence, OutputParserArgs } from \"../agent.js\";\nimport { AgentInput } from \"../types.js\";\nimport { StructuredChatOutputParserWithRetries } from \"./outputParser.js\";\n/**\n * Interface for arguments used to create a prompt for a\n * StructuredChatAgent.\n */\nexport interface StructuredChatCreatePromptArgs {\n    /** String to put after the list of tools. */\n    suffix?: string;\n    /** String to put before the list of tools. */\n    prefix?: string;\n    /** String to use directly as the human message template. */\n    humanMessageTemplate?: string;\n    /** List of input variables the final prompt will expect. */\n    inputVariables?: string[];\n    /** List of historical prompts from memory.  */\n    memoryPrompts?: BaseMessagePromptTemplate[];\n}\n/**\n * Type for input data for creating a StructuredChatAgent, with the\n * 'outputParser' property made optional.\n */\nexport type StructuredChatAgentInput = Optional<AgentInput, \"outputParser\">;\n/**\n * Agent that interoperates with Structured Tools using React logic.\n * @augments Agent\n */\nexport declare class StructuredChatAgent extends Agent {\n    static lc_name(): string;\n    lc_namespace: string[];\n    constructor(input: StructuredChatAgentInput);\n    _agentType(): \"structured-chat-zero-shot-react-description\";\n    observationPrefix(): string;\n    llmPrefix(): string;\n    _stop(): string[];\n    /**\n     * Validates that all provided tools have a description. Throws an error\n     * if any tool lacks a description.\n     * @param tools Array of StructuredTool instances to validate.\n     */\n    static validateTools(tools: StructuredToolInterface[]): void;\n    /**\n     * Returns a default output parser for the StructuredChatAgent. If an LLM\n     * is provided, it creates an output parser with retry logic from the LLM.\n     * @param fields Optional fields to customize the output parser. Can include an LLM and a list of tool names.\n     * @returns An instance of StructuredChatOutputParserWithRetries.\n     */\n    static getDefaultOutputParser(fields?: OutputParserArgs & {\n        toolNames: string[];\n    }): StructuredChatOutputParserWithRetries;\n    /**\n     * Constructs the agent's scratchpad from a list of steps. If the agent's\n     * scratchpad is not empty, it prepends a message indicating that the\n     * agent has not seen any previous work.\n     * @param steps Array of AgentStep instances to construct the scratchpad from.\n     * @returns A Promise that resolves to a string representing the agent's scratchpad.\n     */\n    constructScratchPad(steps: AgentStep[]): Promise<string>;\n    /**\n     * Creates a string representation of the schemas of the provided tools.\n     * @param tools Array of StructuredTool instances to create the schemas string from.\n     * @returns A string representing the schemas of the provided tools.\n     */\n    static createToolSchemasString(tools: StructuredToolInterface[]): string;\n    /**\n     * Create prompt in the style of the agent.\n     *\n     * @param tools - List of tools the agent will have access to, used to format the prompt.\n     * @param args - Arguments to create the prompt with.\n     * @param args.suffix - String to put after the list of tools.\n     * @param args.prefix - String to put before the list of tools.\n     * @param args.inputVariables List of input variables the final prompt will expect.\n     * @param args.memoryPrompts List of historical prompts from memory.\n     */\n    static createPrompt(tools: StructuredToolInterface[], args?: StructuredChatCreatePromptArgs): ChatPromptTemplate<any, any>;\n    /**\n     * Creates a StructuredChatAgent from an LLM and a list of tools.\n     * Validates the tools, creates a prompt, and sets up an LLM chain for the\n     * agent.\n     * @param llm BaseLanguageModel instance to create the agent from.\n     * @param tools Array of StructuredTool instances to create the agent from.\n     * @param args Optional arguments to customize the creation of the agent. Can include arguments for creating the prompt and AgentArgs.\n     * @returns A new instance of StructuredChatAgent.\n     */\n    static fromLLMAndTools(llm: BaseLanguageModelInterface, tools: StructuredToolInterface[], args?: StructuredChatCreatePromptArgs & AgentArgs): StructuredChatAgent;\n}\n/**\n * Params used by the createStructuredChatAgent function.\n */\nexport type CreateStructuredChatAgentParams = {\n    /** LLM to use as the agent. */\n    llm: BaseLanguageModelInterface;\n    /** Tools this agent has access to. */\n    tools: (StructuredToolInterface | ToolDefinition)[];\n    /**\n     * The prompt to use. Must have input keys for\n     * `tools`, `tool_names`, and `agent_scratchpad`.\n     */\n    prompt: BasePromptTemplate;\n    /**\n     * Whether to invoke the underlying model in streaming mode,\n     * allowing streaming of intermediate steps. Defaults to true.\n     */\n    streamRunnable?: boolean;\n};\n/**\n * Create an agent aimed at supporting tools with multiple inputs.\n * @param params Params required to create the agent. Includes an LLM, tools, and prompt.\n * @returns A runnable sequence representing an agent. It takes as input all the same input\n *     variables as the prompt passed in does. It returns as output either an\n *     AgentAction or AgentFinish.\n *\n * @example\n * ```typescript\n * import { AgentExecutor, createStructuredChatAgent } from \"langchain/agents\";\n * import { pull } from \"langchain/hub\";\n * import type { ChatPromptTemplate } from \"@langchain/core/prompts\";\n * import { AIMessage, HumanMessage } from \"@langchain/core/messages\";\n *\n * import { ChatOpenAI } from \"@langchain/openai\";\n *\n * // Define the tools the agent will have access to.\n * const tools = [...];\n *\n * // Get the prompt to use - you can modify this!\n * // If you want to see the prompt in full, you can at:\n * // https://smith.langchain.com/hub/hwchase17/structured-chat-agent\n * const prompt = await pull<ChatPromptTemplate>(\n *   \"hwchase17/structured-chat-agent\"\n * );\n *\n * const llm = new ChatOpenAI({\n *   temperature: 0,\n *   model: \"gpt-3.5-turbo-1106\",\n * });\n *\n * const agent = await createStructuredChatAgent({\n *   llm,\n *   tools,\n *   prompt,\n * });\n *\n * const agentExecutor = new AgentExecutor({\n *   agent,\n *   tools,\n * });\n *\n * const result = await agentExecutor.invoke({\n *   input: \"what is LangChain?\",\n * });\n *\n * // With chat history\n * const result2 = await agentExecutor.invoke({\n *   input: \"what's my name?\",\n *   chat_history: [\n *     new HumanMessage(\"hi! my name is cob\"),\n *     new AIMessage(\"Hello Cob! How can I assist you today?\"),\n *   ],\n * });\n * ```\n */\nexport declare function createStructuredChatAgent({ llm, tools, prompt, streamRunnable }: CreateStructuredChatAgentParams): Promise<AgentRunnableSequence<{\n    steps: AgentStep[];\n}, import(\"@langchain/core/agents\").AgentAction | import(\"@langchain/core/agents\").AgentFinish>>;\n//# sourceMappingURL=index.d.ts.map"],"mappings":";;;;;;;;;;;;;;AAaA;AAgBA;AAKqBgB,UArBJF,8BAAAA,CAqBuB;EAGjBC;EAUSf,MAAAA,CAAAA,EAAAA,MAAAA;EAOWW;EAEnCE,MAAAA,CAAAA,EAAAA,MAAAA;EAQuBP;EAAcW,oBAAAA,CAAAA,EAAAA,MAAAA;EAMHjB;EAWXA,cAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAkCc;EAAiCT,aAAAA,CAAAA,EA1D9ED,yBA0D8EC,EAAAA;;;;;;AA/CjDG,KALrCO,wBAAAA,GAA2BR,QAKUC,CALDI,UAKCJ,EAAAA,cAAAA,CAAAA;AAAK;AA8DtD;;;AAIsCN,cAlEjBc,mBAAAA,SAA4BR,KAAAA,CAkEXN;EAK1BC,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAkB,YAAA,EAAA,MAAA,EAAA;EA+DNgB,WAAAA,CAAAA,KAAAA,EAnIDJ,wBAmI0B;EAAGK,UAAAA,CAAAA,CAAAA,EAAAA,6CAAAA;EAAKC,iBAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAOC,SAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAQC,KAAAA,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAkBL;;;;;EAAkCD,OAAAA,aAAAA,CAAAA,KAAAA,EAzH5FjB,uBAyH4FiB,EAAAA,CAAAA,EAAAA,IAAAA;EAAO;;;;;;yCAlHxFN;;MAEnCE;;;;;;;;6BAQuBP,cAAcW;;;;;;wCAMHjB;;;;;;;;;;;6BAWXA,kCAAkCc,iCAAiCT;;;;;;;;;;8BAUlEJ,mCAAmCD,kCAAkCc,iCAAiCL,YAAYO;;;;;KAKtIE,+BAAAA;;OAEHjB;;UAEGD,0BAA0BE;;;;;UAK1BC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+DYgB,yBAAAA;;;;;GAAkED,kCAAkCD,QAAQP;SACzHJ;GAASkB,uBAAAA,CACgBC,WAAAA,GAAWD,uBAAAA,CAAoCE"}

package/dist/agents/tool_calling/index.d.cts

@@ -1,6 +1,6 @@
 import { ToolsAgentStep } from "./output_parser.cjs";
 import { AgentRunnableSequence } from "../agent.cjs";
-import * as _langchain_core_agents5 from "@langchain/core/agents";
+import * as _langchain_core_agents3 from "@langchain/core/agents";
 import { ChatPromptTemplate } from "@langchain/core/prompts";
 import { LanguageModelLike, ToolDefinition } from "@langchain/core/language_models/base";
 import { StructuredToolInterface } from "@langchain/core/tools";
@@ -83,7 +83,7 @@ declare function createToolCallingAgent({
   streamRunnable
 }: CreateToolCallingAgentParams): AgentRunnableSequence<{
   steps: ToolsAgentStep[];
-}, _langchain_core_agents5.AgentFinish | _langchain_core_agents5.AgentAction[]>;
+}, _langchain_core_agents3.AgentFinish | _langchain_core_agents3.AgentAction[]>;
 //#endregion
 export { CreateToolCallingAgentParams, createToolCallingAgent };
 //# sourceMappingURL=index.d.cts.map

package/dist/agents/tool_calling/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":["ChatPromptTemplate","StructuredToolInterface","LanguageModelLike","ToolDefinition","AgentRunnableSequence","ToolsAgentStep","CreateToolCallingAgentParams","createToolCallingAgent","llm","tools","prompt","streamRunnable","_langchain_core_agents5","AgentFinish","AgentAction"],"sources":["../../../src/agents/tool_calling/index.d.ts"],"sourcesContent":["import { ChatPromptTemplate } from \"@langchain/core/prompts\";\nimport { StructuredToolInterface } from \"@langchain/core/tools\";\nimport { LanguageModelLike, ToolDefinition } from \"@langchain/core/language_models/base\";\nimport { AgentRunnableSequence } from \"../agent.js\";\nimport { ToolsAgentStep } from \"./output_parser.js\";\n/**\n * Params used by the createOpenAIToolsAgent function.\n */\nexport type CreateToolCallingAgentParams = {\n    /**\n     * LLM to use as the agent. Should work with OpenAI tool calling,\n     * so must either be an OpenAI model that supports that or a wrapper of\n     * a different model that adds in equivalent support.\n     */\n    llm: LanguageModelLike;\n    /** Tools this agent has access to. */\n    tools: StructuredToolInterface[] | ToolDefinition[];\n    /** The prompt to use, must have an input key of `agent_scratchpad`. */\n    prompt: ChatPromptTemplate;\n    /**\n     * Whether to invoke the underlying model in streaming mode,\n     * allowing streaming of intermediate steps. Defaults to true.\n     */\n    streamRunnable?: boolean;\n};\n/**\n * Create an agent that uses tools.\n * @param params Params required to create the agent. Includes an LLM, tools, and prompt.\n * @returns A runnable sequence representing an agent. It takes as input all the same input\n *     variables as the prompt passed in does. It returns as output either an\n *     AgentAction or AgentFinish.\n * @example\n * ```typescript\n * import { ChatAnthropic } from \"@langchain/anthropic\";\n * import { ChatPromptTemplate, MessagesPlaceholder } from \"@langchain/core/prompts\";\n * import { AgentExecutor, createToolCallingAgent } from \"langchain/agents\";\n *\n * const prompt = ChatPromptTemplate.fromMessages(\n *   [\n *     [\"system\", \"You are a helpful assistant\"],\n *     [\"placeholder\", \"{chat_history}\"],\n *     [\"human\", \"{input}\"],\n *     [\"placeholder\", \"{agent_scratchpad}\"],\n *   ]\n * );\n *\n *\n * const llm = new ChatAnthropic({\n *   modelName: \"claude-3-opus-20240229\",\n *   temperature: 0,\n * });\n *\n * // Define the tools the agent will have access to.\n * const tools = [...];\n *\n * const agent = createToolCallingAgent({ llm, tools, prompt });\n *\n * const agentExecutor = new AgentExecutor({ agent, tools });\n *\n * const result = await agentExecutor.invoke({input: \"what is LangChain?\"});\n *\n * // Using with chat history\n * import { AIMessage, HumanMessage } from \"@langchain/core/messages\";\n *\n * const result2 = await agentExecutor.invoke(\n *   {\n *     input: \"what's my name?\",\n *     chat_history: [\n *       new HumanMessage({content: \"hi! my name is bob\"}),\n *       new AIMessage({content: \"Hello Bob! How can I assist you today?\"}),\n *     ],\n *   }\n * );\n * ```\n */\nexport declare function createToolCallingAgent({ llm, tools, prompt, streamRunnable }: CreateToolCallingAgentParams): AgentRunnableSequence<{\n    steps: ToolsAgentStep[];\n}, import(\"@langchain/core/agents\").AgentFinish | import(\"@langchain/core/agents\").AgentAction[]>;\n//# sourceMappingURL=index.d.ts.map"],"mappings":";;;;;;;;;;;AAQYM,KAAAA,4BAAAA,GAA4B;EAM/BJ;;;;AAIqB;EAyDNK,GAAAA,EA7DfL,iBA6DeK;EAAyBC;EAAKC,KAAAA,EA3D3CR,uBA2D2CQ,EAAAA,GA3DfN,cA2DeM,EAAAA;EAAOC;EAAQC,MAAAA,EAzDzDX,kBAyDyDW;EAAkBL;;;;EAA+BF,cAAAA,CAAAA,EAAAA,OAAAA;AAAqB,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAnHG,sBAAAA;;;;;GAA+DD,+BAA+BF;SAC3GC;GAAcO,uBAAAA,CACWC,WAAAA,GAAWD,uBAAAA,CAAoCE,WAAAA"}
+{"version":3,"file":"index.d.cts","names":["ChatPromptTemplate","StructuredToolInterface","LanguageModelLike","ToolDefinition","AgentRunnableSequence","ToolsAgentStep","CreateToolCallingAgentParams","createToolCallingAgent","llm","tools","prompt","streamRunnable","_langchain_core_agents3","AgentFinish","AgentAction"],"sources":["../../../src/agents/tool_calling/index.d.ts"],"sourcesContent":["import { ChatPromptTemplate } from \"@langchain/core/prompts\";\nimport { StructuredToolInterface } from \"@langchain/core/tools\";\nimport { LanguageModelLike, ToolDefinition } from \"@langchain/core/language_models/base\";\nimport { AgentRunnableSequence } from \"../agent.js\";\nimport { ToolsAgentStep } from \"./output_parser.js\";\n/**\n * Params used by the createOpenAIToolsAgent function.\n */\nexport type CreateToolCallingAgentParams = {\n    /**\n     * LLM to use as the agent. Should work with OpenAI tool calling,\n     * so must either be an OpenAI model that supports that or a wrapper of\n     * a different model that adds in equivalent support.\n     */\n    llm: LanguageModelLike;\n    /** Tools this agent has access to. */\n    tools: StructuredToolInterface[] | ToolDefinition[];\n    /** The prompt to use, must have an input key of `agent_scratchpad`. */\n    prompt: ChatPromptTemplate;\n    /**\n     * Whether to invoke the underlying model in streaming mode,\n     * allowing streaming of intermediate steps. Defaults to true.\n     */\n    streamRunnable?: boolean;\n};\n/**\n * Create an agent that uses tools.\n * @param params Params required to create the agent. Includes an LLM, tools, and prompt.\n * @returns A runnable sequence representing an agent. It takes as input all the same input\n *     variables as the prompt passed in does. It returns as output either an\n *     AgentAction or AgentFinish.\n * @example\n * ```typescript\n * import { ChatAnthropic } from \"@langchain/anthropic\";\n * import { ChatPromptTemplate, MessagesPlaceholder } from \"@langchain/core/prompts\";\n * import { AgentExecutor, createToolCallingAgent } from \"langchain/agents\";\n *\n * const prompt = ChatPromptTemplate.fromMessages(\n *   [\n *     [\"system\", \"You are a helpful assistant\"],\n *     [\"placeholder\", \"{chat_history}\"],\n *     [\"human\", \"{input}\"],\n *     [\"placeholder\", \"{agent_scratchpad}\"],\n *   ]\n * );\n *\n *\n * const llm = new ChatAnthropic({\n *   modelName: \"claude-3-opus-20240229\",\n *   temperature: 0,\n * });\n *\n * // Define the tools the agent will have access to.\n * const tools = [...];\n *\n * const agent = createToolCallingAgent({ llm, tools, prompt });\n *\n * const agentExecutor = new AgentExecutor({ agent, tools });\n *\n * const result = await agentExecutor.invoke({input: \"what is LangChain?\"});\n *\n * // Using with chat history\n * import { AIMessage, HumanMessage } from \"@langchain/core/messages\";\n *\n * const result2 = await agentExecutor.invoke(\n *   {\n *     input: \"what's my name?\",\n *     chat_history: [\n *       new HumanMessage({content: \"hi! my name is bob\"}),\n *       new AIMessage({content: \"Hello Bob! How can I assist you today?\"}),\n *     ],\n *   }\n * );\n * ```\n */\nexport declare function createToolCallingAgent({ llm, tools, prompt, streamRunnable }: CreateToolCallingAgentParams): AgentRunnableSequence<{\n    steps: ToolsAgentStep[];\n}, import(\"@langchain/core/agents\").AgentFinish | import(\"@langchain/core/agents\").AgentAction[]>;\n//# sourceMappingURL=index.d.ts.map"],"mappings":";;;;;;;;;;;AAQYM,KAAAA,4BAAAA,GAA4B;EAM/BJ;;;;AAIqB;EAyDNK,GAAAA,EA7DfL,iBA6DeK;EAAyBC;EAAKC,KAAAA,EA3D3CR,uBA2D2CQ,EAAAA,GA3DfN,cA2DeM,EAAAA;EAAOC;EAAQC,MAAAA,EAzDzDX,kBAyDyDW;EAAkBL;;;;EAA+BF,cAAAA,CAAAA,EAAAA,OAAAA;AAAqB,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAnHG,sBAAAA;;;;;GAA+DD,+BAA+BF;SAC3GC;GAAcO,uBAAAA,CACWC,WAAAA,GAAWD,uBAAAA,CAAoCE,WAAAA"}

package/dist/agents/tool_calling/index.d.ts

@@ -3,7 +3,7 @@ import { AgentRunnableSequence } from "../agent.js";
 import { ChatPromptTemplate } from "@langchain/core/prompts";
 import { StructuredToolInterface } from "@langchain/core/tools";
 import { LanguageModelLike, ToolDefinition } from "@langchain/core/language_models/base";
-import * as _langchain_core_agents3 from "@langchain/core/agents";
+import * as _langchain_core_agents5 from "@langchain/core/agents";
 
 //#region src/agents/tool_calling/index.d.ts
 /**
@@ -83,7 +83,7 @@ declare function createToolCallingAgent({
   streamRunnable
 }: CreateToolCallingAgentParams): AgentRunnableSequence<{
   steps: ToolsAgentStep[];
-}, _langchain_core_agents3.AgentFinish | _langchain_core_agents3.AgentAction[]>;
+}, _langchain_core_agents5.AgentFinish | _langchain_core_agents5.AgentAction[]>;
 //#endregion
 export { CreateToolCallingAgentParams, createToolCallingAgent };
 //# sourceMappingURL=index.d.ts.map

package/dist/agents/tool_calling/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":["ChatPromptTemplate","StructuredToolInterface","LanguageModelLike","ToolDefinition","AgentRunnableSequence","ToolsAgentStep","CreateToolCallingAgentParams","createToolCallingAgent","llm","tools","prompt","streamRunnable","_langchain_core_agents3","AgentFinish","AgentAction"],"sources":["../../../src/agents/tool_calling/index.d.ts"],"sourcesContent":["import { ChatPromptTemplate } from \"@langchain/core/prompts\";\nimport { StructuredToolInterface } from \"@langchain/core/tools\";\nimport { LanguageModelLike, ToolDefinition } from \"@langchain/core/language_models/base\";\nimport { AgentRunnableSequence } from \"../agent.js\";\nimport { ToolsAgentStep } from \"./output_parser.js\";\n/**\n * Params used by the createOpenAIToolsAgent function.\n */\nexport type CreateToolCallingAgentParams = {\n    /**\n     * LLM to use as the agent. Should work with OpenAI tool calling,\n     * so must either be an OpenAI model that supports that or a wrapper of\n     * a different model that adds in equivalent support.\n     */\n    llm: LanguageModelLike;\n    /** Tools this agent has access to. */\n    tools: StructuredToolInterface[] | ToolDefinition[];\n    /** The prompt to use, must have an input key of `agent_scratchpad`. */\n    prompt: ChatPromptTemplate;\n    /**\n     * Whether to invoke the underlying model in streaming mode,\n     * allowing streaming of intermediate steps. Defaults to true.\n     */\n    streamRunnable?: boolean;\n};\n/**\n * Create an agent that uses tools.\n * @param params Params required to create the agent. Includes an LLM, tools, and prompt.\n * @returns A runnable sequence representing an agent. It takes as input all the same input\n *     variables as the prompt passed in does. It returns as output either an\n *     AgentAction or AgentFinish.\n * @example\n * ```typescript\n * import { ChatAnthropic } from \"@langchain/anthropic\";\n * import { ChatPromptTemplate, MessagesPlaceholder } from \"@langchain/core/prompts\";\n * import { AgentExecutor, createToolCallingAgent } from \"langchain/agents\";\n *\n * const prompt = ChatPromptTemplate.fromMessages(\n *   [\n *     [\"system\", \"You are a helpful assistant\"],\n *     [\"placeholder\", \"{chat_history}\"],\n *     [\"human\", \"{input}\"],\n *     [\"placeholder\", \"{agent_scratchpad}\"],\n *   ]\n * );\n *\n *\n * const llm = new ChatAnthropic({\n *   modelName: \"claude-3-opus-20240229\",\n *   temperature: 0,\n * });\n *\n * // Define the tools the agent will have access to.\n * const tools = [...];\n *\n * const agent = createToolCallingAgent({ llm, tools, prompt });\n *\n * const agentExecutor = new AgentExecutor({ agent, tools });\n *\n * const result = await agentExecutor.invoke({input: \"what is LangChain?\"});\n *\n * // Using with chat history\n * import { AIMessage, HumanMessage } from \"@langchain/core/messages\";\n *\n * const result2 = await agentExecutor.invoke(\n *   {\n *     input: \"what's my name?\",\n *     chat_history: [\n *       new HumanMessage({content: \"hi! my name is bob\"}),\n *       new AIMessage({content: \"Hello Bob! How can I assist you today?\"}),\n *     ],\n *   }\n * );\n * ```\n */\nexport declare function createToolCallingAgent({ llm, tools, prompt, streamRunnable }: CreateToolCallingAgentParams): AgentRunnableSequence<{\n    steps: ToolsAgentStep[];\n}, import(\"@langchain/core/agents\").AgentFinish | import(\"@langchain/core/agents\").AgentAction[]>;\n//# sourceMappingURL=index.d.ts.map"],"mappings":";;;;;;;;;;;AAQYM,KAAAA,4BAAAA,GAA4B;EAM/BJ;;;;AAIqB;EAyDNK,GAAAA,EA7DfL,iBA6DeK;EAAyBC;EAAKC,KAAAA,EA3D3CR,uBA2D2CQ,EAAAA,GA3DfN,cA2DeM,EAAAA;EAAOC;EAAQC,MAAAA,EAzDzDX,kBAyDyDW;EAAkBL;;;;EAA+BF,cAAAA,CAAAA,EAAAA,OAAAA;AAAqB,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAnHG,sBAAAA;;;;;GAA+DD,+BAA+BF;SAC3GC;GAAcO,uBAAAA,CACWC,WAAAA,GAAWD,uBAAAA,CAAoCE,WAAAA"}
+{"version":3,"file":"index.d.ts","names":["ChatPromptTemplate","StructuredToolInterface","LanguageModelLike","ToolDefinition","AgentRunnableSequence","ToolsAgentStep","CreateToolCallingAgentParams","createToolCallingAgent","llm","tools","prompt","streamRunnable","_langchain_core_agents5","AgentFinish","AgentAction"],"sources":["../../../src/agents/tool_calling/index.d.ts"],"sourcesContent":["import { ChatPromptTemplate } from \"@langchain/core/prompts\";\nimport { StructuredToolInterface } from \"@langchain/core/tools\";\nimport { LanguageModelLike, ToolDefinition } from \"@langchain/core/language_models/base\";\nimport { AgentRunnableSequence } from \"../agent.js\";\nimport { ToolsAgentStep } from \"./output_parser.js\";\n/**\n * Params used by the createOpenAIToolsAgent function.\n */\nexport type CreateToolCallingAgentParams = {\n    /**\n     * LLM to use as the agent. Should work with OpenAI tool calling,\n     * so must either be an OpenAI model that supports that or a wrapper of\n     * a different model that adds in equivalent support.\n     */\n    llm: LanguageModelLike;\n    /** Tools this agent has access to. */\n    tools: StructuredToolInterface[] | ToolDefinition[];\n    /** The prompt to use, must have an input key of `agent_scratchpad`. */\n    prompt: ChatPromptTemplate;\n    /**\n     * Whether to invoke the underlying model in streaming mode,\n     * allowing streaming of intermediate steps. Defaults to true.\n     */\n    streamRunnable?: boolean;\n};\n/**\n * Create an agent that uses tools.\n * @param params Params required to create the agent. Includes an LLM, tools, and prompt.\n * @returns A runnable sequence representing an agent. It takes as input all the same input\n *     variables as the prompt passed in does. It returns as output either an\n *     AgentAction or AgentFinish.\n * @example\n * ```typescript\n * import { ChatAnthropic } from \"@langchain/anthropic\";\n * import { ChatPromptTemplate, MessagesPlaceholder } from \"@langchain/core/prompts\";\n * import { AgentExecutor, createToolCallingAgent } from \"langchain/agents\";\n *\n * const prompt = ChatPromptTemplate.fromMessages(\n *   [\n *     [\"system\", \"You are a helpful assistant\"],\n *     [\"placeholder\", \"{chat_history}\"],\n *     [\"human\", \"{input}\"],\n *     [\"placeholder\", \"{agent_scratchpad}\"],\n *   ]\n * );\n *\n *\n * const llm = new ChatAnthropic({\n *   modelName: \"claude-3-opus-20240229\",\n *   temperature: 0,\n * });\n *\n * // Define the tools the agent will have access to.\n * const tools = [...];\n *\n * const agent = createToolCallingAgent({ llm, tools, prompt });\n *\n * const agentExecutor = new AgentExecutor({ agent, tools });\n *\n * const result = await agentExecutor.invoke({input: \"what is LangChain?\"});\n *\n * // Using with chat history\n * import { AIMessage, HumanMessage } from \"@langchain/core/messages\";\n *\n * const result2 = await agentExecutor.invoke(\n *   {\n *     input: \"what's my name?\",\n *     chat_history: [\n *       new HumanMessage({content: \"hi! my name is bob\"}),\n *       new AIMessage({content: \"Hello Bob! How can I assist you today?\"}),\n *     ],\n *   }\n * );\n * ```\n */\nexport declare function createToolCallingAgent({ llm, tools, prompt, streamRunnable }: CreateToolCallingAgentParams): AgentRunnableSequence<{\n    steps: ToolsAgentStep[];\n}, import(\"@langchain/core/agents\").AgentFinish | import(\"@langchain/core/agents\").AgentAction[]>;\n//# sourceMappingURL=index.d.ts.map"],"mappings":";;;;;;;;;;;AAQYM,KAAAA,4BAAAA,GAA4B;EAM/BJ;;;;AAIqB;EAyDNK,GAAAA,EA7DfL,iBA6DeK;EAAyBC;EAAKC,KAAAA,EA3D3CR,uBA2D2CQ,EAAAA,GA3DfN,cA2DeM,EAAAA;EAAOC;EAAQC,MAAAA,EAzDzDX,kBAyDyDW;EAAkBL;;;;EAA+BF,cAAAA,CAAAA,EAAAA,OAAAA;AAAqB,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAnHG,sBAAAA;;;;;GAA+DD,+BAA+BF;SAC3GC;GAAcO,uBAAAA,CACWC,WAAAA,GAAWD,uBAAAA,CAAoCE,WAAAA"}

package/dist/agents/toolkits/conversational_retrieval/token_buffer_memory.d.cts

@@ -1,5 +1,5 @@
 import { BaseChatMemory, BaseChatMemoryInput } from "../../../memory/chat_memory.cjs";
-import * as _langchain_core_messages0 from "@langchain/core/messages";
+import * as _langchain_core_messages2 from "@langchain/core/messages";
 import { InputValues, MemoryVariables, OutputValues } from "@langchain/core/memory";
 import { ChatOpenAI } from "@langchain/openai";
 
@@ -37,7 +37,7 @@ declare class OpenAIAgentTokenBufferMemory extends BaseChatMemory {
    * Retrieves the messages from the chat history.
    * @returns Promise that resolves with the messages from the chat history.
    */
-  getMessages(): Promise<_langchain_core_messages0.BaseMessage<_langchain_core_messages0.MessageStructure<_langchain_core_messages0.MessageToolSet>, _langchain_core_messages0.MessageType>[]>;
+  getMessages(): Promise<_langchain_core_messages2.BaseMessage<_langchain_core_messages2.MessageStructure<_langchain_core_messages2.MessageToolSet>, _langchain_core_messages2.MessageType>[]>;
   /**
    * Loads memory variables from the input values.
    * @param _values Input values.

package/dist/agents/toolkits/conversational_retrieval/token_buffer_memory.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"token_buffer_memory.d.cts","names":["ChatOpenAI","InputValues","MemoryVariables","OutputValues","BaseChatMemory","BaseChatMemoryInput","OpenAIAgentTokenBufferMemoryFields","OpenAIAgentTokenBufferMemory","_langchain_core_messages0","MessageToolSet","MessageStructure","MessageType","BaseMessage","Promise"],"sources":["../../../../src/agents/toolkits/conversational_retrieval/token_buffer_memory.d.ts"],"sourcesContent":["import { ChatOpenAI } from \"@langchain/openai\";\nimport { InputValues, MemoryVariables, OutputValues } from \"@langchain/core/memory\";\nimport { BaseChatMemory, BaseChatMemoryInput } from \"../../../memory/chat_memory.js\";\n/**\n * Type definition for the fields required to initialize an instance of\n * OpenAIAgentTokenBufferMemory.\n */\nexport type OpenAIAgentTokenBufferMemoryFields = BaseChatMemoryInput & {\n    llm: ChatOpenAI;\n    humanPrefix?: string;\n    aiPrefix?: string;\n    memoryKey?: string;\n    maxTokenLimit?: number;\n    returnMessages?: boolean;\n    outputKey?: string;\n    intermediateStepsKey?: string;\n};\n/**\n * Memory used to save agent output and intermediate steps.\n */\nexport declare class OpenAIAgentTokenBufferMemory extends BaseChatMemory {\n    humanPrefix: string;\n    aiPrefix: string;\n    llm: ChatOpenAI;\n    memoryKey: string;\n    maxTokenLimit: number;\n    returnMessages: boolean;\n    outputKey: string;\n    intermediateStepsKey: string;\n    constructor(fields: OpenAIAgentTokenBufferMemoryFields);\n    get memoryKeys(): string[];\n    /**\n     * Retrieves the messages from the chat history.\n     * @returns Promise that resolves with the messages from the chat history.\n     */\n    getMessages(): Promise<import(\"@langchain/core/messages\").BaseMessage<import(\"@langchain/core/messages\").MessageStructure<import(\"@langchain/core/messages\").MessageToolSet>, import(\"@langchain/core/messages\").MessageType>[]>;\n    /**\n     * Loads memory variables from the input values.\n     * @param _values Input values.\n     * @returns Promise that resolves with the loaded memory variables.\n     */\n    loadMemoryVariables(_values: InputValues): Promise<MemoryVariables>;\n    /**\n     * Saves the context of the chat, including user input, AI output, and\n     * intermediate steps. Prunes the chat history if the total token count\n     * exceeds the maximum limit.\n     * @param inputValues Input values.\n     * @param outputValues Output values.\n     * @returns Promise that resolves when the context has been saved.\n     */\n    saveContext(inputValues: InputValues, outputValues: OutputValues): Promise<void>;\n}\n//# sourceMappingURL=token_buffer_memory.d.ts.map"],"mappings":";;;;;;;;;;AAOA;AAaqBO,KAbTD,kCAAAA,GAAqCD,mBAaA,GAAA;EAGxCL,GAAAA,EAfAA,UAeAA;EAMeM,WAAAA,CAAAA,EAAAA,MAAAA;EAAkCE,QAAAA,CAAAA,EAAAA,MAAAA;EAMqHA,SAAAA,CAAAA,EAAAA,MAAAA;EAAlDA,aAAAA,CAAAA,EAAAA,MAAAA;EAAmGA,cAAAA,CAAAA,EAAAA,OAAlKI;EAA3CC,SAAAA,CAAAA,EAAAA,MAAAA;EAMcZ,oBAAAA,CAAAA,EAAAA,MAAAA;CAAsBC;;;;AASgBW,cA9BlDN,4BAAAA,SAAqCH,cAAAA,CA8BaS;EA9BbT,WAAAA,EAAAA,MAAAA;EAAc,QAAA,EAAA,MAAA;OAG/DJ;;;;;;sBAMeM;;;;;;iBAMLO,QAA6ML,yBAAAA,CAAlKI,YAAiHJ,yBAAAA,CAAlEE,iBANnDF,yBAAAA,CAMuGC,cAAAA,GAApCD,yBAAAA,CAAwFG,WAAAA;;;;;;+BAMpLV,cAAcY,QAAQX;;;;;;;;;2BAS1BD,2BAA2BE,eAAeU"}
+{"version":3,"file":"token_buffer_memory.d.cts","names":["ChatOpenAI","InputValues","MemoryVariables","OutputValues","BaseChatMemory","BaseChatMemoryInput","OpenAIAgentTokenBufferMemoryFields","OpenAIAgentTokenBufferMemory","_langchain_core_messages2","MessageToolSet","MessageStructure","MessageType","BaseMessage","Promise"],"sources":["../../../../src/agents/toolkits/conversational_retrieval/token_buffer_memory.d.ts"],"sourcesContent":["import { ChatOpenAI } from \"@langchain/openai\";\nimport { InputValues, MemoryVariables, OutputValues } from \"@langchain/core/memory\";\nimport { BaseChatMemory, BaseChatMemoryInput } from \"../../../memory/chat_memory.js\";\n/**\n * Type definition for the fields required to initialize an instance of\n * OpenAIAgentTokenBufferMemory.\n */\nexport type OpenAIAgentTokenBufferMemoryFields = BaseChatMemoryInput & {\n    llm: ChatOpenAI;\n    humanPrefix?: string;\n    aiPrefix?: string;\n    memoryKey?: string;\n    maxTokenLimit?: number;\n    returnMessages?: boolean;\n    outputKey?: string;\n    intermediateStepsKey?: string;\n};\n/**\n * Memory used to save agent output and intermediate steps.\n */\nexport declare class OpenAIAgentTokenBufferMemory extends BaseChatMemory {\n    humanPrefix: string;\n    aiPrefix: string;\n    llm: ChatOpenAI;\n    memoryKey: string;\n    maxTokenLimit: number;\n    returnMessages: boolean;\n    outputKey: string;\n    intermediateStepsKey: string;\n    constructor(fields: OpenAIAgentTokenBufferMemoryFields);\n    get memoryKeys(): string[];\n    /**\n     * Retrieves the messages from the chat history.\n     * @returns Promise that resolves with the messages from the chat history.\n     */\n    getMessages(): Promise<import(\"@langchain/core/messages\").BaseMessage<import(\"@langchain/core/messages\").MessageStructure<import(\"@langchain/core/messages\").MessageToolSet>, import(\"@langchain/core/messages\").MessageType>[]>;\n    /**\n     * Loads memory variables from the input values.\n     * @param _values Input values.\n     * @returns Promise that resolves with the loaded memory variables.\n     */\n    loadMemoryVariables(_values: InputValues): Promise<MemoryVariables>;\n    /**\n     * Saves the context of the chat, including user input, AI output, and\n     * intermediate steps. Prunes the chat history if the total token count\n     * exceeds the maximum limit.\n     * @param inputValues Input values.\n     * @param outputValues Output values.\n     * @returns Promise that resolves when the context has been saved.\n     */\n    saveContext(inputValues: InputValues, outputValues: OutputValues): Promise<void>;\n}\n//# sourceMappingURL=token_buffer_memory.d.ts.map"],"mappings":";;;;;;;;;;AAOA;AAaqBO,KAbTD,kCAAAA,GAAqCD,mBAaA,GAAA;EAGxCL,GAAAA,EAfAA,UAeAA;EAMeM,WAAAA,CAAAA,EAAAA,MAAAA;EAAkCE,QAAAA,CAAAA,EAAAA,MAAAA;EAMqHA,SAAAA,CAAAA,EAAAA,MAAAA;EAAlDA,aAAAA,CAAAA,EAAAA,MAAAA;EAAmGA,cAAAA,CAAAA,EAAAA,OAAlKI;EAA3CC,SAAAA,CAAAA,EAAAA,MAAAA;EAMcZ,oBAAAA,CAAAA,EAAAA,MAAAA;CAAsBC;;;;AASgBW,cA9BlDN,4BAAAA,SAAqCH,cAAAA,CA8BaS;EA9BbT,WAAAA,EAAAA,MAAAA;EAAc,QAAA,EAAA,MAAA;OAG/DJ;;;;;;sBAMeM;;;;;;iBAMLO,QAA6ML,yBAAAA,CAAlKI,YAAiHJ,yBAAAA,CAAlEE,iBANnDF,yBAAAA,CAMuGC,cAAAA,GAApCD,yBAAAA,CAAwFG,WAAAA;;;;;;+BAMpLV,cAAcY,QAAQX;;;;;;;;;2BAS1BD,2BAA2BE,eAAeU"}

package/dist/evaluation/agents/trajectory.d.cts

@@ -4,7 +4,7 @@ import { ChatGeneration, Generation } from "@langchain/core/outputs";
 import { BaseLLMOutputParser } from "@langchain/core/output_parsers";
 import { ChainValues } from "@langchain/core/utils/types";
 import { BasePromptTemplate } from "@langchain/core/prompts";
-import * as _langchain_core_prompt_values3 from "@langchain/core/prompt_values";
+import * as _langchain_core_prompt_values1 from "@langchain/core/prompt_values";
 import { BaseCallbackConfig, Callbacks } from "@langchain/core/callbacks/manager";
 import { StructuredToolInterface } from "@langchain/core/tools";
 import { BaseChatModel } from "@langchain/core/language_models/chat_models";
@@ -31,7 +31,7 @@ declare class TrajectoryEvalChain extends AgentTrajectoryEvaluator {
   requiresInput: boolean;
   requiresReference: boolean;
   outputParser: TrajectoryOutputParser;
-  static resolveTrajectoryPrompt(prompt?: BasePromptTemplate | undefined, agentTools?: StructuredToolInterface[]): BasePromptTemplate<any, _langchain_core_prompt_values3.BasePromptValueInterface, any>;
+  static resolveTrajectoryPrompt(prompt?: BasePromptTemplate | undefined, agentTools?: StructuredToolInterface[]): BasePromptTemplate<any, _langchain_core_prompt_values1.BasePromptValueInterface, any>;
   /**
    * Get the description of the agent tools.
    *

package/dist/evaluation/agents/trajectory.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"trajectory.d.cts","names":["StructuredToolInterface","BaseLLMOutputParser","AgentStep","ChainValues","ChatGeneration","Generation","BasePromptTemplate","Callbacks","BaseCallbackConfig","BaseChatModel","AgentTrajectoryEvaluator","EvalOutputType","LLMEvalChainInput","LLMTrajectoryEvaluatorArgs","ExtractLLMCallOptions","TrajectoryOutputParser","Promise","TrajectoryEvalChain","_langchain_core_prompt_values3","BasePromptValueInterface","Omit","Partial"],"sources":["../../../src/evaluation/agents/trajectory.d.ts"],"sourcesContent":["import type { StructuredToolInterface } from \"@langchain/core/tools\";\nimport { BaseLLMOutputParser } from \"@langchain/core/output_parsers\";\nimport { AgentStep } from \"@langchain/core/agents\";\nimport { ChainValues } from \"@langchain/core/utils/types\";\nimport { ChatGeneration, Generation } from \"@langchain/core/outputs\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { Callbacks, BaseCallbackConfig } from \"@langchain/core/callbacks/manager\";\nimport { BaseChatModel } from \"@langchain/core/language_models/chat_models\";\nimport { AgentTrajectoryEvaluator, EvalOutputType, LLMEvalChainInput, LLMTrajectoryEvaluatorArgs, type ExtractLLMCallOptions } from \"../base.js\";\n/**\n * A parser for the output of the TrajectoryEvalChain.\n */\nexport declare class TrajectoryOutputParser extends BaseLLMOutputParser<EvalOutputType> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    parseResult(generations: Generation[] | ChatGeneration[], _callbacks: Callbacks | undefined): Promise<EvalOutputType>;\n}\n/**\n * A chain for evaluating ReAct style agents.\n *\n * This chain is used to evaluate ReAct style agents by reasoning about\n * the sequence of actions taken and their outcomes.\n */\nexport declare class TrajectoryEvalChain extends AgentTrajectoryEvaluator {\n    static lc_name(): string;\n    criterionName?: string;\n    evaluationName?: string;\n    requiresInput: boolean;\n    requiresReference: boolean;\n    outputParser: TrajectoryOutputParser;\n    static resolveTrajectoryPrompt(prompt?: BasePromptTemplate | undefined, agentTools?: StructuredToolInterface[]): BasePromptTemplate<any, import(\"@langchain/core/prompt_values\").BasePromptValueInterface, any>;\n    /**\n     * Get the description of the agent tools.\n     *\n     * @returns The description of the agent tools.\n     */\n    static toolsDescription(agentTools: StructuredToolInterface[]): string;\n    /**\n     * Create a new TrajectoryEvalChain.\n     * @param llm\n     * @param agentTools - The tools used by the agent.\n     * @param chainOptions - The options for the chain.\n     */\n    static fromLLM(llm: BaseChatModel, agentTools?: StructuredToolInterface[], chainOptions?: Partial<Omit<LLMEvalChainInput, \"llm\">>): Promise<TrajectoryEvalChain>;\n    _prepareOutput(result: ChainValues): any;\n    /**\n     * Get the agent trajectory as a formatted string.\n     *\n     * @param steps - The agent trajectory.\n     * @returns The formatted agent trajectory.\n     */\n    getAgentTrajectory(steps: AgentStep[]): string;\n    formatReference(reference?: string): string;\n    _evaluateAgentTrajectory(args: LLMTrajectoryEvaluatorArgs, callOptions: ExtractLLMCallOptions<this[\"llm\"]>, config?: Callbacks | BaseCallbackConfig): Promise<ChainValues>;\n}\n//# sourceMappingURL=trajectory.d.ts.map"],"mappings":";;;;;;;;;;;;;;;AAYqBe,cAAAA,sBAAAA,SAA+Bd,mBAAT,CAA6BU,cAA7B,CAAA,CAAA;EAA6BA,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAG3CN,YAAAA,EAAAA,MAAAA,EAAAA;EAAeD,WAAAA,CAAAA,WAAAA,EAAfC,UAAeD,EAAAA,GAAAA,cAAAA,EAAAA,EAAAA,UAAAA,EAA8BG,SAA9BH,GAAAA,SAAAA,CAAAA,EAAsDY,OAAtDZ,CAA8DO,cAA9DP,CAAAA;;;;;AAH2B;AAWvE;;AAO4CE,cAPvBW,mBAAAA,SAA4BP,wBAAAA,CAOLJ;EAA6CN,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAuBkB,aAAAA,CAAAA,EAAAA,MAAAA;EAAKZ,cAAAA,CAAAA,EAAAA,MAAAA;EAM7EN,aAAAA,EAAAA,OAAAA;EAOhBS,iBAAAA,EAAAA,OAAAA;EAA4BT,YAAAA,EAdlCe,sBAckCf;EAAuDY,OAAAA,uBAAAA,CAAAA,MAAAA,CAAAA,EAb/DN,kBAa+DM,GAAAA,SAAAA,EAAAA,UAAAA,CAAAA,EAblBZ,uBAakBY,EAAAA,CAAAA,EAbUN,kBAaVM,CAAAA,GAAAA,EAbKM,8BAAAA,CAAqEC,wBAAAA,EAa1EP,GAAAA,CAAAA;EAALQ;;;;;EAQxElB,OAAAA,gBAAAA,CAAAA,UAAAA,EAfUF,uBAeVE,EAAAA,CAAAA,EAAAA,MAAAA;EAEKW;;;;;;EA9BcH,OAAAA,OAAAA,CAAAA,GAAAA,EAoBzBD,aApByBC,EAAAA,UAAAA,CAAAA,EAoBGV,uBApBHU,EAAAA,EAAAA,YAAAA,CAAAA,EAoB6CW,OApB7CX,CAoBqDU,IApBrDV,CAoB0DE,iBApB1DF,EAAAA,KAAAA,CAAAA,CAAAA,CAAAA,EAoBuFM,OApBvFN,CAoB+FO,mBApB/FP,CAAAA;EAAwB,cAAA,CAAA,MAAA,EAqB9CP,WArB8C,CAAA,EAAA,GAAA;;;;;;;4BA4B3CD;;iCAEKW,yCAAyCC,6CAA6CP,YAAYC,qBAAqBQ,QAAQb"}
+{"version":3,"file":"trajectory.d.cts","names":["StructuredToolInterface","BaseLLMOutputParser","AgentStep","ChainValues","ChatGeneration","Generation","BasePromptTemplate","Callbacks","BaseCallbackConfig","BaseChatModel","AgentTrajectoryEvaluator","EvalOutputType","LLMEvalChainInput","LLMTrajectoryEvaluatorArgs","ExtractLLMCallOptions","TrajectoryOutputParser","Promise","TrajectoryEvalChain","_langchain_core_prompt_values1","BasePromptValueInterface","Omit","Partial"],"sources":["../../../src/evaluation/agents/trajectory.d.ts"],"sourcesContent":["import type { StructuredToolInterface } from \"@langchain/core/tools\";\nimport { BaseLLMOutputParser } from \"@langchain/core/output_parsers\";\nimport { AgentStep } from \"@langchain/core/agents\";\nimport { ChainValues } from \"@langchain/core/utils/types\";\nimport { ChatGeneration, Generation } from \"@langchain/core/outputs\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { Callbacks, BaseCallbackConfig } from \"@langchain/core/callbacks/manager\";\nimport { BaseChatModel } from \"@langchain/core/language_models/chat_models\";\nimport { AgentTrajectoryEvaluator, EvalOutputType, LLMEvalChainInput, LLMTrajectoryEvaluatorArgs, type ExtractLLMCallOptions } from \"../base.js\";\n/**\n * A parser for the output of the TrajectoryEvalChain.\n */\nexport declare class TrajectoryOutputParser extends BaseLLMOutputParser<EvalOutputType> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    parseResult(generations: Generation[] | ChatGeneration[], _callbacks: Callbacks | undefined): Promise<EvalOutputType>;\n}\n/**\n * A chain for evaluating ReAct style agents.\n *\n * This chain is used to evaluate ReAct style agents by reasoning about\n * the sequence of actions taken and their outcomes.\n */\nexport declare class TrajectoryEvalChain extends AgentTrajectoryEvaluator {\n    static lc_name(): string;\n    criterionName?: string;\n    evaluationName?: string;\n    requiresInput: boolean;\n    requiresReference: boolean;\n    outputParser: TrajectoryOutputParser;\n    static resolveTrajectoryPrompt(prompt?: BasePromptTemplate | undefined, agentTools?: StructuredToolInterface[]): BasePromptTemplate<any, import(\"@langchain/core/prompt_values\").BasePromptValueInterface, any>;\n    /**\n     * Get the description of the agent tools.\n     *\n     * @returns The description of the agent tools.\n     */\n    static toolsDescription(agentTools: StructuredToolInterface[]): string;\n    /**\n     * Create a new TrajectoryEvalChain.\n     * @param llm\n     * @param agentTools - The tools used by the agent.\n     * @param chainOptions - The options for the chain.\n     */\n    static fromLLM(llm: BaseChatModel, agentTools?: StructuredToolInterface[], chainOptions?: Partial<Omit<LLMEvalChainInput, \"llm\">>): Promise<TrajectoryEvalChain>;\n    _prepareOutput(result: ChainValues): any;\n    /**\n     * Get the agent trajectory as a formatted string.\n     *\n     * @param steps - The agent trajectory.\n     * @returns The formatted agent trajectory.\n     */\n    getAgentTrajectory(steps: AgentStep[]): string;\n    formatReference(reference?: string): string;\n    _evaluateAgentTrajectory(args: LLMTrajectoryEvaluatorArgs, callOptions: ExtractLLMCallOptions<this[\"llm\"]>, config?: Callbacks | BaseCallbackConfig): Promise<ChainValues>;\n}\n//# sourceMappingURL=trajectory.d.ts.map"],"mappings":";;;;;;;;;;;;;;;AAYqBe,cAAAA,sBAAAA,SAA+Bd,mBAAT,CAA6BU,cAA7B,CAAA,CAAA;EAA6BA,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAG3CN,YAAAA,EAAAA,MAAAA,EAAAA;EAAeD,WAAAA,CAAAA,WAAAA,EAAfC,UAAeD,EAAAA,GAAAA,cAAAA,EAAAA,EAAAA,UAAAA,EAA8BG,SAA9BH,GAAAA,SAAAA,CAAAA,EAAsDY,OAAtDZ,CAA8DO,cAA9DP,CAAAA;;;;;AAH2B;AAWvE;;AAO4CE,cAPvBW,mBAAAA,SAA4BP,wBAAAA,CAOLJ;EAA6CN,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAuBkB,aAAAA,CAAAA,EAAAA,MAAAA;EAAKZ,cAAAA,CAAAA,EAAAA,MAAAA;EAM7EN,aAAAA,EAAAA,OAAAA;EAOhBS,iBAAAA,EAAAA,OAAAA;EAA4BT,YAAAA,EAdlCe,sBAckCf;EAAuDY,OAAAA,uBAAAA,CAAAA,MAAAA,CAAAA,EAb/DN,kBAa+DM,GAAAA,SAAAA,EAAAA,UAAAA,CAAAA,EAblBZ,uBAakBY,EAAAA,CAAAA,EAbUN,kBAaVM,CAAAA,GAAAA,EAbKM,8BAAAA,CAAqEC,wBAAAA,EAa1EP,GAAAA,CAAAA;EAALQ;;;;;EAQxElB,OAAAA,gBAAAA,CAAAA,UAAAA,EAfUF,uBAeVE,EAAAA,CAAAA,EAAAA,MAAAA;EAEKW;;;;;;EA9BcH,OAAAA,OAAAA,CAAAA,GAAAA,EAoBzBD,aApByBC,EAAAA,UAAAA,CAAAA,EAoBGV,uBApBHU,EAAAA,EAAAA,YAAAA,CAAAA,EAoB6CW,OApB7CX,CAoBqDU,IApBrDV,CAoB0DE,iBApB1DF,EAAAA,KAAAA,CAAAA,CAAAA,CAAAA,EAoBuFM,OApBvFN,CAoB+FO,mBApB/FP,CAAAA;EAAwB,cAAA,CAAA,MAAA,EAqB9CP,WArB8C,CAAA,EAAA,GAAA;;;;;;;4BA4B3CD;;iCAEKW,yCAAyCC,6CAA6CP,YAAYC,qBAAqBQ,QAAQb"}

package/dist/evaluation/agents/trajectory.d.ts

@@ -6,7 +6,7 @@ import { BaseCallbackConfig, Callbacks } from "@langchain/core/callbacks/manager
 import { BaseLLMOutputParser } from "@langchain/core/output_parsers";
 import { ChainValues } from "@langchain/core/utils/types";
 import { BaseChatModel } from "@langchain/core/language_models/chat_models";
-import * as _langchain_core_prompt_values1 from "@langchain/core/prompt_values";
+import * as _langchain_core_prompt_values3 from "@langchain/core/prompt_values";
 import { AgentStep } from "@langchain/core/agents";
 
 //#region src/evaluation/agents/trajectory.d.ts
@@ -31,7 +31,7 @@ declare class TrajectoryEvalChain extends AgentTrajectoryEvaluator {
   requiresInput: boolean;
   requiresReference: boolean;
   outputParser: TrajectoryOutputParser;
-  static resolveTrajectoryPrompt(prompt?: BasePromptTemplate | undefined, agentTools?: StructuredToolInterface[]): BasePromptTemplate<any, _langchain_core_prompt_values1.BasePromptValueInterface, any>;
+  static resolveTrajectoryPrompt(prompt?: BasePromptTemplate | undefined, agentTools?: StructuredToolInterface[]): BasePromptTemplate<any, _langchain_core_prompt_values3.BasePromptValueInterface, any>;
   /**
    * Get the description of the agent tools.
    *

package/dist/evaluation/agents/trajectory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"trajectory.d.ts","names":["StructuredToolInterface","BaseLLMOutputParser","AgentStep","ChainValues","ChatGeneration","Generation","BasePromptTemplate","Callbacks","BaseCallbackConfig","BaseChatModel","AgentTrajectoryEvaluator","EvalOutputType","LLMEvalChainInput","LLMTrajectoryEvaluatorArgs","ExtractLLMCallOptions","TrajectoryOutputParser","Promise","TrajectoryEvalChain","_langchain_core_prompt_values1","BasePromptValueInterface","Omit","Partial"],"sources":["../../../src/evaluation/agents/trajectory.d.ts"],"sourcesContent":["import type { StructuredToolInterface } from \"@langchain/core/tools\";\nimport { BaseLLMOutputParser } from \"@langchain/core/output_parsers\";\nimport { AgentStep } from \"@langchain/core/agents\";\nimport { ChainValues } from \"@langchain/core/utils/types\";\nimport { ChatGeneration, Generation } from \"@langchain/core/outputs\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { Callbacks, BaseCallbackConfig } from \"@langchain/core/callbacks/manager\";\nimport { BaseChatModel } from \"@langchain/core/language_models/chat_models\";\nimport { AgentTrajectoryEvaluator, EvalOutputType, LLMEvalChainInput, LLMTrajectoryEvaluatorArgs, type ExtractLLMCallOptions } from \"../base.js\";\n/**\n * A parser for the output of the TrajectoryEvalChain.\n */\nexport declare class TrajectoryOutputParser extends BaseLLMOutputParser<EvalOutputType> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    parseResult(generations: Generation[] | ChatGeneration[], _callbacks: Callbacks | undefined): Promise<EvalOutputType>;\n}\n/**\n * A chain for evaluating ReAct style agents.\n *\n * This chain is used to evaluate ReAct style agents by reasoning about\n * the sequence of actions taken and their outcomes.\n */\nexport declare class TrajectoryEvalChain extends AgentTrajectoryEvaluator {\n    static lc_name(): string;\n    criterionName?: string;\n    evaluationName?: string;\n    requiresInput: boolean;\n    requiresReference: boolean;\n    outputParser: TrajectoryOutputParser;\n    static resolveTrajectoryPrompt(prompt?: BasePromptTemplate | undefined, agentTools?: StructuredToolInterface[]): BasePromptTemplate<any, import(\"@langchain/core/prompt_values\").BasePromptValueInterface, any>;\n    /**\n     * Get the description of the agent tools.\n     *\n     * @returns The description of the agent tools.\n     */\n    static toolsDescription(agentTools: StructuredToolInterface[]): string;\n    /**\n     * Create a new TrajectoryEvalChain.\n     * @param llm\n     * @param agentTools - The tools used by the agent.\n     * @param chainOptions - The options for the chain.\n     */\n    static fromLLM(llm: BaseChatModel, agentTools?: StructuredToolInterface[], chainOptions?: Partial<Omit<LLMEvalChainInput, \"llm\">>): Promise<TrajectoryEvalChain>;\n    _prepareOutput(result: ChainValues): any;\n    /**\n     * Get the agent trajectory as a formatted string.\n     *\n     * @param steps - The agent trajectory.\n     * @returns The formatted agent trajectory.\n     */\n    getAgentTrajectory(steps: AgentStep[]): string;\n    formatReference(reference?: string): string;\n    _evaluateAgentTrajectory(args: LLMTrajectoryEvaluatorArgs, callOptions: ExtractLLMCallOptions<this[\"llm\"]>, config?: Callbacks | BaseCallbackConfig): Promise<ChainValues>;\n}\n//# sourceMappingURL=trajectory.d.ts.map"],"mappings":";;;;;;;;;;;;;;;AAYqBe,cAAAA,sBAAAA,SAA+Bd,mBAAT,CAA6BU,cAA7B,CAAA,CAAA;EAA6BA,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAG3CN,YAAAA,EAAAA,MAAAA,EAAAA;EAAeD,WAAAA,CAAAA,WAAAA,EAAfC,UAAeD,EAAAA,GAAAA,cAAAA,EAAAA,EAAAA,UAAAA,EAA8BG,SAA9BH,GAAAA,SAAAA,CAAAA,EAAsDY,OAAtDZ,CAA8DO,cAA9DP,CAAAA;;;;;AAH2B;AAWvE;;AAO4CE,cAPvBW,mBAAAA,SAA4BP,wBAAAA,CAOLJ;EAA6CN,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAuBkB,aAAAA,CAAAA,EAAAA,MAAAA;EAAKZ,cAAAA,CAAAA,EAAAA,MAAAA;EAM7EN,aAAAA,EAAAA,OAAAA;EAOhBS,iBAAAA,EAAAA,OAAAA;EAA4BT,YAAAA,EAdlCe,sBAckCf;EAAuDY,OAAAA,uBAAAA,CAAAA,MAAAA,CAAAA,EAb/DN,kBAa+DM,GAAAA,SAAAA,EAAAA,UAAAA,CAAAA,EAblBZ,uBAakBY,EAAAA,CAAAA,EAbUN,kBAaVM,CAAAA,GAAAA,EAbKM,8BAAAA,CAAqEC,wBAAAA,EAa1EP,GAAAA,CAAAA;EAALQ;;;;;EAQxElB,OAAAA,gBAAAA,CAAAA,UAAAA,EAfUF,uBAeVE,EAAAA,CAAAA,EAAAA,MAAAA;EAEKW;;;;;;EA9BcH,OAAAA,OAAAA,CAAAA,GAAAA,EAoBzBD,aApByBC,EAAAA,UAAAA,CAAAA,EAoBGV,uBApBHU,EAAAA,EAAAA,YAAAA,CAAAA,EAoB6CW,OApB7CX,CAoBqDU,IApBrDV,CAoB0DE,iBApB1DF,EAAAA,KAAAA,CAAAA,CAAAA,CAAAA,EAoBuFM,OApBvFN,CAoB+FO,mBApB/FP,CAAAA;EAAwB,cAAA,CAAA,MAAA,EAqB9CP,WArB8C,CAAA,EAAA,GAAA;;;;;;;4BA4B3CD;;iCAEKW,yCAAyCC,6CAA6CP,YAAYC,qBAAqBQ,QAAQb"}
+{"version":3,"file":"trajectory.d.ts","names":["StructuredToolInterface","BaseLLMOutputParser","AgentStep","ChainValues","ChatGeneration","Generation","BasePromptTemplate","Callbacks","BaseCallbackConfig","BaseChatModel","AgentTrajectoryEvaluator","EvalOutputType","LLMEvalChainInput","LLMTrajectoryEvaluatorArgs","ExtractLLMCallOptions","TrajectoryOutputParser","Promise","TrajectoryEvalChain","_langchain_core_prompt_values3","BasePromptValueInterface","Omit","Partial"],"sources":["../../../src/evaluation/agents/trajectory.d.ts"],"sourcesContent":["import type { StructuredToolInterface } from \"@langchain/core/tools\";\nimport { BaseLLMOutputParser } from \"@langchain/core/output_parsers\";\nimport { AgentStep } from \"@langchain/core/agents\";\nimport { ChainValues } from \"@langchain/core/utils/types\";\nimport { ChatGeneration, Generation } from \"@langchain/core/outputs\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { Callbacks, BaseCallbackConfig } from \"@langchain/core/callbacks/manager\";\nimport { BaseChatModel } from \"@langchain/core/language_models/chat_models\";\nimport { AgentTrajectoryEvaluator, EvalOutputType, LLMEvalChainInput, LLMTrajectoryEvaluatorArgs, type ExtractLLMCallOptions } from \"../base.js\";\n/**\n * A parser for the output of the TrajectoryEvalChain.\n */\nexport declare class TrajectoryOutputParser extends BaseLLMOutputParser<EvalOutputType> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    parseResult(generations: Generation[] | ChatGeneration[], _callbacks: Callbacks | undefined): Promise<EvalOutputType>;\n}\n/**\n * A chain for evaluating ReAct style agents.\n *\n * This chain is used to evaluate ReAct style agents by reasoning about\n * the sequence of actions taken and their outcomes.\n */\nexport declare class TrajectoryEvalChain extends AgentTrajectoryEvaluator {\n    static lc_name(): string;\n    criterionName?: string;\n    evaluationName?: string;\n    requiresInput: boolean;\n    requiresReference: boolean;\n    outputParser: TrajectoryOutputParser;\n    static resolveTrajectoryPrompt(prompt?: BasePromptTemplate | undefined, agentTools?: StructuredToolInterface[]): BasePromptTemplate<any, import(\"@langchain/core/prompt_values\").BasePromptValueInterface, any>;\n    /**\n     * Get the description of the agent tools.\n     *\n     * @returns The description of the agent tools.\n     */\n    static toolsDescription(agentTools: StructuredToolInterface[]): string;\n    /**\n     * Create a new TrajectoryEvalChain.\n     * @param llm\n     * @param agentTools - The tools used by the agent.\n     * @param chainOptions - The options for the chain.\n     */\n    static fromLLM(llm: BaseChatModel, agentTools?: StructuredToolInterface[], chainOptions?: Partial<Omit<LLMEvalChainInput, \"llm\">>): Promise<TrajectoryEvalChain>;\n    _prepareOutput(result: ChainValues): any;\n    /**\n     * Get the agent trajectory as a formatted string.\n     *\n     * @param steps - The agent trajectory.\n     * @returns The formatted agent trajectory.\n     */\n    getAgentTrajectory(steps: AgentStep[]): string;\n    formatReference(reference?: string): string;\n    _evaluateAgentTrajectory(args: LLMTrajectoryEvaluatorArgs, callOptions: ExtractLLMCallOptions<this[\"llm\"]>, config?: Callbacks | BaseCallbackConfig): Promise<ChainValues>;\n}\n//# sourceMappingURL=trajectory.d.ts.map"],"mappings":";;;;;;;;;;;;;;;AAYqBe,cAAAA,sBAAAA,SAA+Bd,mBAAT,CAA6BU,cAA7B,CAAA,CAAA;EAA6BA,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAG3CN,YAAAA,EAAAA,MAAAA,EAAAA;EAAeD,WAAAA,CAAAA,WAAAA,EAAfC,UAAeD,EAAAA,GAAAA,cAAAA,EAAAA,EAAAA,UAAAA,EAA8BG,SAA9BH,GAAAA,SAAAA,CAAAA,EAAsDY,OAAtDZ,CAA8DO,cAA9DP,CAAAA;;;;;AAH2B;AAWvE;;AAO4CE,cAPvBW,mBAAAA,SAA4BP,wBAAAA,CAOLJ;EAA6CN,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAuBkB,aAAAA,CAAAA,EAAAA,MAAAA;EAAKZ,cAAAA,CAAAA,EAAAA,MAAAA;EAM7EN,aAAAA,EAAAA,OAAAA;EAOhBS,iBAAAA,EAAAA,OAAAA;EAA4BT,YAAAA,EAdlCe,sBAckCf;EAAuDY,OAAAA,uBAAAA,CAAAA,MAAAA,CAAAA,EAb/DN,kBAa+DM,GAAAA,SAAAA,EAAAA,UAAAA,CAAAA,EAblBZ,uBAakBY,EAAAA,CAAAA,EAbUN,kBAaVM,CAAAA,GAAAA,EAbKM,8BAAAA,CAAqEC,wBAAAA,EAa1EP,GAAAA,CAAAA;EAALQ;;;;;EAQxElB,OAAAA,gBAAAA,CAAAA,UAAAA,EAfUF,uBAeVE,EAAAA,CAAAA,EAAAA,MAAAA;EAEKW;;;;;;EA9BcH,OAAAA,OAAAA,CAAAA,GAAAA,EAoBzBD,aApByBC,EAAAA,UAAAA,CAAAA,EAoBGV,uBApBHU,EAAAA,EAAAA,YAAAA,CAAAA,EAoB6CW,OApB7CX,CAoBqDU,IApBrDV,CAoB0DE,iBApB1DF,EAAAA,KAAAA,CAAAA,CAAAA,CAAAA,EAoBuFM,OApBvFN,CAoB+FO,mBApB/FP,CAAAA;EAAwB,cAAA,CAAA,MAAA,EAqB9CP,WArB8C,CAAA,EAAA,GAAA;;;;;;;4BA4B3CD;;iCAEKW,yCAAyCC,6CAA6CP,YAAYC,qBAAqBQ,QAAQb"}

package/dist/evaluation/comparison/pairwise.d.cts

@@ -5,7 +5,7 @@ import { BaseLLMOutputParser } from "@langchain/core/output_parsers";
 import { ChainValues } from "@langchain/core/utils/types";
 import { BasePromptTemplate } from "@langchain/core/prompts";
 import { BaseLanguageModelInterface } from "@langchain/core/language_models/base";
-import * as _langchain_core_prompt_values1 from "@langchain/core/prompt_values";
+import * as _langchain_core_prompt_values4 from "@langchain/core/prompt_values";
 import { BaseCallbackConfig, Callbacks } from "@langchain/core/callbacks/manager";
 
 //#region src/evaluation/comparison/pairwise.d.ts
@@ -30,7 +30,7 @@ declare class PairwiseStringEvalChain extends LLMPairwiseStringEvaluator {
   skipReferenceWarning: string;
   outputParser: PairwiseStringResultOutputParser;
   static resolvePairwiseCriteria(criteria?: CriteriaLike): Record<string, string>;
-  static resolvePairwisePrompt(prompt?: BasePromptTemplate): BasePromptTemplate<any, _langchain_core_prompt_values1.BasePromptValueInterface, any>;
+  static resolvePairwisePrompt(prompt?: BasePromptTemplate): BasePromptTemplate<any, _langchain_core_prompt_values4.BasePromptValueInterface, any>;
   /**
    * Create a new instance of the PairwiseStringEvalChain.
    * @param llm
@@ -49,7 +49,7 @@ declare class PairwiseStringEvalChain extends LLMPairwiseStringEvaluator {
 declare class LabeledPairwiseStringEvalChain extends PairwiseStringEvalChain {
   static lc_name(): string;
   requiresReference: boolean;
-  static resolvePairwisePrompt(prompt?: BasePromptTemplate): BasePromptTemplate<any, _langchain_core_prompt_values1.BasePromptValueInterface, any>;
+  static resolvePairwisePrompt(prompt?: BasePromptTemplate): BasePromptTemplate<any, _langchain_core_prompt_values4.BasePromptValueInterface, any>;
 }
 //#endregion
 export { LabeledPairwiseStringEvalChain, PairwiseStringEvalChain, PairwiseStringResultOutputParser };

package/dist/evaluation/comparison/pairwise.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"pairwise.d.cts","names":["BaseLanguageModelInterface","BaseLLMOutputParser","ChainValues","ChatGeneration","Generation","BasePromptTemplate","Callbacks","BaseCallbackConfig","EvalOutputType","LLMEvalChainInput","LLMPairwiseStringEvaluator","LLMPairwiseStringEvaluatorArgs","ExtractLLMCallOptions","CriteriaLike","PairwiseStringResultOutputParser","Promise","PairwiseStringEvalChain","Record","_langchain_core_prompt_values1","BasePromptValueInterface","Omit","Partial","LabeledPairwiseStringEvalChain"],"sources":["../../../src/evaluation/comparison/pairwise.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { BaseLLMOutputParser } from \"@langchain/core/output_parsers\";\nimport { ChainValues } from \"@langchain/core/utils/types\";\nimport { ChatGeneration, Generation } from \"@langchain/core/outputs\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { Callbacks, BaseCallbackConfig } from \"@langchain/core/callbacks/manager\";\nimport { EvalOutputType, LLMEvalChainInput, LLMPairwiseStringEvaluator, LLMPairwiseStringEvaluatorArgs, type ExtractLLMCallOptions } from \"../base.js\";\nimport { CriteriaLike } from \"../criteria/criteria.js\";\n/**\n * A parser for the output of the PairwiseStringEvalChain.\n */\nexport declare class PairwiseStringResultOutputParser extends BaseLLMOutputParser<EvalOutputType> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    parseResult(generations: Generation[] | ChatGeneration[], _callbacks: Callbacks | undefined): Promise<EvalOutputType>;\n}\n/**\n * A chain for comparing two outputs, such as the outputs\n * of two models, prompts, or outputs of a single model on similar inputs.\n */\nexport declare class PairwiseStringEvalChain extends LLMPairwiseStringEvaluator {\n    static lc_name(): string;\n    criterionName?: string;\n    evaluationName?: string;\n    requiresInput: boolean;\n    requiresReference: boolean;\n    skipReferenceWarning: string;\n    outputParser: PairwiseStringResultOutputParser;\n    static resolvePairwiseCriteria(criteria?: CriteriaLike): Record<string, string>;\n    static resolvePairwisePrompt(prompt?: BasePromptTemplate): BasePromptTemplate<any, import(\"@langchain/core/prompt_values\").BasePromptValueInterface, any>;\n    /**\n     * Create a new instance of the PairwiseStringEvalChain.\n     * @param llm\n     * @param criteria The criteria to use for evaluation.\n     * @param chainOptions Options to pass to the chain.\n     */\n    static fromLLM(llm: BaseLanguageModelInterface, criteria?: CriteriaLike, chainOptions?: Partial<Omit<LLMEvalChainInput, \"llm\">>): Promise<PairwiseStringEvalChain>;\n    _prepareOutput(result: ChainValues): any;\n    _evaluateStringPairs(args: LLMPairwiseStringEvaluatorArgs, callOptions: ExtractLLMCallOptions<this[\"llm\"]>, config?: Callbacks | BaseCallbackConfig): Promise<ChainValues>;\n}\n/**\n * A chain for comparing two outputs, such as the outputs\n * of two models, prompts, or outputs of a single model on similar inputs,\n * with labeled preferences.\n */\nexport declare class LabeledPairwiseStringEvalChain extends PairwiseStringEvalChain {\n    static lc_name(): string;\n    requiresReference: boolean;\n    static resolvePairwisePrompt(prompt?: BasePromptTemplate): BasePromptTemplate<any, import(\"@langchain/core/prompt_values\").BasePromptValueInterface, any>;\n}\n//# sourceMappingURL=pairwise.d.ts.map"],"mappings":";;;;;;;;;;;;;;AAWqBc,cAAAA,gCAAAA,SAAyCb,mBAAT,CAA6BO,cAA7B,CAAA,CAAA;EAA6BA,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAGrDJ,YAAAA,EAAAA,MAAAA,EAAAA;EAAeD,WAAAA,CAAAA,WAAAA,EAAfC,UAAeD,EAAAA,GAAAA,cAAAA,EAAAA,EAAAA,UAAAA,EAA8BG,SAA9BH,GAAAA,SAAAA,CAAAA,EAAsDY,OAAtDZ,CAA8DK,cAA9DL,CAAAA;;;;;AAHqC;AAS5Da,cAAAA,uBAAAA,SAAgCN,0BAAAA,CAAT;EAO1BI,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAC4BD,aAAAA,CAAAA,EAAAA,MAAAA;EAAeI,cAAAA,CAAAA,EAAAA,MAAAA;EACnBZ,aAAAA,EAAAA,OAAAA;EAAkBa,iBAAAA,EAAAA,OAAAA;EAAGb,oBAAAA,EAAAA,MAAAA;EAOvCL,YAAAA,EATNc,gCASMd;EAAuCa,OAAAA,uBAAAA,CAAAA,QAAAA,CAAAA,EARjBA,YAQiBA,CAAAA,EARFI,MAQEJ,CAAAA,MAAAA,EAAAA,MAAAA,CAAAA;EAA0CJ,OAAAA,qBAAAA,CAAAA,MAAAA,CAAAA,EAP/DJ,kBAO+DI,CAAAA,EAP1CJ,kBAO0CI,CAAAA,GAAAA,EAP7CS,8BAAAA,CAAmEC,wBAAAA,EAOtBV,GAAAA,CAAAA;EAALW;;;;;;EAExBR,OAAAA,OAAAA,CAAAA,GAAAA,EAFpDZ,0BAEoDY,EAAAA,QAAAA,CAAAA,EAFbC,YAEaD,EAAAA,YAAAA,CAAAA,EAFgBS,OAEhBT,CAFwBQ,IAExBR,CAF6BH,iBAE7BG,EAAAA,KAAAA,CAAAA,CAAAA,CAAAA,EAF0DG,OAE1DH,CAFkEI,uBAElEJ,CAAAA;EAA6CN,cAAAA,CAAAA,MAAAA,EAD9FJ,WAC8FI,CAAAA,EAAAA,GAAAA;EAAYC,oBAAAA,CAAAA,IAAAA,EAAtGI,8BAAsGJ,EAAAA,WAAAA,EAAzDK,qBAAyDL,CAAAA,IAAAA,CAAAA,KAAAA,CAAAA,CAAAA,EAAAA,MAAAA,CAAAA,EAAZD,SAAYC,GAAAA,kBAAAA,CAAAA,EAAqBQ,OAArBR,CAA6BL,WAA7BK,CAAAA;;;;AAlBtD;AAyB/E;;AAG4DW,cAHvCI,8BAAAA,SAAuCN,uBAAAA,CAGmEG;EAAhEd,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAHHW,iBAAAA,EAAAA,OAAAA;EAAuB,OAAA,qBAAA,CAAA,MAAA,CAAA,EAGzCX,kBAHyC,CAAA,EAGpBA,kBAHoB,CAAA,GAAA,EAGvBa,8BAAAA,CAAmEC,wBAAAA,EAH5C,GAAA,CAAA"}
+{"version":3,"file":"pairwise.d.cts","names":["BaseLanguageModelInterface","BaseLLMOutputParser","ChainValues","ChatGeneration","Generation","BasePromptTemplate","Callbacks","BaseCallbackConfig","EvalOutputType","LLMEvalChainInput","LLMPairwiseStringEvaluator","LLMPairwiseStringEvaluatorArgs","ExtractLLMCallOptions","CriteriaLike","PairwiseStringResultOutputParser","Promise","PairwiseStringEvalChain","Record","_langchain_core_prompt_values4","BasePromptValueInterface","Omit","Partial","LabeledPairwiseStringEvalChain"],"sources":["../../../src/evaluation/comparison/pairwise.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { BaseLLMOutputParser } from \"@langchain/core/output_parsers\";\nimport { ChainValues } from \"@langchain/core/utils/types\";\nimport { ChatGeneration, Generation } from \"@langchain/core/outputs\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { Callbacks, BaseCallbackConfig } from \"@langchain/core/callbacks/manager\";\nimport { EvalOutputType, LLMEvalChainInput, LLMPairwiseStringEvaluator, LLMPairwiseStringEvaluatorArgs, type ExtractLLMCallOptions } from \"../base.js\";\nimport { CriteriaLike } from \"../criteria/criteria.js\";\n/**\n * A parser for the output of the PairwiseStringEvalChain.\n */\nexport declare class PairwiseStringResultOutputParser extends BaseLLMOutputParser<EvalOutputType> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    parseResult(generations: Generation[] | ChatGeneration[], _callbacks: Callbacks | undefined): Promise<EvalOutputType>;\n}\n/**\n * A chain for comparing two outputs, such as the outputs\n * of two models, prompts, or outputs of a single model on similar inputs.\n */\nexport declare class PairwiseStringEvalChain extends LLMPairwiseStringEvaluator {\n    static lc_name(): string;\n    criterionName?: string;\n    evaluationName?: string;\n    requiresInput: boolean;\n    requiresReference: boolean;\n    skipReferenceWarning: string;\n    outputParser: PairwiseStringResultOutputParser;\n    static resolvePairwiseCriteria(criteria?: CriteriaLike): Record<string, string>;\n    static resolvePairwisePrompt(prompt?: BasePromptTemplate): BasePromptTemplate<any, import(\"@langchain/core/prompt_values\").BasePromptValueInterface, any>;\n    /**\n     * Create a new instance of the PairwiseStringEvalChain.\n     * @param llm\n     * @param criteria The criteria to use for evaluation.\n     * @param chainOptions Options to pass to the chain.\n     */\n    static fromLLM(llm: BaseLanguageModelInterface, criteria?: CriteriaLike, chainOptions?: Partial<Omit<LLMEvalChainInput, \"llm\">>): Promise<PairwiseStringEvalChain>;\n    _prepareOutput(result: ChainValues): any;\n    _evaluateStringPairs(args: LLMPairwiseStringEvaluatorArgs, callOptions: ExtractLLMCallOptions<this[\"llm\"]>, config?: Callbacks | BaseCallbackConfig): Promise<ChainValues>;\n}\n/**\n * A chain for comparing two outputs, such as the outputs\n * of two models, prompts, or outputs of a single model on similar inputs,\n * with labeled preferences.\n */\nexport declare class LabeledPairwiseStringEvalChain extends PairwiseStringEvalChain {\n    static lc_name(): string;\n    requiresReference: boolean;\n    static resolvePairwisePrompt(prompt?: BasePromptTemplate): BasePromptTemplate<any, import(\"@langchain/core/prompt_values\").BasePromptValueInterface, any>;\n}\n//# sourceMappingURL=pairwise.d.ts.map"],"mappings":";;;;;;;;;;;;;;AAWqBc,cAAAA,gCAAAA,SAAyCb,mBAAT,CAA6BO,cAA7B,CAAA,CAAA;EAA6BA,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAGrDJ,YAAAA,EAAAA,MAAAA,EAAAA;EAAeD,WAAAA,CAAAA,WAAAA,EAAfC,UAAeD,EAAAA,GAAAA,cAAAA,EAAAA,EAAAA,UAAAA,EAA8BG,SAA9BH,GAAAA,SAAAA,CAAAA,EAAsDY,OAAtDZ,CAA8DK,cAA9DL,CAAAA;;;;;AAHqC;AAS5Da,cAAAA,uBAAAA,SAAgCN,0BAAAA,CAAT;EAO1BI,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAC4BD,aAAAA,CAAAA,EAAAA,MAAAA;EAAeI,cAAAA,CAAAA,EAAAA,MAAAA;EACnBZ,aAAAA,EAAAA,OAAAA;EAAkBa,iBAAAA,EAAAA,OAAAA;EAAGb,oBAAAA,EAAAA,MAAAA;EAOvCL,YAAAA,EATNc,gCASMd;EAAuCa,OAAAA,uBAAAA,CAAAA,QAAAA,CAAAA,EARjBA,YAQiBA,CAAAA,EARFI,MAQEJ,CAAAA,MAAAA,EAAAA,MAAAA,CAAAA;EAA0CJ,OAAAA,qBAAAA,CAAAA,MAAAA,CAAAA,EAP/DJ,kBAO+DI,CAAAA,EAP1CJ,kBAO0CI,CAAAA,GAAAA,EAP7CS,8BAAAA,CAAmEC,wBAAAA,EAOtBV,GAAAA,CAAAA;EAALW;;;;;;EAExBR,OAAAA,OAAAA,CAAAA,GAAAA,EAFpDZ,0BAEoDY,EAAAA,QAAAA,CAAAA,EAFbC,YAEaD,EAAAA,YAAAA,CAAAA,EAFgBS,OAEhBT,CAFwBQ,IAExBR,CAF6BH,iBAE7BG,EAAAA,KAAAA,CAAAA,CAAAA,CAAAA,EAF0DG,OAE1DH,CAFkEI,uBAElEJ,CAAAA;EAA6CN,cAAAA,CAAAA,MAAAA,EAD9FJ,WAC8FI,CAAAA,EAAAA,GAAAA;EAAYC,oBAAAA,CAAAA,IAAAA,EAAtGI,8BAAsGJ,EAAAA,WAAAA,EAAzDK,qBAAyDL,CAAAA,IAAAA,CAAAA,KAAAA,CAAAA,CAAAA,EAAAA,MAAAA,CAAAA,EAAZD,SAAYC,GAAAA,kBAAAA,CAAAA,EAAqBQ,OAArBR,CAA6BL,WAA7BK,CAAAA;;;;AAlBtD;AAyB/E;;AAG4DW,cAHvCI,8BAAAA,SAAuCN,uBAAAA,CAGmEG;EAAhEd,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAHHW,iBAAAA,EAAAA,OAAAA;EAAuB,OAAA,qBAAA,CAAA,MAAA,CAAA,EAGzCX,kBAHyC,CAAA,EAGpBA,kBAHoB,CAAA,GAAA,EAGvBa,8BAAAA,CAAmEC,wBAAAA,EAH5C,GAAA,CAAA"}

package/dist/evaluation/comparison/pairwise.d.ts

@@ -6,7 +6,7 @@ import { ChatGeneration, Generation } from "@langchain/core/outputs";
 import { BaseCallbackConfig, Callbacks } from "@langchain/core/callbacks/manager";
 import { BaseLLMOutputParser } from "@langchain/core/output_parsers";
 import { ChainValues } from "@langchain/core/utils/types";
-import * as _langchain_core_prompt_values4 from "@langchain/core/prompt_values";
+import * as _langchain_core_prompt_values1 from "@langchain/core/prompt_values";
 
 //#region src/evaluation/comparison/pairwise.d.ts
 /**
@@ -30,7 +30,7 @@ declare class PairwiseStringEvalChain extends LLMPairwiseStringEvaluator {
   skipReferenceWarning: string;
   outputParser: PairwiseStringResultOutputParser;
   static resolvePairwiseCriteria(criteria?: CriteriaLike): Record<string, string>;
-  static resolvePairwisePrompt(prompt?: BasePromptTemplate): BasePromptTemplate<any, _langchain_core_prompt_values4.BasePromptValueInterface, any>;
+  static resolvePairwisePrompt(prompt?: BasePromptTemplate): BasePromptTemplate<any, _langchain_core_prompt_values1.BasePromptValueInterface, any>;
   /**
    * Create a new instance of the PairwiseStringEvalChain.
    * @param llm
@@ -49,7 +49,7 @@ declare class PairwiseStringEvalChain extends LLMPairwiseStringEvaluator {
 declare class LabeledPairwiseStringEvalChain extends PairwiseStringEvalChain {
   static lc_name(): string;
   requiresReference: boolean;
-  static resolvePairwisePrompt(prompt?: BasePromptTemplate): BasePromptTemplate<any, _langchain_core_prompt_values4.BasePromptValueInterface, any>;
+  static resolvePairwisePrompt(prompt?: BasePromptTemplate): BasePromptTemplate<any, _langchain_core_prompt_values1.BasePromptValueInterface, any>;
 }
 //#endregion
 export { LabeledPairwiseStringEvalChain, PairwiseStringEvalChain, PairwiseStringResultOutputParser };

package/dist/evaluation/comparison/pairwise.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pairwise.d.ts","names":["BaseLanguageModelInterface","BaseLLMOutputParser","ChainValues","ChatGeneration","Generation","BasePromptTemplate","Callbacks","BaseCallbackConfig","EvalOutputType","LLMEvalChainInput","LLMPairwiseStringEvaluator","LLMPairwiseStringEvaluatorArgs","ExtractLLMCallOptions","CriteriaLike","PairwiseStringResultOutputParser","Promise","PairwiseStringEvalChain","Record","_langchain_core_prompt_values4","BasePromptValueInterface","Omit","Partial","LabeledPairwiseStringEvalChain"],"sources":["../../../src/evaluation/comparison/pairwise.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { BaseLLMOutputParser } from \"@langchain/core/output_parsers\";\nimport { ChainValues } from \"@langchain/core/utils/types\";\nimport { ChatGeneration, Generation } from \"@langchain/core/outputs\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { Callbacks, BaseCallbackConfig } from \"@langchain/core/callbacks/manager\";\nimport { EvalOutputType, LLMEvalChainInput, LLMPairwiseStringEvaluator, LLMPairwiseStringEvaluatorArgs, type ExtractLLMCallOptions } from \"../base.js\";\nimport { CriteriaLike } from \"../criteria/criteria.js\";\n/**\n * A parser for the output of the PairwiseStringEvalChain.\n */\nexport declare class PairwiseStringResultOutputParser extends BaseLLMOutputParser<EvalOutputType> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    parseResult(generations: Generation[] | ChatGeneration[], _callbacks: Callbacks | undefined): Promise<EvalOutputType>;\n}\n/**\n * A chain for comparing two outputs, such as the outputs\n * of two models, prompts, or outputs of a single model on similar inputs.\n */\nexport declare class PairwiseStringEvalChain extends LLMPairwiseStringEvaluator {\n    static lc_name(): string;\n    criterionName?: string;\n    evaluationName?: string;\n    requiresInput: boolean;\n    requiresReference: boolean;\n    skipReferenceWarning: string;\n    outputParser: PairwiseStringResultOutputParser;\n    static resolvePairwiseCriteria(criteria?: CriteriaLike): Record<string, string>;\n    static resolvePairwisePrompt(prompt?: BasePromptTemplate): BasePromptTemplate<any, import(\"@langchain/core/prompt_values\").BasePromptValueInterface, any>;\n    /**\n     * Create a new instance of the PairwiseStringEvalChain.\n     * @param llm\n     * @param criteria The criteria to use for evaluation.\n     * @param chainOptions Options to pass to the chain.\n     */\n    static fromLLM(llm: BaseLanguageModelInterface, criteria?: CriteriaLike, chainOptions?: Partial<Omit<LLMEvalChainInput, \"llm\">>): Promise<PairwiseStringEvalChain>;\n    _prepareOutput(result: ChainValues): any;\n    _evaluateStringPairs(args: LLMPairwiseStringEvaluatorArgs, callOptions: ExtractLLMCallOptions<this[\"llm\"]>, config?: Callbacks | BaseCallbackConfig): Promise<ChainValues>;\n}\n/**\n * A chain for comparing two outputs, such as the outputs\n * of two models, prompts, or outputs of a single model on similar inputs,\n * with labeled preferences.\n */\nexport declare class LabeledPairwiseStringEvalChain extends PairwiseStringEvalChain {\n    static lc_name(): string;\n    requiresReference: boolean;\n    static resolvePairwisePrompt(prompt?: BasePromptTemplate): BasePromptTemplate<any, import(\"@langchain/core/prompt_values\").BasePromptValueInterface, any>;\n}\n//# sourceMappingURL=pairwise.d.ts.map"],"mappings":";;;;;;;;;;;;;;AAWqBc,cAAAA,gCAAAA,SAAyCb,mBAAT,CAA6BO,cAA7B,CAAA,CAAA;EAA6BA,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAGrDJ,YAAAA,EAAAA,MAAAA,EAAAA;EAAeD,WAAAA,CAAAA,WAAAA,EAAfC,UAAeD,EAAAA,GAAAA,cAAAA,EAAAA,EAAAA,UAAAA,EAA8BG,SAA9BH,GAAAA,SAAAA,CAAAA,EAAsDY,OAAtDZ,CAA8DK,cAA9DL,CAAAA;;;;;AAHqC;AAS5Da,cAAAA,uBAAAA,SAAgCN,0BAAAA,CAAT;EAO1BI,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAC4BD,aAAAA,CAAAA,EAAAA,MAAAA;EAAeI,cAAAA,CAAAA,EAAAA,MAAAA;EACnBZ,aAAAA,EAAAA,OAAAA;EAAkBa,iBAAAA,EAAAA,OAAAA;EAAGb,oBAAAA,EAAAA,MAAAA;EAOvCL,YAAAA,EATNc,gCASMd;EAAuCa,OAAAA,uBAAAA,CAAAA,QAAAA,CAAAA,EARjBA,YAQiBA,CAAAA,EARFI,MAQEJ,CAAAA,MAAAA,EAAAA,MAAAA,CAAAA;EAA0CJ,OAAAA,qBAAAA,CAAAA,MAAAA,CAAAA,EAP/DJ,kBAO+DI,CAAAA,EAP1CJ,kBAO0CI,CAAAA,GAAAA,EAP7CS,8BAAAA,CAAmEC,wBAAAA,EAOtBV,GAAAA,CAAAA;EAALW;;;;;;EAExBR,OAAAA,OAAAA,CAAAA,GAAAA,EAFpDZ,0BAEoDY,EAAAA,QAAAA,CAAAA,EAFbC,YAEaD,EAAAA,YAAAA,CAAAA,EAFgBS,OAEhBT,CAFwBQ,IAExBR,CAF6BH,iBAE7BG,EAAAA,KAAAA,CAAAA,CAAAA,CAAAA,EAF0DG,OAE1DH,CAFkEI,uBAElEJ,CAAAA;EAA6CN,cAAAA,CAAAA,MAAAA,EAD9FJ,WAC8FI,CAAAA,EAAAA,GAAAA;EAAYC,oBAAAA,CAAAA,IAAAA,EAAtGI,8BAAsGJ,EAAAA,WAAAA,EAAzDK,qBAAyDL,CAAAA,IAAAA,CAAAA,KAAAA,CAAAA,CAAAA,EAAAA,MAAAA,CAAAA,EAAZD,SAAYC,GAAAA,kBAAAA,CAAAA,EAAqBQ,OAArBR,CAA6BL,WAA7BK,CAAAA;;;;AAlBtD;AAyB/E;;AAG4DW,cAHvCI,8BAAAA,SAAuCN,uBAAAA,CAGmEG;EAAhEd,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAHHW,iBAAAA,EAAAA,OAAAA;EAAuB,OAAA,qBAAA,CAAA,MAAA,CAAA,EAGzCX,kBAHyC,CAAA,EAGpBA,kBAHoB,CAAA,GAAA,EAGvBa,8BAAAA,CAAmEC,wBAAAA,EAH5C,GAAA,CAAA"}
+{"version":3,"file":"pairwise.d.ts","names":["BaseLanguageModelInterface","BaseLLMOutputParser","ChainValues","ChatGeneration","Generation","BasePromptTemplate","Callbacks","BaseCallbackConfig","EvalOutputType","LLMEvalChainInput","LLMPairwiseStringEvaluator","LLMPairwiseStringEvaluatorArgs","ExtractLLMCallOptions","CriteriaLike","PairwiseStringResultOutputParser","Promise","PairwiseStringEvalChain","Record","_langchain_core_prompt_values1","BasePromptValueInterface","Omit","Partial","LabeledPairwiseStringEvalChain"],"sources":["../../../src/evaluation/comparison/pairwise.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { BaseLLMOutputParser } from \"@langchain/core/output_parsers\";\nimport { ChainValues } from \"@langchain/core/utils/types\";\nimport { ChatGeneration, Generation } from \"@langchain/core/outputs\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { Callbacks, BaseCallbackConfig } from \"@langchain/core/callbacks/manager\";\nimport { EvalOutputType, LLMEvalChainInput, LLMPairwiseStringEvaluator, LLMPairwiseStringEvaluatorArgs, type ExtractLLMCallOptions } from \"../base.js\";\nimport { CriteriaLike } from \"../criteria/criteria.js\";\n/**\n * A parser for the output of the PairwiseStringEvalChain.\n */\nexport declare class PairwiseStringResultOutputParser extends BaseLLMOutputParser<EvalOutputType> {\n    static lc_name(): string;\n    lc_namespace: string[];\n    parseResult(generations: Generation[] | ChatGeneration[], _callbacks: Callbacks | undefined): Promise<EvalOutputType>;\n}\n/**\n * A chain for comparing two outputs, such as the outputs\n * of two models, prompts, or outputs of a single model on similar inputs.\n */\nexport declare class PairwiseStringEvalChain extends LLMPairwiseStringEvaluator {\n    static lc_name(): string;\n    criterionName?: string;\n    evaluationName?: string;\n    requiresInput: boolean;\n    requiresReference: boolean;\n    skipReferenceWarning: string;\n    outputParser: PairwiseStringResultOutputParser;\n    static resolvePairwiseCriteria(criteria?: CriteriaLike): Record<string, string>;\n    static resolvePairwisePrompt(prompt?: BasePromptTemplate): BasePromptTemplate<any, import(\"@langchain/core/prompt_values\").BasePromptValueInterface, any>;\n    /**\n     * Create a new instance of the PairwiseStringEvalChain.\n     * @param llm\n     * @param criteria The criteria to use for evaluation.\n     * @param chainOptions Options to pass to the chain.\n     */\n    static fromLLM(llm: BaseLanguageModelInterface, criteria?: CriteriaLike, chainOptions?: Partial<Omit<LLMEvalChainInput, \"llm\">>): Promise<PairwiseStringEvalChain>;\n    _prepareOutput(result: ChainValues): any;\n    _evaluateStringPairs(args: LLMPairwiseStringEvaluatorArgs, callOptions: ExtractLLMCallOptions<this[\"llm\"]>, config?: Callbacks | BaseCallbackConfig): Promise<ChainValues>;\n}\n/**\n * A chain for comparing two outputs, such as the outputs\n * of two models, prompts, or outputs of a single model on similar inputs,\n * with labeled preferences.\n */\nexport declare class LabeledPairwiseStringEvalChain extends PairwiseStringEvalChain {\n    static lc_name(): string;\n    requiresReference: boolean;\n    static resolvePairwisePrompt(prompt?: BasePromptTemplate): BasePromptTemplate<any, import(\"@langchain/core/prompt_values\").BasePromptValueInterface, any>;\n}\n//# sourceMappingURL=pairwise.d.ts.map"],"mappings":";;;;;;;;;;;;;;AAWqBc,cAAAA,gCAAAA,SAAyCb,mBAAT,CAA6BO,cAA7B,CAAA,CAAA;EAA6BA,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAGrDJ,YAAAA,EAAAA,MAAAA,EAAAA;EAAeD,WAAAA,CAAAA,WAAAA,EAAfC,UAAeD,EAAAA,GAAAA,cAAAA,EAAAA,EAAAA,UAAAA,EAA8BG,SAA9BH,GAAAA,SAAAA,CAAAA,EAAsDY,OAAtDZ,CAA8DK,cAA9DL,CAAAA;;;;;AAHqC;AAS5Da,cAAAA,uBAAAA,SAAgCN,0BAAAA,CAAT;EAO1BI,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAC4BD,aAAAA,CAAAA,EAAAA,MAAAA;EAAeI,cAAAA,CAAAA,EAAAA,MAAAA;EACnBZ,aAAAA,EAAAA,OAAAA;EAAkBa,iBAAAA,EAAAA,OAAAA;EAAGb,oBAAAA,EAAAA,MAAAA;EAOvCL,YAAAA,EATNc,gCASMd;EAAuCa,OAAAA,uBAAAA,CAAAA,QAAAA,CAAAA,EARjBA,YAQiBA,CAAAA,EARFI,MAQEJ,CAAAA,MAAAA,EAAAA,MAAAA,CAAAA;EAA0CJ,OAAAA,qBAAAA,CAAAA,MAAAA,CAAAA,EAP/DJ,kBAO+DI,CAAAA,EAP1CJ,kBAO0CI,CAAAA,GAAAA,EAP7CS,8BAAAA,CAAmEC,wBAAAA,EAOtBV,GAAAA,CAAAA;EAALW;;;;;;EAExBR,OAAAA,OAAAA,CAAAA,GAAAA,EAFpDZ,0BAEoDY,EAAAA,QAAAA,CAAAA,EAFbC,YAEaD,EAAAA,YAAAA,CAAAA,EAFgBS,OAEhBT,CAFwBQ,IAExBR,CAF6BH,iBAE7BG,EAAAA,KAAAA,CAAAA,CAAAA,CAAAA,EAF0DG,OAE1DH,CAFkEI,uBAElEJ,CAAAA;EAA6CN,cAAAA,CAAAA,MAAAA,EAD9FJ,WAC8FI,CAAAA,EAAAA,GAAAA;EAAYC,oBAAAA,CAAAA,IAAAA,EAAtGI,8BAAsGJ,EAAAA,WAAAA,EAAzDK,qBAAyDL,CAAAA,IAAAA,CAAAA,KAAAA,CAAAA,CAAAA,EAAAA,MAAAA,CAAAA,EAAZD,SAAYC,GAAAA,kBAAAA,CAAAA,EAAqBQ,OAArBR,CAA6BL,WAA7BK,CAAAA;;;;AAlBtD;AAyB/E;;AAG4DW,cAHvCI,8BAAAA,SAAuCN,uBAAAA,CAGmEG;EAAhEd,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAHHW,iBAAAA,EAAAA,OAAAA;EAAuB,OAAA,qBAAA,CAAA,MAAA,CAAA,EAGzCX,kBAHyC,CAAA,EAGpBA,kBAHoB,CAAA,GAAA,EAGvBa,8BAAAA,CAAmEC,wBAAAA,EAH5C,GAAA,CAAA"}

package/dist/evaluation/criteria/criteria.d.cts

@@ -5,7 +5,7 @@ import { BaseLLMOutputParser } from "@langchain/core/output_parsers";
 import { ChainValues } from "@langchain/core/utils/types";
 import { BasePromptTemplate } from "@langchain/core/prompts";
 import { BaseLanguageModelInterface } from "@langchain/core/language_models/base";
-import * as _langchain_core_prompt_values4 from "@langchain/core/prompt_values";
+import * as _langchain_core_prompt_values2 from "@langchain/core/prompt_values";
 import { BaseCallbackConfig, Callbacks } from "@langchain/core/callbacks/manager";
 
 //#region src/evaluation/criteria/criteria.d.ts
@@ -50,7 +50,7 @@ declare class CriteriaEvalChain extends LLMStringEvaluator {
    * Resolve the prompt to use for the evaluation.
    * @param prompt
    */
-  static resolvePrompt(prompt?: BasePromptTemplate): BasePromptTemplate<any, _langchain_core_prompt_values4.BasePromptValueInterface, any>;
+  static resolvePrompt(prompt?: BasePromptTemplate): BasePromptTemplate<any, _langchain_core_prompt_values2.BasePromptValueInterface, any>;
   /**
    * Create a new instance of the CriteriaEvalChain.
    * @param llm
@@ -76,7 +76,7 @@ declare class CriteriaEvalChain extends LLMStringEvaluator {
 declare class LabeledCriteriaEvalChain extends CriteriaEvalChain {
   static lc_name(): string;
   requiresReference: boolean;
-  static resolvePrompt(prompt?: BasePromptTemplate): BasePromptTemplate<any, _langchain_core_prompt_values4.BasePromptValueInterface, any>;
+  static resolvePrompt(prompt?: BasePromptTemplate): BasePromptTemplate<any, _langchain_core_prompt_values2.BasePromptValueInterface, any>;
 }
 //#endregion
 export { Criteria, CriteriaEvalChain, CriteriaEvalInput, CriteriaLike, CriteriaResultOutputParser, LabeledCriteriaEvalChain };

package/dist/evaluation/criteria/criteria.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"criteria.d.cts","names":["BaseLanguageModelInterface","BaseLLMOutputParser","ChainValues","ChatGeneration","Generation","BasePromptTemplate","Callbacks","BaseCallbackConfig","EvalOutputType","LLMEvalChainInput","LLMStringEvaluator","StringEvaluatorArgs","ExtractLLMCallOptions","ConstitutionalPrinciple","Criteria","CriteriaLike","CriteriaResultOutputParser","Promise","CriteriaEvalInput","CriteriaEvalChain","Record","_langchain_core_prompt_values4","BasePromptValueInterface","Omit","Partial","input","prediction","reference","LabeledCriteriaEvalChain"],"sources":["../../../src/evaluation/criteria/criteria.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { BaseLLMOutputParser } from \"@langchain/core/output_parsers\";\nimport { ChainValues } from \"@langchain/core/utils/types\";\nimport { ChatGeneration, Generation } from \"@langchain/core/outputs\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { Callbacks, BaseCallbackConfig } from \"@langchain/core/callbacks/manager\";\nimport { EvalOutputType, LLMEvalChainInput, LLMStringEvaluator, StringEvaluatorArgs, type ExtractLLMCallOptions } from \"../base.js\";\nimport { ConstitutionalPrinciple } from \"../../chains/constitutional_ai/constitutional_principle.js\";\n/**\n * A Criteria to evaluate.\n */\nexport type Criteria = \"conciseness\" | \"relevance\" | \"correctness\" | \"coherence\" | \"harmfulness\" | \"maliciousness\" | \"helpfulness\" | \"controversiality\" | \"misogyny\" | \"criminality\" | \"insensitivity\" | \"depth\" | \"creativity\" | \"detail\";\nexport type CriteriaLike = {\n    [key: string]: string;\n} | Criteria | ConstitutionalPrinciple;\n/**\n * A parser for the output of the CriteriaEvalChain.\n */\nexport declare class CriteriaResultOutputParser extends BaseLLMOutputParser<EvalOutputType> {\n    lc_namespace: string[];\n    parseResult(generations: Generation[] | ChatGeneration[], _callbacks: Callbacks | undefined): Promise<EvalOutputType>;\n}\nexport interface CriteriaEvalInput {\n    input?: string;\n    output: string;\n    reference?: string;\n}\nexport declare class CriteriaEvalChain extends LLMStringEvaluator {\n    static lc_name(): string;\n    criterionName?: string;\n    evaluationName?: string;\n    requiresInput: boolean;\n    requiresReference: boolean;\n    skipReferenceWarning: string;\n    outputParser: BaseLLMOutputParser<EvalOutputType>;\n    /**\n     * Resolve the criteria to evaluate.\n     * @param criteria The criteria to evaluate the runs against. It can be:\n     *                 -  a mapping of a criterion name to its description\n     *                 -  a single criterion name present in one of the default criteria\n     *                 -  a single `ConstitutionalPrinciple` instance\n     *\n     * @return A dictionary mapping criterion names to descriptions.\n     */\n    static resolveCriteria(criteria?: CriteriaLike): Record<string, string>;\n    /**\n     * Resolve the prompt to use for the evaluation.\n     * @param prompt\n     */\n    static resolvePrompt(prompt?: BasePromptTemplate): BasePromptTemplate<any, import(\"@langchain/core/prompt_values\").BasePromptValueInterface, any>;\n    /**\n     * Create a new instance of the CriteriaEvalChain.\n     * @param llm\n     * @param criteria\n     * @param chainOptions Options to pass to the constructor of the LLMChain.\n     */\n    static fromLLM(llm: BaseLanguageModelInterface, criteria?: CriteriaLike, chainOptions?: Partial<Omit<LLMEvalChainInput, \"llm\">>): Promise<CriteriaEvalChain>;\n    getEvalInput({ input, prediction, reference }: StringEvaluatorArgs): CriteriaEvalInput;\n    /**\n     * Prepare the output of the evaluation.\n     * @param result\n     */\n    _prepareOutput(result: ChainValues): any;\n    _evaluateStrings(args: StringEvaluatorArgs & ExtractLLMCallOptions<this[\"llm\"]>, config?: Callbacks | BaseCallbackConfig): Promise<ChainValues>;\n}\n/**\n * Criteria evaluation chain that requires references.\n */\nexport declare class LabeledCriteriaEvalChain extends CriteriaEvalChain {\n    static lc_name(): string;\n    requiresReference: boolean;\n    static resolvePrompt(prompt?: BasePromptTemplate): BasePromptTemplate<any, import(\"@langchain/core/prompt_values\").BasePromptValueInterface, any>;\n}\n//# sourceMappingURL=criteria.d.ts.map"],"mappings":";;;;;;;;;;;;;;AAWYc,KAAAA,QAAAA,GAAQ,aAAA,GAAA,WAAA,GAAA,aAAA,GAAA,WAAA,GAAA,aAAA,GAAA,eAAA,GAAA,aAAA,GAAA,kBAAA,GAAA,UAAA,GAAA,aAAA,GAAA,eAAA,GAAA,OAAA,GAAA,YAAA,GAAA,QAAA;AACRC,KAAAA,YAAAA,GAAY;EAMHC,CAAAA,GAAAA,EAAAA,MAAAA,CAAAA,EAAAA,MAAAA;CAAuDR,GAJxEM,QAIwEN,GAJ7DK,uBAI6DL;;;;AAE8BA,cAFrFQ,0BAAAA,SAAmCf,mBAEkDO,CAF9BA,cAE8BA,CAAAA,CAAAA;EAARS,YAAAA,EAAAA,MAAAA,EAAAA;EAF1ChB,WAAAA,CAAAA,WAAAA,EAE3BG,UAF2BH,EAAAA,GAEZE,cAFYF,EAAAA,EAAAA,UAAAA,EAEkBK,SAFlBL,GAAAA,SAAAA,CAAAA,EAE0CgB,OAF1ChB,CAEkDO,cAFlDP,CAAAA;AAAmB;AAI1DiB,UAAAA,iBAAAA,CAAiB;EAKbC,KAAAA,CAAAA,EAAAA,MAAAA;EAOiBX,MAAAA,EAAAA,MAAAA;EAApBP,SAAAA,CAAAA,EAAAA,MAAAA;;AAUmCmB,cAjBhCD,iBAAAA,SAA0BT,kBAAAA,CAiBMU;EAKnBf,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAkBgB,aAAAA,CAAAA,EAAAA,MAAAA;EAAGhB,cAAAA,CAAAA,EAAAA,MAAAA;EAO/BL,aAAAA,EAAAA,OAAAA;EAAuCe,iBAAAA,EAAAA,OAAAA;EAA0CN,oBAAAA,EAAAA,MAAAA;EAALc,YAAAA,EAtBlFtB,mBAsBkFsB,CAtB9Df,cAsB8De,CAAAA;EAARC;;;;;;;;;EAOjEb,OAAAA,eAAAA,CAAAA,QAAAA,CAAAA,EAnBWI,YAmBXJ,CAAAA,EAnB0BS,MAmB1BT,CAAAA,MAAAA,EAAAA,MAAAA,CAAAA;EAAsBC;;;;EAA8EK,OAAAA,aAAAA,CAAAA,MAAAA,CAAAA,EAd7FZ,kBAc6FY,CAAAA,EAdxEZ,kBAcwEY,CAAAA,GAAAA,EAd3EI,8BAAAA,CAAmEC,wBAAAA,EAcQL,GAAAA,CAAAA;EApChFP;AAAkB;AAyCjE;;;;EAAsDS,OAAAA,OAAAA,CAAAA,GAAAA,EAZ9BnB,0BAY8BmB,EAAAA,QAAAA,CAAAA,EAZSJ,YAYTI,EAAAA,YAAAA,CAAAA,EAZsCK,OAYtCL,CAZ8CI,IAY9CJ,CAZmDV,iBAYnDU,EAAAA,KAAAA,CAAAA,CAAAA,CAAAA,EAZgFF,OAYhFE,CAZwFA,iBAYxFA,CAAAA;EAAiB,YAAA,CAAA;IAAA,KAAA;IAAA,UAAA;IAAA;EAAA,CAAA,EAXpBR,mBAWoB,CAAA,EAXEO,iBAWF;;;;;yBAN5ChB;yBACAS,sBAAsBC,6CAA6CN,YAAYC,qBAAqBU,QAAQf;;;;;cAKlH0B,wBAAAA,SAAiCT,iBAAAA;;;gCAGpBd,qBAAqBA,wBAAHgB,8BAAAA,CAAmEC,wBAAAA"}
+{"version":3,"file":"criteria.d.cts","names":["BaseLanguageModelInterface","BaseLLMOutputParser","ChainValues","ChatGeneration","Generation","BasePromptTemplate","Callbacks","BaseCallbackConfig","EvalOutputType","LLMEvalChainInput","LLMStringEvaluator","StringEvaluatorArgs","ExtractLLMCallOptions","ConstitutionalPrinciple","Criteria","CriteriaLike","CriteriaResultOutputParser","Promise","CriteriaEvalInput","CriteriaEvalChain","Record","_langchain_core_prompt_values2","BasePromptValueInterface","Omit","Partial","input","prediction","reference","LabeledCriteriaEvalChain"],"sources":["../../../src/evaluation/criteria/criteria.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { BaseLLMOutputParser } from \"@langchain/core/output_parsers\";\nimport { ChainValues } from \"@langchain/core/utils/types\";\nimport { ChatGeneration, Generation } from \"@langchain/core/outputs\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { Callbacks, BaseCallbackConfig } from \"@langchain/core/callbacks/manager\";\nimport { EvalOutputType, LLMEvalChainInput, LLMStringEvaluator, StringEvaluatorArgs, type ExtractLLMCallOptions } from \"../base.js\";\nimport { ConstitutionalPrinciple } from \"../../chains/constitutional_ai/constitutional_principle.js\";\n/**\n * A Criteria to evaluate.\n */\nexport type Criteria = \"conciseness\" | \"relevance\" | \"correctness\" | \"coherence\" | \"harmfulness\" | \"maliciousness\" | \"helpfulness\" | \"controversiality\" | \"misogyny\" | \"criminality\" | \"insensitivity\" | \"depth\" | \"creativity\" | \"detail\";\nexport type CriteriaLike = {\n    [key: string]: string;\n} | Criteria | ConstitutionalPrinciple;\n/**\n * A parser for the output of the CriteriaEvalChain.\n */\nexport declare class CriteriaResultOutputParser extends BaseLLMOutputParser<EvalOutputType> {\n    lc_namespace: string[];\n    parseResult(generations: Generation[] | ChatGeneration[], _callbacks: Callbacks | undefined): Promise<EvalOutputType>;\n}\nexport interface CriteriaEvalInput {\n    input?: string;\n    output: string;\n    reference?: string;\n}\nexport declare class CriteriaEvalChain extends LLMStringEvaluator {\n    static lc_name(): string;\n    criterionName?: string;\n    evaluationName?: string;\n    requiresInput: boolean;\n    requiresReference: boolean;\n    skipReferenceWarning: string;\n    outputParser: BaseLLMOutputParser<EvalOutputType>;\n    /**\n     * Resolve the criteria to evaluate.\n     * @param criteria The criteria to evaluate the runs against. It can be:\n     *                 -  a mapping of a criterion name to its description\n     *                 -  a single criterion name present in one of the default criteria\n     *                 -  a single `ConstitutionalPrinciple` instance\n     *\n     * @return A dictionary mapping criterion names to descriptions.\n     */\n    static resolveCriteria(criteria?: CriteriaLike): Record<string, string>;\n    /**\n     * Resolve the prompt to use for the evaluation.\n     * @param prompt\n     */\n    static resolvePrompt(prompt?: BasePromptTemplate): BasePromptTemplate<any, import(\"@langchain/core/prompt_values\").BasePromptValueInterface, any>;\n    /**\n     * Create a new instance of the CriteriaEvalChain.\n     * @param llm\n     * @param criteria\n     * @param chainOptions Options to pass to the constructor of the LLMChain.\n     */\n    static fromLLM(llm: BaseLanguageModelInterface, criteria?: CriteriaLike, chainOptions?: Partial<Omit<LLMEvalChainInput, \"llm\">>): Promise<CriteriaEvalChain>;\n    getEvalInput({ input, prediction, reference }: StringEvaluatorArgs): CriteriaEvalInput;\n    /**\n     * Prepare the output of the evaluation.\n     * @param result\n     */\n    _prepareOutput(result: ChainValues): any;\n    _evaluateStrings(args: StringEvaluatorArgs & ExtractLLMCallOptions<this[\"llm\"]>, config?: Callbacks | BaseCallbackConfig): Promise<ChainValues>;\n}\n/**\n * Criteria evaluation chain that requires references.\n */\nexport declare class LabeledCriteriaEvalChain extends CriteriaEvalChain {\n    static lc_name(): string;\n    requiresReference: boolean;\n    static resolvePrompt(prompt?: BasePromptTemplate): BasePromptTemplate<any, import(\"@langchain/core/prompt_values\").BasePromptValueInterface, any>;\n}\n//# sourceMappingURL=criteria.d.ts.map"],"mappings":";;;;;;;;;;;;;;AAWYc,KAAAA,QAAAA,GAAQ,aAAA,GAAA,WAAA,GAAA,aAAA,GAAA,WAAA,GAAA,aAAA,GAAA,eAAA,GAAA,aAAA,GAAA,kBAAA,GAAA,UAAA,GAAA,aAAA,GAAA,eAAA,GAAA,OAAA,GAAA,YAAA,GAAA,QAAA;AACRC,KAAAA,YAAAA,GAAY;EAMHC,CAAAA,GAAAA,EAAAA,MAAAA,CAAAA,EAAAA,MAAAA;CAAuDR,GAJxEM,QAIwEN,GAJ7DK,uBAI6DL;;;;AAE8BA,cAFrFQ,0BAAAA,SAAmCf,mBAEkDO,CAF9BA,cAE8BA,CAAAA,CAAAA;EAARS,YAAAA,EAAAA,MAAAA,EAAAA;EAF1ChB,WAAAA,CAAAA,WAAAA,EAE3BG,UAF2BH,EAAAA,GAEZE,cAFYF,EAAAA,EAAAA,UAAAA,EAEkBK,SAFlBL,GAAAA,SAAAA,CAAAA,EAE0CgB,OAF1ChB,CAEkDO,cAFlDP,CAAAA;AAAmB;AAI1DiB,UAAAA,iBAAAA,CAAiB;EAKbC,KAAAA,CAAAA,EAAAA,MAAAA;EAOiBX,MAAAA,EAAAA,MAAAA;EAApBP,SAAAA,CAAAA,EAAAA,MAAAA;;AAUmCmB,cAjBhCD,iBAAAA,SAA0BT,kBAAAA,CAiBMU;EAKnBf,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAkBgB,aAAAA,CAAAA,EAAAA,MAAAA;EAAGhB,cAAAA,CAAAA,EAAAA,MAAAA;EAO/BL,aAAAA,EAAAA,OAAAA;EAAuCe,iBAAAA,EAAAA,OAAAA;EAA0CN,oBAAAA,EAAAA,MAAAA;EAALc,YAAAA,EAtBlFtB,mBAsBkFsB,CAtB9Df,cAsB8De,CAAAA;EAARC;;;;;;;;;EAOjEb,OAAAA,eAAAA,CAAAA,QAAAA,CAAAA,EAnBWI,YAmBXJ,CAAAA,EAnB0BS,MAmB1BT,CAAAA,MAAAA,EAAAA,MAAAA,CAAAA;EAAsBC;;;;EAA8EK,OAAAA,aAAAA,CAAAA,MAAAA,CAAAA,EAd7FZ,kBAc6FY,CAAAA,EAdxEZ,kBAcwEY,CAAAA,GAAAA,EAd3EI,8BAAAA,CAAmEC,wBAAAA,EAcQL,GAAAA,CAAAA;EApChFP;AAAkB;AAyCjE;;;;EAAsDS,OAAAA,OAAAA,CAAAA,GAAAA,EAZ9BnB,0BAY8BmB,EAAAA,QAAAA,CAAAA,EAZSJ,YAYTI,EAAAA,YAAAA,CAAAA,EAZsCK,OAYtCL,CAZ8CI,IAY9CJ,CAZmDV,iBAYnDU,EAAAA,KAAAA,CAAAA,CAAAA,CAAAA,EAZgFF,OAYhFE,CAZwFA,iBAYxFA,CAAAA;EAAiB,YAAA,CAAA;IAAA,KAAA;IAAA,UAAA;IAAA;EAAA,CAAA,EAXpBR,mBAWoB,CAAA,EAXEO,iBAWF;;;;;yBAN5ChB;yBACAS,sBAAsBC,6CAA6CN,YAAYC,qBAAqBU,QAAQf;;;;;cAKlH0B,wBAAAA,SAAiCT,iBAAAA;;;gCAGpBd,qBAAqBA,wBAAHgB,8BAAAA,CAAmEC,wBAAAA"}

package/dist/evaluation/criteria/criteria.d.ts

@@ -6,7 +6,7 @@ import { ChatGeneration, Generation } from "@langchain/core/outputs";
 import { BaseCallbackConfig, Callbacks } from "@langchain/core/callbacks/manager";
 import { BaseLLMOutputParser } from "@langchain/core/output_parsers";
 import { ChainValues } from "@langchain/core/utils/types";
-import * as _langchain_core_prompt_values2 from "@langchain/core/prompt_values";
+import * as _langchain_core_prompt_values4 from "@langchain/core/prompt_values";
 
 //#region src/evaluation/criteria/criteria.d.ts
 /**
@@ -50,7 +50,7 @@ declare class CriteriaEvalChain extends LLMStringEvaluator {
    * Resolve the prompt to use for the evaluation.
    * @param prompt
    */
-  static resolvePrompt(prompt?: BasePromptTemplate): BasePromptTemplate<any, _langchain_core_prompt_values2.BasePromptValueInterface, any>;
+  static resolvePrompt(prompt?: BasePromptTemplate): BasePromptTemplate<any, _langchain_core_prompt_values4.BasePromptValueInterface, any>;
   /**
    * Create a new instance of the CriteriaEvalChain.
    * @param llm
@@ -76,7 +76,7 @@ declare class CriteriaEvalChain extends LLMStringEvaluator {
 declare class LabeledCriteriaEvalChain extends CriteriaEvalChain {
   static lc_name(): string;
   requiresReference: boolean;
-  static resolvePrompt(prompt?: BasePromptTemplate): BasePromptTemplate<any, _langchain_core_prompt_values2.BasePromptValueInterface, any>;
+  static resolvePrompt(prompt?: BasePromptTemplate): BasePromptTemplate<any, _langchain_core_prompt_values4.BasePromptValueInterface, any>;
 }
 //#endregion
 export { Criteria, CriteriaEvalChain, CriteriaEvalInput, CriteriaLike, CriteriaResultOutputParser, LabeledCriteriaEvalChain };

package/dist/evaluation/criteria/criteria.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"criteria.d.ts","names":["BaseLanguageModelInterface","BaseLLMOutputParser","ChainValues","ChatGeneration","Generation","BasePromptTemplate","Callbacks","BaseCallbackConfig","EvalOutputType","LLMEvalChainInput","LLMStringEvaluator","StringEvaluatorArgs","ExtractLLMCallOptions","ConstitutionalPrinciple","Criteria","CriteriaLike","CriteriaResultOutputParser","Promise","CriteriaEvalInput","CriteriaEvalChain","Record","_langchain_core_prompt_values2","BasePromptValueInterface","Omit","Partial","input","prediction","reference","LabeledCriteriaEvalChain"],"sources":["../../../src/evaluation/criteria/criteria.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { BaseLLMOutputParser } from \"@langchain/core/output_parsers\";\nimport { ChainValues } from \"@langchain/core/utils/types\";\nimport { ChatGeneration, Generation } from \"@langchain/core/outputs\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { Callbacks, BaseCallbackConfig } from \"@langchain/core/callbacks/manager\";\nimport { EvalOutputType, LLMEvalChainInput, LLMStringEvaluator, StringEvaluatorArgs, type ExtractLLMCallOptions } from \"../base.js\";\nimport { ConstitutionalPrinciple } from \"../../chains/constitutional_ai/constitutional_principle.js\";\n/**\n * A Criteria to evaluate.\n */\nexport type Criteria = \"conciseness\" | \"relevance\" | \"correctness\" | \"coherence\" | \"harmfulness\" | \"maliciousness\" | \"helpfulness\" | \"controversiality\" | \"misogyny\" | \"criminality\" | \"insensitivity\" | \"depth\" | \"creativity\" | \"detail\";\nexport type CriteriaLike = {\n    [key: string]: string;\n} | Criteria | ConstitutionalPrinciple;\n/**\n * A parser for the output of the CriteriaEvalChain.\n */\nexport declare class CriteriaResultOutputParser extends BaseLLMOutputParser<EvalOutputType> {\n    lc_namespace: string[];\n    parseResult(generations: Generation[] | ChatGeneration[], _callbacks: Callbacks | undefined): Promise<EvalOutputType>;\n}\nexport interface CriteriaEvalInput {\n    input?: string;\n    output: string;\n    reference?: string;\n}\nexport declare class CriteriaEvalChain extends LLMStringEvaluator {\n    static lc_name(): string;\n    criterionName?: string;\n    evaluationName?: string;\n    requiresInput: boolean;\n    requiresReference: boolean;\n    skipReferenceWarning: string;\n    outputParser: BaseLLMOutputParser<EvalOutputType>;\n    /**\n     * Resolve the criteria to evaluate.\n     * @param criteria The criteria to evaluate the runs against. It can be:\n     *                 -  a mapping of a criterion name to its description\n     *                 -  a single criterion name present in one of the default criteria\n     *                 -  a single `ConstitutionalPrinciple` instance\n     *\n     * @return A dictionary mapping criterion names to descriptions.\n     */\n    static resolveCriteria(criteria?: CriteriaLike): Record<string, string>;\n    /**\n     * Resolve the prompt to use for the evaluation.\n     * @param prompt\n     */\n    static resolvePrompt(prompt?: BasePromptTemplate): BasePromptTemplate<any, import(\"@langchain/core/prompt_values\").BasePromptValueInterface, any>;\n    /**\n     * Create a new instance of the CriteriaEvalChain.\n     * @param llm\n     * @param criteria\n     * @param chainOptions Options to pass to the constructor of the LLMChain.\n     */\n    static fromLLM(llm: BaseLanguageModelInterface, criteria?: CriteriaLike, chainOptions?: Partial<Omit<LLMEvalChainInput, \"llm\">>): Promise<CriteriaEvalChain>;\n    getEvalInput({ input, prediction, reference }: StringEvaluatorArgs): CriteriaEvalInput;\n    /**\n     * Prepare the output of the evaluation.\n     * @param result\n     */\n    _prepareOutput(result: ChainValues): any;\n    _evaluateStrings(args: StringEvaluatorArgs & ExtractLLMCallOptions<this[\"llm\"]>, config?: Callbacks | BaseCallbackConfig): Promise<ChainValues>;\n}\n/**\n * Criteria evaluation chain that requires references.\n */\nexport declare class LabeledCriteriaEvalChain extends CriteriaEvalChain {\n    static lc_name(): string;\n    requiresReference: boolean;\n    static resolvePrompt(prompt?: BasePromptTemplate): BasePromptTemplate<any, import(\"@langchain/core/prompt_values\").BasePromptValueInterface, any>;\n}\n//# sourceMappingURL=criteria.d.ts.map"],"mappings":";;;;;;;;;;;;;;AAWYc,KAAAA,QAAAA,GAAQ,aAAA,GAAA,WAAA,GAAA,aAAA,GAAA,WAAA,GAAA,aAAA,GAAA,eAAA,GAAA,aAAA,GAAA,kBAAA,GAAA,UAAA,GAAA,aAAA,GAAA,eAAA,GAAA,OAAA,GAAA,YAAA,GAAA,QAAA;AACRC,KAAAA,YAAAA,GAAY;EAMHC,CAAAA,GAAAA,EAAAA,MAAAA,CAAAA,EAAAA,MAAAA;CAAuDR,GAJxEM,QAIwEN,GAJ7DK,uBAI6DL;;;;AAE8BA,cAFrFQ,0BAAAA,SAAmCf,mBAEkDO,CAF9BA,cAE8BA,CAAAA,CAAAA;EAARS,YAAAA,EAAAA,MAAAA,EAAAA;EAF1ChB,WAAAA,CAAAA,WAAAA,EAE3BG,UAF2BH,EAAAA,GAEZE,cAFYF,EAAAA,EAAAA,UAAAA,EAEkBK,SAFlBL,GAAAA,SAAAA,CAAAA,EAE0CgB,OAF1ChB,CAEkDO,cAFlDP,CAAAA;AAAmB;AAI1DiB,UAAAA,iBAAAA,CAAiB;EAKbC,KAAAA,CAAAA,EAAAA,MAAAA;EAOiBX,MAAAA,EAAAA,MAAAA;EAApBP,SAAAA,CAAAA,EAAAA,MAAAA;;AAUmCmB,cAjBhCD,iBAAAA,SAA0BT,kBAAAA,CAiBMU;EAKnBf,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAkBgB,aAAAA,CAAAA,EAAAA,MAAAA;EAAGhB,cAAAA,CAAAA,EAAAA,MAAAA;EAO/BL,aAAAA,EAAAA,OAAAA;EAAuCe,iBAAAA,EAAAA,OAAAA;EAA0CN,oBAAAA,EAAAA,MAAAA;EAALc,YAAAA,EAtBlFtB,mBAsBkFsB,CAtB9Df,cAsB8De,CAAAA;EAARC;;;;;;;;;EAOjEb,OAAAA,eAAAA,CAAAA,QAAAA,CAAAA,EAnBWI,YAmBXJ,CAAAA,EAnB0BS,MAmB1BT,CAAAA,MAAAA,EAAAA,MAAAA,CAAAA;EAAsBC;;;;EAA8EK,OAAAA,aAAAA,CAAAA,MAAAA,CAAAA,EAd7FZ,kBAc6FY,CAAAA,EAdxEZ,kBAcwEY,CAAAA,GAAAA,EAd3EI,8BAAAA,CAAmEC,wBAAAA,EAcQL,GAAAA,CAAAA;EApChFP;AAAkB;AAyCjE;;;;EAAsDS,OAAAA,OAAAA,CAAAA,GAAAA,EAZ9BnB,0BAY8BmB,EAAAA,QAAAA,CAAAA,EAZSJ,YAYTI,EAAAA,YAAAA,CAAAA,EAZsCK,OAYtCL,CAZ8CI,IAY9CJ,CAZmDV,iBAYnDU,EAAAA,KAAAA,CAAAA,CAAAA,CAAAA,EAZgFF,OAYhFE,CAZwFA,iBAYxFA,CAAAA;EAAiB,YAAA,CAAA;IAAA,KAAA;IAAA,UAAA;IAAA;EAAA,CAAA,EAXpBR,mBAWoB,CAAA,EAXEO,iBAWF;;;;;yBAN5ChB;yBACAS,sBAAsBC,6CAA6CN,YAAYC,qBAAqBU,QAAQf;;;;;cAKlH0B,wBAAAA,SAAiCT,iBAAAA;;;gCAGpBd,qBAAqBA,wBAAHgB,8BAAAA,CAAmEC,wBAAAA"}
+{"version":3,"file":"criteria.d.ts","names":["BaseLanguageModelInterface","BaseLLMOutputParser","ChainValues","ChatGeneration","Generation","BasePromptTemplate","Callbacks","BaseCallbackConfig","EvalOutputType","LLMEvalChainInput","LLMStringEvaluator","StringEvaluatorArgs","ExtractLLMCallOptions","ConstitutionalPrinciple","Criteria","CriteriaLike","CriteriaResultOutputParser","Promise","CriteriaEvalInput","CriteriaEvalChain","Record","_langchain_core_prompt_values4","BasePromptValueInterface","Omit","Partial","input","prediction","reference","LabeledCriteriaEvalChain"],"sources":["../../../src/evaluation/criteria/criteria.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport { BaseLLMOutputParser } from \"@langchain/core/output_parsers\";\nimport { ChainValues } from \"@langchain/core/utils/types\";\nimport { ChatGeneration, Generation } from \"@langchain/core/outputs\";\nimport { BasePromptTemplate } from \"@langchain/core/prompts\";\nimport { Callbacks, BaseCallbackConfig } from \"@langchain/core/callbacks/manager\";\nimport { EvalOutputType, LLMEvalChainInput, LLMStringEvaluator, StringEvaluatorArgs, type ExtractLLMCallOptions } from \"../base.js\";\nimport { ConstitutionalPrinciple } from \"../../chains/constitutional_ai/constitutional_principle.js\";\n/**\n * A Criteria to evaluate.\n */\nexport type Criteria = \"conciseness\" | \"relevance\" | \"correctness\" | \"coherence\" | \"harmfulness\" | \"maliciousness\" | \"helpfulness\" | \"controversiality\" | \"misogyny\" | \"criminality\" | \"insensitivity\" | \"depth\" | \"creativity\" | \"detail\";\nexport type CriteriaLike = {\n    [key: string]: string;\n} | Criteria | ConstitutionalPrinciple;\n/**\n * A parser for the output of the CriteriaEvalChain.\n */\nexport declare class CriteriaResultOutputParser extends BaseLLMOutputParser<EvalOutputType> {\n    lc_namespace: string[];\n    parseResult(generations: Generation[] | ChatGeneration[], _callbacks: Callbacks | undefined): Promise<EvalOutputType>;\n}\nexport interface CriteriaEvalInput {\n    input?: string;\n    output: string;\n    reference?: string;\n}\nexport declare class CriteriaEvalChain extends LLMStringEvaluator {\n    static lc_name(): string;\n    criterionName?: string;\n    evaluationName?: string;\n    requiresInput: boolean;\n    requiresReference: boolean;\n    skipReferenceWarning: string;\n    outputParser: BaseLLMOutputParser<EvalOutputType>;\n    /**\n     * Resolve the criteria to evaluate.\n     * @param criteria The criteria to evaluate the runs against. It can be:\n     *                 -  a mapping of a criterion name to its description\n     *                 -  a single criterion name present in one of the default criteria\n     *                 -  a single `ConstitutionalPrinciple` instance\n     *\n     * @return A dictionary mapping criterion names to descriptions.\n     */\n    static resolveCriteria(criteria?: CriteriaLike): Record<string, string>;\n    /**\n     * Resolve the prompt to use for the evaluation.\n     * @param prompt\n     */\n    static resolvePrompt(prompt?: BasePromptTemplate): BasePromptTemplate<any, import(\"@langchain/core/prompt_values\").BasePromptValueInterface, any>;\n    /**\n     * Create a new instance of the CriteriaEvalChain.\n     * @param llm\n     * @param criteria\n     * @param chainOptions Options to pass to the constructor of the LLMChain.\n     */\n    static fromLLM(llm: BaseLanguageModelInterface, criteria?: CriteriaLike, chainOptions?: Partial<Omit<LLMEvalChainInput, \"llm\">>): Promise<CriteriaEvalChain>;\n    getEvalInput({ input, prediction, reference }: StringEvaluatorArgs): CriteriaEvalInput;\n    /**\n     * Prepare the output of the evaluation.\n     * @param result\n     */\n    _prepareOutput(result: ChainValues): any;\n    _evaluateStrings(args: StringEvaluatorArgs & ExtractLLMCallOptions<this[\"llm\"]>, config?: Callbacks | BaseCallbackConfig): Promise<ChainValues>;\n}\n/**\n * Criteria evaluation chain that requires references.\n */\nexport declare class LabeledCriteriaEvalChain extends CriteriaEvalChain {\n    static lc_name(): string;\n    requiresReference: boolean;\n    static resolvePrompt(prompt?: BasePromptTemplate): BasePromptTemplate<any, import(\"@langchain/core/prompt_values\").BasePromptValueInterface, any>;\n}\n//# sourceMappingURL=criteria.d.ts.map"],"mappings":";;;;;;;;;;;;;;AAWYc,KAAAA,QAAAA,GAAQ,aAAA,GAAA,WAAA,GAAA,aAAA,GAAA,WAAA,GAAA,aAAA,GAAA,eAAA,GAAA,aAAA,GAAA,kBAAA,GAAA,UAAA,GAAA,aAAA,GAAA,eAAA,GAAA,OAAA,GAAA,YAAA,GAAA,QAAA;AACRC,KAAAA,YAAAA,GAAY;EAMHC,CAAAA,GAAAA,EAAAA,MAAAA,CAAAA,EAAAA,MAAAA;CAAuDR,GAJxEM,QAIwEN,GAJ7DK,uBAI6DL;;;;AAE8BA,cAFrFQ,0BAAAA,SAAmCf,mBAEkDO,CAF9BA,cAE8BA,CAAAA,CAAAA;EAARS,YAAAA,EAAAA,MAAAA,EAAAA;EAF1ChB,WAAAA,CAAAA,WAAAA,EAE3BG,UAF2BH,EAAAA,GAEZE,cAFYF,EAAAA,EAAAA,UAAAA,EAEkBK,SAFlBL,GAAAA,SAAAA,CAAAA,EAE0CgB,OAF1ChB,CAEkDO,cAFlDP,CAAAA;AAAmB;AAI1DiB,UAAAA,iBAAAA,CAAiB;EAKbC,KAAAA,CAAAA,EAAAA,MAAAA;EAOiBX,MAAAA,EAAAA,MAAAA;EAApBP,SAAAA,CAAAA,EAAAA,MAAAA;;AAUmCmB,cAjBhCD,iBAAAA,SAA0BT,kBAAAA,CAiBMU;EAKnBf,OAAAA,OAAAA,CAAAA,CAAAA,EAAAA,MAAAA;EAAkBgB,aAAAA,CAAAA,EAAAA,MAAAA;EAAGhB,cAAAA,CAAAA,EAAAA,MAAAA;EAO/BL,aAAAA,EAAAA,OAAAA;EAAuCe,iBAAAA,EAAAA,OAAAA;EAA0CN,oBAAAA,EAAAA,MAAAA;EAALc,YAAAA,EAtBlFtB,mBAsBkFsB,CAtB9Df,cAsB8De,CAAAA;EAARC;;;;;;;;;EAOjEb,OAAAA,eAAAA,CAAAA,QAAAA,CAAAA,EAnBWI,YAmBXJ,CAAAA,EAnB0BS,MAmB1BT,CAAAA,MAAAA,EAAAA,MAAAA,CAAAA;EAAsBC;;;;EAA8EK,OAAAA,aAAAA,CAAAA,MAAAA,CAAAA,EAd7FZ,kBAc6FY,CAAAA,EAdxEZ,kBAcwEY,CAAAA,GAAAA,EAd3EI,8BAAAA,CAAmEC,wBAAAA,EAcQL,GAAAA,CAAAA;EApChFP;AAAkB;AAyCjE;;;;EAAsDS,OAAAA,OAAAA,CAAAA,GAAAA,EAZ9BnB,0BAY8BmB,EAAAA,QAAAA,CAAAA,EAZSJ,YAYTI,EAAAA,YAAAA,CAAAA,EAZsCK,OAYtCL,CAZ8CI,IAY9CJ,CAZmDV,iBAYnDU,EAAAA,KAAAA,CAAAA,CAAAA,CAAAA,EAZgFF,OAYhFE,CAZwFA,iBAYxFA,CAAAA;EAAiB,YAAA,CAAA;IAAA,KAAA;IAAA,UAAA;IAAA;EAAA,CAAA,EAXpBR,mBAWoB,CAAA,EAXEO,iBAWF;;;;;yBAN5ChB;yBACAS,sBAAsBC,6CAA6CN,YAAYC,qBAAqBU,QAAQf;;;;;cAKlH0B,wBAAAA,SAAiCT,iBAAAA;;;gCAGpBd,qBAAqBA,wBAAHgB,8BAAAA,CAAmEC,wBAAAA"}

package/dist/experimental/autogpt/prompt.d.cts

@@ -1,5 +1,5 @@
 import { ObjectTool } from "./schema.cjs";
-import * as _langchain_core_messages3 from "@langchain/core/messages";
+import * as _langchain_core_messages0 from "@langchain/core/messages";
 import { BaseMessage } from "@langchain/core/messages";
 import { PartialValues } from "@langchain/core/utils/types";
 import { BaseChatPromptTemplate, SerializedBasePromptTemplate } from "@langchain/core/prompts";
@@ -54,7 +54,7 @@ declare class AutoGPTPrompt extends BaseChatPromptTemplate implements AutoGPTPro
     memory: VectorStoreRetrieverInterface;
     messages: BaseMessage[];
     user_input: string;
-  }): Promise<BaseMessage<_langchain_core_messages3.MessageStructure<_langchain_core_messages3.MessageToolSet>, _langchain_core_messages3.MessageType>[]>;
+  }): Promise<BaseMessage<_langchain_core_messages0.MessageStructure<_langchain_core_messages0.MessageToolSet>, _langchain_core_messages0.MessageType>[]>;
   /**
    * This method is not implemented in the AutoGPTPrompt class and will
    * throw an error if called.

package/dist/experimental/autogpt/prompt.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"prompt.d.cts","names":["VectorStoreRetrieverInterface","BaseChatPromptTemplate","SerializedBasePromptTemplate","BaseMessage","PartialValues","ObjectTool","AutoGPTPromptInput","Promise","AutoGPTPrompt","goals","memory","previousMessages","user_input","_langchain_core_messages3","MessageToolSet","MessageStructure","MessageType"],"sources":["../../../src/experimental/autogpt/prompt.d.ts"],"sourcesContent":["import type { VectorStoreRetrieverInterface } from \"@langchain/core/vectorstores\";\nimport { BaseChatPromptTemplate, SerializedBasePromptTemplate } from \"@langchain/core/prompts\";\nimport { BaseMessage } from \"@langchain/core/messages\";\nimport { PartialValues } from \"@langchain/core/utils/types\";\nimport { ObjectTool } from \"./schema.js\";\n/**\n * Interface for the input parameters of the AutoGPTPrompt class.\n */\nexport interface AutoGPTPromptInput {\n    aiName: string;\n    aiRole: string;\n    tools: ObjectTool[];\n    tokenCounter: (text: string) => Promise<number>;\n    sendTokenLimit?: number;\n}\n/**\n * Class used to generate prompts for the AutoGPT model. It takes into\n * account the AI's name, role, tools, token counter, and send token\n * limit. The class also handles the formatting of messages and the\n * construction of the full prompt.\n */\nexport declare class AutoGPTPrompt extends BaseChatPromptTemplate implements AutoGPTPromptInput {\n    aiName: string;\n    aiRole: string;\n    tools: ObjectTool[];\n    tokenCounter: (text: string) => Promise<number>;\n    sendTokenLimit: number;\n    constructor(fields: AutoGPTPromptInput);\n    _getPromptType(): \"autogpt\";\n    /**\n     * Constructs the full prompt based on the provided goals.\n     * @param goals An array of goals.\n     * @returns The full prompt as a string.\n     */\n    constructFullPrompt(goals: string[]): string;\n    /**\n     * Formats the messages based on the provided parameters.\n     * @param goals An array of goals.\n     * @param memory A VectorStoreRetriever instance.\n     * @param messages An array of previous messages.\n     * @param user_input The user's input.\n     * @returns An array of formatted messages.\n     */\n    formatMessages({ goals, memory, messages: previousMessages, user_input }: {\n        goals: string[];\n        memory: VectorStoreRetrieverInterface;\n        messages: BaseMessage[];\n        user_input: string;\n    }): Promise<BaseMessage<import(\"@langchain/core/messages\").MessageStructure<import(\"@langchain/core/messages\").MessageToolSet>, import(\"@langchain/core/messages\").MessageType>[]>;\n    /**\n     * This method is not implemented in the AutoGPTPrompt class and will\n     * throw an error if called.\n     * @param _values Partial values.\n     * @returns Throws an error.\n     */\n    partial(_values: PartialValues): Promise<BaseChatPromptTemplate>;\n    serialize(): SerializedBasePromptTemplate;\n}\n//# sourceMappingURL=prompt.d.ts.map"],"mappings":";;;;;;;;;;;AAQiBM,UAAAA,kBAAAA,CAAkB;EAadE,MAAAA,EAAAA,MAAAA;EAGVH,MAAAA,EAAAA,MAAAA;EACyBE,KAAAA,EAdzBF,UAcyBE,EAAAA;EAEZD,YAAAA,EAAAA,CAAAA,IAAAA,EAAAA,MAAAA,EAAAA,GAfYC,OAeZD,CAAAA,MAAAA,CAAAA;EAgBHG,cAAAA,CAAAA,EAAAA,MAAAA;;;;;;;;AAK0DI,cA3B1DL,aAAAA,SAAsBP,sBAAAA,YAAkCK,kBA2B0FU,CAAAA;EAAvJb,MAAAA,EAAAA,MAAAA;EAARI,MAAAA,EAAAA,MAAAA;EAOaH,KAAAA,EA/BVC,UA+BUD,EAAAA;EAAwBH,YAAAA,EAAAA,CAAAA,IAAAA,EAAAA,MAAAA,EAAAA,GA9BTM,OA8BSN,CAAAA,MAAAA,CAAAA;EAARM,cAAAA,EAAAA,MAAAA;EACpBL,WAAAA,CAAAA,MAAAA,EA7BOI,kBA6BPJ;EAnC0BD,cAAAA,CAAAA,CAAAA,EAAAA,SAAAA;EAAkCK;AAAkB;;;;;;;;;;;;;;;;cAsBjDK;;;;YAE9BX;cACEG;;MAEVI,QAAQJ,YAAiHU,yBAAAA,CAAlEE,iBAFlCF,yBAAAA,CAEsFC,cAAAA,GAApCD,yBAAAA,CAAwFG,WAAAA;;;;;;;mBAOlJZ,gBAAgBG,QAAQN;eAC5BC"}
+{"version":3,"file":"prompt.d.cts","names":["VectorStoreRetrieverInterface","BaseChatPromptTemplate","SerializedBasePromptTemplate","BaseMessage","PartialValues","ObjectTool","AutoGPTPromptInput","Promise","AutoGPTPrompt","goals","memory","previousMessages","user_input","_langchain_core_messages0","MessageToolSet","MessageStructure","MessageType"],"sources":["../../../src/experimental/autogpt/prompt.d.ts"],"sourcesContent":["import type { VectorStoreRetrieverInterface } from \"@langchain/core/vectorstores\";\nimport { BaseChatPromptTemplate, SerializedBasePromptTemplate } from \"@langchain/core/prompts\";\nimport { BaseMessage } from \"@langchain/core/messages\";\nimport { PartialValues } from \"@langchain/core/utils/types\";\nimport { ObjectTool } from \"./schema.js\";\n/**\n * Interface for the input parameters of the AutoGPTPrompt class.\n */\nexport interface AutoGPTPromptInput {\n    aiName: string;\n    aiRole: string;\n    tools: ObjectTool[];\n    tokenCounter: (text: string) => Promise<number>;\n    sendTokenLimit?: number;\n}\n/**\n * Class used to generate prompts for the AutoGPT model. It takes into\n * account the AI's name, role, tools, token counter, and send token\n * limit. The class also handles the formatting of messages and the\n * construction of the full prompt.\n */\nexport declare class AutoGPTPrompt extends BaseChatPromptTemplate implements AutoGPTPromptInput {\n    aiName: string;\n    aiRole: string;\n    tools: ObjectTool[];\n    tokenCounter: (text: string) => Promise<number>;\n    sendTokenLimit: number;\n    constructor(fields: AutoGPTPromptInput);\n    _getPromptType(): \"autogpt\";\n    /**\n     * Constructs the full prompt based on the provided goals.\n     * @param goals An array of goals.\n     * @returns The full prompt as a string.\n     */\n    constructFullPrompt(goals: string[]): string;\n    /**\n     * Formats the messages based on the provided parameters.\n     * @param goals An array of goals.\n     * @param memory A VectorStoreRetriever instance.\n     * @param messages An array of previous messages.\n     * @param user_input The user's input.\n     * @returns An array of formatted messages.\n     */\n    formatMessages({ goals, memory, messages: previousMessages, user_input }: {\n        goals: string[];\n        memory: VectorStoreRetrieverInterface;\n        messages: BaseMessage[];\n        user_input: string;\n    }): Promise<BaseMessage<import(\"@langchain/core/messages\").MessageStructure<import(\"@langchain/core/messages\").MessageToolSet>, import(\"@langchain/core/messages\").MessageType>[]>;\n    /**\n     * This method is not implemented in the AutoGPTPrompt class and will\n     * throw an error if called.\n     * @param _values Partial values.\n     * @returns Throws an error.\n     */\n    partial(_values: PartialValues): Promise<BaseChatPromptTemplate>;\n    serialize(): SerializedBasePromptTemplate;\n}\n//# sourceMappingURL=prompt.d.ts.map"],"mappings":";;;;;;;;;;;AAQiBM,UAAAA,kBAAAA,CAAkB;EAadE,MAAAA,EAAAA,MAAAA;EAGVH,MAAAA,EAAAA,MAAAA;EACyBE,KAAAA,EAdzBF,UAcyBE,EAAAA;EAEZD,YAAAA,EAAAA,CAAAA,IAAAA,EAAAA,MAAAA,EAAAA,GAfYC,OAeZD,CAAAA,MAAAA,CAAAA;EAgBHG,cAAAA,CAAAA,EAAAA,MAAAA;;;;;;;;AAK0DI,cA3B1DL,aAAAA,SAAsBP,sBAAAA,YAAkCK,kBA2B0FU,CAAAA;EAAvJb,MAAAA,EAAAA,MAAAA;EAARI,MAAAA,EAAAA,MAAAA;EAOaH,KAAAA,EA/BVC,UA+BUD,EAAAA;EAAwBH,YAAAA,EAAAA,CAAAA,IAAAA,EAAAA,MAAAA,EAAAA,GA9BTM,OA8BSN,CAAAA,MAAAA,CAAAA;EAARM,cAAAA,EAAAA,MAAAA;EACpBL,WAAAA,CAAAA,MAAAA,EA7BOI,kBA6BPJ;EAnC0BD,cAAAA,CAAAA,CAAAA,EAAAA,SAAAA;EAAkCK;AAAkB;;;;;;;;;;;;;;;;cAsBjDK;;;;YAE9BX;cACEG;;MAEVI,QAAQJ,YAAiHU,yBAAAA,CAAlEE,iBAFlCF,yBAAAA,CAEsFC,cAAAA,GAApCD,yBAAAA,CAAwFG,WAAAA;;;;;;;mBAOlJZ,gBAAgBG,QAAQN;eAC5BC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/classic",
-  "version": "1.0.9",
+  "version": "1.0.10",
   "description": "Old abstractions form LangChain.js",
   "author": "LangChain",
   "license": "MIT",
@@ -170,37 +170,37 @@
     "voy-search": "0.6.2",
     "weaviate-client": "^3.8.0",
     "zod-to-json-schema": "^3.24.6",
-    "@langchain/anthropic": "1.3.8",
-    "@langchain/aws": "1.2.0",
+    "@langchain/anthropic": "1.3.11",
+    "@langchain/aws": "1.2.1",
+    "@langchain/azure-cosmosdb": "1.1.0",
     "@langchain/azure-dynamic-sessions": "1.0.1",
     "@langchain/baidu-qianfan": "1.0.1",
     "@langchain/cloudflare": "1.0.1",
     "@langchain/cohere": "1.0.1",
-    "@langchain/core": "1.1.13",
-    "@langchain/azure-cosmosdb": "1.1.0",
-    "@langchain/deepseek": "1.0.5",
+    "@langchain/core": "1.1.16",
+    "@langchain/deepseek": "1.0.6",
     "@langchain/eslint": "0.1.1",
     "@langchain/exa": "1.0.1",
-    "@langchain/google-cloud-sql-pg": "1.0.14",
-    "@langchain/google-common": "2.1.8",
-    "@langchain/google-genai": "2.1.8",
-    "@langchain/google-vertexai": "2.1.8",
-    "@langchain/google-vertexai-web": "2.1.8",
+    "@langchain/google-cloud-sql-pg": "1.0.17",
+    "@langchain/google-common": "2.1.11",
+    "@langchain/google-genai": "2.1.11",
+    "@langchain/google-vertexai": "2.1.11",
+    "@langchain/google-vertexai-web": "2.1.11",
     "@langchain/groq": "1.0.3",
-    "@langchain/mistralai": "1.0.2",
+    "@langchain/mistralai": "1.0.3",
     "@langchain/mongodb": "1.1.0",
     "@langchain/nomic": "1.0.1",
-    "@langchain/ollama": "1.2.0",
+    "@langchain/ollama": "1.2.1",
     "@langchain/pinecone": "1.0.1",
     "@langchain/qdrant": "1.0.1",
     "@langchain/redis": "1.0.1",
     "@langchain/tavily": "1.2.0",
     "@langchain/textsplitters": "1.0.1",
     "@langchain/weaviate": "1.0.1",
-    "@langchain/xai": "1.2.1",
+    "@langchain/xai": "1.2.2",
     "@langchain/yandex": "1.0.1",
     "@langchain/tsconfig": "0.0.1",
-    "langchain": "1.2.8"
+    "langchain": "1.2.11"
   },
   "peerDependencies": {
     "@langchain/core": "^1.0.0",
@@ -227,7 +227,7 @@
     "uuid": "^10.0.0",
     "yaml": "^2.2.1",
     "zod": "^3.25.76 || ^4",
-    "@langchain/openai": "1.2.2",
+    "@langchain/openai": "1.2.3",
     "@langchain/textsplitters": "1.0.1"
   },
   "optionalDependencies": {