@langchain/classic 1.0.0-alpha.1 → 1.0.1

package/CHANGELOG.md

@@ -0,0 +1,13 @@
+# @langchain/classic
+
+## 1.0.1
+
+### Patch Changes
+
+- dda9ea4: reinstate `OpenAIModerationChain`
+  - @langchain/textsplitters@1.0.0
+  - @langchain/openai@1.0.0
+
+## 1.0.0
+
+This release updates the package for compatibility with LangChain v1.0. See the v1.0 [release notes](https://docs.langchain.com/oss/javascript/releases/langchain-v1) for details on what's new.

package/LICENSE

@@ -1,6 +1,6 @@
-The MIT License
+MIT License
 
-Copyright (c) Harrison Chase
+Copyright (c) LangChain, Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -9,13 +9,13 @@ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:
 
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
 
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,109 +1,217 @@
-# 🦜️🔗 LangChain.js
+# @langchain/classic
 
-⚡ Building applications with LLMs through composability ⚡
+This package contains functionality from LangChain v0.x that has been moved out of the main `langchain` package as part of the v1.0 release. It exists to provide backward compatibility for existing applications while the core `langchain` package focuses on the essential building blocks for modern agent development.
 
-[![CI](https://github.com/langchain-ai/langchainjs/actions/workflows/ci.yml/badge.svg)](https://github.com/langchain-ai/langchainjs/actions/workflows/ci.yml) ![npm](https://img.shields.io/npm/dm/langchain) [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) [![Twitter](https://img.shields.io/twitter/url/https/twitter.com/langchainai.svg?style=social&label=Follow%20%40LangChainAI)](https://twitter.com/langchainai) [![Open in Dev Containers](https://img.shields.io/static/v1?label=Dev%20Containers&message=Open&color=blue&logo=visualstudiocode)](https://vscode.dev/redirect?url=vscode://ms-vscode-remote.remote-containers/cloneInVolume?url=https://github.com/langchain-ai/langchainjs)
-[<img src="https://github.com/codespaces/badge.svg" title="Open in Github Codespace" width="150" height="20">](https://codespaces.new/langchain-ai/langchainjs)
+## When to use this package
 
-Looking for the Python version? Check out [LangChain](https://github.com/langchain-ai/langchain).
+Use `@langchain/classic` if you:
 
-To help you ship LangChain apps to production faster, check out [LangSmith](https://smith.langchain.com).
-[LangSmith](https://smith.langchain.com) is a unified developer platform for building, testing, and monitoring LLM applications.
+- Have existing code that uses legacy chains (e.g., `LLMChain`, `ConversationalRetrievalQAChain`, `RetrievalQAChain`)
+- Use the indexing API
+- Depend on functionality from `@langchain/community` that was previously re-exported from `langchain`
+- Are maintaining an existing application and not yet ready to migrate to the new `createAgent` API
 
-## ⚡️ Quick Install
+## When NOT to use this package
 
-You can use npm, yarn, or pnpm to install LangChain.js
+**For new projects, use `langchain` v1.0 instead.** The new APIs provide:
 
-`npm install -S langchain` or `yarn add langchain` or `pnpm add langchain`
+- **`createAgent`**: A cleaner, more powerful way to build agents with middleware support
+- **Better performance**: Optimized for modern agent workflows
+- **Focused API surface**: Less complexity, easier to learn
+- **Active development**: New features and improvements will focus on v1.0 APIs
 
-## 🌐 Supported Environments
+See the [LangChain v1.0 release notes](https://docs.langchain.com/oss/javascript/releases/langchain-v1) for more information.
 
-LangChain is written in TypeScript and can be used in:
+## Installation
 
-- Node.js (ESM and CommonJS) - 18.x, 19.x, 20.x, 22.x
-- Cloudflare Workers
-- Vercel / Next.js (Browser, Serverless and Edge functions)
-- Supabase Edge Functions
-- Browser
-- Deno
+```bash npm2yarn
+npm install @langchain/classic
+```
 
-## 🤔 What is LangChain?
+This package requires `@langchain/core` as a peer dependency:
 
-**LangChain** is a framework for developing applications powered by language models. It enables applications that:
+```bash npm2yarn
+npm install @langchain/core
+```
 
-- **Are context-aware**: connect a language model to sources of context (prompt instructions, few shot examples, content to ground its response in, etc.)
-- **Reason**: rely on a language model to reason (about how to answer based on provided context, what actions to take, etc.)
+## What's included
 
-This framework consists of several parts.
+### Legacy Chains
 
-- **Open-source libraries**: Build your applications using LangChain's open-source [building blocks](https://js.langchain.com/docs/concepts/lcel), [components](https://js.langchain.com/docs/concepts), and [third-party integrations](https://js.langchain.com/docs/integrations/platforms/).
-  Use [LangGraph.js](https://js.langchain.com/docs/concepts/#langgraphjs) to build stateful agents with first-class streaming and human-in-the-loop support.
-- **Productionization**: Use [LangSmith](https://docs.smith.langchain.com/) to inspect, monitor and evaluate your chains, so that you can continuously optimize and deploy with confidence.
-- **Deployment**: Turn your LangGraph applications into production-ready APIs and Assistants with [LangGraph Cloud](https://langchain-ai.github.io/langgraph/cloud/).
+All chain implementations from v0.x, including:
 
-The LangChain libraries themselves are made up of several different packages.
+- `LLMChain` - Basic chain for calling an LLM with a prompt template
+- `ConversationalRetrievalQAChain` - Chain for conversational question-answering over documents
+- `RetrievalQAChain` - Chain for question-answering over documents without conversation memory
+- `StuffDocumentsChain` - Chain for stuffing documents into a prompt
+- `MapReduceDocumentsChain` - Chain for map-reduce operations over documents
+- `RefineDocumentsChain` - Chain for iterative refinement over documents
+- And many more...
 
-- **[`@langchain/core`](https://github.com/langchain-ai/langchainjs/blob/main/langchain-core)**: Base abstractions and LangChain Expression Language.
-- **[`@langchain/community`](https://github.com/langchain-ai/langchainjs/blob/main/libs/langchain-community)**: Third party integrations.
-- **[`langchain`](https://github.com/langchain-ai/langchainjs/blob/main/langchain)**: Chains, agents, and retrieval strategies that make up an application's cognitive architecture.
-- **[LangGraph.js](https://langchain-ai.github.io/langgraphjs/)**: LangGraph powers production-grade agents, trusted by Linkedin, Uber, Klarna, GitLab, and many more. Build robust and stateful multi-actor applications with LLMs by modeling steps as edges and nodes in a graph. Integrates smoothly with LangChain, but can be used without it.
+### Indexing API
 
-Integrations may also be split into their own compatible packages.
+The `RecordManager` and related indexing functionality for managing document updates in vector stores.
 
-![LangChain Stack](https://github.com/langchain-ai/langchainjs/blob/main/docs/core_docs/static/svg/langchain_stack_062024.svg)
+### Community Integrations
 
-This library aims to assist in the development of those types of applications. Common examples of these applications include:
+Re-exports from `@langchain/community` that were previously available in the main `langchain` package.
 
-**❓Question Answering over specific documents**
+### Other Deprecated Functionality
 
-- [Documentation](https://js.langchain.com/docs/tutorials/rag/)
-- End-to-end Example: [Doc-Chatbot](https://github.com/dissorial/doc-chatbot)
+Various utilities and abstractions that have been replaced by better alternatives in v1.0.
 
-**💬 Chatbots**
+## Migration
 
-- [Documentation](https://js.langchain.com/docs/tutorials/chatbot)
-- End-to-end Example: [Chat-LangChain](https://github.com/langchain-ai/chat-langchain)
+### From `langchain` v0.x to `@langchain/classic`
 
-## 🚀 How does LangChain help?
+If you're upgrading to `langchain` v1.0 but want to keep using legacy functionality:
 
-The main value props of the LangChain libraries are:
+1. Install `@langchain/classic`:
 
-1. **Components**: composable tools and integrations for working with language models. Components are modular and easy-to-use, whether you are using the rest of the LangChain framework or not
-2. **Off-the-shelf chains**: built-in assemblages of components for accomplishing higher-level tasks
+   ```bash npm2yarn
+   npm install @langchain/classic
+   ```
 
-Off-the-shelf chains make it easy to get started. Components make it easy to customize existing chains and build new ones.
+2. Update your imports:
 
-Components fall into the following **modules**:
+   ```typescript
+   // Before (v0.x)
+   import { LLMChain } from "langchain/chains";
+   import { ConversationalRetrievalQAChain } from "langchain/chains";
 
-**📃 Model I/O:**
+   // After (v1.0)
+   import { LLMChain } from "@langchain/classic/chains";
+   import { ConversationalRetrievalQAChain } from "@langchain/classic/chains";
+   ```
 
-This includes prompt management, prompt optimization, a generic interface for all LLMs, and common utilities for working with LLMs.
+   Or if you imported from the root:
 
-**📚 Retrieval:**
+   ```typescript
+   // Before (v0.x)
+   import { LLMChain } from "langchain";
 
-Data Augmented Generation involves specific types of chains that first interact with an external data source to fetch data for use in the generation step. Examples include summarization of long pieces of text and question/answering over specific data sources.
+   // After (v1.0)
+   import { LLMChain } from "@langchain/classic";
+   ```
 
-**🤖 Agents:**
+### From `@langchain/classic` to `langchain` v1.0
 
-Agents allow an LLM autonomy over how a task is accomplished. Agents make decisions about which Actions to take, then take that Action, observe the result, and repeat until the task is complete. LangChain provides a [standard interface for agents](https://js.langchain.com/docs/concepts/#agents), along with [LangGraph.js](https://github.com/langchain-ai/langgraphjs/) for building custom agents.
+**For new development, we recommend using `createAgent` instead of legacy chains.**
 
-## 📖 Additional Resources
+Example migration from `LLMChain`:
 
-- [Getting started](https://js.langchain.com/docs/introduction): installation, setting up the environment, simple examples
-- Overview of the [interfaces](https://js.langchain.com/docs/how_to/lcel_cheatsheet/), [modules](https://js.langchain.com/docs/concepts) and [integrations](https://js.langchain.com/docs/integrations/platforms/)
-- [Full Documentation](https://js.langchain.com)
-- [Tutorial](https://js.langchain.com/docs/tutorials/) walkthroughs
-- [Langhain Forum](https://forum.langchain.com)
-- [API Reference](https://api.js.langchain.com)
+```typescript
+// Before (using LLMChain)
+import { LLMChain } from "@langchain/classic/chains";
+import { ChatOpenAI } from "@langchain/openai";
+import { PromptTemplate } from "@langchain/core/prompts";
 
-## 💁 Contributing
+const model = new ChatOpenAI({ model: "gpt-4" });
+const prompt = PromptTemplate.fromTemplate(
+  "What is a good name for a company that makes {product}?"
+);
+const chain = new LLMChain({ llm: model, prompt });
+const result = await chain.call({ product: "colorful socks" });
 
-As an open-source project in a rapidly developing field, we are extremely open to contributions, whether it be in the form of a new feature, improved infrastructure, or better documentation.
+// After (using createAgent)
+import { createAgent } from "langchain";
 
-For detailed information on how to contribute, see [here](https://github.com/langchain-ai/langchainjs/blob/main/CONTRIBUTING.md).
+const agent = createAgent({
+  model: "openai:gpt-4",
+  systemPrompt: "You are a creative assistant that helps name companies.",
+});
 
-Please report any security issues or concerns following our [security guidelines](https://github.com/langchain-ai/langchainjs/blob/main/SECURITY.md).
+const result = await agent.invoke({
+  messages: [
+    {
+      role: "user",
+      content: "What is a good name for a company that makes colorful socks?",
+    },
+  ],
+});
+```
 
-## 🖇️ Relationship with Python LangChain
+For more complex migrations, see the [migration guide](https://docs.langchain.com/oss/javascript/migrate/langchain-v1).
 
-This is built to integrate as seamlessly as possible with the [LangChain Python package](https://github.com/langchain-ai/langchain). Specifically, this means all objects (prompts, LLMs, chains, etc) are designed in a way where they can be serialized and shared between languages.
+## Support and Maintenance
+
+`@langchain/classic` will receive:
+
+- **Bug fixes**: Critical bugs will be fixed
+- **Security updates**: Security vulnerabilities will be patched
+- **No new features**: New functionality will focus on `langchain` v1.0 APIs
+
+This package is in **maintenance mode**. For new features and active development, use `langchain` v1.0.
+
+## Examples
+
+### Using a legacy chain
+
+```typescript
+import { LLMChain } from "@langchain/classic/chains";
+import { ChatOpenAI } from "@langchain/openai";
+import { PromptTemplate } from "@langchain/core/prompts";
+
+const model = new ChatOpenAI({ model: "gpt-4" });
+
+const prompt = PromptTemplate.fromTemplate(
+  "Tell me a {adjective} joke about {content}."
+);
+
+const chain = new LLMChain({ llm: model, prompt });
+
+const result = await chain.call({
+  adjective: "funny",
+  content: "chickens",
+});
+
+console.log(result.text);
+```
+
+### Using ConversationalRetrievalQAChain
+
+```typescript
+import { ConversationalRetrievalQAChain } from "@langchain/classic/chains";
+import { ChatOpenAI } from "@langchain/openai";
+import { OpenAIEmbeddings } from "@langchain/openai";
+import { MemoryVectorStore } from "langchain/vectorstores/memory";
+
+// Create vector store with documents
+const vectorStore = await MemoryVectorStore.fromTexts(
+  ["Document 1 text...", "Document 2 text..."],
+  [{ id: 1 }, { id: 2 }],
+  new OpenAIEmbeddings()
+);
+
+// Create chain
+const model = new ChatOpenAI({ model: "gpt-4" });
+const chain = ConversationalRetrievalQAChain.fromLLM(
+  model,
+  vectorStore.asRetriever()
+);
+
+// Use chain
+const result = await chain.call({
+  question: "What is in the documents?",
+  chat_history: [],
+});
+
+console.log(result.text);
+```
+
+## Resources
+
+- [LangChain v1.0 Release Notes](https://docs.langchain.com/oss/javascript/releases/langchain-v1)
+- [Migration Guide](https://docs.langchain.com/oss/javascript/migrate/langchain-v1)
+- [LangChain v1.0 Documentation](https://docs.langchain.com/oss/javascript/langchain/agents)
+- [GitHub Repository](https://github.com/langchain-ai/langchainjs)
+
+## Support
+
+For bug reports and issues, please open an issue on [GitHub](https://github.com/langchain-ai/langchainjs/issues).
+
+For questions and discussions, join our [Discord community](https://discord.gg/langchain).
+
+## License
+
+This package is licensed under the MIT License. See the [LICENSE](../../LICENSE) file for details.

package/dist/agents/initialize.d.ts

@@ -7,7 +7,7 @@ import { StructuredChatAgent } from "./structured_chat/index.js";
 import { OpenAIAgent } from "./openai_functions/index.js";
 import { XMLAgent } from "./xml/index.js";
 import { StructuredToolInterface, ToolInterface } from "@langchain/core/tools";
-import * as _langchain_core_language_models_base2 from "@langchain/core/language_models/base";
+import * as _langchain_core_language_models_base0 from "@langchain/core/language_models/base";
 import { BaseLanguageModelInterface } from "@langchain/core/language_models/base";
 import { CallbackManager } from "@langchain/core/callbacks/manager";
 
@@ -19,7 +19,7 @@ import { CallbackManager } from "@langchain/core/callbacks/manager";
  * "chat-conversational-react-description".
  */
 type AgentType = "zero-shot-react-description" | "chat-zero-shot-react-description" | "chat-conversational-react-description";
-declare const initializeAgentExecutor: (tools: ToolInterface<StringInputToolSchema, any, any>[], llm: BaseLanguageModelInterface<any, _langchain_core_language_models_base2.BaseLanguageModelCallOptions>, _agentType?: AgentType | undefined, _verbose?: boolean | undefined, _callbackManager?: CallbackManager | undefined) => Promise<AgentExecutor>;
+declare const initializeAgentExecutor: (tools: ToolInterface<StringInputToolSchema, any, any>[], llm: BaseLanguageModelInterface<any, _langchain_core_language_models_base0.BaseLanguageModelCallOptions>, _agentType?: AgentType | undefined, _verbose?: boolean | undefined, _callbackManager?: CallbackManager | undefined) => Promise<AgentExecutor>;
 /**
  * @interface
  */

package/dist/agents/initialize.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"initialize.d.ts","names":["_langchain_core_language_models_base2","BaseLanguageModelInterface","StructuredToolInterface","ToolInterface","CallbackManager","ChatAgent","ChatConversationalAgent","StructuredChatAgent","AgentExecutor","AgentExecutorInput","ZeroShotAgent","OpenAIAgent","XMLAgent","AgentType","initializeAgentExecutor","_________langchain_core_dist_tools_types_js0","StringInputToolSchema","BaseLanguageModelCallOptions","Promise","InitializeAgentExecutorOptions","fromLLMAndTools","Parameters","Omit","InitializeAgentExecutorOptionsStructured","initializeAgentExecutorWithOptions"],"sources":["../../src/agents/initialize.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport type { StructuredToolInterface, ToolInterface } from \"@langchain/core/tools\";\nimport { CallbackManager } from \"@langchain/core/callbacks/manager\";\nimport { ChatAgent } from \"./chat/index.js\";\nimport { ChatConversationalAgent } from \"./chat_convo/index.js\";\nimport { StructuredChatAgent } from \"./structured_chat/index.js\";\nimport { AgentExecutor, AgentExecutorInput } from \"./executor.js\";\nimport { ZeroShotAgent } from \"./mrkl/index.js\";\nimport { OpenAIAgent } from \"./openai_functions/index.js\";\nimport { XMLAgent } from \"./xml/index.js\";\n/**\n * Represents the type of an agent in LangChain. It can be\n * \"zero-shot-react-description\", \"chat-zero-shot-react-description\", or\n * \"chat-conversational-react-description\".\n */\ntype AgentType = \"zero-shot-react-description\" | \"chat-zero-shot-react-description\" | \"chat-conversational-react-description\";\nexport declare const initializeAgentExecutor: (tools: ToolInterface<import(\"../../../langchain-core/dist/tools/types.js\").StringInputToolSchema, any, any>[], llm: BaseLanguageModelInterface<any, import(\"@langchain/core/language_models/base\").BaseLanguageModelCallOptions>, _agentType?: AgentType | undefined, _verbose?: boolean | undefined, _callbackManager?: CallbackManager | undefined) => Promise<AgentExecutor>;\n/**\n * @interface\n */\nexport type InitializeAgentExecutorOptions = ({\n    agentType: \"zero-shot-react-description\";\n    agentArgs?: Parameters<typeof ZeroShotAgent.fromLLMAndTools>[2];\n    memory?: never;\n} & Omit<AgentExecutorInput, \"agent\" | \"tools\">) | ({\n    agentType: \"chat-zero-shot-react-description\";\n    agentArgs?: Parameters<typeof ChatAgent.fromLLMAndTools>[2];\n    memory?: never;\n} & Omit<AgentExecutorInput, \"agent\" | \"tools\">) | ({\n    agentType: \"chat-conversational-react-description\";\n    agentArgs?: Parameters<typeof ChatConversationalAgent.fromLLMAndTools>[2];\n} & Omit<AgentExecutorInput, \"agent\" | \"tools\">) | ({\n    agentType: \"xml\";\n    agentArgs?: Parameters<typeof XMLAgent.fromLLMAndTools>[2];\n} & Omit<AgentExecutorInput, \"agent\" | \"tools\">);\n/**\n * @interface\n */\nexport type InitializeAgentExecutorOptionsStructured = ({\n    agentType: \"structured-chat-zero-shot-react-description\";\n    agentArgs?: Parameters<typeof StructuredChatAgent.fromLLMAndTools>[2];\n} & Omit<AgentExecutorInput, \"agent\" | \"tools\">) | ({\n    agentType: \"openai-functions\";\n    agentArgs?: Parameters<typeof OpenAIAgent.fromLLMAndTools>[2];\n} & Omit<AgentExecutorInput, \"agent\" | \"tools\">);\n/**\n * Initialize an agent executor with options.\n * @param tools Array of tools to use in the agent\n * @param llm LLM or ChatModel to use in the agent\n * @param options Options for the agent, including agentType, agentArgs, and other options for AgentExecutor.fromAgentAndTools\n * @returns AgentExecutor\n */\nexport declare function initializeAgentExecutorWithOptions(tools: StructuredToolInterface[], llm: BaseLanguageModelInterface, options: InitializeAgentExecutorOptionsStructured): Promise<AgentExecutor>;\nexport declare function initializeAgentExecutorWithOptions(tools: ToolInterface[], llm: BaseLanguageModelInterface, options?: InitializeAgentExecutorOptions): Promise<AgentExecutor>;\nexport {};\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAS0C;AAO1C,KADKa,SAAAA,GACgBC,6BAAyY,GAAA,kCAAA,GAAA,uCAAA;AAAA,cAAzYA,uBAAyY,EAAA,CAAA,KAAA,EAAxWX,aAAwW,CAAA,qBAAA,EAAA,GAAA,EAAA,GAAA,CAAA,EAAA,EAAA,GAAA,EAA3PF,0BAA2P,CAAA,GAAA,EAA3VD,qCAAAA,CAA+KiB,4BAAAA,CAA4K,EAAA,UAAA,CAAA,EAAhIJ,SAAgI,GAAA,SAAA,EAAA,QAAA,CAAA,EAAA,OAAA,GAAA,SAAA,EAAA,gBAAA,CAAA,EAAtDT,eAAsD,GAAA,SAAA,EAAA,GAAtBc,OAAsB,CAAdV,aAAc,CAAA;;;;AAA3PP,KAIvJkB,8BAAAA,GAJuJlB,CAAAA;EAA0B,SAAiGY,EAAAA,6BAAAA;EAAS,SAAiET,CAAAA,EAMxViB,UANwVjB,CAAAA,OAMtUM,aAAAA,CAAcU,eANwThB,CAAAA,CAAAA,CAAAA,CAAAA;EAAe,MAAyBI,CAAAA,EAAAA,KAAAA;CAAa,GAQzZc,IARoYJ,CAQ/XT,kBAR+XS,EAAAA,OAAAA,GAAAA,OAAAA,CAAAA,CAAAA,GAAAA,CAAAA;EAAO,SAAA,EAAA,kCAAA;EAInYC,SAAAA,CAAAA,EAMIE,UANJF,CAAAA,OAMsBd,SAAAA,CAAUe,eANF,CAAA,CAAA,CAAA,CAAA;EAAA,MAAA,CAAA,EAAA,KAAA;CAAA,GAQtCE,IAN8BZ,CAMzBD,kBANuCW,EAAAA,OAAAA,GAAAA,OAAAA,CAAAA,CAAAA,GAAAA,CAAAA;EAAe,SAA/CC,EAAAA,uCAAAA;EAAU,SAEjBZ,CAAAA,EAMOY,UANPZ,CAAAA,OAMyBH,uBAAAA,CAAwBc,eANjDX,CAAAA,CAAAA,CAAAA,CAAAA;CAAkB,GAOvBa,IAPAA,CAOKb,kBAPLa,EAAAA,OAAAA,GAAAA,OAAAA,CAAAA,CAAAA,GAAAA,CAAAA;EAAI,SAE0BjB,EAAAA,KAAUe;EAAe,SAA3CC,CAAAA,EAOAA,UAPAA,CAAAA,OAOkBT,QAAAA,CAASQ,eAP3BC,CAAAA,CAAAA,CAAAA,CAAAA;CAAU,GAQtBC,IANKb,CAMAA,kBANAA,EAAAA,OAAAA,GAAAA,OAAAA,CAAAA,CAAAA;;;;AAGAA,KAOGc,wCAAAA,GAPHd,CAAAA;EAAkB,SAAvBa,EAAAA,6CAAAA;EAAI,SAE0BV,CAAAA,EAOlBS,UAP2BD,CAAAA,OAOTb,mBAAAA,CAAoBa,eAPXA,CAAAA,CAAAA,CAAAA,CAAAA;CAAe,GAQtDE,IARYD,CAQPZ,kBAROY,EAAAA,OAAAA,GAAAA,OAAAA,CAAAA,CAAAA,GAAAA,CAAAA;EAAU,SACjBZ,EAAAA,kBAAAA;EAAkB,SAAvBa,CAAAA,EASYD,UATZC,CAAAA,OAS8BX,WAAAA,CAAYS,eAT1CE,CAAAA,CAAAA,CAAAA,CAAAA;AAAI,CAAA,GAUJA,IAVI,CAUCb,kBAVD,EAAA,OAAA,GAAA,OAAA,CAAA,CAAA;AAIR;;;;;;;AAKgBY,iBASQG,kCAAAA,CATRH,KAAAA,EASkDnB,uBATlDmB,EAAAA,EAAAA,GAAAA,EASkFpB,0BATlFoB,EAAAA,OAAAA,EASuHE,wCATvHF,CAAAA,EASkKH,OATlKG,CAS0Kb,aAT1Ka,CAAAA;AACPZ,iBASee,kCAAAA,CATff,KAAAA,EASyDN,aATzDM,EAAAA,EAAAA,GAAAA,EAS+ER,0BAT/EQ,EAAAA,OAAAA,CAAAA,EASqHU,8BATrHV,CAAAA,EASsJS,OATtJT,CAS8JD,aAT9JC,CAAAA"}
+{"version":3,"file":"initialize.d.ts","names":["_langchain_core_language_models_base0","BaseLanguageModelInterface","StructuredToolInterface","ToolInterface","CallbackManager","ChatAgent","ChatConversationalAgent","StructuredChatAgent","AgentExecutor","AgentExecutorInput","ZeroShotAgent","OpenAIAgent","XMLAgent","AgentType","initializeAgentExecutor","_________langchain_core_dist_tools_types_js0","StringInputToolSchema","BaseLanguageModelCallOptions","Promise","InitializeAgentExecutorOptions","fromLLMAndTools","Parameters","Omit","InitializeAgentExecutorOptionsStructured","initializeAgentExecutorWithOptions"],"sources":["../../src/agents/initialize.d.ts"],"sourcesContent":["import type { BaseLanguageModelInterface } from \"@langchain/core/language_models/base\";\nimport type { StructuredToolInterface, ToolInterface } from \"@langchain/core/tools\";\nimport { CallbackManager } from \"@langchain/core/callbacks/manager\";\nimport { ChatAgent } from \"./chat/index.js\";\nimport { ChatConversationalAgent } from \"./chat_convo/index.js\";\nimport { StructuredChatAgent } from \"./structured_chat/index.js\";\nimport { AgentExecutor, AgentExecutorInput } from \"./executor.js\";\nimport { ZeroShotAgent } from \"./mrkl/index.js\";\nimport { OpenAIAgent } from \"./openai_functions/index.js\";\nimport { XMLAgent } from \"./xml/index.js\";\n/**\n * Represents the type of an agent in LangChain. It can be\n * \"zero-shot-react-description\", \"chat-zero-shot-react-description\", or\n * \"chat-conversational-react-description\".\n */\ntype AgentType = \"zero-shot-react-description\" | \"chat-zero-shot-react-description\" | \"chat-conversational-react-description\";\nexport declare const initializeAgentExecutor: (tools: ToolInterface<import(\"../../../langchain-core/dist/tools/types.js\").StringInputToolSchema, any, any>[], llm: BaseLanguageModelInterface<any, import(\"@langchain/core/language_models/base\").BaseLanguageModelCallOptions>, _agentType?: AgentType | undefined, _verbose?: boolean | undefined, _callbackManager?: CallbackManager | undefined) => Promise<AgentExecutor>;\n/**\n * @interface\n */\nexport type InitializeAgentExecutorOptions = ({\n    agentType: \"zero-shot-react-description\";\n    agentArgs?: Parameters<typeof ZeroShotAgent.fromLLMAndTools>[2];\n    memory?: never;\n} & Omit<AgentExecutorInput, \"agent\" | \"tools\">) | ({\n    agentType: \"chat-zero-shot-react-description\";\n    agentArgs?: Parameters<typeof ChatAgent.fromLLMAndTools>[2];\n    memory?: never;\n} & Omit<AgentExecutorInput, \"agent\" | \"tools\">) | ({\n    agentType: \"chat-conversational-react-description\";\n    agentArgs?: Parameters<typeof ChatConversationalAgent.fromLLMAndTools>[2];\n} & Omit<AgentExecutorInput, \"agent\" | \"tools\">) | ({\n    agentType: \"xml\";\n    agentArgs?: Parameters<typeof XMLAgent.fromLLMAndTools>[2];\n} & Omit<AgentExecutorInput, \"agent\" | \"tools\">);\n/**\n * @interface\n */\nexport type InitializeAgentExecutorOptionsStructured = ({\n    agentType: \"structured-chat-zero-shot-react-description\";\n    agentArgs?: Parameters<typeof StructuredChatAgent.fromLLMAndTools>[2];\n} & Omit<AgentExecutorInput, \"agent\" | \"tools\">) | ({\n    agentType: \"openai-functions\";\n    agentArgs?: Parameters<typeof OpenAIAgent.fromLLMAndTools>[2];\n} & Omit<AgentExecutorInput, \"agent\" | \"tools\">);\n/**\n * Initialize an agent executor with options.\n * @param tools Array of tools to use in the agent\n * @param llm LLM or ChatModel to use in the agent\n * @param options Options for the agent, including agentType, agentArgs, and other options for AgentExecutor.fromAgentAndTools\n * @returns AgentExecutor\n */\nexport declare function initializeAgentExecutorWithOptions(tools: StructuredToolInterface[], llm: BaseLanguageModelInterface, options: InitializeAgentExecutorOptionsStructured): Promise<AgentExecutor>;\nexport declare function initializeAgentExecutorWithOptions(tools: ToolInterface[], llm: BaseLanguageModelInterface, options?: InitializeAgentExecutorOptions): Promise<AgentExecutor>;\nexport {};\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAS0C;AAO1C,KADKa,SAAAA,GACgBC,6BAAyY,GAAA,kCAAA,GAAA,uCAAA;AAAA,cAAzYA,uBAAyY,EAAA,CAAA,KAAA,EAAxWX,aAAwW,CAAA,qBAAA,EAAA,GAAA,EAAA,GAAA,CAAA,EAAA,EAAA,GAAA,EAA3PF,0BAA2P,CAAA,GAAA,EAA3VD,qCAAAA,CAA+KiB,4BAAAA,CAA4K,EAAA,UAAA,CAAA,EAAhIJ,SAAgI,GAAA,SAAA,EAAA,QAAA,CAAA,EAAA,OAAA,GAAA,SAAA,EAAA,gBAAA,CAAA,EAAtDT,eAAsD,GAAA,SAAA,EAAA,GAAtBc,OAAsB,CAAdV,aAAc,CAAA;;;;AAA3PP,KAIvJkB,8BAAAA,GAJuJlB,CAAAA;EAA0B,SAAiGY,EAAAA,6BAAAA;EAAS,SAAiET,CAAAA,EAMxViB,UANwVjB,CAAAA,OAMtUM,aAAAA,CAAcU,eANwThB,CAAAA,CAAAA,CAAAA,CAAAA;EAAe,MAAyBI,CAAAA,EAAAA,KAAAA;CAAa,GAQzZc,IARoYJ,CAQ/XT,kBAR+XS,EAAAA,OAAAA,GAAAA,OAAAA,CAAAA,CAAAA,GAAAA,CAAAA;EAAO,SAAA,EAAA,kCAAA;EAInYC,SAAAA,CAAAA,EAMIE,UANJF,CAAAA,OAMsBd,SAAAA,CAAUe,eANF,CAAA,CAAA,CAAA,CAAA;EAAA,MAAA,CAAA,EAAA,KAAA;CAAA,GAQtCE,IAN8BZ,CAMzBD,kBANuCW,EAAAA,OAAAA,GAAAA,OAAAA,CAAAA,CAAAA,GAAAA,CAAAA;EAAe,SAA/CC,EAAAA,uCAAAA;EAAU,SAEjBZ,CAAAA,EAMOY,UANPZ,CAAAA,OAMyBH,uBAAAA,CAAwBc,eANjDX,CAAAA,CAAAA,CAAAA,CAAAA;CAAkB,GAOvBa,IAPAA,CAOKb,kBAPLa,EAAAA,OAAAA,GAAAA,OAAAA,CAAAA,CAAAA,GAAAA,CAAAA;EAAI,SAE0BjB,EAAAA,KAAUe;EAAe,SAA3CC,CAAAA,EAOAA,UAPAA,CAAAA,OAOkBT,QAAAA,CAASQ,eAP3BC,CAAAA,CAAAA,CAAAA,CAAAA;CAAU,GAQtBC,IANKb,CAMAA,kBANAA,EAAAA,OAAAA,GAAAA,OAAAA,CAAAA,CAAAA;;;;AAGAA,KAOGc,wCAAAA,GAPHd,CAAAA;EAAkB,SAAvBa,EAAAA,6CAAAA;EAAI,SAE0BV,CAAAA,EAOlBS,UAP2BD,CAAAA,OAOTb,mBAAAA,CAAoBa,eAPXA,CAAAA,CAAAA,CAAAA,CAAAA;CAAe,GAQtDE,IARYD,CAQPZ,kBAROY,EAAAA,OAAAA,GAAAA,OAAAA,CAAAA,CAAAA,GAAAA,CAAAA;EAAU,SACjBZ,EAAAA,kBAAAA;EAAkB,SAAvBa,CAAAA,EASYD,UATZC,CAAAA,OAS8BX,WAAAA,CAAYS,eAT1CE,CAAAA,CAAAA,CAAAA,CAAAA;AAAI,CAAA,GAUJA,IAVI,CAUCb,kBAVD,EAAA,OAAA,GAAA,OAAA,CAAA,CAAA;AAIR;;;;;;;AAKgBY,iBASQG,kCAAAA,CATRH,KAAAA,EASkDnB,uBATlDmB,EAAAA,EAAAA,GAAAA,EASkFpB,0BATlFoB,EAAAA,OAAAA,EASuHE,wCATvHF,CAAAA,EASkKH,OATlKG,CAS0Kb,aAT1Ka,CAAAA;AACPZ,iBASee,kCAAAA,CATff,KAAAA,EASyDN,aATzDM,EAAAA,EAAAA,GAAAA,EAS+ER,0BAT/EQ,EAAAA,OAAAA,CAAAA,EASqHU,8BATrHV,CAAAA,EASsJS,OATtJT,CAS8JD,aAT9JC,CAAAA"}

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"],"mappings":";;;;;;AAOA;;;AAUyBI,cAVJD,yBAAAA,SAAkCF,uBAAAA,CAU9BG;EAAO,YAVuBH,EAAAA,MAAAA,EAAAA;EAAuB,cAAA,EAAA,MAAA;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"],"mappings":";;;;;;AAOA;;;AAUyBI,cAVJD,yBAAAA,SAAkCF,uBAAAA,CAU9BG;EAAO,YAVuBH,EAAAA,MAAAA,EAAAA;EAAuB,cAAA,EAAA,MAAA;uBAGrDD;;;;;;;uBAOAI"}

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","___index_js0","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[]\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n         | 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(\"../index.js\").AgentFinish | import(\"../index.js\").AgentAction[]>>;\n"],"mappings":";;;;;;;;;;;;;;AAWYS,KAAAA,4BAAAA,GAA4B;EAAA;;;;;EAMlB,GAMXT,EANFC,aAMED,CANYE,wBAMZF,GAAAA;IAA4BK,KAAAA,CAAAA,EALvBL,uBAKuBK,EAAAA,GALKD,YAAAA,CAAaM,kBAKlBL;IAE3BF;IAAAA,EAAkB,GAAA,EAAA;EA+DNQ,CAAAA,CAAAA;EAAsB;EAAA,KAAGC,EAjEtCZ,uBAiEsCY,EAAAA,GAjEVP,cAiEUO,EAAAA;EAAG;EAAO,MAAEE,EA/DjDX,kBA+DiDW;EAAM;;;;EAE/B,cAAA,CAAA,EAAA,OAAA;CAAoC;;AAFqD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAArGH,sBAAAA;;;;;GAA+DF,+BAA+BU,QAAQX;SACnHD;GAAc,WAAA,GACW,WAAA"}
+{"version":3,"file":"index.d.cts","names":["StructuredToolInterface","BaseChatModel","BaseChatModelCallOptions","ChatPromptTemplate","OpenAIClient","ToolDefinition","OpenAIToolsAgentOutputParser","ToolsAgentStep","AgentRunnableSequence","CreateOpenAIToolsAgentParams","ChatCompletionTool","createOpenAIToolsAgent","llm","tools","prompt","streamRunnable","___index_js1","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[]\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n         | 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(\"../index.js\").AgentFinish | import(\"../index.js\").AgentAction[]>>;\n"],"mappings":";;;;;;;;;;;;;;AAWYS,KAAAA,4BAAAA,GAA4B;EAAA;;;;;EAMlB,GAMXT,EANFC,aAMED,CANYE,wBAMZF,GAAAA;IAA4BK,KAAAA,CAAAA,EALvBL,uBAKuBK,EAAAA,GALKD,YAAAA,CAAaM,kBAKlBL;IAE3BF;IAAAA,EAAkB,GAAA,EAAA;EA+DNQ,CAAAA,CAAAA;EAAsB;EAAA,KAAGC,EAjEtCZ,uBAiEsCY,EAAAA,GAjEVP,cAiEUO,EAAAA;EAAG;EAAO,MAAEE,EA/DjDX,kBA+DiDW;EAAM;;;;EAE/B,cAAA,CAAA,EAAA,OAAA;CAAoC;;AAFqD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAArGH,sBAAAA;;;;;GAA+DF,+BAA+BU,QAAQX;SACnHD;GAAc,WAAA,GACW,WAAA"}

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","___index_js0","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[]\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n         | 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(\"../index.js\").AgentFinish | import(\"../index.js\").AgentAction[]>>;\n"],"mappings":";;;;;;;;;;;;;;AAWYS,KAAAA,4BAAAA,GAA4B;EAAA;;;;;EAMlB,GAMXT,EANFC,aAMED,CANYE,wBAMZF,GAAAA;IAA4BK,KAAAA,CAAAA,EALvBL,uBAKuBK,EAAAA,GALKD,YAAAA,CAAaM,kBAKlBL;IAE3BF;IAAAA,EAAkB,GAAA,EAAA;EA+DNQ,CAAAA,CAAAA;EAAsB;EAAA,KAAGC,EAjEtCZ,uBAiEsCY,EAAAA,GAjEVP,cAiEUO,EAAAA;EAAG;EAAO,MAAEE,EA/DjDX,kBA+DiDW;EAAM;;;;EAE/B,cAAA,CAAA,EAAA,OAAA;CAAoC;;AAFqD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAArGH,sBAAAA;;;;;GAA+DF,+BAA+BU,QAAQX;SACnHD;GAAc,WAAA,GACW,WAAA"}
+{"version":3,"file":"index.d.ts","names":["StructuredToolInterface","BaseChatModel","BaseChatModelCallOptions","ChatPromptTemplate","OpenAIClient","ToolDefinition","OpenAIToolsAgentOutputParser","ToolsAgentStep","AgentRunnableSequence","CreateOpenAIToolsAgentParams","ChatCompletionTool","createOpenAIToolsAgent","llm","tools","prompt","streamRunnable","___index_js1","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[]\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n         | 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(\"../index.js\").AgentFinish | import(\"../index.js\").AgentAction[]>>;\n"],"mappings":";;;;;;;;;;;;;;AAWYS,KAAAA,4BAAAA,GAA4B;EAAA;;;;;EAMlB,GAMXT,EANFC,aAMED,CANYE,wBAMZF,GAAAA;IAA4BK,KAAAA,CAAAA,EALvBL,uBAKuBK,EAAAA,GALKD,YAAAA,CAAaM,kBAKlBL;IAE3BF;IAAAA,EAAkB,GAAA,EAAA;EA+DNQ,CAAAA,CAAAA;EAAsB;EAAA,KAAGC,EAjEtCZ,uBAiEsCY,EAAAA,GAjEVP,cAiEUO,EAAAA;EAAG;EAAO,MAAEE,EA/DjDX,kBA+DiDW;EAAM;;;;EAE/B,cAAA,CAAA,EAAA,OAAA;CAAoC;;AAFqD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAArGH,sBAAAA;;;;;GAA+DF,+BAA+BU,QAAQX;SACnHD;GAAc,WAAA,GACW,WAAA"}

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

@@ -2,7 +2,7 @@ import { AgentRunnableSequence } from "../agent.js";
 import { BasePromptTemplate } from "@langchain/core/prompts";
 import { ToolInterface } from "@langchain/core/tools";
 import { BaseLanguageModelInterface } from "@langchain/core/language_models/base";
-import * as _langchain_core_agents1 from "@langchain/core/agents";
+import * as _langchain_core_agents0 from "@langchain/core/agents";
 import { AgentStep } from "@langchain/core/agents";
 
 //#region src/agents/react/index.d.ts
@@ -75,7 +75,7 @@ declare function createReactAgent({
   streamRunnable
 }: CreateReactAgentParams): Promise<AgentRunnableSequence<{
   steps: AgentStep[];
-}, _langchain_core_agents1.AgentAction | _langchain_core_agents1.AgentFinish>>;
+}, _langchain_core_agents0.AgentAction | _langchain_core_agents0.AgentFinish>>;
 //#endregion
 export { CreateReactAgentParams, createReactAgent };
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":["ToolInterface","BasePromptTemplate","BaseLanguageModelInterface","AgentStep","AgentRunnableSequence","CreateReactAgentParams","createReactAgent","llm","tools","prompt","streamRunnable","_langchain_core_agents1","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"],"mappings":";;;;;;;;;;;AAQYK,KAAAA,sBAAAA,GAAsB;EAAA;EAAA,GAEzBH,EAAAA,0BAAAA;EAA0B;EAEX,KAKZD,EALDD,aAKCC,EAAAA;EAAkB;AAkD9B;;;EAA8C,MAAEO,EAlDpCP,kBAkDoCO;EAAK;;;;EACjC,cAAAG,CAAAA,EAAAA,OAAAA;CAC2B;;;AAFkE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAzFL,gBAAAA;;;;;GAAyDD,yBAAyBS,QAAQV;SACvGD;GAASQ,uBAAAA,CACgBC,WAAAA,GAAWD,uBAAAA,CAAoCE"}
+{"version":3,"file":"index.d.ts","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"],"mappings":";;;;;;;;;;;AAQYK,KAAAA,sBAAAA,GAAsB;EAAA;EAAA,GAEzBH,EAAAA,0BAAAA;EAA0B;EAEX,KAKZD,EALDD,aAKCC,EAAAA;EAAkB;AAkD9B;;;EAA8C,MAAEO,EAlDpCP,kBAkDoCO;EAAK;;;;EACjC,cAAAG,CAAAA,EAAAA,OAAAA;CAC2B;;;AAFkE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAzFL,gBAAAA;;;;;GAAyDD,yBAAyBS,QAAQV;SACvGD;GAASQ,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_agents0 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_agents0.AgentAction | _langchain_core_agents0.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_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"],"mappings":";;;;;;;;;;;;;;AAaA;AAgBA;AAAoC,UAhBnBc,8BAAAA,CAgBmB;EAAA;EAAsB,MAAnBP,CAAAA,EAAAA,MAAAA;EAAQ;EAK1BS,MAAAA,CAAAA,EAAAA,MAAAA;EAAmB;EAAA,oBAGjBD,CAAAA,EAAAA,MAAAA;EAAwB;EAUQ,cAOZJ,CAAAA,EAAAA,MAAAA,EAAAA;EAAgB;EAEd,aAQdL,CAAAA,EAzCXF,yBAyCWE,EAAAA;;;;;;AA2BCL,KA9DpBc,wBAAAA,GAA2BR,QA8DPN,CA9DgBW,UA8DhBX,EAAAA,cAAAA,CAAAA;;;;;AAzDiBO,cAA5BQ,mBAAAA,SAA4BR,KAAAA,CAAAA;EAAK,OAAA,OAAA,CAAA,CAAA,EAAA,MAAA;EA8D1CU,YAAAA,EAAAA,MAAAA,EAAAA;EAA+B,WAAA,CAAA,KAAA,EA3DpBH,wBA2DoB;EAAA,UAElCd,CAAAA,CAAAA,EAAAA,6CAAAA;EAA0B,iBAEvBD,CAAAA,CAAAA,EAAAA,MAAAA;EAAuB,SAAGE,CAAAA,CAAAA,EAAAA,MAAAA;EAAc,KAKxCC,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAkB;AA+D9B;;;;EAA8D,OAAEmB,aAAAA,CAAAA,KAAAA,EAzHhCtB,uBAyHgCsB,EAAAA,CAAAA,EAAAA,IAAAA;EAAM;;;;;;EAAmF,OAA7BL,sBAAAA,CAAAA,OAAAA,EAlHjFN,gBAkHiFM,GAAAA;IAAO,SAAA,EAAA,MAAA,EAAA;MAhH3HJ;;;;;;;;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"],"mappings":";;;;;;;;;;;;;;AAaA;AAgBA;AAAoC,UAhBnBc,8BAAAA,CAgBmB;EAAA;EAAsB,MAAnBP,CAAAA,EAAAA,MAAAA;EAAQ;EAK1BS,MAAAA,CAAAA,EAAAA,MAAAA;EAAmB;EAAA,oBAGjBD,CAAAA,EAAAA,MAAAA;EAAwB;EAUQ,cAOZJ,CAAAA,EAAAA,MAAAA,EAAAA;EAAgB;EAEd,aAQdL,CAAAA,EAzCXF,yBAyCWE,EAAAA;;;;;;AA2BCL,KA9DpBc,wBAAAA,GAA2BR,QA8DPN,CA9DgBW,UA8DhBX,EAAAA,cAAAA,CAAAA;;;;;AAzDiBO,cAA5BQ,mBAAAA,SAA4BR,KAAAA,CAAAA;EAAK,OAAA,OAAA,CAAA,CAAA,EAAA,MAAA;EA8D1CU,YAAAA,EAAAA,MAAAA,EAAAA;EAA+B,WAAA,CAAA,KAAA,EA3DpBH,wBA2DoB;EAAA,UAElCd,CAAAA,CAAAA,EAAAA,6CAAAA;EAA0B,iBAEvBD,CAAAA,CAAAA,EAAAA,MAAAA;EAAuB,SAAGE,CAAAA,CAAAA,EAAAA,MAAAA;EAAc,KAKxCC,CAAAA,CAAAA,EAAAA,MAAAA,EAAAA;EAAkB;AA+D9B;;;;EAA8D,OAAEmB,aAAAA,CAAAA,KAAAA,EAzHhCtB,uBAyHgCsB,EAAAA,CAAAA,EAAAA,IAAAA;EAAM;;;;;;EAAmF,OAA7BL,sBAAAA,CAAAA,OAAAA,EAlHjFN,gBAkHiFM,GAAAA;IAAO,SAAA,EAAA,MAAA,EAAA;MAhH3HJ;;;;;;;;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.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":["ChatPromptTemplate","StructuredToolInterface","LanguageModelLike","ToolDefinition","AgentRunnableSequence","ToolsAgentStep","CreateToolCallingAgentParams","createToolCallingAgent","llm","tools","prompt","streamRunnable","___index_js1","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(\"../index.js\").AgentFinish | import(\"../index.js\").AgentAction[]>;\n"],"mappings":";;;;;;;;;;;AAQYM,KAAAA,4BAAAA,GAA4B;EAAA;;;;;EAUV,GAAA,EAJrBJ,iBAIqB;EAyDNK;EAAsB,KAAA,EA3DnCN,uBA2DmC,EAAA,GA3DPE,cA2DO,EAAA;EAAA;EAAM,MAAEM,EAzD1CT,kBAyD0CS;EAAK;;;;EAClC,cAAA,CAAA,EAAA,OAAA;CACW;;AAFuG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAnHF,sBAAAA;;;;;GAA+DD,+BAA+BF;SAC3GC;GAAc,WAAA,GACW,WAAA"}
+{"version":3,"file":"index.d.cts","names":["ChatPromptTemplate","StructuredToolInterface","LanguageModelLike","ToolDefinition","AgentRunnableSequence","ToolsAgentStep","CreateToolCallingAgentParams","createToolCallingAgent","llm","tools","prompt","streamRunnable","___index_js0","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(\"../index.js\").AgentFinish | import(\"../index.js\").AgentAction[]>;\n"],"mappings":";;;;;;;;;;;AAQYM,KAAAA,4BAAAA,GAA4B;EAAA;;;;;EAUV,GAAA,EAJrBJ,iBAIqB;EAyDNK;EAAsB,KAAA,EA3DnCN,uBA2DmC,EAAA,GA3DPE,cA2DO,EAAA;EAAA;EAAM,MAAEM,EAzD1CT,kBAyD0CS;EAAK;;;;EAClC,cAAA,CAAA,EAAA,OAAA;CACW;;AAFuG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAnHF,sBAAAA;;;;;GAA+DD,+BAA+BF;SAC3GC;GAAc,WAAA,GACW,WAAA"}