langchain 0.3.22__py3-none-any.whl → 0.3.24__py3-none-any.whl

langchain/agents/agent.py

@@ -3,21 +3,17 @@
 from __future__ import annotations
 
 import asyncio
+import builtins
 import json
 import logging
 import time
 from abc import abstractmethod
+from collections.abc import AsyncIterator, Iterator, Sequence
 from pathlib import Path
 from typing import (
     Any,
-    AsyncIterator,
     Callable,
-    Dict,
-    Iterator,
-    List,
     Optional,
-    Sequence,
-    Tuple,
     Union,
     cast,
 )
@@ -62,17 +58,17 @@ class BaseSingleActionAgent(BaseModel):
     """Base Single Action Agent class."""
 
     @property
-    def return_values(self) -> List[str]:
+    def return_values(self) -> list[str]:
         """Return values of the agent."""
         return ["output"]
 
-    def get_allowed_tools(self) -> Optional[List[str]]:
+    def get_allowed_tools(self) -> Optional[list[str]]:
         return None
 
     @abstractmethod
     def plan(
         self,
-        intermediate_steps: List[Tuple[AgentAction, str]],
+        intermediate_steps: list[tuple[AgentAction, str]],
         callbacks: Callbacks = None,
         **kwargs: Any,
     ) -> Union[AgentAction, AgentFinish]:
@@ -91,7 +87,7 @@ class BaseSingleActionAgent(BaseModel):
     @abstractmethod
     async def aplan(
         self,
-        intermediate_steps: List[Tuple[AgentAction, str]],
+        intermediate_steps: list[tuple[AgentAction, str]],
         callbacks: Callbacks = None,
         **kwargs: Any,
     ) -> Union[AgentAction, AgentFinish]:
@@ -109,7 +105,7 @@ class BaseSingleActionAgent(BaseModel):
 
     @property
     @abstractmethod
-    def input_keys(self) -> List[str]:
+    def input_keys(self) -> list[str]:
         """Return the input keys.
 
         :meta private:
@@ -118,7 +114,7 @@ class BaseSingleActionAgent(BaseModel):
     def return_stopped_response(
         self,
         early_stopping_method: str,
-        intermediate_steps: List[Tuple[AgentAction, str]],
+        intermediate_steps: list[tuple[AgentAction, str]],
         **kwargs: Any,
     ) -> AgentFinish:
         """Return response when agent has been stopped due to max iterations.
@@ -171,7 +167,7 @@ class BaseSingleActionAgent(BaseModel):
         """Return Identifier of an agent type."""
         raise NotImplementedError
 
-    def dict(self, **kwargs: Any) -> Dict:
+    def dict(self, **kwargs: Any) -> builtins.dict:
         """Return dictionary representation of agent.
 
         Returns:
@@ -223,7 +219,7 @@ class BaseSingleActionAgent(BaseModel):
         else:
             raise ValueError(f"{save_path} must be json or yaml")
 
-    def tool_run_logging_kwargs(self) -> Dict:
+    def tool_run_logging_kwargs(self) -> builtins.dict:
         """Return logging kwargs for tool run."""
         return {}
 
@@ -232,11 +228,11 @@ class BaseMultiActionAgent(BaseModel):
     """Base Multi Action Agent class."""
 
     @property
-    def return_values(self) -> List[str]:
+    def return_values(self) -> list[str]:
         """Return values of the agent."""
         return ["output"]
 
-    def get_allowed_tools(self) -> Optional[List[str]]:
+    def get_allowed_tools(self) -> Optional[list[str]]:
         """Get allowed tools.
 
         Returns:
