langchain 1.0.0a4__py3-none-any.whl → 1.0.0a5__py3-none-any.whl

langchain/__init__.py

@@ -2,7 +2,7 @@
 
 from typing import Any
 
-__version__ = "1.0.0a3"
+__version__ = "1.0.0a4"
 
 
 def __getattr__(name: str) -> Any:  # noqa: ANN401

langchain/_internal/_lazy_import.py

@@ -1,13 +1,12 @@
 """Lazy import utilities."""
 
 from importlib import import_module
-from typing import Union
 
 
 def import_attr(
     attr_name: str,
-    module_name: Union[str, None],
-    package: Union[str, None],
+    module_name: str | None,
+    package: str | None,
 ) -> object:
     """Import an attribute from a module located in a package.
 

langchain/_internal/_prompts.py

@@ -12,7 +12,7 @@ particularly for summarization chains and other document processing workflows.
 from __future__ import annotations
 
 import inspect
-from typing import TYPE_CHECKING, Union
+from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
     from collections.abc import Awaitable, Callable
@@ -24,11 +24,7 @@ if TYPE_CHECKING:
 
 
 def resolve_prompt(
-    prompt: Union[
-        str,
-        None,
-        Callable[[StateT, Runtime[ContextT]], list[MessageLikeRepresentation]],
-    ],
+    prompt: str | None | Callable[[StateT, Runtime[ContextT]], list[MessageLikeRepresentation]],
     state: StateT,
     runtime: Runtime[ContextT],
     default_user_content: str,
@@ -61,6 +57,7 @@ def resolve_prompt(
         def custom_prompt(state, runtime):
             return [{"role": "system", "content": "Custom"}]
 
+
         messages = resolve_prompt(custom_prompt, state, runtime, "content", "default")
         messages = resolve_prompt("Custom system", state, runtime, "content", "default")
         messages = resolve_prompt(None, state, runtime, "content", "Default")
@@ -88,12 +85,10 @@ def resolve_prompt(
 
 
 async def aresolve_prompt(
-    prompt: Union[
-        str,
-        None,
-        Callable[[StateT, Runtime[ContextT]], list[MessageLikeRepresentation]],
-        Callable[[StateT, Runtime[ContextT]], Awaitable[list[MessageLikeRepresentation]]],
-    ],
+    prompt: str
+    | None
+    | Callable[[StateT, Runtime[ContextT]], list[MessageLikeRepresentation]]
+    | Callable[[StateT, Runtime[ContextT]], Awaitable[list[MessageLikeRepresentation]]],
     state: StateT,
     runtime: Runtime[ContextT],
     default_user_content: str,
@@ -128,15 +123,13 @@ async def aresolve_prompt(
         async def async_prompt(state, runtime):
             return [{"role": "system", "content": "Async"}]
 
+
         def sync_prompt(state, runtime):
             return [{"role": "system", "content": "Sync"}]
 
-        messages = await aresolve_prompt(
-            async_prompt, state, runtime, "content", "default"
-        )
-        messages = await aresolve_prompt(
-            sync_prompt, state, runtime, "content", "default"
-        )
+
+        messages = await aresolve_prompt(async_prompt, state, runtime, "content", "default")
+        messages = await aresolve_prompt(sync_prompt, state, runtime, "content", "default")
         messages = await aresolve_prompt("Custom", state, runtime, "content", "default")
         ```
 

langchain/_internal/_typing.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, ClassVar, Protocol, TypeAlias, TypeVar, Union
+from typing import TYPE_CHECKING, Any, ClassVar, Protocol, TypeAlias, TypeVar
 
 from langgraph.graph._node import StateNode
 from pydantic import BaseModel
@@ -44,7 +44,7 @@ class DataclassLike(Protocol):
     __dataclass_fields__: ClassVar[dict[str, Field[Any]]]
 
 
-StateLike: TypeAlias = Union[TypedDictLikeV1, TypedDictLikeV2, DataclassLike, BaseModel]
+StateLike: TypeAlias = TypedDictLikeV1 | TypedDictLikeV2 | DataclassLike | BaseModel
 """Type alias for state-like types.
 
 It can either be a ``TypedDict``, ``dataclass``, or Pydantic ``BaseModel``.
