langchain 1.0.0rc2__py3-none-any.whl → 1.0.2__py3-none-any.whl

langchain/agents/middleware/types.py

@@ -45,7 +45,6 @@ __all__ = [
     "ModelRequest",
     "ModelResponse",
     "OmitFromSchema",
-    "PublicAgentState",
     "after_agent",
     "after_model",
     "before_agent",
@@ -172,11 +171,14 @@ class AgentState(TypedDict, Generic[ResponseT]):
     structured_response: NotRequired[Annotated[ResponseT, OmitFromInput]]
 
 
-class PublicAgentState(TypedDict, Generic[ResponseT]):
-    """Public state schema for the agent.
+class _InputAgentState(TypedDict):  # noqa: PYI049
+    """Input state schema for the agent."""
 
-    Just used for typing purposes.
-    """
+    messages: Required[Annotated[list[AnyMessage | dict], add_messages]]
+
+
+class _OutputAgentState(TypedDict, Generic[ResponseT]):  # noqa: PYI049
+    """Output state schema for the agent."""
 
     messages: Required[Annotated[list[AnyMessage], add_messages]]
     structured_response: NotRequired[ResponseT]

langchain/chat_models/base.py

@@ -4,14 +4,7 @@ from __future__ import annotations
 
 import warnings
 from importlib import util
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Literal,
-    TypeAlias,
-    cast,
-    overload,
-)
+from typing import TYPE_CHECKING, Any, Literal, TypeAlias, cast, overload
 
 from langchain_core.language_models import BaseChatModel, LanguageModelInput
 from langchain_core.messages import AIMessage, AnyMessage
@@ -83,7 +76,7 @@ def init_chat_model(
         for supported model parameters.
 
     Args:
-        model: The name of the model, e.g. `'o3-mini'`, `'claude-sonnet-4-5-20250929'`.
+        model: The name of the model, e.g. `'o3-mini'`, `'claude-sonnet-4-5'`.
 
             You can also specify model and model provider in a single argument using:
 
@@ -179,7 +172,7 @@ def init_chat_model(
         from langchain.chat_models import init_chat_model
 
         o3_mini = init_chat_model("openai:o3-mini", temperature=0)
-        claude_sonnet = init_chat_model("anthropic:claude-sonnet-4-5-20250929", temperature=0)
+        claude_sonnet = init_chat_model("anthropic:claude-sonnet-4-5", temperature=0)
         gemini_2_flash = init_chat_model("google_vertexai:gemini-2.5-flash", temperature=0)
 
         o3_mini.invoke("what's your name")
@@ -201,7 +194,7 @@ def init_chat_model(
 
         configurable_model.invoke(
             "what's your name",
-            config={"configurable": {"model": "claude-sonnet-4-5-20250929"}},
+            config={"configurable": {"model": "claude-sonnet-4-5"}},
         )
         ```
 
@@ -225,7 +218,7 @@ def init_chat_model(
             "what's your name",
             config={
                 "configurable": {
-                    "foo_model": "anthropic:claude-sonnet-4-5-20250929",
+                    "foo_model": "anthropic:claude-sonnet-4-5",
                     "foo_temperature": 0.6,
                 }
             },
@@ -271,7 +264,7 @@ def init_chat_model(
 
         configurable_model_with_tools.invoke(
             "Which city is hotter today and which is bigger: LA or NY?",
-            config={"configurable": {"model": "claude-sonnet-4-5-20250929"}},
+            config={"configurable": {"model": "claude-sonnet-4-5"}},
         )
         ```
 
@@ -612,10 +605,7 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
     @property
     def InputType(self) -> TypeAlias:
         """Get the input type for this `Runnable`."""
-        from langchain_core.prompt_values import (
-            ChatPromptValueConcrete,
-            StringPromptValue,
-        )
+        from langchain_core.prompt_values import ChatPromptValueConcrete, StringPromptValue
 
         # This is a version of LanguageModelInput which replaces the abstract
         # base class BaseMessage with a union of its subclasses, which makes

langchain/embeddings/__init__.py

@@ -4,6 +4,12 @@
     This page contains **reference documentation** for Embeddings. See
     [the docs](https://docs.langchain.com/oss/python/langchain/retrieval#embedding-models)
     for conceptual guides, tutorials, and examples on using Embeddings.
+
+!!! warning "Modules moved"
+    With the release of `langchain 1.0.0`, several embeddings modules were moved to
+    `langchain-classic`, such as `CacheBackedEmbeddings` and all community
+    embeddings. See [list](https://github.com/langchain-ai/langchain/blob/bdf1cd383ce36dc18381a3bf3fb0a579337a32b5/libs/langchain/langchain/embeddings/__init__.py)
+    of moved modules to inform your migration.
 """
 
 from langchain_core.embeddings import Embeddings

langchain/embeddings/base.py

@@ -133,20 +133,34 @@ def init_embeddings(
         installed.
 
     Args:
-        model: Name of the model to use. Can be either:
+        model: Name of the model to use.
+
+            Can be either:
+
             - A model string like `"openai:text-embedding-3-small"`
-            - Just the model name if provider is specified
-        provider: Optional explicit provider name. If not specified,
-            will attempt to parse from the model string. Supported providers
-            and their required packages:
+            - Just the model name if the provider is specified separately or can be
+                inferred.
+
+            See supported providers under the `provider` arg description.
+        provider: Optional explicit provider name. If not specified, will attempt to
+            parse from the model string in the `model` arg.
+
+            Supported providers:
 
-            {_get_provider_list()}
+            - `openai`                  -> [`langchain-openai`](https://docs.langchain.com/oss/python/integrations/providers/openai)
+            - `azure_openai`            -> [`langchain-openai`](https://docs.langchain.com/oss/python/integrations/providers/openai)
+            - `bedrock`                 -> [`langchain-aws`](https://docs.langchain.com/oss/python/integrations/providers/aws)
+            - `cohere`                  -> [`langchain-cohere`](https://docs.langchain.com/oss/python/integrations/providers/cohere)
+            - `google_vertexai`         -> [`langchain-google-vertexai`](https://docs.langchain.com/oss/python/integrations/providers/google)
+            - `huggingface`             -> [`langchain-huggingface`](https://docs.langchain.com/oss/python/integrations/providers/huggingface)
+            - `mistraiai`               -> [`langchain-mistralai`](https://docs.langchain.com/oss/python/integrations/providers/mistralai)
+            - `ollama`                  -> [`langchain-ollama`](https://docs.langchain.com/oss/python/integrations/providers/ollama)
 
         **kwargs: Additional model-specific parameters passed to the embedding model.
             These vary by provider, see the provider-specific documentation for details.
 
     Returns:
-        An Embeddings instance that can generate embeddings for text.
+        An `Embeddings` instance that can generate embeddings for text.
 
     Raises:
         ValueError: If the model provider is not supported or cannot be determined

langchain/tools/tool_node.py

@@ -13,10 +13,10 @@ The module implements design patterns for:
 - Command-based state updates for advanced control flow
 
 Key Components:
-    ToolNode: Main class for executing tools in LangGraph workflows
-    InjectedState: Annotation for injecting graph state into tools
-    InjectedStore: Annotation for injecting persistent store into tools
-    tools_condition: Utility function for conditional routing based on tool calls
+    `ToolNode`: Main class for executing tools in LangGraph workflows
+    `InjectedState`: Annotation for injecting graph state into tools
+    `InjectedStore`: Annotation for injecting persistent store into tools
+    `tools_condition`: Utility function for conditional routing based on tool calls
 
 Typical Usage:
     ```python
@@ -49,7 +49,6 @@ from typing import (
     Generic,
     Literal,
     TypedDict,
-    TypeVar,
     Union,
     cast,
     get_args,
@@ -84,15 +83,19 @@ from langgraph.graph.message import REMOVE_ALL_MESSAGES
 from langgraph.store.base import BaseStore  # noqa: TC002
 from langgraph.types import Command, Send, StreamWriter
 from pydantic import BaseModel, ValidationError
-from typing_extensions import Unpack
+from typing_extensions import TypeVar, Unpack
 
 if TYPE_CHECKING:
     from collections.abc import Sequence
 
     from langgraph.runtime import Runtime
+    from pydantic_core import ErrorDetails
 
-StateT = TypeVar("StateT")
-ContextT = TypeVar("ContextT")
+# right now we use a dict as the default, can change this to AgentState, but depends
+# on if this lives in LangChain or LangGraph... ideally would have some typed
+# messages key
+StateT = TypeVar("StateT", default=dict)
+ContextT = TypeVar("ContextT", default=None)
 
 INVALID_TOOL_NAME_ERROR_TEMPLATE = (
     "Error: {requested_tool} is not a valid tool, try one of [{available_tools}]."
@@ -123,11 +126,11 @@ class ToolCallRequest:
     Attributes:
         tool_call: Tool call dict with name, args, and id from model output.
         tool: BaseTool instance to be invoked, or None if tool is not
-            registered with the ToolNode. When tool is None, interceptors can
-            handle the request without validation. If the interceptor calls execute(),
+            registered with the `ToolNode`. When tool is `None`, interceptors can
+            handle the request without validation. If the interceptor calls `execute()`,
             validation will occur and raise an error for unregistered tools.
-        state: Agent state (dict, list, or BaseModel).
-        runtime: LangGraph runtime context (optional, None if outside graph).
+        state: Agent state (`dict`, `list`, or `BaseModel`).
+        runtime: LangGraph runtime context (optional, `None` if outside graph).
     """
 
     tool_call: ToolCall
@@ -178,7 +181,7 @@ The execute callable can be invoked multiple times for retry logic,
 with potentially modified requests each time. Each call to execute
 is independent and stateless.
 
-Note:
+!!! note
     When implementing middleware for `create_agent`, use
     `AgentMiddleware.wrap_tool_call` which provides properly typed
     state parameter for better type safety.
@@ -247,7 +250,7 @@ AsyncToolCallWrapper = Callable[
 class ToolCallWithContext(TypedDict):
     """ToolCall with additional context for graph state.
 
-    This is an internal data structure meant to help the ToolNode accept
+    This is an internal data structure meant to help the `ToolNode` accept
     tool calls with additional context (e.g. state) when dispatched using the
     Send API.
 
@@ -268,16 +271,16 @@ class ToolCallWithContext(TypedDict):
 
 
 def msg_content_output(output: Any) -> str | list[dict]:
-    """Convert tool output to ToolMessage content format.
+    """Convert tool output to `ToolMessage` content format.
 
-    Handles str, list[dict] (content blocks), and arbitrary objects by attempting
+    Handles `str`, `list[dict]` (content blocks), and arbitrary objects by attempting
     JSON serialization with fallback to str().
 
     Args:
         output: Tool execution output of any type.
 
     Returns:
-        String or list of content blocks suitable for ToolMessage.content.
+        String or list of content blocks suitable for `ToolMessage.content`.
     """
     if isinstance(output, str) or (
         isinstance(output, list)
@@ -297,11 +300,15 @@ def msg_content_output(output: Any) -> str | list[dict]:
 class ToolInvocationError(ToolException):
     """An error occurred while invoking a tool due to invalid arguments.
 
-    This exception is only raised when invoking a tool using the ToolNode!
+    This exception is only raised when invoking a tool using the `ToolNode`!
     """
 
     def __init__(
-        self, tool_name: str, source: ValidationError, tool_kwargs: dict[str, Any]
+        self,
+        tool_name: str,
+        source: ValidationError,
+        tool_kwargs: dict[str, Any],
+        filtered_errors: list[ErrorDetails] | None = None,
     ) -> None:
         """Initialize the ToolInvocationError.
 
@@ -309,13 +316,28 @@ class ToolInvocationError(ToolException):
             tool_name: The name of the tool that failed.
             source: The exception that occurred.
             tool_kwargs: The keyword arguments that were passed to the tool.
+            filtered_errors: Optional list of filtered validation errors excluding
+                injected arguments.
         """
+        # Format error display based on filtered errors if provided
+        if filtered_errors is not None:
+            # Manually format the filtered errors without URLs or fancy formatting
+            error_str_parts = []
+            for error in filtered_errors:
+                loc_str = ".".join(str(loc) for loc in error.get("loc", ()))
+                msg = error.get("msg", "Unknown error")
+                error_str_parts.append(f"{loc_str}: {msg}")
+            error_display_str = "\n".join(error_str_parts)
+        else:
+            error_display_str = str(source)
+
         self.message = TOOL_INVOCATION_ERROR_TEMPLATE.format(
-            tool_name=tool_name, tool_kwargs=tool_kwargs, error=source
+            tool_name=tool_name, tool_kwargs=tool_kwargs, error=error_display_str
         )
         self.tool_name = tool_name
         self.tool_kwargs = tool_kwargs
         self.source = source
+        self.filtered_errors = filtered_errors
         super().__init__(self.message)
 
 
@@ -338,7 +360,7 @@ def _handle_tool_error(
     """Generate error message content based on exception handling configuration.
 
     This function centralizes error message generation logic, supporting different
-    error handling strategies configured via the ToolNode's handle_tool_errors
+    error handling strategies configured via the `ToolNode`'s `handle_tool_errors`
     parameter.
 
     Args:
@@ -350,12 +372,12 @@ def _handle_tool_error(
             - tuple: Not used in this context (handled by caller)
 
     Returns:
-        A string containing the error message to include in the ToolMessage.
+        A string containing the error message to include in the `ToolMessage`.
 
     Raises:
         ValueError: If flag is not one of the supported types.
 
-    Note:
+    !!! note
         The tuple case is handled by the caller through exception type checking,
         not by this function directly.
     """
@@ -392,9 +414,9 @@ def _infer_handled_types(handler: Callable[..., str]) -> tuple[type[Exception],
 
     Raises:
         ValueError: If the handler's annotation contains non-Exception types or
-                   if Union types contain non-Exception types.
+            if Union types contain non-Exception types.
 
-    Note:
+    !!! note
         This function supports both single exception types and Union types for
         handlers that need to handle multiple exception types differently.
     """
@@ -440,6 +462,59 @@ def _infer_handled_types(handler: Callable[..., str]) -> tuple[type[Exception],
     return (Exception,)
 
 
+def _filter_validation_errors(
+    validation_error: ValidationError,
+    tool_to_state_args: dict[str, str | None],
+    tool_to_store_arg: str | None,
+    tool_to_runtime_arg: str | None,
+) -> list[ErrorDetails]:
+    """Filter validation errors to only include LLM-controlled arguments.
+
+    When a tool invocation fails validation, only errors for arguments that the LLM
+    controls should be included in error messages. This ensures the LLM receives
+    focused, actionable feedback about parameters it can actually fix. System-injected
+    arguments (state, store, runtime) are filtered out since the LLM has no control
+    over them.
+
+    This function also removes injected argument values from the `input` field in error
+    details, ensuring that only LLM-provided arguments appear in error messages.
+
+    Args:
+        validation_error: The Pydantic ValidationError raised during tool invocation.
+        tool_to_state_args: Mapping of state argument names to state field names.
+        tool_to_store_arg: Name of the store argument, if any.
+        tool_to_runtime_arg: Name of the runtime argument, if any.
+
+    Returns:
+        List of ErrorDetails containing only errors for LLM-controlled arguments,
+        with system-injected argument values removed from the input field.
+    """
+    injected_args = set(tool_to_state_args.keys())
+    if tool_to_store_arg:
+        injected_args.add(tool_to_store_arg)
+    if tool_to_runtime_arg:
+        injected_args.add(tool_to_runtime_arg)
+
+    filtered_errors: list[ErrorDetails] = []
+    for error in validation_error.errors():
+        # Check if error location contains any injected argument
+        # error['loc'] is a tuple like ('field_name',) or ('field_name', 'nested_field')
+        if error["loc"] and error["loc"][0] not in injected_args:
+            # Create a copy of the error dict to avoid mutating the original
+            error_copy: dict[str, Any] = {**error}
+
+            # Remove injected arguments from input_value if it's a dict
+            if isinstance(error_copy.get("input"), dict):
+                input_dict = error_copy["input"]
+                input_copy = {k: v for k, v in input_dict.items() if k not in injected_args}
+                error_copy["input"] = input_copy
+
+            # Cast is safe because ErrorDetails is a TypedDict compatible with this structure
+            filtered_errors.append(error_copy)  # type: ignore[arg-type]
+
+    return filtered_errors
+
+
 class _ToolNode(RunnableCallable):
     """A node for executing tools in LangGraph workflows.
 
@@ -560,7 +635,7 @@ class _ToolNode(RunnableCallable):
         wrap_tool_call: ToolCallWrapper | None = None,
         awrap_tool_call: AsyncToolCallWrapper | None = None,
     ) -> None:
-        """Initialize ToolNode with tools and configuration.
+        """Initialize `ToolNode` with tools and configuration.
 
         Args:
             tools: Sequence of tools to make available for execution.
@@ -621,17 +696,10 @@ class _ToolNode(RunnableCallable):
             )
             tool_runtimes.append(tool_runtime)
 
-        # Inject tool arguments (including runtime)
-
-        injected_tool_calls = []
+        # Pass original tool calls without injection
         input_types = [input_type] * len(tool_calls)
-        for call, tool_runtime in zip(tool_calls, tool_runtimes, strict=False):
-            injected_call = self._inject_tool_args(call, tool_runtime)
-            injected_tool_calls.append(injected_call)
         with get_executor_for_config(config) as executor:
-            outputs = list(
-                executor.map(self._run_one, injected_tool_calls, input_types, tool_runtimes)
-            )
+            outputs = list(executor.map(self._run_one, tool_calls, input_types, tool_runtimes))
 
         return self._combine_tool_outputs(outputs, input_type)
 
@@ -658,12 +726,10 @@ class _ToolNode(RunnableCallable):
             )
             tool_runtimes.append(tool_runtime)
 
-        injected_tool_calls = []
+        # Pass original tool calls without injection
         coros = []
         for call, tool_runtime in zip(tool_calls, tool_runtimes, strict=False):
-            injected_call = self._inject_tool_args(call, tool_runtime)
-            injected_tool_calls.append(injected_call)
-            coros.append(self._arun_one(injected_call, input_type, tool_runtime))
+            coros.append(self._arun_one(call, input_type, tool_runtime))  # type: ignore[arg-type]
         outputs = await asyncio.gather(*coros)
 
         return self._combine_tool_outputs(outputs, input_type)
@@ -740,13 +806,23 @@ class _ToolNode(RunnableCallable):
             msg = f"Tool {call['name']} is not registered with ToolNode"
             raise TypeError(msg)
 
-        call_args = {**call, "type": "tool_call"}
+        # Inject state, store, and runtime right before invocation
+        injected_call = self._inject_tool_args(call, request.runtime)
+        call_args = {**injected_call, "type": "tool_call"}
 
         try:
             try:
                 response = tool.invoke(call_args, config)
             except ValidationError as exc:
-                raise ToolInvocationError(call["name"], exc, call["args"]) from exc
+                # Filter out errors for injected arguments
+                filtered_errors = _filter_validation_errors(
+                    exc,
+                    self._tool_to_state_args.get(call["name"], {}),
+                    self._tool_to_store_arg.get(call["name"]),
+                    self._tool_to_runtime_arg.get(call["name"]),
+                )
+                # Use original call["args"] without injected values for error reporting
+                raise ToolInvocationError(call["name"], exc, call["args"], filtered_errors) from exc
 
         # GraphInterrupt is a special exception that will always be raised.
         # It can be triggered in the following scenarios,
@@ -885,13 +961,23 @@ class _ToolNode(RunnableCallable):
             msg = f"Tool {call['name']} is not registered with ToolNode"
             raise TypeError(msg)
 
-        call_args = {**call, "type": "tool_call"}
+        # Inject state, store, and runtime right before invocation
+        injected_call = self._inject_tool_args(call, request.runtime)
+        call_args = {**injected_call, "type": "tool_call"}
 
         try:
             try:
                 response = await tool.ainvoke(call_args, config)
             except ValidationError as exc:
-                raise ToolInvocationError(call["name"], exc, call["args"]) from exc
+                # Filter out errors for injected arguments
+                filtered_errors = _filter_validation_errors(
+                    exc,
+                    self._tool_to_state_args.get(call["name"], {}),
+                    self._tool_to_store_arg.get(call["name"]),
+                    self._tool_to_runtime_arg.get(call["name"]),
+                )
+                # Use original call["args"] without injected values for error reporting
+                raise ToolInvocationError(call["name"], exc, call["args"], filtered_errors) from exc
 
         # GraphInterrupt is a special exception that will always be raised.
         # It can be triggered in the following scenarios,
@@ -1181,11 +1267,11 @@ class _ToolNode(RunnableCallable):
 
         Raises:
             ValueError: If a tool requires store injection but no store is provided,
-                       or if state injection requirements cannot be satisfied.
+                or if state injection requirements cannot be satisfied.
 
-        Note:
+        !!! note
             This method is called automatically during tool execution. It should not
-            be called from outside the ToolNode.
+            be called from outside the `ToolNode`.
         """
         if tool_call["name"] not in self.tools_by_name:
             return tool_call
@@ -1329,9 +1415,9 @@ def tools_condition(
             return tools_condition(state, messages_key="chat_history")
         ```
 
-    Note:
-        This function is designed to work seamlessly with ToolNode and standard
-        LangGraph patterns. It expects the last message to be an AIMessage when
+    !!! note
+        This function is designed to work seamlessly with `ToolNode` and standard
+        LangGraph patterns. It expects the last message to be an `AIMessage` when
         tool calls are present, which is the standard output format for tool-calling
         language models.
     """
@@ -1353,16 +1439,16 @@ def tools_condition(
 class ToolRuntime(_DirectlyInjectedToolArg, Generic[ContextT, StateT]):
     """Runtime context automatically injected into tools.
 
-    When a tool function has a parameter named 'tool_runtime' with type hint
-    'ToolRuntime', the tool execution system will automatically inject
-    an instance containing:
+    When a tool function has a parameter named `tool_runtime` with type hint
+    `ToolRuntime`, the tool execution system will automatically inject an instance
+    containing:
 
-    - state: The current graph state
-    - tool_call_id: The ID of the current tool call
-    - config: RunnableConfig for the current execution
-    - context: Runtime context (from langgraph Runtime)
-    - store: BaseStore instance for persistent storage (from langgraph Runtime)
-    - stream_writer: StreamWriter for streaming output (from langgraph Runtime)
+    - `state`: The current graph state
+    - `tool_call_id`: The ID of the current tool call
+    - `config`: `RunnableConfig` for the current execution
+    - `context`: Runtime context (from langgraph `Runtime`)
+    - `store`: `BaseStore` instance for persistent storage (from langgraph `Runtime`)
+    - `stream_writer`: `StreamWriter` for streaming output (from langgraph `Runtime`)
 
     No `Annotated` wrapper is needed - just use `runtime: ToolRuntime`
     as a parameter.
@@ -1396,7 +1482,7 @@ class ToolRuntime(_DirectlyInjectedToolArg, Generic[ContextT, StateT]):
             return f"Processed {x}"
         ```
 
-    Note:
+    !!! note
         This is a marker class used for type checking and detection.
         The actual runtime object will be constructed during tool execution.
     """
@@ -1470,7 +1556,7 @@ class InjectedState(InjectedToolArg):
         ]
         ```
 
-    Note:
+    !!! note
         - `InjectedState` arguments are automatically excluded from tool schemas
             presented to language models
         - `ToolNode` handles the injection process during execution
@@ -1550,7 +1636,7 @@ class InjectedStore(InjectedToolArg):
         result2 = graph.invoke({"messages": [HumanMessage("What's my favorite color?")]})
         ```
 
-    Note:
+    !!! note
         - `InjectedStore` arguments are automatically excluded from tool schemas
             presented to language models
         - The store instance is automatically injected by `ToolNode` during execution

{langchain-1.0.0rc2.dist-info → langchain-1.0.2.dist-info}/METADATA

@@ -1,18 +1,19 @@
 Metadata-Version: 2.4
 Name: langchain
-Version: 1.0.0rc2
+Version: 1.0.2
 Summary: Building applications with LLMs through composability
-Project-URL: homepage, https://docs.langchain.com/
-Project-URL: repository, https://github.com/langchain-ai/langchain/tree/master/libs/langchain
-Project-URL: changelog, https://github.com/langchain-ai/langchain/releases?q=tag%3A%22langchain%3D%3D1%22
-Project-URL: twitter, https://x.com/LangChainAI
-Project-URL: slack, https://www.langchain.com/join-community
-Project-URL: reddit, https://www.reddit.com/r/LangChain/
+Project-URL: Homepage, https://docs.langchain.com/
+Project-URL: Documentation, https://reference.langchain.com/python/langchain/langchain/
+Project-URL: Source, https://github.com/langchain-ai/langchain/tree/master/libs/langchain
+Project-URL: Changelog, https://github.com/langchain-ai/langchain/releases?q=tag%3A%22langchain%3D%3D1%22
+Project-URL: Twitter, https://x.com/LangChainAI
+Project-URL: Slack, https://www.langchain.com/join-community
+Project-URL: Reddit, https://www.reddit.com/r/LangChain/
 License: MIT
 License-File: LICENSE
 Requires-Python: <4.0.0,>=3.10.0
-Requires-Dist: langchain-core<2.0.0,>=1.0.0rc3
-Requires-Dist: langgraph<2.0.0,>=1.0.0a4
+Requires-Dist: langchain-core<2.0.0,>=1.0.0
+Requires-Dist: langgraph<1.1.0,>=1.0.0
 Requires-Dist: pydantic<3.0.0,>=2.7.4
 Provides-Extra: anthropic
 Requires-Dist: langchain-anthropic; extra == 'anthropic'
@@ -30,6 +31,8 @@ Provides-Extra: google-vertexai
 Requires-Dist: langchain-google-vertexai; extra == 'google-vertexai'
 Provides-Extra: groq
 Requires-Dist: langchain-groq; extra == 'groq'
+Provides-Extra: huggingface
+Requires-Dist: langchain-huggingface; extra == 'huggingface'
 Provides-Extra: mistralai
 Requires-Dist: langchain-mistralai; extra == 'mistralai'
 Provides-Extra: ollama

{langchain-1.0.0rc2.dist-info → langchain-1.0.2.dist-info}/RECORD

@@ -1,30 +1,34 @@
-langchain/__init__.py,sha256=zTVJXeQnKRDdEeQc-ivRY9P9TV6An_dmmkgW6phY86I,64
+langchain/__init__.py,sha256=3EzcPFwVNXhQEus521J89yt2GHHJs6VenVpzltp09Uk,61
 langchain/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langchain/agents/__init__.py,sha256=tDjbhFSC6XHQUZ_XvjHwmbICFfjxmE9xKFMbUVSIwfs,522
-langchain/agents/factory.py,sha256=RhClhqWInb2i0pjNJj9-0OvnB6waj0r8Qbm5bN7ofw8,62214
+langchain/agents/factory.py,sha256=vUpv5sD91eaLUH_2GK5TrjnblwEl7h9L-3GrDtBueq4,62774
 langchain/agents/structured_output.py,sha256=BDSF6PWVih41M7IGyjCHWy46jmDxZsfBt_B4llE9OOc,13764
-langchain/agents/middleware/__init__.py,sha256=FBoTr4TAyuLJiOKV-mJN3oaLE6D6Q5ubI5sCbnsCCSs,1955
+langchain/agents/middleware/__init__.py,sha256=Vm-Ajh4YoaahAa9b_XEAuiyoupKNIwZVzX-8JN1xKkA,2251
+langchain/agents/middleware/_execution.py,sha256=Xyjh3HxTHbgA-C9FFE4WXUOqKUW8mdOB455XRlA_BOU,14251
+langchain/agents/middleware/_redaction.py,sha256=LJeNOvdZ0gd4273Lqgpbxh7EiuuZ6q5LlqeHK4eyin4,11210
 langchain/agents/middleware/context_editing.py,sha256=0sUpDc0FvOKMERNnEKnhBqrTjX_rCVWjIX8hH3RTG8U,8749
+langchain/agents/middleware/file_search.py,sha256=RiBNJRfy8R5E8TvjQRVgXf1O0UDtXqEarirFPnihbtI,12757
 langchain/agents/middleware/human_in_the_loop.py,sha256=N7Vt31rlHS7J-cA0EBDS2mlQW-SMvvxyAwjBnAY9vZU,12650
 langchain/agents/middleware/model_call_limit.py,sha256=yYBcOY5DKNIG6_9f-rkTjIj_BLVUO1tuShgxt00P8W0,7735
 langchain/agents/middleware/model_fallback.py,sha256=VKDN81jfFB9zJOaJZ94tfwzodk3zRXRwz6CqQ6MkJtw,4097
-langchain/agents/middleware/pii.py,sha256=rkGojBFIJGMs1p1cKNh0npafts_0UUJ0_NeZsyJo498,24760
+langchain/agents/middleware/pii.py,sha256=I3nTAnfvrHqre9SoRJvlw0koT8-x3gGZdSvb0uKH5xg,10978
+langchain/agents/middleware/shell_tool.py,sha256=HqPTht0Gx3zAv3JmWS_R1Hsd6yQEkvDjlCXXwQq8Fg8,26627
 langchain/agents/middleware/summarization.py,sha256=H1VxRkkbauw4p4sMMKyc_uZGbJhtqoVvOF7y_5JBXTc,10329
 langchain/agents/middleware/todo.py,sha256=0PyHV4u5JaBBuMmPWmDr3orZ5T5F6lk2jiVoBzVVMM4,9808
 langchain/agents/middleware/tool_call_limit.py,sha256=AHA-No4oUze2-2d1INnX8d_9otFuDB8uoWayJpt9nPo,12321
 langchain/agents/middleware/tool_emulator.py,sha256=UmN5UIMsikDnFvcPbNLNDOF4RXvIxqd-AMG46LVI0iA,7211
 langchain/agents/middleware/tool_retry.py,sha256=M76csBFFZa37djxtfUCqNU-x2erTNtxZqoO__DozWxA,13787
 langchain/agents/middleware/tool_selection.py,sha256=6RYdgkg6aSNx1w-YxRyL2Hct7UPnMRgGg6YVZVtW5TU,11638
-langchain/agents/middleware/types.py,sha256=FVuYue9cLB5C1ZNcYLIGNPN6IUaNXY3UsWQ6gC-gZNs,55547
+langchain/agents/middleware/types.py,sha256=4oQAoTSHL1LQh9OiUxz_WJ6JrAvKRiUSXUAHawOcLkU,55670
 langchain/chat_models/__init__.py,sha256=lQwcJkHtGjrclCL7sBFocQuzRdRgZRPzIIPnGhEJmVQ,533
-langchain/chat_models/base.py,sha256=k1Qnuh7O_3LwsWtcVFSWsWP00hxiEyninwltTdi1rk8,35655
-langchain/embeddings/__init__.py,sha256=crY7GUw7RSA25JgpYl7I4WPloVCVY6eUmJbSSSchWis,444
-langchain/embeddings/base.py,sha256=1aNxDLQmS_l7RMcvjnK7Cv7rtgKrKt6Sl7mgXM2_JWI,7329
+langchain/chat_models/base.py,sha256=XowWNeNZbVpGOOGGd2Wmvs2h6h7TzjFcQOx4KnJ2g4M,35544
+langchain/embeddings/__init__.py,sha256=FYmjgpgjQc8wTy_qu2VnwgYiSqF6tUtwH6jtea6VbSs,843
+langchain/embeddings/base.py,sha256=V9YgYiRAJs5U5o8BQUsmfV8XtRQrRWV3rENXHLKiECg,8511
 langchain/messages/__init__.py,sha256=p7NlF1yf8MkMgJzJ2wggXGkkA_okz1f-g63KoflL6PA,1710
 langchain/rate_limiters/__init__.py,sha256=5490xUNhet37N2nX6kbJlDgf8u1DX-C1Cs_r7etXn8A,351
 langchain/tools/__init__.py,sha256=hMzbaGcfHhNYfJx20uV57uMd9a-gNLbmopG4gDReeEc,628
-langchain/tools/tool_node.py,sha256=0rk5SZ0L80X6DJA5ohzyuqydL-S40i5LHMXJsY2t0JI,65016
-langchain-1.0.0rc2.dist-info/METADATA,sha256=WG0BlqzPbwur0AlHyITXIE35MX7iSpzGIfqqD4dFLxc,4544
-langchain-1.0.0rc2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-langchain-1.0.0rc2.dist-info/licenses/LICENSE,sha256=TsZ-TKbmch26hJssqCJhWXyGph7iFLvyFBYAa3stBHg,1067
-langchain-1.0.0rc2.dist-info/RECORD,,
+langchain/tools/tool_node.py,sha256=3wHSg6TQk43Zv3xrkuLwYZn5Hv5w3oZOv0vkmI_40sQ,69489
+langchain-1.0.2.dist-info/METADATA,sha256=XNAflqRgEm9FqOvFckJKFFhjmP4ouNOJ8HdPXJrKgbc,4709
+langchain-1.0.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+langchain-1.0.2.dist-info/licenses/LICENSE,sha256=TsZ-TKbmch26hJssqCJhWXyGph7iFLvyFBYAa3stBHg,1067
+langchain-1.0.2.dist-info/RECORD,,