langchain 1.0.0-alpha.9 → 1.0.1

package/CHANGELOG.md

@@ -0,0 +1,260 @@
+# langchain
+
+## 1.0.0
+
+🎉 **LangChain v1.0** is here! This release provides a focused, production-ready foundation for building agents. We've streamlined the framework around three core improvements: **`createAgent`**, **standard content blocks**, and a **simplified package structure**. See the [release notes](https://docs.langchain.com/oss/javascript/releases/langchain-v1) for complete details.
+
+### ✨ Major Features
+
+#### `createAgent` - A new standard for building agents
+
+`createAgent` is the new standard way to build agents in LangChain 1.0. It provides a simpler interface than `createReactAgent` from LangGraph while offering greater customization potential through middleware.
+
+**Key features:**
+
+- **Clean, intuitive API**: Build agents with minimal boilerplate
+- **Built on LangGraph**: Get persistence, streaming, human-in-the-loop, and time travel out of the box
+- **Middleware-first design**: Highly customizable through composable middleware
+- **Improved structured output**: Generate structured outputs in the main agent loop without additional LLM calls
+
+Example:
+
+```typescript
+import { createAgent } from "langchain";
+
+const agent = createAgent({
+  model: "anthropic:claude-sonnet-4-5-20250929",
+  tools: [getWeather],
+  systemPrompt: "You are a helpful assistant.",
+});
+
+const result = await agent.invoke({
+  messages: [{ role: "user", content: "What is the weather in Tokyo?" }],
+});
+
+console.log(result.content);
+```
+
+Under the hood, `createAgent` is built on the basic agent loop—calling a model using LangGraph, letting it choose tools to execute, and then finishing when it calls no more tools.
+
+**Built on LangGraph features (work out of the box):**
+
+- **Persistence**: Conversations automatically persist across sessions with built-in checkpointing
+- **Streaming**: Stream tokens, tool calls, and reasoning traces in real-time
+- **Human-in-the-loop**: Pause agent execution for human approval before sensitive actions
+- **Time travel**: Rewind conversations to any point and explore alternate paths
+
+**Structured output improvements:**
+
+- Generate structured outputs in the main loop instead of requiring an additional LLM call
+- Models can choose between calling tools or using provider-side structured output generation
+- Significant cost reduction by eliminating extra LLM calls
+
+Example:
+
+```typescript
+import { createAgent } from "langchain";
+import * as z from "zod";
+
+const weatherSchema = z.object({
+  temperature: z.number(),
+  condition: z.string(),
+});
+
+const agent = createAgent({
+  model: "openai:gpt-4o-mini",
+  tools: [getWeather],
+  responseFormat: weatherSchema,
+});
+
+const result = await agent.invoke({
+  messages: [{ role: "user", content: "What is the weather in Tokyo?" }],
+});
+
+console.log(result.structuredResponse);
+```
+
+For more information, see [Agents documentation](https://docs.langchain.com/oss/javascript/langchain/agents).
+
+#### Middleware
+
+Middleware is what makes `createAgent` highly customizable, raising the ceiling for what you can build. Great agents require **context engineering**—getting the right information to the model at the right time. Middleware helps you control dynamic prompts, conversation summarization, selective tool access, state management, and guardrails through a composable abstraction.
+
+**Prebuilt middleware** for common patterns:
+
+```typescript
+import {
+  createAgent,
+  summarizationMiddleware,
+  humanInTheLoopMiddleware,
+  piiRedactionMiddleware,
+} from "langchain";
+
+const agent = createAgent({
+  model: "anthropic:claude-sonnet-4-5-20250929",
+  tools: [readEmail, sendEmail],
+  middleware: [
+    piiRedactionMiddleware({ patterns: ["email", "phone", "ssn"] }),
+    summarizationMiddleware({
+      model: "anthropic:claude-sonnet-4-5-20250929",
+      maxTokensBeforeSummary: 500,
+    }),
+    humanInTheLoopMiddleware({
+      interruptOn: {
+        sendEmail: {
+          allowedDecisions: ["approve", "edit", "reject"],
+        },
+      },
+    }),
+  ] as const,
+});
+```
+
+**Custom middleware** with lifecycle hooks:
+
+| Hook            | When it runs             | Use cases                               |
+| --------------- | ------------------------ | --------------------------------------- |
+| `beforeAgent`   | Before calling the agent | Load memory, validate input             |
+| `beforeModel`   | Before each LLM call     | Update prompts, trim messages           |
+| `wrapModelCall` | Around each LLM call     | Intercept and modify requests/responses |
+| `wrapToolCall`  | Around each tool call    | Intercept and modify tool execution     |
+| `afterModel`    | After each LLM response  | Validate output, apply guardrails       |
+| `afterAgent`    | After agent completes    | Save results, cleanup                   |
+
+Example custom middleware:
+
+```typescript
+import { createMiddleware } from "langchain";
+
+const contextSchema = z.object({
+  userExpertise: z.enum(["beginner", "expert"]).default("beginner"),
+});
+
+const expertiseBasedToolMiddleware = createMiddleware({
+  wrapModelCall: async (request, handler) => {
+    const userLevel = request.runtime.context.userExpertise;
+    if (userLevel === "expert") {
+      const tools = [advancedSearch, dataAnalysis];
+      return handler(request.replace("openai:gpt-5", tools));
+    }
+    const tools = [simpleSearch, basicCalculator];
+    return handler(request.replace("openai:gpt-5-nano", tools));
+  },
+});
+
+const agent = createAgent({
+  model: "anthropic:claude-sonnet-4-5-20250929",
+  tools: [simpleSearch, advancedSearch, basicCalculator, dataAnalysis],
+  middleware: [expertiseBasedToolMiddleware],
+  contextSchema,
+});
+```
+
+For more information, see the [complete middleware guide](https://docs.langchain.com/oss/javascript/langchain/middleware).
+
+#### Simplified Package
+
+LangChain v1 streamlines the `langchain` package namespace to focus on essential building blocks for agents. The package exposes only the most useful and relevant functionality (most re-exported from `@langchain/core` for convenience).
+
+**What's in the core `langchain` package:**
+
+- `createAgent` and agent-related utilities
+- Core message types and content blocks
+- Middleware infrastructure
+- Tool definitions and schemas
+- Prompt templates
+- Output parsers
+- Base runnable abstractions
+
+### 🔄 Migration Notes
+
+#### `@langchain/classic` for Legacy Functionality
+
+Legacy functionality has moved to [`@langchain/classic`](https://www.npmjs.com/package/@langchain/classic) to keep the core package lean and focused.
+
+**What's in `@langchain/classic`:**
+
+- Legacy chains and chain implementations
+- The indexing API
+- [`@langchain/community`](https://www.npmjs.com/package/@langchain/community) exports
+- Other deprecated functionality
+
+**To migrate legacy code:**
+
+1. Install `@langchain/classic`:
+
+   ```bash
+   npm install @langchain/classic
+   ```
+
+2. Update your imports:
+
+   ```typescript
+   import { ... } from "langchain"; // [!code --]
+   import { ... } from "@langchain/classic"; // [!code ++]
+
+   import { ... } from "langchain/chains"; // [!code --]
+   import { ... } from "@langchain/classic/chains"; // [!code ++]
+   ```
+
+#### Upgrading to v1
+
+Install the v1 packages:
+
+```bash
+npm install langchain@1.0.0 @langchain/core@1.0.0
+```
+
+### 📚 Additional Resources
+
+- [LangChain 1.0 Announcement](https://blog.langchain.com/langchain-langchain-1-0-alpha-releases/)
+- [Migration Guide](https://docs.langchain.com/oss/javascript/migrate/langchain-v1)
+- [Agents Documentation](https://docs.langchain.com/oss/javascript/langchain/agents)
+- [Middleware Guide](https://blog.langchain.com/agent-middleware/)
+
+---
+
+## 0.3.36
+
+### Patch Changes
+
+- cabd762: fix(langchain): add ChatMistralAI to well known models
+- Updated dependencies [e63c7cc]
+- Updated dependencies [b8ffc1e]
+  - @langchain/openai@0.6.16
+
+## 0.3.35
+
+### Patch Changes
+
+- fd4691f: use `keyEncoder` instead of insecure cache key getter
+- 2f19cd5: feat: Add Perplexity support to universal chat model
+- 3c94076: fix(langchain): Bind schemas for other types of pulled hub prompts
+- Updated dependencies [d38e9d6]
+  - @langchain/openai@0.6.14
+
+## 0.3.34
+
+### Patch Changes
+
+- 6019a7d: update JSONL loader to support complex json structures
+- caf5579: prevent ConfigurableModel mutation when using withStructuredOutput or bindTools
+- d60f40f: infer mistralai models
+- Updated dependencies [41bd944]
+- Updated dependencies [707a768]
+  - @langchain/openai@0.6.12
+
+## 0.3.33
+
+### Patch Changes
+
+- d2c7f09: support prompts not created from RunnableBinding
+
+## 0.3.32
+
+### Patch Changes
+
+- e0bd88c: add support for conversion of ref in array schema
+- Updated dependencies [4a3f5af]
+- Updated dependencies [424360b]
+  - @langchain/openai@0.6.10

package/README.md

@@ -1,24 +1,42 @@
 # 🦜️🔗 LangChain.js
 
-⚡ Building applications with LLMs through composability ⚡
+![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)
 
-[![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)
+LangChain is a framework for building LLM-powered applications. It helps you chain together interoperable components and third-party integrations to simplify AI application development — all while future-proofing decisions as the underlying technology evolves.
 
-Looking for the Python version? Check out [LangChain](https://github.com/langchain-ai/langchain).
+**Documentation**: To learn more about LangChain, check out [the docs](https://docs.langchain.com/oss/javascript/langchain/overview).
+
+If you're looking for more advanced customization or agent orchestration, check out [LangGraph.js](https://langchain-ai.github.io/langgraphjs/). our framework for building agents and controllable workflows.
+
+> [!NOTE]
+> Looking for the Python version? Check out [LangChain](https://github.com/langchain-ai/langchain).
 
 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.
 
 ## ⚡️ Quick Install
 
-You can use npm, yarn, or pnpm to install LangChain.js
+You can use npm, pnpm, or yarn to install LangChain.js
+
+`npm install -S langchain` or `pnpm install langchain` or `yarn add langchain`
+
+## 🚀 Why use LangChain?
+
+LangChain helps developers build applications powered by LLMs through a standard interface for agents, models, embeddings, vector stores, and more.
 
-`npm install -S langchain` or `yarn add langchain` or `pnpm add langchain`
+Use LangChain for:
+
+- **Real-time data augmentation**. Easily connect LLMs to diverse data sources and external/internal systems, drawing from LangChain’s vast library of integrations with model providers, tools, vector stores, retrievers, and more.
+- **Model interoperability**. Swap models in and out as your engineering team experiments to find the best choice for your application’s needs. As the industry frontier evolves, adapt quickly — LangChain’s abstractions keep you moving without losing momentum.
+
+## 📦 LangChain's ecosystem
+
+- [LangSmith](https://www.langchain.com/langsmith) - Unified developer platform for building, testing, and monitoring LLM applications. With LangSmith, you can debug poor-performing LLM app runs, evaluate agent trajectories, gain visibility in production, and deploy agents with confidence.
+- [LangGraph](https://docs.langchain.com/oss/javascript/langgraph/overview) - Build agents that can reliably handle complex tasks with LangGraph, our low-level agent orchestration framework. LangGraph offers customizable architecture, long-term memory, and human-in-the-loop workflows — and is trusted in production by companies like LinkedIn, Uber, Klarna, and GitLab.
 
 ## 🌐 Supported Environments
 
-LangChain is written in TypeScript and can be used in:
+LangChain.js is written in TypeScript and can be used in:
 
 - Node.js (ESM and CommonJS) - 18.x, 19.x, 20.x, 22.x
 - Cloudflare Workers
@@ -27,74 +45,12 @@ LangChain is written in TypeScript and can be used in:
 - Browser
 - Deno
 
-## 🤔 What is LangChain?
-
-**LangChain** is a framework for developing applications powered by language models. It enables applications that:
-
-- **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.)
-
-This framework consists of several parts.
-
-- **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/).
-
-The LangChain libraries themselves are made up of several different packages.
-
-- **[`@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.
-
-Integrations may also be split into their own compatible packages.
-
-![LangChain Stack](https://github.com/langchain-ai/langchainjs/blob/main/docs/core_docs/static/svg/langchain_stack_062024.svg)
-
-This library aims to assist in the development of those types of applications. Common examples of these applications include:
-
-**❓Question Answering over specific documents**
-
-- [Documentation](https://js.langchain.com/docs/tutorials/rag/)
-- End-to-end Example: [Doc-Chatbot](https://github.com/dissorial/doc-chatbot)
-
-**💬 Chatbots**
-
-- [Documentation](https://js.langchain.com/docs/tutorials/chatbot)
-- End-to-end Example: [Chat-LangChain](https://github.com/langchain-ai/chat-langchain)
-
-## 🚀 How does LangChain help?
-
-The main value props of the LangChain libraries are:
-
-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
-
-Off-the-shelf chains make it easy to get started. Components make it easy to customize existing chains and build new ones.
-
-Components fall into the following **modules**:
-
-**📃 Model I/O:**
-
-This includes prompt management, prompt optimization, a generic interface for all LLMs, and common utilities for working with LLMs.
-
-**📚 Retrieval:**
-
-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.
-
-**🤖 Agents:**
-
-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.
-
 ## 📖 Additional Resources
 
-- [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)
+- [Getting started](https://docs.langchain.com/oss/javascript/langchain/overview): Installation, setting up the environment, simple examples
+- [Learn](https://docs.langchain.com/oss/javascript/langchain/learn): Learn about the core concepts of LangChain.
+- [LangChain Forum](https://forum.langchain.com): Connect with the community and share all of your technical questions, ideas, and feedback.
+- [Chat LangChain](https://chat.langchain.com): Ask questions & chat with our documentaiton.
 
 ## 💁 Contributing
 
@@ -103,7 +59,3 @@ As an open-source project in a rapidly developing field, we are extremely open t
 For detailed information on how to contribute, see [here](https://github.com/langchain-ai/langchainjs/blob/main/CONTRIBUTING.md).
 
 Please report any security issues or concerns following our [security guidelines](https://github.com/langchain-ai/langchainjs/blob/main/SECURITY.md).
-
-## 🖇️ Relationship with Python LangChain
-
-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.

package/dist/agents/ReactAgent.cjs

@@ -4,6 +4,7 @@ const require_utils = require('./utils.cjs');
 const require_utils$1 = require('./nodes/utils.cjs');
 const require_AgentNode = require('./nodes/AgentNode.cjs');
 const require_ToolNode = require('./nodes/ToolNode.cjs');
+const require_utils$2 = require('./middleware/utils.cjs');
 const require_BeforeAgentNode = require('./nodes/BeforeAgentNode.cjs');
 const require_BeforeModelNode = require('./nodes/BeforeModelNode.cjs');
 const require_AfterModelNode = require('./nodes/AfterModelNode.cjs');
@@ -41,7 +42,7 @@ var ReactAgent = class {
 		* Create a schema that merges agent base schema with middleware state schemas
 		* Using Zod with withLangGraph ensures LangGraph Studio gets proper metadata
 		*/
-		const schema = require_annotation.createAgentAnnotationConditional(this.options.responseFormat !== void 0, this.options.middleware);
+		const schema = require_annotation.createAgentAnnotationConditional(this.options.responseFormat !== void 0, this.options.stateSchema, this.options.middleware);
 		const workflow = new __langchain_langgraph.StateGraph(schema, this.options.contextSchema);
 		const allNodeWorkflows = workflow;
 		const beforeAgentNodes = [];
@@ -77,7 +78,7 @@ var ReactAgent = class {
 				beforeAgentNodes.push({
 					index: i,
 					name,
-					allowed: m.beforeAgentJumpTo
+					allowed: require_utils$2.getHookConstraint(m.beforeAgent)
 				});
 				allNodeWorkflows.addNode(name, beforeAgentNode, beforeAgentNode.nodeOptions);
 			}
@@ -87,7 +88,7 @@ var ReactAgent = class {
 				beforeModelNodes.push({
 					index: i,
 					name,
-					allowed: m.beforeModelJumpTo
+					allowed: require_utils$2.getHookConstraint(m.beforeModel)
 				});
 				allNodeWorkflows.addNode(name, beforeModelNode, beforeModelNode.nodeOptions);
 			}
@@ -97,7 +98,7 @@ var ReactAgent = class {
 				afterModelNodes.push({
 					index: i,
 					name,
-					allowed: m.afterModelJumpTo
+					allowed: require_utils$2.getHookConstraint(m.afterModel)
 				});
 				allNodeWorkflows.addNode(name, afterModelNode, afterModelNode.nodeOptions);
 			}
@@ -107,7 +108,7 @@ var ReactAgent = class {
 				afterAgentNodes.push({
 					index: i,
 					name,
-					allowed: m.afterAgentJumpTo
+					allowed: require_utils$2.getHookConstraint(m.afterAgent)
 				});
 				allNodeWorkflows.addNode(name, afterAgentNode, afterAgentNode.nodeOptions);
 			}