@@ -58,7 +58,7 @@ It can either be a ``TypedDict``, ``dataclass``, or Pydantic ``BaseModel``.
 StateT = TypeVar("StateT", bound=StateLike)
 """Type variable used to represent the state in a graph."""
 
-ContextT = TypeVar("ContextT", bound=Union[StateLike, None])
+ContextT = TypeVar("ContextT", bound=StateLike | None)
 """Type variable for context types."""
 
 

langchain/agents/_internal/_typing.py

@@ -3,11 +3,11 @@
 from __future__ import annotations
 
 from collections.abc import Awaitable, Callable
-from typing import TypeVar, Union
+from typing import TypeVar
 
 from typing_extensions import ParamSpec
 
 P = ParamSpec("P")
 R = TypeVar("R")
 
-SyncOrAsync = Callable[P, Union[R, Awaitable[R]]]
+SyncOrAsync = Callable[P, R | Awaitable[R]]

langchain/agents/interrupt.py

@@ -1,6 +1,6 @@
 """Interrupt types to use with agent inbox like setups."""
 
-from typing import Literal, Union
+from typing import Literal
 
 from typing_extensions import TypedDict
 
@@ -53,15 +53,15 @@ class HumanInterrupt(TypedDict):
         request = HumanInterrupt(
             action_request=ActionRequest(
                 action="run_command",  # The action being requested
-                args={"command": "ls", "args": ["-l"]}  # Arguments for the action
+                args={"command": "ls", "args": ["-l"]},  # Arguments for the action
             ),
             config=HumanInterruptConfig(
-                allow_ignore=True,    # Allow skipping this step
-                allow_respond=True,   # Allow text feedback
-                allow_edit=False,     # Don't allow editing
-                allow_accept=True     # Allow direct acceptance
+                allow_ignore=True,  # Allow skipping this step
+                allow_respond=True,  # Allow text feedback
+                allow_edit=False,  # Don't allow editing
+                allow_accept=True,  # Allow direct acceptance
             ),
-            description="Please review the command before execution"
+            description="Please review the command before execution",
         )
         # Send the interrupt request and get the response
         response = interrupt([request])[0]
@@ -74,19 +74,24 @@ class HumanInterrupt(TypedDict):
 
 
 class HumanResponse(TypedDict):
-    """The response provided by a human to an interrupt, which is returned when graph execution resumes.
+    """Human response.
+
+    The response provided by a human to an interrupt,
+    which is returned when graph execution resumes.
 
     Attributes:
         type: The type of response:
+
             - "accept": Approves the current state without changes
             - "ignore": Skips/ignores the current step
             - "response": Provides text feedback or instructions
             - "edit": Modifies the current state/content
         args: The response payload:
+
             - None: For ignore/accept actions
             - str: For text responses
             - ActionRequest: For edit actions with updated content
     """
 
     type: Literal["accept", "ignore", "response", "edit"]
-    args: Union[None, str, ActionRequest]
+    args: None | str | ActionRequest

langchain/agents/middleware/human_in_the_loop.py

@@ -65,7 +65,10 @@ class HumanInTheLoopMiddleware(AgentMiddleware):
         # Right now, we do not support multiple tool calls with interrupts
         if len(interrupt_tool_calls) > 1:
             tool_names = [t["name"] for t in interrupt_tool_calls]
-            msg = f"Called the following tools which require interrupts: {tool_names}\n\nYou may only call ONE tool that requires an interrupt at a time"
+            msg = (
+                f"Called the following tools which require interrupts: {tool_names}\n\n"
+                "You may only call ONE tool that requires an interrupt at a time"
+            )
             return {
                 "messages": _generate_correction_tool_messages(msg, last_message.tool_calls),
                 "jump_to": "model",
@@ -74,7 +77,11 @@ class HumanInTheLoopMiddleware(AgentMiddleware):
         # Right now, we do not support interrupting a tool call if other tool calls exist
         if auto_approved_tool_calls:
             tool_names = [t["name"] for t in interrupt_tool_calls]
-            msg = f"Called the following tools which require interrupts: {tool_names}. You also called other tools that do not require interrupts. If you call a tool that requires and interrupt, you may ONLY call that tool."
+            msg = (
+                f"Called the following tools which require interrupts: {tool_names}. "
+                "You also called other tools that do not require interrupts. "
+                "If you call a tool that requires and interrupt, you may ONLY call that tool."
+            )
             return {
                 "messages": _generate_correction_tool_messages(msg, last_message.tool_calls),
                 "jump_to": "model",

langchain/agents/middleware/prompt_caching.py

@@ -6,9 +6,12 @@ from langchain.agents.middleware.types import AgentMiddleware, AgentState, Model
 
 
 class AnthropicPromptCachingMiddleware(AgentMiddleware):
-    """Prompt Caching Middleware - Optimizes API usage by caching conversation prefixes for Anthropic models.
+    """Prompt Caching Middleware.
 
-    Learn more about anthropic prompt caching [here](https://docs.anthropic.com/en/docs/build-with-claude/prompt-caching).
+    Optimizes API usage by caching conversation prefixes for Anthropic models.
+
+    Learn more about Anthropic prompt caching
+    `here <https://docs.anthropic.com/en/docs/build-with-claude/prompt-caching>`__.
     """
 
     def __init__(
@@ -22,7 +25,8 @@ class AnthropicPromptCachingMiddleware(AgentMiddleware):
         Args:
             type: The type of cache to use, only "ephemeral" is supported.
             ttl: The time to live for the cache, only "5m" and "1h" are supported.
-            min_messages_to_cache: The minimum number of messages until the cache is used, default is 0.
+            min_messages_to_cache: The minimum number of messages until the cache is used,
+                default is 0.
         """
         self.type = type
         self.ttl = ttl
@@ -34,15 +38,16 @@ class AnthropicPromptCachingMiddleware(AgentMiddleware):
             from langchain_anthropic import ChatAnthropic
         except ImportError:
             msg = (
-                "AnthropicPromptCachingMiddleware caching middleware only supports Anthropic models."
+                "AnthropicPromptCachingMiddleware caching middleware only supports "
+                "Anthropic models."
                 "Please install langchain-anthropic."
             )
             raise ValueError(msg)
 
         if not isinstance(request.model, ChatAnthropic):
             msg = (
-                "AnthropicPromptCachingMiddleware caching middleware only supports Anthropic models, "
-                f"not instances of {type(request.model)}"
+                "AnthropicPromptCachingMiddleware caching middleware only supports "
+                f"Anthropic models, not instances of {type(request.model)}"
             )
             raise ValueError(msg)
 

langchain/agents/middleware/summarization.py

@@ -48,7 +48,7 @@ Respond ONLY with the extracted context. Do not include any additional informati
 <messages>
 Messages to summarize:
 {messages}
-</messages>"""
+</messages>"""  # noqa: E501
 
 SUMMARY_PREFIX = "## Previous conversation summary:"
 

langchain/agents/middleware/types.py

@@ -58,7 +58,8 @@ StateT = TypeVar("StateT", bound=AgentState)
 class AgentMiddleware(Generic[StateT]):
     """Base middleware class for an agent.
 
-    Subclass this and implement any of the defined methods to customize agent behavior between steps in the main agent loop.
+    Subclass this and implement any of the defined methods to customize agent behavior
+    between steps in the main agent loop.
     """
 
     state_schema: type[StateT] = cast("type[StateT]", AgentState)

langchain/agents/middleware_agent.py

@@ -2,10 +2,10 @@
 
 import itertools
 from collections.abc import Callable, Sequence
-from typing import Any, Union
+from typing import Any
 
 from langchain_core.language_models.chat_models import BaseChatModel
-from langchain_core.messages import AIMessage, AnyMessage, SystemMessage, ToolMessage
+from langchain_core.messages import AIMessage, SystemMessage, ToolMessage
 from langchain_core.runnables import Runnable
 from langchain_core.tools import BaseTool
 from langgraph.constants import END, START
@@ -59,7 +59,7 @@ def _filter_state_for_schema(state: dict[str, Any], schema: type) -> dict[str, A
     return {k: v for k, v in state.items() if k in schema_fields}
 
 
-def _supports_native_structured_output(model: Union[str, BaseChatModel]) -> bool:
+def _supports_native_structured_output(model: str | BaseChatModel) -> bool:
     """Check if a model supports native structured output."""
     model_name: str | None = None
     if isinstance(model, str):
@@ -211,24 +211,6 @@ def create_agent(  # noqa: PLR0915
         context_schema=context_schema,
     )
 
-    def _prepare_model_request(state: dict[str, Any]) -> tuple[ModelRequest, list[AnyMessage]]:
-        """Prepare model request and messages."""
-        request = state.get("model_request") or ModelRequest(
-            model=model,
-            tools=default_tools,
-            system_prompt=system_prompt,
-            response_format=response_format,
-            messages=state["messages"],
-            tool_choice=None,
-        )
-
-        # prepare messages
-        messages = request.messages
-        if request.system_prompt:
-            messages = [SystemMessage(request.system_prompt), *messages]
-
-        return request, messages
-
     def _handle_model_output(state: dict[str, Any], output: AIMessage) -> dict[str, Any]:
         """Handle model output including structured responses."""
         # Handle structured output with native strategy
@@ -342,8 +324,14 @@ def create_agent(  # noqa: PLR0915
 
     def model_request(state: dict[str, Any]) -> dict[str, Any]:
         """Sync model request handler with sequential middleware processing."""
-        # Start with the base model request
-        request, messages = _prepare_model_request(state)
+        request = ModelRequest(
+            model=model,
+            tools=default_tools,
+            system_prompt=system_prompt,
+            response_format=response_format,
+            messages=state["messages"],
+            tool_choice=None,
+        )
 
         # Apply modify_model_request middleware in sequence
         for m in middleware_w_modify_model_request:
@@ -351,15 +339,26 @@ def create_agent(  # noqa: PLR0915
             filtered_state = _filter_state_for_schema(state, m.state_schema)
             request = m.modify_model_request(request, filtered_state)
 
-        # Get the bound model with the final request
+        # Get the final model and messages
         model_ = _get_bound_model(request)
+        messages = request.messages
+        if request.system_prompt:
+            messages = [SystemMessage(request.system_prompt), *messages]
+
         output = model_.invoke(messages)
         return _handle_model_output(state, output)
 
     async def amodel_request(state: dict[str, Any]) -> dict[str, Any]:
         """Async model request handler with sequential middleware processing."""
         # Start with the base model request
-        request, messages = _prepare_model_request(state)
+        request = ModelRequest(
+            model=model,
+            tools=default_tools,
+            system_prompt=system_prompt,
+            response_format=response_format,
+            messages=state["messages"],
+            tool_choice=None,
+        )
 
         # Apply modify_model_request middleware in sequence
         for m in middleware_w_modify_model_request:
@@ -367,8 +366,12 @@ def create_agent(  # noqa: PLR0915
             filtered_state = _filter_state_for_schema(state, m.state_schema)
             request = m.modify_model_request(request, filtered_state)
 
-        # Get the bound model with the final request
+        # Get the final model and messages
         model_ = _get_bound_model(request)
+        messages = request.messages
+        if request.system_prompt:
+            messages = [SystemMessage(request.system_prompt), *messages]
+
         output = await model_.ainvoke(messages)
         return _handle_model_output(state, output)