langchain 1.2.3__py3-none-any.whl → 1.2.4__py3-none-any.whl

langchain/__init__.py

@@ -1,3 +1,3 @@
 """Main entrypoint into LangChain."""
 
-__version__ = "1.2.3"
+__version__ = "1.2.4"

langchain/agents/factory.py

@@ -51,7 +51,7 @@ from langchain.chat_models import init_chat_model
 if TYPE_CHECKING:
     from collections.abc import Awaitable, Callable, Sequence
 
-    from langchain_core.runnables import Runnable
+    from langchain_core.runnables import Runnable, RunnableConfig
     from langgraph.cache.base import BaseCache
     from langgraph.graph.state import CompiledStateGraph
     from langgraph.runtime import Runtime
@@ -288,6 +288,9 @@ def _resolve_schema(schemas: set[type], schema_name: str, omit_flag: str | None
         schema_name: Name for the generated `TypedDict`
         omit_flag: If specified, omit fields with this flag set (`'input'` or
             `'output'`)
+
+    Returns:
+        Merged schema as `TypedDict`
     """
     all_annotations = {}
 
@@ -311,7 +314,7 @@ def _resolve_schema(schemas: set[type], schema_name: str, omit_flag: str | None
     return TypedDict(schema_name, all_annotations)  # type: ignore[operator]
 
 
-def _extract_metadata(type_: type) -> list:
+def _extract_metadata(type_: type) -> list[Any]:
     """Extract metadata from a field type, handling Required/NotRequired and Annotated wrappers."""
     # Handle Required[Annotated[...]] or NotRequired[Annotated[...]]
     if get_origin(type_) in {Required, NotRequired}:
@@ -361,7 +364,9 @@ def _get_can_jump_to(middleware: AgentMiddleware[Any, Any], hook_name: str) -> l
     return []
 
 
-def _supports_provider_strategy(model: str | BaseChatModel, tools: list | None = None) -> bool:
+def _supports_provider_strategy(
+    model: str | BaseChatModel, tools: list[BaseTool | dict[str, Any]] | None = None
+) -> bool:
     """Check if a model supports provider-specific structured output.
 
     Args:
@@ -400,7 +405,7 @@ def _supports_provider_strategy(model: str | BaseChatModel, tools: list | None =
 
 def _handle_structured_output_error(
     exception: Exception,
-    response_format: ResponseFormat,
+    response_format: ResponseFormat[Any],
 ) -> tuple[bool, str]:
     """Handle structured output error. Returns `(should_retry, retry_tool_message)`."""
     if not isinstance(response_format, ToolStrategy):
@@ -414,18 +419,15 @@ def _handle_structured_output_error(
         return True, STRUCTURED_OUTPUT_ERROR_TEMPLATE.format(error=str(exception))
     if isinstance(handle_errors, str):
         return True, handle_errors
-    if isinstance(handle_errors, type) and issubclass(handle_errors, Exception):
-        if isinstance(exception, handle_errors):
+    if isinstance(handle_errors, type):
+        if issubclass(handle_errors, Exception) and isinstance(exception, handle_errors):
             return True, STRUCTURED_OUTPUT_ERROR_TEMPLATE.format(error=str(exception))
         return False, ""
     if isinstance(handle_errors, tuple):
         if any(isinstance(exception, exc_type) for exc_type in handle_errors):
             return True, STRUCTURED_OUTPUT_ERROR_TEMPLATE.format(error=str(exception))
         return False, ""
-    if callable(handle_errors):
-        # type narrowing not working appropriately w/ callable check, can fix later
-        return True, handle_errors(exception)  # type: ignore[return-value,call-arg]
-    return False, ""
+    return True, handle_errors(exception)
 
 
 def _chain_tool_call_wrappers(
@@ -455,10 +457,10 @@ def _chain_tool_call_wrappers(
 
         def composed(
             request: ToolCallRequest,
-            execute: Callable[[ToolCallRequest], ToolMessage | Command],
-        ) -> ToolMessage | Command:
+            execute: Callable[[ToolCallRequest], ToolMessage | Command[Any]],
+        ) -> ToolMessage | Command[Any]:
             # Create a callable that invokes inner with the original execute
-            def call_inner(req: ToolCallRequest) -> ToolMessage | Command:
+            def call_inner(req: ToolCallRequest) -> ToolMessage | Command[Any]:
                 return inner(req, execute)
 
             # Outer can call call_inner multiple times
@@ -477,14 +479,14 @@ def _chain_tool_call_wrappers(
 def _chain_async_tool_call_wrappers(
     wrappers: Sequence[
         Callable[
-            [ToolCallRequest, Callable[[ToolCallRequest], Awaitable[ToolMessage | Command]]],
-            Awaitable[ToolMessage | Command],
+            [ToolCallRequest, Callable[[ToolCallRequest], Awaitable[ToolMessage | Command[Any]]]],
+            Awaitable[ToolMessage | Command[Any]],
         ]
     ],
 ) -> (
     Callable[
-        [ToolCallRequest, Callable[[ToolCallRequest], Awaitable[ToolMessage | Command]]],
-        Awaitable[ToolMessage | Command],
+        [ToolCallRequest, Callable[[ToolCallRequest], Awaitable[ToolMessage | Command[Any]]]],
+        Awaitable[ToolMessage | Command[Any]],
     ]
     | None
 ):
@@ -504,25 +506,25 @@ def _chain_async_tool_call_wrappers(
 
     def compose_two(
         outer: Callable[
-            [ToolCallRequest, Callable[[ToolCallRequest], Awaitable[ToolMessage | Command]]],
-            Awaitable[ToolMessage | Command],
+            [ToolCallRequest, Callable[[ToolCallRequest], Awaitable[ToolMessage | Command[Any]]]],
+            Awaitable[ToolMessage | Command[Any]],
         ],
         inner: Callable[
-            [ToolCallRequest, Callable[[ToolCallRequest], Awaitable[ToolMessage | Command]]],
-            Awaitable[ToolMessage | Command],
+            [ToolCallRequest, Callable[[ToolCallRequest], Awaitable[ToolMessage | Command[Any]]]],
+            Awaitable[ToolMessage | Command[Any]],
         ],
     ) -> Callable[
-        [ToolCallRequest, Callable[[ToolCallRequest], Awaitable[ToolMessage | Command]]],
-        Awaitable[ToolMessage | Command],
+        [ToolCallRequest, Callable[[ToolCallRequest], Awaitable[ToolMessage | Command[Any]]]],
+        Awaitable[ToolMessage | Command[Any]],
     ]:
         """Compose two async wrappers where outer wraps inner."""
 
         async def composed(
             request: ToolCallRequest,
-            execute: Callable[[ToolCallRequest], Awaitable[ToolMessage | Command]],
-        ) -> ToolMessage | Command:
+            execute: Callable[[ToolCallRequest], Awaitable[ToolMessage | Command[Any]]],
+        ) -> ToolMessage | Command[Any]:
             # Create an async callable that invokes inner with the original execute
-            async def call_inner(req: ToolCallRequest) -> ToolMessage | Command:
+            async def call_inner(req: ToolCallRequest) -> ToolMessage | Command[Any]:
                 return await inner(req, execute)
 
             # Outer can call call_inner multiple times
@@ -540,11 +542,11 @@ def _chain_async_tool_call_wrappers(
 
 def create_agent(
     model: str | BaseChatModel,
-    tools: Sequence[BaseTool | Callable | dict[str, Any]] | None = None,
+    tools: Sequence[BaseTool | Callable[..., Any] | dict[str, Any]] | None = None,
     *,
     system_prompt: str | SystemMessage | None = None,
     middleware: Sequence[AgentMiddleware[StateT_co, ContextT]] = (),
-    response_format: ResponseFormat[ResponseT] | type[ResponseT] | None = None,
+    response_format: ResponseFormat[ResponseT] | type[ResponseT] | dict[str, Any] | None = None,
     state_schema: type[AgentState[ResponseT]] | None = None,
     context_schema: type[ContextT] | None = None,
     checkpointer: Checkpointer | None = None,
@@ -553,7 +555,7 @@ def create_agent(
     interrupt_after: list[str] | None = None,
     debug: bool = False,
     name: str | None = None,
-    cache: BaseCache | None = None,
+    cache: BaseCache[Any] | None = None,
 ) -> CompiledStateGraph[
     AgentState[ResponseT], ContextT, _InputAgentState, _OutputAgentState[ResponseT]
 ]:
@@ -653,6 +655,9 @@ def create_agent(
     Returns:
         A compiled `StateGraph` that can be used for chat interactions.
 
+    Raises:
+        AssertionError: If duplicate middleware instances are provided.
+
     The agent node calls the language model with the messages list (after applying
     the system prompt). If the resulting [`AIMessage`][langchain.messages.AIMessage]
     contains `tool_calls`, the graph will then call the tools. The tools node executes
@@ -701,7 +706,7 @@ def create_agent(
     # Raw schemas are wrapped in AutoStrategy to preserve auto-detection intent.
     # AutoStrategy is converted to ToolStrategy upfront to calculate tools during agent creation,
     # but may be replaced with ProviderStrategy later based on model capabilities.
-    initial_response_format: ToolStrategy | ProviderStrategy | AutoStrategy | None
+    initial_response_format: ToolStrategy[Any] | ProviderStrategy[Any] | AutoStrategy[Any] | None
     if response_format is None:
         initial_response_format = None
     elif isinstance(response_format, (ToolStrategy, ProviderStrategy)):
@@ -716,13 +721,13 @@ def create_agent(
 
     # For AutoStrategy, convert to ToolStrategy to setup tools upfront
     # (may be replaced with ProviderStrategy later based on model)
-    tool_strategy_for_setup: ToolStrategy | None = None
+    tool_strategy_for_setup: ToolStrategy[Any] | None = None
     if isinstance(initial_response_format, AutoStrategy):
         tool_strategy_for_setup = ToolStrategy(schema=initial_response_format.schema)
     elif isinstance(initial_response_format, ToolStrategy):
         tool_strategy_for_setup = initial_response_format
 
-    structured_output_tools: dict[str, OutputToolBinding] = {}
+    structured_output_tools: dict[str, OutputToolBinding[Any]] = {}
     if tool_strategy_for_setup:
         for response_schema in tool_strategy_for_setup.schema_specs:
             structured_tool_info = OutputToolBinding.from_schema_spec(response_schema)
@@ -869,7 +874,7 @@ def create_agent(
     )
 
     def _handle_model_output(
-        output: AIMessage, effective_response_format: ResponseFormat | None
+        output: AIMessage, effective_response_format: ResponseFormat[Any] | None
     ) -> dict[str, Any]:
         """Handle model output including structured responses.
 
@@ -972,7 +977,9 @@ def create_agent(
 
         return {"messages": [output]}
 
-    def _get_bound_model(request: ModelRequest) -> tuple[Runnable, ResponseFormat | None]:
+    def _get_bound_model(
+        request: ModelRequest,
+    ) -> tuple[Runnable[Any, Any], ResponseFormat[Any] | None]:
         """Get the model with appropriate tool bindings.
 
         Performs auto-detection of strategy if needed based on model capabilities.
@@ -984,6 +991,10 @@ def create_agent(
             Tuple of `(bound_model, effective_response_format)` where
             `effective_response_format` is the actual strategy used (may differ from
             initial if auto-detected).
+
+        Raises:
+            ValueError: If middleware returned unknown client-side tool names.
+            ValueError: If `ToolStrategy` specifies tools not declared upfront.
         """
         # Validate ONLY client-side tools that need to exist in tool_node
         # Build map of available client-side tools from the ToolNode
@@ -1018,7 +1029,7 @@ def create_agent(
             raise ValueError(msg)
 
         # Determine effective response format (auto-detect if needed)
-        effective_response_format: ResponseFormat | None
+        effective_response_format: ResponseFormat[Any] | None
         if isinstance(request.response_format, AutoStrategy):
             # User provided raw schema via AutoStrategy - auto-detect best strategy based on model
             if _supports_provider_strategy(request.model, tools=request.tools):
@@ -1112,7 +1123,7 @@ def create_agent(
             structured_response=structured_response,
         )
 
-    def model_node(state: AgentState, runtime: Runtime[ContextT]) -> dict[str, Any]:
+    def model_node(state: AgentState[Any], runtime: Runtime[ContextT]) -> dict[str, Any]:
         """Sync model request handler with sequential middleware processing."""
         request = ModelRequest(
             model=model,
@@ -1167,7 +1178,7 @@ def create_agent(
             structured_response=structured_response,
         )
 
-    async def amodel_node(state: AgentState, runtime: Runtime[ContextT]) -> dict[str, Any]:
+    async def amodel_node(state: AgentState[Any], runtime: Runtime[ContextT]) -> dict[str, Any]:
         """Async model request handler with sequential middleware processing."""
         request = ModelRequest(
             model=model,
@@ -1471,6 +1482,10 @@ def create_agent(
             can_jump_to=_get_can_jump_to(middleware_w_after_agent[0], "after_agent"),
         )
 
+    config: RunnableConfig = {"recursion_limit": 10_000}
+    if name:
+        config["metadata"] = {"lc_agent_name": name}
+
     return graph.compile(
         checkpointer=checkpointer,
         store=store,
@@ -1479,7 +1494,7 @@ def create_agent(
         debug=debug,
         name=name,
         cache=cache,
-    ).with_config({"recursion_limit": 10_000})
+    ).with_config(config)
 
 
 def _resolve_jump(
@@ -1516,7 +1531,7 @@ def _fetch_last_ai_and_tool_messages(
 def _make_model_to_tools_edge(
     *,
     model_destination: str,
-    structured_output_tools: dict[str, OutputToolBinding],
+    structured_output_tools: dict[str, OutputToolBinding[Any]],
     end_destination: str,
 ) -> Callable[[dict[str, Any]], str | list[Send] | None]:
     def model_to_tools(
@@ -1600,7 +1615,7 @@ def _make_tools_to_model_edge(
     *,
     tool_node: ToolNode,
     model_destination: str,
-    structured_output_tools: dict[str, OutputToolBinding],
+    structured_output_tools: dict[str, OutputToolBinding[Any]],
     end_destination: str,
 ) -> Callable[[dict[str, Any]], str | None]:
     def tools_to_model(state: dict[str, Any]) -> str | None:

langchain/agents/middleware/__init__.py

@@ -1,32 +1,29 @@
 """Entrypoint to using [middleware](https://docs.langchain.com/oss/python/langchain/middleware) plugins with [Agents](https://docs.langchain.com/oss/python/langchain/agents)."""  # noqa: E501
 
-from .context_editing import (
-    ClearToolUsesEdit,
-    ContextEditingMiddleware,
-)
-from .file_search import FilesystemFileSearchMiddleware
-from .human_in_the_loop import (
+from langchain.agents.middleware.context_editing import ClearToolUsesEdit, ContextEditingMiddleware
+from langchain.agents.middleware.file_search import FilesystemFileSearchMiddleware
+from langchain.agents.middleware.human_in_the_loop import (
     HumanInTheLoopMiddleware,
     InterruptOnConfig,
 )
-from .model_call_limit import ModelCallLimitMiddleware
-from .model_fallback import ModelFallbackMiddleware
-from .model_retry import ModelRetryMiddleware
-from .pii import PIIDetectionError, PIIMiddleware
-from .shell_tool import (
+from langchain.agents.middleware.model_call_limit import ModelCallLimitMiddleware
+from langchain.agents.middleware.model_fallback import ModelFallbackMiddleware
+from langchain.agents.middleware.model_retry import ModelRetryMiddleware
+from langchain.agents.middleware.pii import PIIDetectionError, PIIMiddleware
+from langchain.agents.middleware.shell_tool import (
     CodexSandboxExecutionPolicy,
     DockerExecutionPolicy,
     HostExecutionPolicy,
     RedactionRule,
     ShellToolMiddleware,
 )
-from .summarization import SummarizationMiddleware
-from .todo import TodoListMiddleware
-from .tool_call_limit import ToolCallLimitMiddleware
-from .tool_emulator import LLMToolEmulator
-from .tool_retry import ToolRetryMiddleware
-from .tool_selection import LLMToolSelectorMiddleware
-from .types import (
+from langchain.agents.middleware.summarization import SummarizationMiddleware
+from langchain.agents.middleware.todo import TodoListMiddleware
+from langchain.agents.middleware.tool_call_limit import ToolCallLimitMiddleware
+from langchain.agents.middleware.tool_emulator import LLMToolEmulator
+from langchain.agents.middleware.tool_retry import ToolRetryMiddleware
+from langchain.agents.middleware.tool_selection import LLMToolSelectorMiddleware
+from langchain.agents.middleware.types import (
     AgentMiddleware,
     AgentState,
     ModelRequest,

langchain/agents/middleware/_execution.py

@@ -15,8 +15,10 @@ from pathlib import Path
 
 try:  # pragma: no cover - optional dependency on POSIX platforms
     import resource
+
+    _HAS_RESOURCE = True
 except ImportError:  # pragma: no cover - non-POSIX systems
-    resource = None  # type: ignore[assignment]
+    _HAS_RESOURCE = False
 
 
 SHELL_TEMP_PREFIX = "langchain-shell-"
@@ -119,7 +121,7 @@ class HostExecutionPolicy(BaseExecutionPolicy):
         self._limits_requested = any(
             value is not None for value in (self.cpu_time_seconds, self.memory_bytes)
         )
-        if self._limits_requested and resource is None:
+        if self._limits_requested and not _HAS_RESOURCE:
             msg = (
                 "HostExecutionPolicy cpu/memory limits require the Python 'resource' module. "
                 "Either remove the limits or run on a POSIX platform."
@@ -163,11 +165,9 @@ class HostExecutionPolicy(BaseExecutionPolicy):
     def _apply_post_spawn_limits(self, process: subprocess.Popen[str]) -> None:
         if not self._limits_requested or not self._can_use_prlimit():
             return
-        if resource is None:  # pragma: no cover - defensive
+        if not _HAS_RESOURCE:  # pragma: no cover - defensive
             return
         pid = process.pid
-        if pid is None:
-            return
         try:
             prlimit = typing.cast("typing.Any", resource).prlimit
             if self.cpu_time_seconds is not None:
@@ -184,11 +184,7 @@ class HostExecutionPolicy(BaseExecutionPolicy):
 
     @staticmethod
     def _can_use_prlimit() -> bool:
-        return (
-            resource is not None
-            and hasattr(resource, "prlimit")
-            and sys.platform.startswith("linux")
-        )
+        return _HAS_RESOURCE and hasattr(resource, "prlimit") and sys.platform.startswith("linux")
 
 
 @dataclass
@@ -251,9 +247,9 @@ class CodexSandboxExecutionPolicy(BaseExecutionPolicy):
             return self.platform
         if sys.platform.startswith("linux"):
             return "linux"
-        if sys.platform == "darwin":
+        if sys.platform == "darwin":  # type: ignore[unreachable, unused-ignore]
             return "macos"
-        msg = (
+        msg = (  # type: ignore[unreachable, unused-ignore]
             "Codex sandbox policy could not determine a supported platform; "
             "set 'platform' explicitly."
         )

langchain/agents/middleware/_redaction.py

@@ -48,7 +48,14 @@ Detector = Callable[[str], list[PIIMatch]]
 
 
 def detect_email(content: str) -> list[PIIMatch]:
-    """Detect email addresses in content."""
+    """Detect email addresses in content.
+
+    Args:
+        content: The text content to scan for email addresses.
+
+    Returns:
+        A list of detected email matches.
+    """
     pattern = r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b"
     return [
         PIIMatch(
@@ -62,7 +69,14 @@ def detect_email(content: str) -> list[PIIMatch]:
 
 
 def detect_credit_card(content: str) -> list[PIIMatch]:
-    """Detect credit card numbers in content using Luhn validation."""
+    """Detect credit card numbers in content using Luhn validation.
+
+    Args:
+        content: The text content to scan for credit card numbers.
+
+    Returns:
+        A list of detected credit card matches.
+    """
     pattern = r"\b\d{4}[\s-]?\d{4}[\s-]?\d{4}[\s-]?\d{4}\b"
     matches = []
 
@@ -82,7 +96,14 @@ def detect_credit_card(content: str) -> list[PIIMatch]:
 
 
 def detect_ip(content: str) -> list[PIIMatch]:
-    """Detect IPv4 or IPv6 addresses in content."""
+    """Detect IPv4 or IPv6 addresses in content.
+
+    Args:
+        content: The text content to scan for IP addresses.
+
+    Returns:
+        A list of detected IP address matches.
+    """
     matches: list[PIIMatch] = []
     ipv4_pattern = r"\b(?:[0-9]{1,3}\.){3}[0-9]{1,3}\b"
 
@@ -105,7 +126,14 @@ def detect_ip(content: str) -> list[PIIMatch]:
 
 
 def detect_mac_address(content: str) -> list[PIIMatch]:
-    """Detect MAC addresses in content."""
+    """Detect MAC addresses in content.
+
+    Args:
+        content: The text content to scan for MAC addresses.
+
+    Returns:
+        A list of detected MAC address matches.
+    """
     pattern = r"\b([0-9A-Fa-f]{2}[:-]){5}[0-9A-Fa-f]{2}\b"
     return [
         PIIMatch(
@@ -119,7 +147,14 @@ def detect_mac_address(content: str) -> list[PIIMatch]:
 
 
 def detect_url(content: str) -> list[PIIMatch]:
-    """Detect URLs in content using regex and stdlib validation."""
+    """Detect URLs in content using regex and stdlib validation.
+
+    Args:
+        content: The text content to scan for URLs.
+
+    Returns:
+        A list of detected URL matches.
+    """
     matches: list[PIIMatch] = []
 
     # Pattern 1: URLs with scheme (http:// or https://)
@@ -273,7 +308,20 @@ def apply_strategy(
     matches: list[PIIMatch],
     strategy: RedactionStrategy,
 ) -> str:
-    """Apply the configured strategy to matches within content."""
+    """Apply the configured strategy to matches within content.
+
+    Args:
+        content: The content to apply strategy to.
+        matches: List of detected PII matches.
+        strategy: The redaction strategy to apply.
+
+    Returns:
+        The content with the strategy applied.
+
+    Raises:
+        PIIDetectionError: If the strategy is `'block'` and matches are found.
+        ValueError: If the strategy is unknown.
+    """
     if not matches:
         return content
     if strategy == "redact":
@@ -284,12 +332,24 @@ def apply_strategy(
         return _apply_hash_strategy(content, matches)
     if strategy == "block":
         raise PIIDetectionError(matches[0]["type"], matches)
-    msg = f"Unknown redaction strategy: {strategy}"
+    msg = f"Unknown redaction strategy: {strategy}"  # type: ignore[unreachable]
     raise ValueError(msg)
 
 
 def resolve_detector(pii_type: str, detector: Detector | str | None) -> Detector:
-    """Return a callable detector for the given configuration."""
+    """Return a callable detector for the given configuration.
+
+    Args:
+        pii_type: The PII type name.
+        detector: Optional custom detector or regex pattern. If `None`, a built-in detector
+            for the given PII type will be used.
+
+    Returns:
+        The resolved detector.
+
+    Raises:
+        ValueError: If an unknown PII type is specified without a custom detector or regex.
+    """
     if detector is None:
         if pii_type not in BUILTIN_DETECTORS:
             msg = (
@@ -325,7 +385,11 @@ class RedactionRule:
     detector: Detector | str | None = None
 
     def resolve(self) -> ResolvedRedactionRule:
-        """Resolve runtime detector and return an immutable rule."""
+        """Resolve runtime detector and return an immutable rule.
+
+        Returns:
+            The resolved redaction rule.
+        """
         resolved_detector = resolve_detector(self.pii_type, self.detector)
         return ResolvedRedactionRule(
             pii_type=self.pii_type,
@@ -343,7 +407,14 @@ class ResolvedRedactionRule:
     detector: Detector
 
     def apply(self, content: str) -> tuple[str, list[PIIMatch]]:
-        """Apply this rule to content, returning new content and matches."""
+        """Apply this rule to content, returning new content and matches.
+
+        Args:
+            content: The text content to scan and redact.
+
+        Returns:
+            A tuple of (updated content, list of detected matches).
+        """
         matches = self.detector(content)
         if not matches:
             return content, []

langchain/agents/middleware/context_editing.py

@@ -152,8 +152,8 @@ class ClearToolUsesEdit(ContextEdit):
 
         return
 
+    @staticmethod
     def _build_cleared_tool_input_message(
-        self,
         message: AIMessage,
         tool_call_id: str,
     ) -> AIMessage:
@@ -220,7 +220,16 @@ class ContextEditingMiddleware(AgentMiddleware):
         request: ModelRequest,
         handler: Callable[[ModelRequest], ModelResponse],
     ) -> ModelCallResult:
-        """Apply context edits before invoking the model via handler."""
+        """Apply context edits before invoking the model via handler.
+
+        Args:
+            request: Model request to execute (includes state and runtime).
+            handler: Async callback that executes the model request and returns
+                `ModelResponse`.
+
+        Returns:
+            The result of invoking the handler with potentially edited messages.
+        """
         if not request.messages:
             return handler(request)
 
@@ -248,7 +257,16 @@ class ContextEditingMiddleware(AgentMiddleware):
         request: ModelRequest,
         handler: Callable[[ModelRequest], Awaitable[ModelResponse]],
     ) -> ModelCallResult:
-        """Apply context edits before invoking the model via handler (async version)."""
+        """Apply context edits before invoking the model via handler.
+
+        Args:
+            request: Model request to execute (includes state and runtime).
+            handler: Async callback that executes the model request and returns
+                `ModelResponse`.
+
+        Returns:
+            The result of invoking the handler with potentially edited messages.
+        """
         if not request.messages:
             return await handler(request)
 

langchain/agents/middleware/file_search.py

@@ -352,8 +352,8 @@ class FilesystemFileSearchMiddleware(AgentMiddleware):
 
         return results
 
+    @staticmethod
     def _format_grep_results(
-        self,
         results: dict[str, list[tuple[int, str]]],
         output_mode: str,
     ) -> str: