The agent engineering platform.
Python agentsaiai-agentsanthropicchatgptdeepagentsenterpriseframeworkgeminigenerative-ailangchainlanggraphllmmultiagentopen-sourceopenaipydanticpythonragtypescript
feat(langchain_v1): tool emulator (#33357)
Eugene Yurtsev045e7ad4a1aa
diff --git a/libs/langchain_v1/langchain/agents/middleware/__init__.py b/libs/langchain_v1/langchain/agents/middleware/__init__.pyindex 27caab235f..de89191aa0 100644--- a/libs/langchain_v1/langchain/agents/middleware/__init__.py+++ b/libs/langchain_v1/langchain/agents/middleware/__init__.py@@ -15,6 +15,7 @@ from .planning import PlanningMiddlewarefrom .prompt_caching import AnthropicPromptCachingMiddlewarefrom .summarization import SummarizationMiddlewarefrom .tool_call_limit import ToolCallLimitMiddleware+from .tool_emulator import LLMToolEmulatorfrom .tool_selection import LLMToolSelectorMiddlewarefrom .types import (AgentMiddleware,@@ -38,6 +39,7 @@ __all__ = ["ContextEditingMiddleware","HumanInTheLoopMiddleware","InterruptOnConfig",+ "LLMToolEmulator","LLMToolSelectorMiddleware","ModelCallLimitMiddleware","ModelFallbackMiddleware",diff --git a/libs/langchain_v1/langchain/agents/middleware/tool_emulator.py b/libs/langchain_v1/langchain/agents/middleware/tool_emulator.pynew file mode 100644index 0000000000..3ba141badf--- /dev/null+++ b/libs/langchain_v1/langchain/agents/middleware/tool_emulator.py@@ -0,0 +1,200 @@+"""Tool emulator middleware for testing."""++from __future__ import annotations++from typing import TYPE_CHECKING++from langchain_core.language_models.chat_models import BaseChatModel+from langchain_core.messages import HumanMessage, ToolMessage++from langchain.agents.middleware.types import AgentMiddleware+from langchain.chat_models.base import init_chat_model++if TYPE_CHECKING:+ from collections.abc import Awaitable, Callable++ from langgraph.types import Command++ from langchain.tools import BaseTool+ from langchain.tools.tool_node import ToolCallRequest+++class LLMToolEmulator(AgentMiddleware):+ """Middleware that emulates specified tools using an LLM instead of executing them.++ This middleware allows selective emulation of tools for testing purposes.+ By default (when tools=None), all tools are emulated. You can specify which+ tools to emulate by passing a list of tool names or BaseTool instances.++ Examples:+ Emulate all tools (default behavior):+ ```python+ from langchain.agents.middleware import LLMToolEmulator++ middleware = LLMToolEmulator()++ agent = create_agent(+ model="openai:gpt-4o",+ tools=[get_weather, get_user_location, calculator],+ middleware=[middleware],+ )+ ```++ Emulate specific tools by name:+ ```python+ middleware = LLMToolEmulator(tools=["get_weather", "get_user_location"])+ ```++ Use a custom model for emulation:+ ```python+ middleware = LLMToolEmulator(+ tools=["get_weather"], model="anthropic:claude-3-5-sonnet-latest"+ )+ ```++ Emulate specific tools by passing tool instances:+ ```python+ middleware = LLMToolEmulator(tools=[get_weather, get_user_location])+ ```+ """++ def __init__(+ self,+ *,+ tools: list[str | BaseTool] | None = None,+ model: str | BaseChatModel | None = None,+ ) -> None:+ """Initialize the tool emulator.++ Args:+ tools: List of tool names (str) or BaseTool instances to emulate.+ If None (default), ALL tools will be emulated.+ If empty list, no tools will be emulated.+ model: Model to use for emulation.+ Defaults to "anthropic:claude-3-5-sonnet-latest".+ Can be a model identifier string or BaseChatModel instance.+ """+ super().__init__()++ # Extract tool names from tools+ # None means emulate all tools+ self.emulate_all = tools is None+ self.tools_to_emulate: set[str] = set()++ if not self.emulate_all and tools is not None:+ for tool in tools:+ if isinstance(tool, str):+ self.tools_to_emulate.add(tool)+ else:+ # Assume BaseTool with .name attribute+ self.tools_to_emulate.add(tool.name)++ # Initialize emulator model+ if model is None:+ self.model = init_chat_model("anthropic:claude-3-5-sonnet-latest", temperature=1)+ elif isinstance(model, BaseChatModel):+ self.model = model+ else:+ self.model = init_chat_model(model, temperature=1)++ def wrap_tool_call(+ self,+ request: ToolCallRequest,+ handler: Callable[[ToolCallRequest], ToolMessage | Command],+ ) -> ToolMessage | Command:+ """Emulate tool execution using LLM if tool should be emulated.++ Args:+ request: Tool call request to potentially emulate.+ handler: Callback to execute the tool (can be called multiple times).++ Returns:+ ToolMessage with emulated response if tool should be emulated,+ otherwise calls handler for normal execution.+ """+ tool_name = request.tool_call["name"]++ # Check if this tool should be emulated+ should_emulate = self.emulate_all or tool_name in self.tools_to_emulate++ if not should_emulate:+ # Let it execute normally by calling the handler+ return handler(request)++ # Extract tool information for emulation+ tool_args = request.tool_call["args"]+ tool_description = request.tool.description++ # Build prompt for emulator LLM+ prompt = (+ f"You are emulating a tool call for testing purposes.\n\n"+ f"Tool: {tool_name}\n"+ f"Description: {tool_description}\n"+ f"Arguments: {tool_args}\n\n"+ f"Generate a realistic response that this tool would return "+ f"given these arguments.\n"+ f"Return ONLY the tool's output, no explanation or preamble. "+ f"Introduce variation into your responses."+ )++ # Get emulated response from LLM+ response = self.model.invoke([HumanMessage(prompt)])++ # Short-circuit: return emulated result without executing real tool+ return ToolMessage(+ content=response.content,+ tool_call_id=request.tool_call["id"],+ name=tool_name,+ )++ async def awrap_tool_call(+ self,+ request: ToolCallRequest,+ handler: Callable[[ToolCallRequest], Awaitable[ToolMessage | Command]],+ ) -> ToolMessage | Command:+ """Async version of wrap_tool_call.++ Emulate tool execution using LLM if tool should be emulated.++ Args:+ request: Tool call request to potentially emulate.+ handler: Async callback to execute the tool (can be called multiple times).++ Returns:+ ToolMessage with emulated response if tool should be emulated,+ otherwise calls handler for normal execution.+ """+ tool_name = request.tool_call["name"]++ # Check if this tool should be emulated+ should_emulate = self.emulate_all or tool_name in self.tools_to_emulate++ if not should_emulate:+ # Let it execute normally by calling the handler+ return await handler(request)++ # Extract tool information for emulation+ tool_args = request.tool_call["args"]+ tool_description = request.tool.description++ # Build prompt for emulator LLM+ prompt = (+ f"You are emulating a tool call for testing purposes.\n\n"+ f"Tool: {tool_name}\n"+ f"Description: {tool_description}\n"+ f"Arguments: {tool_args}\n\n"+ f"Generate a realistic response that this tool would return "+ f"given these arguments.\n"+ f"Return ONLY the tool's output, no explanation or preamble. "+ f"Introduce variation into your responses."+ )++ # Get emulated response from LLM (using async invoke)+ response = await self.model.ainvoke([HumanMessage(prompt)])++ # Short-circuit: return emulated result without executing real tool+ return ToolMessage(+ content=response.content,+ tool_call_id=request.tool_call["id"],+ name=tool_name,+ )diff --git a/libs/langchain_v1/tests/unit_tests/agents/middleware/test_tool_emulator.py b/libs/langchain_v1/tests/unit_tests/agents/middleware/test_tool_emulator.pynew file mode 100644index 0000000000..ee8871f91e--- /dev/null+++ b/libs/langchain_v1/tests/unit_tests/agents/middleware/test_tool_emulator.py@@ -0,0 +1,625 @@+"""Unit tests for tool emulator middleware."""++import typing+from collections.abc import Callable+from itertools import cycle+from typing import Any, Literal, Union++from pydantic import BaseModel++from langchain.agents import create_agent+from langchain.agents.middleware import LLMToolEmulator+from langchain.messages import AIMessage+from langchain_core.language_models import LanguageModelInput+from langchain_core.language_models.chat_models import BaseChatModel+from langchain_core.language_models.fake_chat_models import GenericFakeChatModel+from langchain_core.messages import BaseMessage, HumanMessage+from langchain_core.runnables import Runnable+from langchain_core.tools import BaseTool, tool+++@tool+def get_weather(location: str) -> str:+ """Get current weather for a location."""+ raise NotImplementedError("This tool should be emulated")+++@tool+def search_web(query: str) -> str:+ """Search the web for information."""+ raise NotImplementedError("This tool should be emulated")+++@tool+def calculator(expression: str) -> str:+ """Perform mathematical calculations."""+ # This tool executes normally (not emulated)+ return f"Result: {eval(expression)}"+++class FakeModel(GenericFakeChatModel):+ """Fake model that supports bind_tools."""++ tool_style: Literal["openai", "anthropic"] = "openai"++ def bind_tools(+ self,+ tools: typing.Sequence[Union[dict[str, Any], type[BaseModel], Callable, BaseTool]],+ **kwargs: Any,+ ) -> Runnable[LanguageModelInput, BaseMessage]:+ if len(tools) == 0:+ msg = "Must provide at least one tool"+ raise ValueError(msg)++ tool_dicts = []+ for tool in tools:+ if isinstance(tool, dict):+ tool_dicts.append(tool)+ continue+ if not isinstance(tool, BaseTool):+ msg = "Only BaseTool and dict is supported by FakeModel.bind_tools"+ raise TypeError(msg)++ # NOTE: this is a simplified tool spec for testing purposes only+ if self.tool_style == "openai":+ tool_dicts.append(+ {+ "type": "function",+ "function": {+ "name": tool.name,+ },+ }+ )+ elif self.tool_style == "anthropic":+ tool_dicts.append(+ {+ "name": tool.name,+ }+ )++ return self.bind(tools=tool_dicts)+++class FakeEmulatorModel(BaseChatModel):+ """Fake model for emulating tool responses."""++ responses: list[str] = ["Emulated response"]+ response_index: int = 0++ def _generate(+ self,+ messages: list[BaseMessage],+ stop: list[str] | None = None,+ run_manager: Any = None,+ **kwargs: Any,+ ) -> Any:+ from langchain_core.outputs import ChatGeneration, ChatResult++ response = self.responses[self.response_index % len(self.responses)]+ self.response_index += 1+ return ChatResult(generations=[ChatGeneration(message=AIMessage(content=response))])++ async def _agenerate(+ self,+ messages: list[BaseMessage],+ stop: list[str] | None = None,+ run_manager: Any = None,+ **kwargs: Any,+ ) -> Any:+ from langchain_core.outputs import ChatGeneration, ChatResult++ response = self.responses[self.response_index % len(self.responses)]+ self.response_index += 1+ return ChatResult(generations=[ChatGeneration(message=AIMessage(content=response))])++ @property+ def _llm_type(self) -> str:+ return "fake_emulator"+++class TestLLMToolEmulatorBasic:+ """Test basic tool emulator functionality."""++ def test_emulates_specified_tool_by_name(self) -> None:+ """Test that tools specified by name are emulated."""+ # Model that will call the tool+ agent_model = FakeModel(+ messages=cycle(+ [+ AIMessage(+ content="",+ tool_calls=[+ {"name": "get_weather", "id": "1", "args": {"location": "Paris"}}+ ],+ ),+ AIMessage(content="The weather has been retrieved."),+ ]+ )+ )++ # Model that emulates tool responses+ emulator_model = FakeEmulatorModel(responses=["Emulated: 72°F, sunny in Paris"])++ emulator = LLMToolEmulator(tools=["get_weather"], model=emulator_model)++ agent = create_agent(+ model=agent_model,+ tools=[get_weather, calculator],+ middleware=[emulator],+ )++ result = agent.invoke({"messages": [HumanMessage("What's the weather in Paris?")]})++ # Should complete without raising NotImplementedError+ assert isinstance(result["messages"][-1], AIMessage)++ def test_emulates_specified_tool_by_instance(self) -> None:+ """Test that tools specified by BaseTool instance are emulated."""+ agent_model = FakeModel(+ messages=cycle(+ [+ AIMessage(+ content="",+ tool_calls=[{"name": "search_web", "id": "1", "args": {"query": "Python"}}],+ ),+ AIMessage(content="Search results retrieved."),+ ]+ )+ )++ emulator_model = FakeEmulatorModel(responses=["Emulated: Python is a programming language"])++ emulator = LLMToolEmulator(tools=[search_web], model=emulator_model)++ agent = create_agent(+ model=agent_model,+ tools=[search_web, calculator],+ middleware=[emulator],+ )++ result = agent.invoke({"messages": [HumanMessage("Search for Python")]})++ assert isinstance(result["messages"][-1], AIMessage)++ def test_non_emulated_tools_execute_normally(self) -> None:+ """Test that tools not in tools_to_emulate execute normally."""+ agent_model = FakeModel(+ messages=cycle(+ [+ AIMessage(+ content="",+ tool_calls=[+ {"name": "calculator", "id": "1", "args": {"expression": "2+2"}}+ ],+ ),+ AIMessage(content="The calculation is complete."),+ ]+ )+ )++ emulator_model = FakeEmulatorModel(responses=["Should not be used"])++ # Only emulate get_weather, not calculator+ emulator = LLMToolEmulator(tools=["get_weather"], model=emulator_model)++ agent = create_agent(+ model=agent_model,+ tools=[get_weather, calculator],+ middleware=[emulator],+ )++ result = agent.invoke({"messages": [HumanMessage("Calculate 2+2")]})++ # Calculator should execute normally and return Result: 4+ tool_messages = [+ msg for msg in result["messages"] if hasattr(msg, "name") and msg.name == "calculator"+ ]+ assert len(tool_messages) > 0+ assert "Result: 4" in tool_messages[0].content++ def test_empty_tools_to_emulate_does_nothing(self) -> None:+ """Test that empty tools_to_emulate list means no emulation occurs."""+ agent_model = FakeModel(+ messages=cycle(+ [+ AIMessage(+ content="",+ tool_calls=[+ {"name": "calculator", "id": "1", "args": {"expression": "5*5"}}+ ],+ ),+ AIMessage(content="Done."),+ ]+ )+ )++ emulator_model = FakeEmulatorModel(responses=["Should not be used"])++ emulator = LLMToolEmulator(tools=[], model=emulator_model)++ agent = create_agent(+ model=agent_model,+ tools=[calculator],+ middleware=[emulator],+ )++ result = agent.invoke({"messages": [HumanMessage("Calculate 5*5")]})++ # Calculator should execute normally+ tool_messages = [+ msg for msg in result["messages"] if hasattr(msg, "name") and msg.name == "calculator"+ ]+ assert len(tool_messages) > 0+ assert "Result: 25" in tool_messages[0].content++ def test_none_tools_emulates_all(self) -> None:+ """Test that None tools means ALL tools are emulated (emulate_all behavior)."""+ agent_model = FakeModel(+ messages=cycle(+ [+ AIMessage(+ content="",+ tool_calls=[+ {"name": "get_weather", "id": "1", "args": {"location": "NYC"}}+ ],+ ),+ AIMessage(content="Done."),+ ]+ )+ )++ emulator_model = FakeEmulatorModel(responses=["Emulated: 65°F in NYC"])++ # tools=None means emulate ALL tools+ emulator = LLMToolEmulator(tools=None, model=emulator_model)++ agent = create_agent(+ model=agent_model,+ tools=[get_weather],+ middleware=[emulator],+ )++ result = agent.invoke({"messages": [HumanMessage("What's the weather in NYC?")]})++ # Should complete without raising NotImplementedError+ # (get_weather would normally raise NotImplementedError)+ assert isinstance(result["messages"][-1], AIMessage)+++class TestLLMToolEmulatorMultipleTools:+ """Test emulating multiple tools."""++ def test_emulate_multiple_tools(self) -> None:+ """Test that multiple tools can be emulated."""+ agent_model = FakeModel(+ messages=cycle(+ [+ AIMessage(+ content="",+ tool_calls=[+ {"name": "get_weather", "id": "1", "args": {"location": "Paris"}},+ {"name": "search_web", "id": "2", "args": {"query": "Paris"}},+ ],+ ),+ AIMessage(content="Both tools executed."),+ ]+ )+ )++ emulator_model = FakeEmulatorModel(+ responses=["Emulated weather: 20°C", "Emulated search results for Paris"]+ )++ emulator = LLMToolEmulator(tools=["get_weather", "search_web"], model=emulator_model)++ agent = create_agent(+ model=agent_model,+ tools=[get_weather, search_web, calculator],+ middleware=[emulator],+ )++ result = agent.invoke({"messages": [HumanMessage("Get weather and search for Paris")]})++ # Both tools should be emulated without raising NotImplementedError+ assert isinstance(result["messages"][-1], AIMessage)++ def test_mixed_emulated_and_real_tools(self) -> None:+ """Test that some tools can be emulated while others execute normally."""+ agent_model = FakeModel(+ messages=cycle(+ [+ AIMessage(+ content="",+ tool_calls=[+ {"name": "get_weather", "id": "1", "args": {"location": "NYC"}},+ {"name": "calculator", "id": "2", "args": {"expression": "10*2"}},+ ],+ ),+ AIMessage(content="Both completed."),+ ]+ )+ )++ emulator_model = FakeEmulatorModel(responses=["Emulated: 65°F in NYC"])++ # Only emulate get_weather+ emulator = LLMToolEmulator(tools=["get_weather"], model=emulator_model)++ agent = create_agent(+ model=agent_model,+ tools=[get_weather, calculator],+ middleware=[emulator],+ )++ result = agent.invoke({"messages": [HumanMessage("Weather and calculate")]})++ tool_messages = [msg for msg in result["messages"] if hasattr(msg, "name")]+ assert len(tool_messages) >= 2++ # Calculator should have real result+ calc_messages = [msg for msg in tool_messages if msg.name == "calculator"]+ assert len(calc_messages) > 0+ assert "Result: 20" in calc_messages[0].content+++class TestLLMToolEmulatorModelConfiguration:+ """Test custom model configuration for emulation."""++ def test_custom_model_string(self) -> None:+ """Test passing a model string for emulation."""+ # Just test that initialization works - don't require anthropic package+ try:+ emulator = LLMToolEmulator(+ tools=["get_weather"], model="anthropic:claude-3-5-sonnet-latest"+ )+ assert emulator.model is not None+ assert "get_weather" in emulator.tools_to_emulate+ except ImportError:+ # If anthropic isn't installed, that's fine for this unit test+ pass++ def test_custom_model_instance(self) -> None:+ """Test passing a BaseChatModel instance for emulation."""+ agent_model = FakeModel(+ messages=cycle(+ [+ AIMessage(+ content="",+ tool_calls=[{"name": "search_web", "id": "1", "args": {"query": "test"}}],+ ),+ AIMessage(content="Done."),+ ]+ )+ )++ custom_emulator_model = FakeEmulatorModel(responses=["Custom emulated response"])++ emulator = LLMToolEmulator(tools=["search_web"], model=custom_emulator_model)++ agent = create_agent(+ model=agent_model,+ tools=[search_web],+ middleware=[emulator],+ )++ result = agent.invoke({"messages": [HumanMessage("Search for test")]})++ # Should use the custom model for emulation+ assert isinstance(result["messages"][-1], AIMessage)++ def test_default_model_used_when_none(self) -> None:+ """Test that default model is used when model=None."""+ # Just test that initialization doesn't fail - don't require anthropic package+ # The actual default model requires langchain_anthropic which may not be installed+ try:+ emulator = LLMToolEmulator(tools=["get_weather"], model=None)+ assert emulator.model is not None+ except ImportError:+ # If anthropic isn't installed, that's fine for this unit test+ # The integration tests will verify the full functionality+ pass+++class TestLLMToolEmulatorAsync:+ """Test async tool emulator functionality."""++ async def test_async_emulates_specified_tool_by_name(self) -> None:+ """Test that tools specified by name are emulated in async mode."""+ agent_model = FakeModel(+ messages=cycle(+ [+ AIMessage(+ content="",+ tool_calls=[+ {"name": "get_weather", "id": "1", "args": {"location": "Paris"}}+ ],+ ),+ AIMessage(content="The weather has been retrieved."),+ ]+ )+ )++ emulator_model = FakeEmulatorModel(responses=["Emulated: 72°F, sunny in Paris"])++ emulator = LLMToolEmulator(tools=["get_weather"], model=emulator_model)++ agent = create_agent(+ model=agent_model,+ tools=[get_weather, calculator],+ middleware=[emulator],+ )++ result = await agent.ainvoke({"messages": [HumanMessage("What's the weather in Paris?")]})++ # Should complete without raising NotImplementedError+ assert isinstance(result["messages"][-1], AIMessage)++ async def test_async_emulates_specified_tool_by_instance(self) -> None:+ """Test that tools specified by BaseTool instance are emulated in async mode."""+ agent_model = FakeModel(+ messages=cycle(+ [+ AIMessage(+ content="",+ tool_calls=[{"name": "search_web", "id": "1", "args": {"query": "Python"}}],+ ),+ AIMessage(content="Search results retrieved."),+ ]+ )+ )++ emulator_model = FakeEmulatorModel(responses=["Emulated: Python is a programming language"])++ emulator = LLMToolEmulator(tools=[search_web], model=emulator_model)++ agent = create_agent(+ model=agent_model,+ tools=[search_web, calculator],+ middleware=[emulator],+ )++ result = await agent.ainvoke({"messages": [HumanMessage("Search for Python")]})++ assert isinstance(result["messages"][-1], AIMessage)++ async def test_async_non_emulated_tools_execute_normally(self) -> None:+ """Test that tools not in tools_to_emulate execute normally in async mode."""+ agent_model = FakeModel(+ messages=cycle(+ [+ AIMessage(+ content="",+ tool_calls=[+ {"name": "calculator", "id": "1", "args": {"expression": "2+2"}}+ ],+ ),+ AIMessage(content="The calculation is complete."),+ ]+ )+ )++ emulator_model = FakeEmulatorModel(responses=["Should not be used"])++ # Only emulate get_weather, not calculator+ emulator = LLMToolEmulator(tools=["get_weather"], model=emulator_model)++ agent = create_agent(+ model=agent_model,+ tools=[get_weather, calculator],+ middleware=[emulator],+ )++ result = await agent.ainvoke({"messages": [HumanMessage("Calculate 2+2")]})++ # Calculator should execute normally and return Result: 4+ tool_messages = [+ msg for msg in result["messages"] if hasattr(msg, "name") and msg.name == "calculator"+ ]+ assert len(tool_messages) > 0+ assert "Result: 4" in tool_messages[0].content++ async def test_async_none_tools_emulates_all(self) -> None:+ """Test that None tools means ALL tools are emulated in async mode."""+ agent_model = FakeModel(+ messages=cycle(+ [+ AIMessage(+ content="",+ tool_calls=[+ {"name": "get_weather", "id": "1", "args": {"location": "NYC"}}+ ],+ ),+ AIMessage(content="Done."),+ ]+ )+ )++ emulator_model = FakeEmulatorModel(responses=["Emulated: 65°F in NYC"])++ # tools=None means emulate ALL tools+ emulator = LLMToolEmulator(tools=None, model=emulator_model)++ agent = create_agent(+ model=agent_model,+ tools=[get_weather],+ middleware=[emulator],+ )++ result = await agent.ainvoke({"messages": [HumanMessage("What's the weather in NYC?")]})++ # Should complete without raising NotImplementedError+ assert isinstance(result["messages"][-1], AIMessage)++ async def test_async_emulate_multiple_tools(self) -> None:+ """Test that multiple tools can be emulated in async mode."""+ agent_model = FakeModel(+ messages=cycle(+ [+ AIMessage(+ content="",+ tool_calls=[+ {"name": "get_weather", "id": "1", "args": {"location": "Paris"}},+ {"name": "search_web", "id": "2", "args": {"query": "Paris"}},+ ],+ ),+ AIMessage(content="Both tools executed."),+ ]+ )+ )++ emulator_model = FakeEmulatorModel(+ responses=["Emulated weather: 20°C", "Emulated search results for Paris"]+ )++ emulator = LLMToolEmulator(tools=["get_weather", "search_web"], model=emulator_model)++ agent = create_agent(+ model=agent_model,+ tools=[get_weather, search_web, calculator],+ middleware=[emulator],+ )++ result = await agent.ainvoke(+ {"messages": [HumanMessage("Get weather and search for Paris")]}+ )++ # Both tools should be emulated without raising NotImplementedError+ assert isinstance(result["messages"][-1], AIMessage)++ async def test_async_mixed_emulated_and_real_tools(self) -> None:+ """Test that some tools can be emulated while others execute normally in async mode."""+ agent_model = FakeModel(+ messages=cycle(+ [+ AIMessage(+ content="",+ tool_calls=[+ {"name": "get_weather", "id": "1", "args": {"location": "NYC"}},+ {"name": "calculator", "id": "2", "args": {"expression": "10*2"}},+ ],+ ),+ AIMessage(content="Both completed."),+ ]+ )+ )++ emulator_model = FakeEmulatorModel(responses=["Emulated: 65°F in NYC"])++ # Only emulate get_weather+ emulator = LLMToolEmulator(tools=["get_weather"], model=emulator_model)++ agent = create_agent(+ model=agent_model,+ tools=[get_weather, calculator],+ middleware=[emulator],+ )++ result = await agent.ainvoke({"messages": [HumanMessage("Weather and calculate")]})++ tool_messages = [msg for msg in result["messages"] if hasattr(msg, "name")]+ assert len(tool_messages) >= 2++ # Calculator should have real result+ calc_messages = [msg for msg in tool_messages if msg.name == "calculator"]+ assert len(calc_messages) > 0+ assert "Result: 20" in calc_messages[0].content