@@ -247,10 +243,10 @@ class BaseMultiActionAgent(BaseModel):
     @abstractmethod
     def plan(
         self,
-        intermediate_steps: List[Tuple[AgentAction, str]],
+        intermediate_steps: list[tuple[AgentAction, str]],
         callbacks: Callbacks = None,
         **kwargs: Any,
-    ) -> Union[List[AgentAction], AgentFinish]:
+    ) -> Union[list[AgentAction], AgentFinish]:
         """Given input, decided what to do.
 
         Args:
@@ -266,10 +262,10 @@ class BaseMultiActionAgent(BaseModel):
     @abstractmethod
     async def aplan(
         self,
-        intermediate_steps: List[Tuple[AgentAction, str]],
+        intermediate_steps: list[tuple[AgentAction, str]],
         callbacks: Callbacks = None,
         **kwargs: Any,
-    ) -> Union[List[AgentAction], AgentFinish]:
+    ) -> Union[list[AgentAction], AgentFinish]:
         """Async given input, decided what to do.
 
         Args:
@@ -284,7 +280,7 @@ class BaseMultiActionAgent(BaseModel):
 
     @property
     @abstractmethod
-    def input_keys(self) -> List[str]:
+    def input_keys(self) -> list[str]:
         """Return the input keys.
 
         :meta private:
@@ -293,7 +289,7 @@ class BaseMultiActionAgent(BaseModel):
     def return_stopped_response(
         self,
         early_stopping_method: str,
-        intermediate_steps: List[Tuple[AgentAction, str]],
+        intermediate_steps: list[tuple[AgentAction, str]],
         **kwargs: Any,
     ) -> AgentFinish:
         """Return response when agent has been stopped due to max iterations.
@@ -323,7 +319,7 @@ class BaseMultiActionAgent(BaseModel):
         """Return Identifier of an agent type."""
         raise NotImplementedError
 
-    def dict(self, **kwargs: Any) -> Dict:
+    def dict(self, **kwargs: Any) -> builtins.dict:
         """Return dictionary representation of agent."""
         _dict = super().model_dump()
         try:
@@ -371,7 +367,7 @@ class BaseMultiActionAgent(BaseModel):
         else:
             raise ValueError(f"{save_path} must be json or yaml")
 
-    def tool_run_logging_kwargs(self) -> Dict:
+    def tool_run_logging_kwargs(self) -> builtins.dict:
         """Return logging kwargs for tool run."""
 
         return {}
@@ -386,7 +382,7 @@ class AgentOutputParser(BaseOutputParser[Union[AgentAction, AgentFinish]]):
 
 
 class MultiActionAgentOutputParser(
-    BaseOutputParser[Union[List[AgentAction], AgentFinish]]
+    BaseOutputParser[Union[list[AgentAction], AgentFinish]]
 ):
     """Base class for parsing agent output into agent actions/finish.
 
@@ -394,7 +390,7 @@ class MultiActionAgentOutputParser(
     """
 
     @abstractmethod
-    def parse(self, text: str) -> Union[List[AgentAction], AgentFinish]:
+    def parse(self, text: str) -> Union[list[AgentAction], AgentFinish]:
         """Parse text into agent actions/finish.
 
         Args:
@@ -411,8 +407,8 @@ class RunnableAgent(BaseSingleActionAgent):
 
     runnable: Runnable[dict, Union[AgentAction, AgentFinish]]
     """Runnable to call to get agent action."""
-    input_keys_arg: List[str] = []
-    return_keys_arg: List[str] = []
+    input_keys_arg: list[str] = []
+    return_keys_arg: list[str] = []
     stream_runnable: bool = True
     """Whether to stream from the runnable or not.
 
@@ -427,18 +423,18 @@ class RunnableAgent(BaseSingleActionAgent):
     )
 
     @property
-    def return_values(self) -> List[str]:
+    def return_values(self) -> list[str]:
         """Return values of the agent."""
         return self.return_keys_arg
 
     @property
-    def input_keys(self) -> List[str]:
+    def input_keys(self) -> list[str]:
         """Return the input keys."""
         return self.input_keys_arg
 
     def plan(
         self,
-        intermediate_steps: List[Tuple[AgentAction, str]],
+        intermediate_steps: list[tuple[AgentAction, str]],
         callbacks: Callbacks = None,
         **kwargs: Any,
     ) -> Union[AgentAction, AgentFinish]:
@@ -474,7 +470,7 @@ class RunnableAgent(BaseSingleActionAgent):
 
     async def aplan(
         self,
-        intermediate_steps: List[Tuple[AgentAction, str]],
+        intermediate_steps: list[tuple[AgentAction, str]],
         callbacks: Callbacks = None,
         **kwargs: Any,
     ) -> Union[
@@ -518,10 +514,10 @@ class RunnableAgent(BaseSingleActionAgent):
 class RunnableMultiActionAgent(BaseMultiActionAgent):
     """Agent powered by Runnables."""
 
-    runnable: Runnable[dict, Union[List[AgentAction], AgentFinish]]
+    runnable: Runnable[dict, Union[list[AgentAction], AgentFinish]]
     """Runnable to call to get agent actions."""
-    input_keys_arg: List[str] = []
-    return_keys_arg: List[str] = []
+    input_keys_arg: list[str] = []
+    return_keys_arg: list[str] = []
     stream_runnable: bool = True
     """Whether to stream from the runnable or not.
 
@@ -536,12 +532,12 @@ class RunnableMultiActionAgent(BaseMultiActionAgent):
     )
 
     @property
-    def return_values(self) -> List[str]:
+    def return_values(self) -> list[str]:
         """Return values of the agent."""
         return self.return_keys_arg
 
     @property
-    def input_keys(self) -> List[str]:
+    def input_keys(self) -> list[str]:
         """Return the input keys.
 
         Returns:
@@ -551,11 +547,11 @@ class RunnableMultiActionAgent(BaseMultiActionAgent):
 
     def plan(
         self,
-        intermediate_steps: List[Tuple[AgentAction, str]],
+        intermediate_steps: list[tuple[AgentAction, str]],
         callbacks: Callbacks = None,
         **kwargs: Any,
     ) -> Union[
-        List[AgentAction],
+        list[AgentAction],
         AgentFinish,
     ]:
         """Based on past history and current inputs, decide what to do.
@@ -590,11 +586,11 @@ class RunnableMultiActionAgent(BaseMultiActionAgent):
 
     async def aplan(
         self,
-        intermediate_steps: List[Tuple[AgentAction, str]],
+        intermediate_steps: list[tuple[AgentAction, str]],
         callbacks: Callbacks = None,
         **kwargs: Any,
     ) -> Union[
-        List[AgentAction],
+        list[AgentAction],
         AgentFinish,
     ]:
         """Async based on past history and current inputs, decide what to do.
@@ -644,11 +640,11 @@ class LLMSingleActionAgent(BaseSingleActionAgent):
     """LLMChain to use for agent."""
     output_parser: AgentOutputParser
     """Output parser to use for agent."""
-    stop: List[str]
+    stop: list[str]
     """List of strings to stop on."""
 
     @property
-    def input_keys(self) -> List[str]:
+    def input_keys(self) -> list[str]:
         """Return the input keys.
 
         Returns:
@@ -656,7 +652,7 @@ class LLMSingleActionAgent(BaseSingleActionAgent):
         """
         return list(set(self.llm_chain.input_keys) - {"intermediate_steps"})
 
-    def dict(self, **kwargs: Any) -> Dict:
+    def dict(self, **kwargs: Any) -> builtins.dict:
         """Return dictionary representation of agent."""
         _dict = super().dict()
         del _dict["output_parser"]
@@ -664,7 +660,7 @@ class LLMSingleActionAgent(BaseSingleActionAgent):
 
     def plan(
         self,
-        intermediate_steps: List[Tuple[AgentAction, str]],
+        intermediate_steps: list[tuple[AgentAction, str]],
         callbacks: Callbacks = None,
         **kwargs: Any,
     ) -> Union[AgentAction, AgentFinish]:
@@ -689,7 +685,7 @@ class LLMSingleActionAgent(BaseSingleActionAgent):
 
     async def aplan(
         self,
-        intermediate_steps: List[Tuple[AgentAction, str]],
+        intermediate_steps: list[tuple[AgentAction, str]],
         callbacks: Callbacks = None,
         **kwargs: Any,
     ) -> Union[AgentAction, AgentFinish]:
@@ -712,7 +708,7 @@ class LLMSingleActionAgent(BaseSingleActionAgent):
         )
         return self.output_parser.parse(output)
 
-    def tool_run_logging_kwargs(self) -> Dict:
+    def tool_run_logging_kwargs(self) -> builtins.dict:
         """Return logging kwargs for tool run."""
         return {
             "llm_prefix": "",
@@ -737,21 +733,21 @@ class Agent(BaseSingleActionAgent):
     """LLMChain to use for agent."""
     output_parser: AgentOutputParser
     """Output parser to use for agent."""
-    allowed_tools: Optional[List[str]] = None
+    allowed_tools: Optional[list[str]] = None
     """Allowed tools for the agent. If None, all tools are allowed."""
 
-    def dict(self, **kwargs: Any) -> Dict:
+    def dict(self, **kwargs: Any) -> builtins.dict:
         """Return dictionary representation of agent."""
         _dict = super().dict()
         del _dict["output_parser"]
         return _dict
 
-    def get_allowed_tools(self) -> Optional[List[str]]:
+    def get_allowed_tools(self) -> Optional[list[str]]:
         """Get allowed tools."""
         return self.allowed_tools
 
     @property
-    def return_values(self) -> List[str]:
+    def return_values(self) -> list[str]:
         """Return values of the agent."""
         return ["output"]
 
@@ -767,15 +763,15 @@ class Agent(BaseSingleActionAgent):
         raise ValueError("fix_text not implemented for this agent.")
 
     @property
-    def _stop(self) -> List[str]:
+    def _stop(self) -> list[str]:
         return [
             f"\n{self.observation_prefix.rstrip()}",
             f"\n\t{self.observation_prefix.rstrip()}",
         ]
 
     def _construct_scratchpad(
-        self, intermediate_steps: List[Tuple[AgentAction, str]]
-    ) -> Union[str, List[BaseMessage]]:
+        self, intermediate_steps: list[tuple[AgentAction, str]]
+    ) -> Union[str, list[BaseMessage]]:
         """Construct the scratchpad that lets the agent continue its thought process."""
         thoughts = ""
         for action, observation in intermediate_steps:
@@ -785,7 +781,7 @@ class Agent(BaseSingleActionAgent):
 
     def plan(
         self,
-        intermediate_steps: List[Tuple[AgentAction, str]],
+        intermediate_steps: list[tuple[AgentAction, str]],
         callbacks: Callbacks = None,
         **kwargs: Any,
     ) -> Union[AgentAction, AgentFinish]:
@@ -806,7 +802,7 @@ class Agent(BaseSingleActionAgent):
 
     async def aplan(
         self,
-        intermediate_steps: List[Tuple[AgentAction, str]],
+        intermediate_steps: list[tuple[AgentAction, str]],
         callbacks: Callbacks = None,
         **kwargs: Any,
     ) -> Union[AgentAction, AgentFinish]:
@@ -827,8 +823,8 @@ class Agent(BaseSingleActionAgent):
         return agent_output
 
     def get_full_inputs(
-        self, intermediate_steps: List[Tuple[AgentAction, str]], **kwargs: Any
-    ) -> Dict[str, Any]:
+        self, intermediate_steps: list[tuple[AgentAction, str]], **kwargs: Any
+    ) -> builtins.dict[str, Any]:
         """Create the full inputs for the LLMChain from intermediate steps.
 
         Args:
@@ -845,7 +841,7 @@ class Agent(BaseSingleActionAgent):
         return full_inputs
 
     @property
-    def input_keys(self) -> List[str]:
+    def input_keys(self) -> list[str]:
         """Return the input keys.
 
         :meta private:
@@ -957,7 +953,7 @@ class Agent(BaseSingleActionAgent):
     def return_stopped_response(
         self,
         early_stopping_method: str,
-        intermediate_steps: List[Tuple[AgentAction, str]],
+        intermediate_steps: list[tuple[AgentAction, str]],
         **kwargs: Any,
     ) -> AgentFinish:
         """Return response when agent has been stopped due to max iterations.
@@ -1009,7 +1005,7 @@ class Agent(BaseSingleActionAgent):
                 f"got {early_stopping_method}"
             )
 
-    def tool_run_logging_kwargs(self) -> Dict:
+    def tool_run_logging_kwargs(self) -> builtins.dict:
         """Return logging kwargs for tool run."""
         return {
             "llm_prefix": self.llm_prefix,
@@ -1017,7 +1013,7 @@ class Agent(BaseSingleActionAgent):
         }
 
 
-class ExceptionTool(BaseTool):  # type: ignore[override]
+class ExceptionTool(BaseTool):
     """Tool that just returns the query."""
 
     name: str = "_Exception"
@@ -1040,7 +1036,7 @@ class ExceptionTool(BaseTool):  # type: ignore[override]
         return query
 
 
-NextStepOutput = List[Union[AgentFinish, AgentAction, AgentStep]]
+NextStepOutput = list[Union[AgentFinish, AgentAction, AgentStep]]
 RunnableAgentType = Union[RunnableAgent, RunnableMultiActionAgent]
 
 
@@ -1086,7 +1082,7 @@ class AgentExecutor(Chain):
       as an observation.
     """
     trim_intermediate_steps: Union[
-        int, Callable[[List[Tuple[AgentAction, str]]], List[Tuple[AgentAction, str]]]
+        int, Callable[[list[tuple[AgentAction, str]]], list[tuple[AgentAction, str]]]
     ] = -1
     """How to trim the intermediate steps before returning them.
     Defaults to -1, which means no trimming.
@@ -1133,7 +1129,7 @@ class AgentExecutor(Chain):
         """
         agent = self.agent
         tools = self.tools
-        allowed_tools = agent.get_allowed_tools()  # type: ignore
+        allowed_tools = agent.get_allowed_tools()  # type: ignore[union-attr]
         if allowed_tools is not None:
             if set(allowed_tools) != set([tool.name for tool in tools]):
                 raise ValueError(
@@ -1144,7 +1140,7 @@ class AgentExecutor(Chain):
 
     @model_validator(mode="before")
     @classmethod
-    def validate_runnable_agent(cls, values: Dict) -> Any:
+    def validate_runnable_agent(cls, values: dict) -> Any:
         """Convert runnable to agent if passed in.
 
         Args:
@@ -1160,7 +1156,7 @@ class AgentExecutor(Chain):
             except Exception as _:
                 multi_action = False
             else:
-                multi_action = output_type == Union[List[AgentAction], AgentFinish]
+                multi_action = output_type == Union[list[AgentAction], AgentFinish]
 
             stream_runnable = values.pop("stream_runnable", True)
             if multi_action:
@@ -1239,7 +1235,7 @@ class AgentExecutor(Chain):
         )
 
     @property
-    def input_keys(self) -> List[str]:
+    def input_keys(self) -> list[str]:
         """Return the input keys.
 
         :meta private:
@@ -1247,7 +1243,7 @@ class AgentExecutor(Chain):
         return self._action_agent.input_keys
 
     @property
-    def output_keys(self) -> List[str]:
+    def output_keys(self) -> list[str]:
         """Return the singular output key.
 
         :meta private:
@@ -1284,7 +1280,7 @@ class AgentExecutor(Chain):
         output: AgentFinish,
         intermediate_steps: list,
         run_manager: Optional[CallbackManagerForChainRun] = None,
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         if run_manager:
             run_manager.on_agent_finish(output, color="green", verbose=self.verbose)
         final_output = output.return_values
@@ -1297,7 +1293,7 @@ class AgentExecutor(Chain):
         output: AgentFinish,
         intermediate_steps: list,
         run_manager: Optional[AsyncCallbackManagerForChainRun] = None,
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         if run_manager:
             await run_manager.on_agent_finish(
                 output, color="green", verbose=self.verbose
@@ -1309,7 +1305,7 @@ class AgentExecutor(Chain):
 
     def _consume_next_step(
         self, values: NextStepOutput
-    ) -> Union[AgentFinish, List[Tuple[AgentAction, str]]]:
+    ) -> Union[AgentFinish, list[tuple[AgentAction, str]]]:
         if isinstance(values[-1], AgentFinish):
             assert len(values) == 1
             return values[-1]
@@ -1320,12 +1316,12 @@ class AgentExecutor(Chain):
 
     def _take_next_step(
         self,
-        name_to_tool_map: Dict[str, BaseTool],
-        color_mapping: Dict[str, str],
-        inputs: Dict[str, str],
-        intermediate_steps: List[Tuple[AgentAction, str]],
+        name_to_tool_map: dict[str, BaseTool],
+        color_mapping: dict[str, str],
+        inputs: dict[str, str],
+        intermediate_steps: list[tuple[AgentAction, str]],
         run_manager: Optional[CallbackManagerForChainRun] = None,
-    ) -> Union[AgentFinish, List[Tuple[AgentAction, str]]]:
+    ) -> Union[AgentFinish, list[tuple[AgentAction, str]]]:
         return self._consume_next_step(
             [
                 a
@@ -1341,10 +1337,10 @@ class AgentExecutor(Chain):
 
     def _iter_next_step(
         self,
-        name_to_tool_map: Dict[str, BaseTool],
-        color_mapping: Dict[str, str],
-        inputs: Dict[str, str],
-        intermediate_steps: List[Tuple[AgentAction, str]],
+        name_to_tool_map: dict[str, BaseTool],
+        color_mapping: dict[str, str],
+        inputs: dict[str, str],
+        intermediate_steps: list[tuple[AgentAction, str]],
         run_manager: Optional[CallbackManagerForChainRun] = None,
     ) -> Iterator[Union[AgentFinish, AgentAction, AgentStep]]:
         """Take a single step in the thought-action-observation loop.
@@ -1404,7 +1400,7 @@ class AgentExecutor(Chain):
             yield output
             return
 
-        actions: List[AgentAction]
+        actions: list[AgentAction]
         if isinstance(output, AgentAction):
             actions = [output]
         else:
@@ -1418,8 +1414,8 @@ class AgentExecutor(Chain):
 
     def _perform_agent_action(
         self,
-        name_to_tool_map: Dict[str, BaseTool],
-        color_mapping: Dict[str, str],
+        name_to_tool_map: dict[str, BaseTool],
+        color_mapping: dict[str, str],
         agent_action: AgentAction,
         run_manager: Optional[CallbackManagerForChainRun] = None,
     ) -> AgentStep:
@@ -1457,12 +1453,12 @@ class AgentExecutor(Chain):
 
     async def _atake_next_step(
         self,
-        name_to_tool_map: Dict[str, BaseTool],
-        color_mapping: Dict[str, str],
-        inputs: Dict[str, str],
-        intermediate_steps: List[Tuple[AgentAction, str]],
+        name_to_tool_map: dict[str, BaseTool],
+        color_mapping: dict[str, str],
+        inputs: dict[str, str],
+        intermediate_steps: list[tuple[AgentAction, str]],
         run_manager: Optional[AsyncCallbackManagerForChainRun] = None,
-    ) -> Union[AgentFinish, List[Tuple[AgentAction, str]]]:
+    ) -> Union[AgentFinish, list[tuple[AgentAction, str]]]:
         return self._consume_next_step(
             [
                 a
@@ -1478,10 +1474,10 @@ class AgentExecutor(Chain):
 
     async def _aiter_next_step(
         self,
-        name_to_tool_map: Dict[str, BaseTool],
-        color_mapping: Dict[str, str],
-        inputs: Dict[str, str],
-        intermediate_steps: List[Tuple[AgentAction, str]],
+        name_to_tool_map: dict[str, BaseTool],
+        color_mapping: dict[str, str],
+        inputs: dict[str, str],
+        intermediate_steps: list[tuple[AgentAction, str]],
         run_manager: Optional[AsyncCallbackManagerForChainRun] = None,
     ) -> AsyncIterator[Union[AgentFinish, AgentAction, AgentStep]]:
         """Take a single step in the thought-action-observation loop.
@@ -1539,7 +1535,7 @@ class AgentExecutor(Chain):
             yield output
             return
 
-        actions: List[AgentAction]
+        actions: list[AgentAction]
         if isinstance(output, AgentAction):
             actions = [output]
         else:
@@ -1563,8 +1559,8 @@ class AgentExecutor(Chain):
 
     async def _aperform_agent_action(
         self,
-        name_to_tool_map: Dict[str, BaseTool],
-        color_mapping: Dict[str, str],
+        name_to_tool_map: dict[str, BaseTool],
+        color_mapping: dict[str, str],
         agent_action: AgentAction,
         run_manager: Optional[AsyncCallbackManagerForChainRun] = None,
     ) -> AgentStep:
@@ -1604,9 +1600,9 @@ class AgentExecutor(Chain):
 
     def _call(
         self,
-        inputs: Dict[str, str],
+        inputs: dict[str, str],
         run_manager: Optional[CallbackManagerForChainRun] = None,
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         """Run text through and get agent response."""
         # Construct a mapping of tool name to tool for easy lookup
         name_to_tool_map = {tool.name: tool for tool in self.tools}
@@ -1614,7 +1610,7 @@ class AgentExecutor(Chain):
         color_mapping = get_color_mapping(
             [tool.name for tool in self.tools], excluded_colors=["green", "red"]
         )
-        intermediate_steps: List[Tuple[AgentAction, str]] = []
+        intermediate_steps: list[tuple[AgentAction, str]] = []
         # Let's start tracking the number of iterations and time elapsed
         iterations = 0
         time_elapsed = 0.0
@@ -1651,9 +1647,9 @@ class AgentExecutor(Chain):
 
     async def _acall(
         self,
-        inputs: Dict[str, str],
+        inputs: dict[str, str],
         run_manager: Optional[AsyncCallbackManagerForChainRun] = None,
-    ) -> Dict[str, str]:
+    ) -> dict[str, str]:
         """Async run text through and get agent response."""
         # Construct a mapping of tool name to tool for easy lookup
         name_to_tool_map = {tool.name: tool for tool in self.tools}
@@ -1661,7 +1657,7 @@ class AgentExecutor(Chain):
         color_mapping = get_color_mapping(
             [tool.name for tool in self.tools], excluded_colors=["green"]
         )
-        intermediate_steps: List[Tuple[AgentAction, str]] = []
+        intermediate_steps: list[tuple[AgentAction, str]] = []
         # Let's start tracking the number of iterations and time elapsed
         iterations = 0
         time_elapsed = 0.0
@@ -1712,7 +1708,7 @@ class AgentExecutor(Chain):
             )
 
     def _get_tool_return(
-        self, next_step_output: Tuple[AgentAction, str]
+        self, next_step_output: tuple[AgentAction, str]
     ) -> Optional[AgentFinish]:
         """Check if the tool is a returning tool."""
         agent_action, observation = next_step_output
@@ -1730,8 +1726,8 @@ class AgentExecutor(Chain):
         return None
 
     def _prepare_intermediate_steps(
-        self, intermediate_steps: List[Tuple[AgentAction, str]]
-    ) -> List[Tuple[AgentAction, str]]:
+        self, intermediate_steps: list[tuple[AgentAction, str]]
+    ) -> list[tuple[AgentAction, str]]:
         if (
             isinstance(self.trim_intermediate_steps, int)
             and self.trim_intermediate_steps > 0
@@ -1744,7 +1740,7 @@ class AgentExecutor(Chain):
 
     def stream(
         self,
-        input: Union[Dict[str, Any], Any],
+        input: Union[dict[str, Any], Any],
         config: Optional[RunnableConfig] = None,
         **kwargs: Any,
     ) -> Iterator[AddableDict]:
@@ -1770,12 +1766,11 @@ class AgentExecutor(Chain):
             yield_actions=True,
             **kwargs,
         )
-        for step in iterator:
-            yield step
+        yield from iterator
 
     async def astream(
         self,
-        input: Union[Dict[str, Any], Any],
+        input: Union[dict[str, Any], Any],
         config: Optional[RunnableConfig] = None,
         **kwargs: Any,
     ) -> AsyncIterator[AddableDict]: