langchain 1.0.0a13__tar.gz → 1.0.0a14__tar.gz

{langchain-1.0.0a13 → langchain-1.0.0a14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langchain
-Version: 1.0.0a13
+Version: 1.0.0a14
 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

{langchain-1.0.0a13 → langchain-1.0.0a14}/langchain/agents/factory.py

@@ -13,9 +13,6 @@ from typing import (
     get_type_hints,
 )
 
-if TYPE_CHECKING:
-    from collections.abc import Awaitable
-
 from langchain_core.language_models.chat_models import BaseChatModel
 from langchain_core.messages import AIMessage, AnyMessage, SystemMessage, ToolMessage
 from langchain_core.tools import BaseTool
@@ -47,11 +44,10 @@ from langchain.agents.structured_output import (
     ToolStrategy,
 )
 from langchain.chat_models import init_chat_model
-from langchain.tools import ToolNode
-from langchain.tools.tool_node import ToolCallWithContext
+from langchain.tools.tool_node import ToolCallWithContext, _ToolNode
 
 if TYPE_CHECKING:
-    from collections.abc import Callable, Sequence
+    from collections.abc import Awaitable, Callable, Sequence
 
     from langchain_core.runnables import Runnable
     from langgraph.cache.base import BaseCache
@@ -449,6 +445,70 @@ def _chain_tool_call_wrappers(
     return result
 
 
+def _chain_async_tool_call_wrappers(
+    wrappers: Sequence[
+        Callable[
+            [ToolCallRequest, Callable[[ToolCallRequest], Awaitable[ToolMessage | Command]]],
+            Awaitable[ToolMessage | Command],
+        ]
+    ],
+) -> (
+    Callable[
+        [ToolCallRequest, Callable[[ToolCallRequest], Awaitable[ToolMessage | Command]]],
+        Awaitable[ToolMessage | Command],
+    ]
+    | None
+):
+    """Compose async wrappers into middleware stack (first = outermost).
+
+    Args:
+        wrappers: Async wrappers in middleware order.
+
+    Returns:
+        Composed async wrapper, or None if empty.
+    """
+    if not wrappers:
+        return None
+
+    if len(wrappers) == 1:
+        return wrappers[0]
+
+    def compose_two(
+        outer: Callable[
+            [ToolCallRequest, Callable[[ToolCallRequest], Awaitable[ToolMessage | Command]]],
+            Awaitable[ToolMessage | Command],
+        ],
+        inner: Callable[
+            [ToolCallRequest, Callable[[ToolCallRequest], Awaitable[ToolMessage | Command]]],
+            Awaitable[ToolMessage | Command],
+        ],
+    ) -> Callable[
+        [ToolCallRequest, Callable[[ToolCallRequest], Awaitable[ToolMessage | Command]]],
+        Awaitable[ToolMessage | Command],
+    ]:
+        """Compose two async wrappers where outer wraps inner."""
+
+        async def composed(
+            request: ToolCallRequest,
+            execute: Callable[[ToolCallRequest], Awaitable[ToolMessage | Command]],
+        ) -> ToolMessage | Command:
+            # Create an async callable that invokes inner with the original execute
+            async def call_inner(req: ToolCallRequest) -> ToolMessage | Command:
+                return await inner(req, execute)
+
+            # Outer can call call_inner multiple times
+            return await outer(request, call_inner)
+
+        return composed
+
+    # Chain all wrappers: first -> second -> ... -> last
+    result = wrappers[-1]
+    for wrapper in reversed(wrappers[:-1]):
+        result = compose_two(wrapper, result)
+
+    return result
+
+
 def create_agent(  # noqa: PLR0915
     model: str | BaseChatModel,
     tools: Sequence[BaseTool | Callable | dict[str, Any]] | None = None,
@@ -576,9 +636,14 @@ def create_agent(  # noqa: PLR0915
             structured_output_tools[structured_tool_info.tool.name] = structured_tool_info
     middleware_tools = [t for m in middleware for t in getattr(m, "tools", [])]
 
-    # Collect middleware with wrap_tool_call hooks
+    # Collect middleware with wrap_tool_call or awrap_tool_call hooks
+    # Include middleware with either implementation to ensure NotImplementedError is raised
+    # when middleware doesn't support the execution path
     middleware_w_wrap_tool_call = [
-        m for m in middleware if m.__class__.wrap_tool_call is not AgentMiddleware.wrap_tool_call
+        m
+        for m in middleware
+        if m.__class__.wrap_tool_call is not AgentMiddleware.wrap_tool_call
+        or m.__class__.awrap_tool_call is not AgentMiddleware.awrap_tool_call
     ]
 
     # Chain all wrap_tool_call handlers into a single composed handler
@@ -587,8 +652,24 @@ def create_agent(  # noqa: PLR0915
         wrappers = [m.wrap_tool_call for m in middleware_w_wrap_tool_call]
         wrap_tool_call_wrapper = _chain_tool_call_wrappers(wrappers)
 
+    # Collect middleware with awrap_tool_call or wrap_tool_call hooks
+    # Include middleware with either implementation to ensure NotImplementedError is raised
+    # when middleware doesn't support the execution path
+    middleware_w_awrap_tool_call = [
+        m
+        for m in middleware
+        if m.__class__.awrap_tool_call is not AgentMiddleware.awrap_tool_call
+        or m.__class__.wrap_tool_call is not AgentMiddleware.wrap_tool_call
+    ]
+
+    # Chain all awrap_tool_call handlers into a single composed async handler
+    awrap_tool_call_wrapper = None
+    if middleware_w_awrap_tool_call:
+        async_wrappers = [m.awrap_tool_call for m in middleware_w_awrap_tool_call]
+        awrap_tool_call_wrapper = _chain_async_tool_call_wrappers(async_wrappers)
+
     # Setup tools
-    tool_node: ToolNode | None = None
+    tool_node: _ToolNode | None = None
     # Extract built-in provider tools (dict format) and regular tools (BaseTool/callables)
     built_in_tools = [t for t in tools if isinstance(t, dict)]
     regular_tools = [t for t in tools if not isinstance(t, dict)]
@@ -598,7 +679,11 @@ def create_agent(  # noqa: PLR0915
 
     # Only create ToolNode if we have client-side tools
     tool_node = (
-        ToolNode(tools=available_tools, wrap_tool_call=wrap_tool_call_wrapper)
+        _ToolNode(
+            tools=available_tools,
+            wrap_tool_call=wrap_tool_call_wrapper,
+            awrap_tool_call=awrap_tool_call_wrapper,
+        )
         if available_tools
         else None
     )
@@ -640,13 +725,23 @@ def create_agent(  # noqa: PLR0915
         if m.__class__.after_agent is not AgentMiddleware.after_agent
         or m.__class__.aafter_agent is not AgentMiddleware.aafter_agent
     ]
+    # Collect middleware with wrap_model_call or awrap_model_call hooks
+    # Include middleware with either implementation to ensure NotImplementedError is raised
+    # when middleware doesn't support the execution path
     middleware_w_wrap_model_call = [
-        m for m in middleware if m.__class__.wrap_model_call is not AgentMiddleware.wrap_model_call
+        m
+        for m in middleware
+        if m.__class__.wrap_model_call is not AgentMiddleware.wrap_model_call
+        or m.__class__.awrap_model_call is not AgentMiddleware.awrap_model_call
     ]
+    # Collect middleware with awrap_model_call or wrap_model_call hooks
+    # Include middleware with either implementation to ensure NotImplementedError is raised
+    # when middleware doesn't support the execution path
     middleware_w_awrap_model_call = [
         m
         for m in middleware
         if m.__class__.awrap_model_call is not AgentMiddleware.awrap_model_call
+        or m.__class__.wrap_model_call is not AgentMiddleware.wrap_model_call
     ]
 
     # Compose wrap_model_call handlers into a single middleware stack (sync)
@@ -1378,7 +1473,7 @@ def _make_model_to_model_edge(
 
 def _make_tools_to_model_edge(
     *,
-    tool_node: ToolNode,
+    tool_node: _ToolNode,
     model_destination: str,
     structured_output_tools: dict[str, OutputToolBinding],
     end_destination: str,

{langchain-1.0.0a13 → langchain-1.0.0a14}/langchain/agents/middleware/pii.py

@@ -431,14 +431,12 @@ class PIIMiddleware(AgentMiddleware):
 
     Strategy Selection Guide:
 
-        ========  ===================  =======================================
-        Strategy  Preserves Identity?  Best For
-        ========  ===================  =======================================
-        `block`   N/A                  Avoid PII completely
-        `redact`  No                   General compliance, log sanitization
-        `mask`    No                   Human readability, customer service UIs
-        `hash`    Yes (pseudonymous)   Analytics, debugging
-        ========  ===================  =======================================
+        | Strategy | Preserves Identity? | Best For                                |
+        | -------- | ------------------- | --------------------------------------- |
+        | `block`  | N/A                 | Avoid PII completely                    |
+        | `redact` | No                  | General compliance, log sanitization    |
+        | `mask`   | No                  | Human readability, customer service UIs |
+        | `hash`   | Yes (pseudonymous)  | Analytics, debugging                    |
 
     Example:
         ```python

{langchain-1.0.0a13 → langchain-1.0.0a14}/langchain/agents/middleware/types.py

@@ -21,7 +21,7 @@ if TYPE_CHECKING:
 
     from langchain.tools.tool_node import ToolCallRequest
 
-# needed as top level import for pydantic schema generation on AgentState
+# Needed as top level import for Pydantic schema generation on AgentState
 from typing import TypeAlias
 
 from langchain_core.messages import AIMessage, AnyMessage, BaseMessage, ToolMessage  # noqa: TC002
@@ -263,18 +263,35 @@ class AgentMiddleware(Generic[StateT, ContextT]):
                 return AIMessage(content="Simplified response")
             ```
         """
-        raise NotImplementedError
+        msg = (
+            "Synchronous implementation of wrap_model_call is not available. "
+            "You are likely encountering this error because you defined only the async version "
+            "(awrap_model_call) and invoked your agent in a synchronous context "
+            "(e.g., using `stream()` or `invoke()`). "
+            "To resolve this, either: "
+            "(1) subclass AgentMiddleware and implement the synchronous wrap_model_call method, "
+            "(2) use the @wrap_model_call decorator on a standalone sync function, or "
+            "(3) invoke your agent asynchronously using `astream()` or `ainvoke()`."
+        )
+        raise NotImplementedError(msg)
 
     async def awrap_model_call(
         self,
         request: ModelRequest,
         handler: Callable[[ModelRequest], Awaitable[ModelResponse]],
     ) -> ModelCallResult:
-        """Async version of wrap_model_call.
+        """Intercept and control async model execution via handler callback.
+
+        The handler callback executes the model request and returns a ModelResponse.
+        Middleware can call the handler multiple times for retry logic, skip calling
+        it to short-circuit, or modify the request/response. Multiple middleware
+        compose with first in list as outermost layer.
 
         Args:
             request: Model request to execute (includes state and runtime).
-            handler: Async callback that executes the model request.
+            handler: Async callback that executes the model request and returns ModelResponse.
+                     Call this to execute the model. Can be called multiple times
+                     for retry logic. Can skip calling it to short-circuit.
 
         Returns:
             ModelCallResult
@@ -291,7 +308,17 @@ class AgentMiddleware(Generic[StateT, ContextT]):
                             raise
             ```
         """
-        raise NotImplementedError
+        msg = (
+            "Asynchronous implementation of awrap_model_call is not available. "
+            "You are likely encountering this error because you defined only the sync version "
+            "(wrap_model_call) and invoked your agent in an asynchronous context "
+            "(e.g., using `astream()` or `ainvoke()`). "
+            "To resolve this, either: "
+            "(1) subclass AgentMiddleware and implement the asynchronous awrap_model_call method, "
+            "(2) use the @wrap_model_call decorator on a standalone async function, or "
+            "(3) invoke your agent synchronously using `stream()` or `invoke()`."
+        )
+        raise NotImplementedError(msg)
 
     def after_agent(self, state: StateT, runtime: Runtime[ContextT]) -> dict[str, Any] | None:
         """Logic to run after the agent execution completes."""
@@ -353,7 +380,77 @@ class AgentMiddleware(Generic[StateT, ContextT]):
                         continue
                     return result
         """
-        raise NotImplementedError
+        msg = (
+            "Synchronous implementation of wrap_tool_call is not available. "
+            "You are likely encountering this error because you defined only the async version "
+            "(awrap_tool_call) and invoked your agent in a synchronous context "
+            "(e.g., using `stream()` or `invoke()`). "
+            "To resolve this, either: "
+            "(1) subclass AgentMiddleware and implement the synchronous wrap_tool_call method, "
+            "(2) use the @wrap_tool_call decorator on a standalone sync function, or "
+            "(3) invoke your agent asynchronously using `astream()` or `ainvoke()`."
+        )
+        raise NotImplementedError(msg)
+
+    async def awrap_tool_call(
+        self,
+        request: ToolCallRequest,
+        handler: Callable[[ToolCallRequest], Awaitable[ToolMessage | Command]],
+    ) -> ToolMessage | Command:
+        """Intercept and control async tool execution via handler callback.
+
+        The handler callback executes the tool call and returns a ToolMessage or Command.
+        Middleware can call the handler multiple times for retry logic, skip calling
+        it to short-circuit, or modify the request/response. Multiple middleware
+        compose with first in list as outermost layer.
+
+        Args:
+            request: Tool call request with call dict, BaseTool, state, and runtime.
+                Access state via request.state and runtime via request.runtime.
+            handler: Async callable to execute the tool and returns ToolMessage or Command.
+                     Call this to execute the tool. Can be called multiple times
+                     for retry logic. Can skip calling it to short-circuit.
+
+        Returns:
+            ToolMessage or Command (the final result).
+
+        The handler callable can be invoked multiple times for retry logic.
+        Each call to handler is independent and stateless.
+
+        Examples:
+            Async retry on error:
+            ```python
+            async def awrap_tool_call(self, request, handler):
+                for attempt in range(3):
+                    try:
+                        result = await handler(request)
+                        if is_valid(result):
+                            return result
+                    except Exception:
+                        if attempt == 2:
+                            raise
+                return result
+            ```
+
+
+            async def awrap_tool_call(self, request, handler):
+                if cached := await get_cache_async(request):
+                    return ToolMessage(content=cached, tool_call_id=request.tool_call["id"])
+                result = await handler(request)
+                await save_cache_async(request, result)
+                return result
+        """
+        msg = (
+            "Asynchronous implementation of awrap_tool_call is not available. "
+            "You are likely encountering this error because you defined only the sync version "
+            "(wrap_tool_call) and invoked your agent in an asynchronous context "
+            "(e.g., using `astream()` or `ainvoke()`). "
+            "To resolve this, either: "
+            "(1) subclass AgentMiddleware and implement the asynchronous awrap_tool_call method, "
+            "(2) use the @wrap_tool_call decorator on a standalone async function, or "
+            "(3) invoke your agent synchronously using `stream()` or `invoke()`."
+        )
+        raise NotImplementedError(msg)
 
 
 class _CallableWithStateAndRuntime(Protocol[StateT_contra, ContextT]):
@@ -1104,6 +1201,16 @@ def dynamic_prompt(
             request.system_prompt = prompt
             return handler(request)
 
+        async def async_wrapped_from_sync(
+            self: AgentMiddleware[StateT, ContextT],  # noqa: ARG001
+            request: ModelRequest,
+            handler: Callable[[ModelRequest], Awaitable[ModelResponse]],
+        ) -> ModelCallResult:
+            # Delegate to sync function
+            prompt = cast("str", func(request))
+            request.system_prompt = prompt
+            return await handler(request)
+
         middleware_name = cast("str", getattr(func, "__name__", "DynamicPromptMiddleware"))
 
         return type(
@@ -1113,6 +1220,7 @@ def dynamic_prompt(
                 "state_schema": AgentState,
                 "tools": [],
                 "wrap_model_call": wrapped,
+                "awrap_model_call": async_wrapped_from_sync,
             },
         )()
 
@@ -1309,6 +1417,7 @@ def wrap_tool_call(
     Args:
         func: Function accepting (request, handler) that calls
             handler(request) to execute the tool and returns final ToolMessage or Command.
+            Can be sync or async.
         tools: Additional tools to register with this middleware.
         name: Middleware class name. Defaults to function name.
 
@@ -1316,13 +1425,6 @@ def wrap_tool_call(
         AgentMiddleware instance if func provided, otherwise a decorator.
 
     Examples:
-        Basic passthrough:
-        ```python
-        @wrap_tool_call
-        def passthrough(request, handler):
-            return handler(request)
-        ```
-
         Retry logic:
         ```python
         @wrap_tool_call
@@ -1336,6 +1438,18 @@ def wrap_tool_call(
                         raise
         ```
 
+        Async retry logic:
+        ```python
+        @wrap_tool_call
+        async def async_retry(request, handler):
+            for attempt in range(3):
+                try:
+                    return await handler(request)
+                except Exception:
+                    if attempt == 2:
+                        raise
+        ```
+
         Modify request:
         ```python
         @wrap_tool_call
@@ -1359,6 +1473,31 @@ def wrap_tool_call(
     def decorator(
         func: _CallableReturningToolResponse,
     ) -> AgentMiddleware:
+        is_async = iscoroutinefunction(func)
+
+        if is_async:
+
+            async def async_wrapped(
+                self: AgentMiddleware,  # noqa: ARG001
+                request: ToolCallRequest,
+                handler: Callable[[ToolCallRequest], Awaitable[ToolMessage | Command]],
+            ) -> ToolMessage | Command:
+                return await func(request, handler)  # type: ignore[arg-type,misc]
+
+            middleware_name = name or cast(
+                "str", getattr(func, "__name__", "WrapToolCallMiddleware")
+            )
+
+            return type(
+                middleware_name,
+                (AgentMiddleware,),
+                {
+                    "state_schema": AgentState,
+                    "tools": tools or [],
+                    "awrap_tool_call": async_wrapped,
+                },
+            )()
+
         def wrapped(
             self: AgentMiddleware,  # noqa: ARG001
             request: ToolCallRequest,

{langchain-1.0.0a13 → langchain-1.0.0a14}/langchain/embeddings/__init__.py

@@ -3,10 +3,8 @@
 from langchain_core.embeddings import Embeddings
 
 from langchain.embeddings.base import init_embeddings
-from langchain.embeddings.cache import CacheBackedEmbeddings
 
 __all__ = [
-    "CacheBackedEmbeddings",
     "Embeddings",
     "init_embeddings",
 ]

langchain-1.0.0a14/langchain/messages/__init__.py

@@ -0,0 +1,63 @@
+"""Message types."""
+
+from langchain_core.messages import (
+    AIMessage,
+    AIMessageChunk,
+    Annotation,
+    AnyMessage,
+    AudioContentBlock,
+    Citation,
+    ContentBlock,
+    DataContentBlock,
+    FileContentBlock,
+    HumanMessage,
+    ImageContentBlock,
+    InvalidToolCall,
+    MessageLikeRepresentation,
+    NonStandardAnnotation,
+    NonStandardContentBlock,
+    PlainTextContentBlock,
+    ReasoningContentBlock,
+    RemoveMessage,
+    ServerToolCall,
+    ServerToolCallChunk,
+    ServerToolResult,
+    SystemMessage,
+    TextContentBlock,
+    ToolCall,
+    ToolCallChunk,
+    ToolMessage,
+    VideoContentBlock,
+    trim_messages,
+)
+
+__all__ = [
+    "AIMessage",
+    "AIMessageChunk",
+    "Annotation",
+    "AnyMessage",
+    "AudioContentBlock",
+    "Citation",
+    "ContentBlock",
+    "DataContentBlock",
+    "FileContentBlock",
+    "HumanMessage",
+    "ImageContentBlock",
+    "InvalidToolCall",
+    "MessageLikeRepresentation",
+    "NonStandardAnnotation",
+    "NonStandardContentBlock",
+    "PlainTextContentBlock",
+    "ReasoningContentBlock",
+    "RemoveMessage",
+    "ServerToolCall",
+    "ServerToolCallChunk",
+    "ServerToolResult",
+    "SystemMessage",
+    "TextContentBlock",
+    "ToolCall",
+    "ToolCallChunk",
+    "ToolMessage",
+    "VideoContentBlock",
+    "trim_messages",
+]

{langchain-1.0.0a13 → langchain-1.0.0a14}/langchain/tools/__init__.py

@@ -8,11 +8,7 @@ from langchain_core.tools import (
     tool,
 )
 
-from langchain.tools.tool_node import (
-    InjectedState,
-    InjectedStore,
-    ToolNode,
-)
+from langchain.tools.tool_node import InjectedState, InjectedStore, ToolInvocationError
 
 __all__ = [
     "BaseTool",
@@ -21,6 +17,6 @@ __all__ = [
     "InjectedToolArg",
     "InjectedToolCallId",
     "ToolException",
-    "ToolNode",
+    "ToolInvocationError",
     "tool",
 ]

{langchain-1.0.0a13 → langchain-1.0.0a14}/langchain/tools/tool_node.py

@@ -38,7 +38,7 @@ from __future__ import annotations
 import asyncio
 import inspect
 import json
-from collections.abc import Callable
+from collections.abc import Awaitable, Callable
 from copy import copy, deepcopy
 from dataclasses import dataclass, replace
 from types import UnionType
@@ -72,6 +72,7 @@ from langchain_core.tools import BaseTool, InjectedToolArg
 from langchain_core.tools import tool as create_tool
 from langchain_core.tools.base import (
     TOOL_MESSAGE_BLOCK_TYPES,
+    ToolException,
     get_all_basemodel_annotations,
 )
 from langgraph._internal._runnable import RunnableCallable
@@ -188,6 +189,12 @@ Examples:
         return result
 """
 
+AsyncToolCallWrapper = Callable[
+    [ToolCallRequest, Callable[[ToolCallRequest], Awaitable[ToolMessage | Command]]],
+    Awaitable[ToolMessage | Command],
+]
+"""Async wrapper for tool call execution with multi-call support."""
+
 
 class ToolCallWithContext(TypedDict):
     """ToolCall with additional context for graph state.
@@ -239,8 +246,11 @@ def msg_content_output(output: Any) -> str | list[dict]:
         return str(output)
 
 
-class ToolInvocationError(Exception):
-    """Exception raised when a tool invocation fails due to invalid arguments."""
+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!
+    """
 
     def __init__(
         self, tool_name: str, source: ValidationError, tool_kwargs: dict[str, Any]
@@ -382,7 +392,7 @@ def _infer_handled_types(handler: Callable[..., str]) -> tuple[type[Exception],
     return (Exception,)
 
 
-class ToolNode(RunnableCallable):
+class _ToolNode(RunnableCallable):
     """A node for executing tools in LangGraph workflows.
 
     Handles tool execution patterns including function calls, state injection,
@@ -500,6 +510,7 @@ class ToolNode(RunnableCallable):
         | tuple[type[Exception], ...] = _default_handle_tool_errors,
         messages_key: str = "messages",
         wrap_tool_call: ToolCallWrapper | None = None,
+        awrap_tool_call: AsyncToolCallWrapper | None = None,
     ) -> None:
         """Initialize ToolNode with tools and configuration.
 
@@ -509,9 +520,11 @@ class ToolNode(RunnableCallable):
             tags: Optional metadata tags.
             handle_tool_errors: Error handling configuration.
             messages_key: State key containing messages.
-            wrap_tool_call: Wrapper function to intercept tool execution. Receives
+            wrap_tool_call: Sync wrapper function to intercept tool execution. Receives
                 ToolCallRequest and execute callable, returns ToolMessage or Command.
                 Enables retries, caching, request modification, and control flow.
+            awrap_tool_call: Async wrapper function to intercept tool execution.
+                If not provided, falls back to wrap_tool_call for async execution.
         """
         super().__init__(self._func, self._afunc, name=name, tags=tags, trace=False)
         self._tools_by_name: dict[str, BaseTool] = {}
@@ -520,6 +533,7 @@ class ToolNode(RunnableCallable):
         self._handle_tool_errors = handle_tool_errors
         self._messages_key = messages_key
         self._wrap_tool_call = wrap_tool_call
+        self._awrap_tool_call = awrap_tool_call
         for tool in tools:
             if not isinstance(tool, BaseTool):
                 tool_ = create_tool(cast("type[BaseTool]", tool))
@@ -855,7 +869,7 @@ class ToolNode(RunnableCallable):
         input: list[AnyMessage] | dict[str, Any] | BaseModel,
         runtime: Any,
     ) -> ToolMessage | Command:
-        """Execute single tool call asynchronously with wrap_tool_call wrapper if configured.
+        """Execute single tool call asynchronously with awrap_tool_call wrapper if configured.
 
         Args:
             call: Tool call dict.
@@ -883,7 +897,7 @@ class ToolNode(RunnableCallable):
             runtime=runtime,
         )
 
-        if self._wrap_tool_call is None:
+        if self._awrap_tool_call is None and self._wrap_tool_call is None:
             # No wrapper - execute directly
             return await self._execute_tool_async(tool_request, input_type, config)
 
@@ -892,12 +906,17 @@ class ToolNode(RunnableCallable):
             """Execute tool with given request. Can be called multiple times."""
             return await self._execute_tool_async(req, input_type, config)
 
+        def _sync_execute(req: ToolCallRequest) -> ToolMessage | Command:
+            """Sync execute fallback for sync wrapper."""
+            return self._execute_tool_sync(req, input_type, config)
+
         # Call wrapper with request and execute callable
-        # Note: wrapper is sync, but execute callable is async
         try:
-            result = self._wrap_tool_call(tool_request, execute)  # type: ignore[arg-type]
-            # If result is a coroutine, await it (though wrapper should be sync)
-            return await result if hasattr(result, "__await__") else result
+            if self._awrap_tool_call is not None:
+                return await self._awrap_tool_call(tool_request, execute)
+            # None check was performed above already
+            self._wrap_tool_call = cast("ToolCallWrapper", self._wrap_tool_call)
+            return self._wrap_tool_call(tool_request, _sync_execute)
         except Exception as e:
             # Wrapper threw an exception
             if not self._handle_tool_errors: