haystack-experimental 0.14.3__py3-none-any.whl → 0.15.1__py3-none-any.whl

haystack_experimental/components/agents/agent.py

@@ -22,11 +22,11 @@ import haystack_experimental.core.pipeline.breakpoint as exp_breakpoint
 hs_breakpoint._create_agent_snapshot = exp_breakpoint._create_agent_snapshot
 hs_breakpoint._create_pipeline_snapshot_from_tool_invoker = exp_breakpoint._create_pipeline_snapshot_from_tool_invoker  # type: ignore[assignment]
 
-from haystack import logging
+from haystack import DeserializationError, logging
 from haystack.components.agents.agent import Agent as HaystackAgent
 from haystack.components.agents.agent import _ExecutionContext as Haystack_ExecutionContext
 from haystack.components.agents.agent import _schema_from_dict
-from haystack.components.agents.state import replace_values
+from haystack.components.agents.state import replace_values, State
 from haystack.components.generators.chat.types import ChatGenerator
 from haystack.core.errors import PipelineRuntimeError
 from haystack.core.pipeline import AsyncPipeline, Pipeline
@@ -36,19 +36,25 @@ from haystack.core.pipeline.breakpoint import (
 )
 from haystack.core.pipeline.utils import _deepcopy_with_exceptions
 from haystack.core.serialization import default_from_dict, import_class_by_name
-from haystack.dataclasses import ChatMessage
+from haystack.dataclasses import ChatMessage, ChatRole
 from haystack.dataclasses.breakpoints import AgentBreakpoint, ToolBreakpoint
-from haystack.dataclasses.streaming_chunk import StreamingCallbackT
+from haystack.dataclasses.streaming_chunk import StreamingCallbackT, select_streaming_callback
 from haystack.tools import ToolsType, deserialize_tools_or_toolset_inplace
 from haystack.utils.callable_serialization import deserialize_callable
 from haystack.utils.deserialization import deserialize_chatgenerator_inplace
 
+from haystack_experimental.chat_message_stores.types import ChatMessageStore
 from haystack_experimental.components.agents.human_in_the_loop import (
     ConfirmationStrategy,
     ToolExecutionDecision,
     HITLBreakpointException,
 )
-from haystack_experimental.components.agents.human_in_the_loop.strategies import _process_confirmation_strategies
+from haystack_experimental.components.agents.human_in_the_loop.strategies import (
+    _process_confirmation_strategies,
+    _process_confirmation_strategies_async,
+)
+from haystack_experimental.components.retrievers import ChatMessageRetriever
+from haystack_experimental.components.writers import ChatMessageWriter
 
 logger = logging.getLogger(__name__)
 
@@ -62,9 +68,15 @@ class _ExecutionContext(Haystack_ExecutionContext):
 
     :param tool_execution_decisions: Optional list of ToolExecutionDecision objects to use instead of prompting
         the user. This is useful when restarting from a snapshot where tool execution decisions were already made.
+    :param confirmation_strategy_context: Optional dictionary for passing request-scoped resources
+        to confirmation strategies. In web/server environments, this enables passing per-request
+        objects (e.g., WebSocket connections, async queues, or pub/sub clients) that strategies can use for
+        non-blocking user interaction. This is passed directly to strategies via the `confirmation_strategy_context`
+        parameter in their `run()` and `run_async()` methods.
     """
 
     tool_execution_decisions: Optional[list[ToolExecutionDecision]] = None
+    confirmation_strategy_context: Optional[dict[str, Any]] = None
 
 
 class Agent(HaystackAgent):
@@ -131,6 +143,7 @@ class Agent(HaystackAgent):
         raise_on_tool_invocation_failure: bool = False,
         confirmation_strategies: Optional[dict[str, ConfirmationStrategy]] = None,
         tool_invoker_kwargs: Optional[dict[str, Any]] = None,
+        chat_message_store: Optional[ChatMessageStore] = None,
     ) -> None:
         """
         Initialize the agent component.
@@ -164,6 +177,13 @@ class Agent(HaystackAgent):
             tool_invoker_kwargs=tool_invoker_kwargs,
         )
         self._confirmation_strategies = confirmation_strategies or {}
+        self._chat_message_store = chat_message_store
+        self._chat_message_retriever = (
+            ChatMessageRetriever(chat_message_store=chat_message_store) if chat_message_store else None
+        )
+        self._chat_message_writer = (
+            ChatMessageWriter(chat_message_store=chat_message_store) if chat_message_store else None
+        )
 
     def _initialize_fresh_execution(
         self,
@@ -174,6 +194,8 @@ class Agent(HaystackAgent):
         system_prompt: Optional[str] = None,
         generation_kwargs: Optional[dict[str, Any]] = None,
         tools: Optional[Union[ToolsType, list[str]]] = None,
+        confirmation_strategy_context: Optional[dict[str, Any]] = None,
+        chat_message_store_kwargs: Optional[dict[str, Any]] = None,
         **kwargs: dict[str, Any],
     ) -> _ExecutionContext:
         """
@@ -185,41 +207,56 @@ class Agent(HaystackAgent):
         :param system_prompt: System prompt for the agent. If provided, it overrides the default system prompt.
         :param tools: Optional list of Tool objects, a Toolset, or list of tool names to use for this run.
             When passing tool names, tools are selected from the Agent's originally configured tools.
+        :param confirmation_strategy_context: Optional dictionary for passing request-scoped resources
+            to confirmation strategies.
+        :param chat_message_store_kwargs: Optional dictionary of keyword arguments to pass to the ChatMessageStore.
         :param kwargs: Additional data to pass to the State used by the Agent.
         """
-        # The PR https://github.com/deepset-ai/haystack/pull/9616 added the generation_kwargs parameter to
-        # _initialize_fresh_execution. This change has been released in Haystack 2.20.0.
-        # To maintain compatibility with Haystack 2.19 we check the number of parameters and call accordingly.
-        if inspect.signature(super(Agent, self)._initialize_fresh_execution).parameters.get("generation_kwargs"):
-            exe_context = super(Agent, self)._initialize_fresh_execution(
-                messages=messages,
-                streaming_callback=streaming_callback,
-                requires_async=requires_async,
-                system_prompt=system_prompt,
-                generation_kwargs=generation_kwargs,
-                tools=tools,
-                **kwargs,
-            )
-        else:
-            exe_context = super(Agent, self)._initialize_fresh_execution(
-                messages=messages,
-                streaming_callback=streaming_callback,
-                requires_async=requires_async,
-                system_prompt=system_prompt,
-                tools=tools,
-                **kwargs,
-            )
-        # NOTE: 1st difference with parent method to add this to tool_invoker_inputs
+        system_prompt = system_prompt or self.system_prompt
+        if system_prompt is not None:
+            messages = [ChatMessage.from_system(system_prompt)] + messages
+
+        # NOTE: difference with parent method to add chat message retrieval
+        if self._chat_message_retriever:
+            retriever_kwargs = _select_kwargs(self._chat_message_retriever, chat_message_store_kwargs or {})
+            if "chat_history_id" in retriever_kwargs:
+                messages = self._chat_message_retriever.run(
+                    current_messages=messages,
+                    **retriever_kwargs,
+                )["messages"]
+
+        if all(m.is_from(ChatRole.SYSTEM) for m in messages):
+            logger.warning("All messages provided to the Agent component are system messages. This is not recommended.")
+
+        state = State(schema=self.state_schema, data=kwargs)
+        state.set("messages", messages)
+
+        streaming_callback = select_streaming_callback(  # type: ignore[call-overload]
+            init_callback=self.streaming_callback, runtime_callback=streaming_callback, requires_async=requires_async
+        )
+
+        selected_tools = self._select_tools(tools)
+        tool_invoker_inputs: dict[str, Any] = {"tools": selected_tools}
+        generator_inputs: dict[str, Any] = {"tools": selected_tools}
+        if streaming_callback is not None:
+            tool_invoker_inputs["streaming_callback"] = streaming_callback
+            generator_inputs["streaming_callback"] = streaming_callback
+        if generation_kwargs is not None:
+            generator_inputs["generation_kwargs"] = generation_kwargs
+
+        # NOTE: difference with parent method to add this to tool_invoker_inputs
         if self._tool_invoker:
-            exe_context.tool_invoker_inputs["enable_streaming_callback_passthrough"] = (
+            tool_invoker_inputs["enable_streaming_callback_passthrough"] = (
                 self._tool_invoker.enable_streaming_callback_passthrough
             )
-        # NOTE: 2nd difference is to use the extended _ExecutionContext
+
+        # NOTE: difference is to use the extended _ExecutionContext with confirmation_strategy_context
         return _ExecutionContext(
-            state=exe_context.state,
-            component_visits=exe_context.component_visits,
-            chat_generator_inputs=exe_context.chat_generator_inputs,
-            tool_invoker_inputs=exe_context.tool_invoker_inputs,
+            state=state,
+            component_visits=dict.fromkeys(["chat_generator", "tool_invoker"], 0),
+            chat_generator_inputs=generator_inputs,
+            tool_invoker_inputs=tool_invoker_inputs,
+            confirmation_strategy_context=confirmation_strategy_context,
         )
 
     def _initialize_from_snapshot(  # type: ignore[override]
@@ -230,6 +267,7 @@ class Agent(HaystackAgent):
         *,
         generation_kwargs: Optional[dict[str, Any]] = None,
         tools: Optional[Union[ToolsType, list[str]]] = None,
+        confirmation_strategy_context: Optional[dict[str, Any]] = None,
     ) -> _ExecutionContext:
         """
         Initialize execution context from an AgentSnapshot.
@@ -241,12 +279,14 @@ class Agent(HaystackAgent):
             override the parameters passed during component initialization.
         :param tools: Optional list of Tool objects, a Toolset, or list of tool names to use for this run.
             When passing tool names, tools are selected from the Agent's originally configured tools.
+        :param confirmation_strategy_context: Optional dictionary for passing request-scoped resources
+            to confirmation strategies.
         """
         # The PR https://github.com/deepset-ai/haystack/pull/9616 added the generation_kwargs parameter to
         # _initialize_from_snapshot. This change has been released in Haystack 2.20.0.
         # To maintain compatibility with Haystack 2.19 we check the number of parameters and call accordingly.
         if inspect.signature(super(Agent, self)._initialize_from_snapshot).parameters.get("generation_kwargs"):
-            exe_context = super(Agent, self)._initialize_from_snapshot(
+            exe_context = super(Agent, self)._initialize_from_snapshot(  # type: ignore[call-arg]
                 snapshot=snapshot,
                 streaming_callback=streaming_callback,
                 requires_async=requires_async,
@@ -262,7 +302,8 @@ class Agent(HaystackAgent):
             exe_context.tool_invoker_inputs["enable_streaming_callback_passthrough"] = (
                 self._tool_invoker.enable_streaming_callback_passthrough
             )
-        # NOTE: 2nd difference is to use the extended _ExecutionContext and add tool_execution_decisions
+        # NOTE: 2nd difference is to use the extended _ExecutionContext
+        # and add tool_execution_decisions + confirmation_strategy_context
         return _ExecutionContext(
             state=exe_context.state,
             component_visits=exe_context.component_visits,
@@ -271,18 +312,21 @@ class Agent(HaystackAgent):
             counter=exe_context.counter,
             skip_chat_generator=exe_context.skip_chat_generator,
             tool_execution_decisions=snapshot.tool_execution_decisions,
+            confirmation_strategy_context=confirmation_strategy_context,
         )
 
-    def run(  # noqa: PLR0915
+    def run(  # type: ignore[override]  # noqa: PLR0915
         self,
         messages: list[ChatMessage],
         streaming_callback: Optional[StreamingCallbackT] = None,
         *,
         generation_kwargs: Optional[dict[str, Any]] = None,
         break_point: Optional[AgentBreakpoint] = None,
-        snapshot: Optional[AgentSnapshot] = None,  # type: ignore[override]
+        snapshot: Optional[AgentSnapshot] = None,
         system_prompt: Optional[str] = None,
         tools: Optional[Union[ToolsType, list[str]]] = None,
+        confirmation_strategy_context: Optional[dict[str, Any]] = None,
+        chat_message_store_kwargs: Optional[dict[str, Any]] = None,
         **kwargs: Any,
     ) -> dict[str, Any]:
         """
@@ -300,6 +344,12 @@ class Agent(HaystackAgent):
         :param system_prompt: System prompt for the agent. If provided, it overrides the default system prompt.
         :param tools: Optional list of Tool objects, a Toolset, or list of tool names to use for this run.
             When passing tool names, tools are selected from the Agent's originally configured tools.
+        :param confirmation_strategy_context: Optional dictionary for passing request-scoped resources
+            to confirmation strategies. Useful in web/server environments to provide per-request
+            objects (e.g., WebSocket connections, async queues, Redis pub/sub clients) that strategies
+            can use for non-blocking user interaction.
+        :param chat_message_store_kwargs: Optional dictionary of keyword arguments to pass to the ChatMessageStore.
+            For example, it can include the `chat_history_id` and `last_k` parameters for retrieving chat history.
         :param kwargs: Additional data to pass to the State schema used by the Agent.
             The keys must match the schema defined in the Agent's `state_schema`.
         :returns:
@@ -334,6 +384,7 @@ class Agent(HaystackAgent):
                 requires_async=False,
                 generation_kwargs=generation_kwargs,
                 tools=tools,
+                confirmation_strategy_context=confirmation_strategy_context,
             )
         else:
             exe_context = self._initialize_fresh_execution(
@@ -343,6 +394,8 @@ class Agent(HaystackAgent):
                 system_prompt=system_prompt,
                 generation_kwargs=generation_kwargs,
                 tools=tools,
+                confirmation_strategy_context=confirmation_strategy_context,
+                chat_message_store_kwargs=chat_message_store_kwargs,
                 **kwargs,
             )
 
@@ -469,18 +522,27 @@ class Agent(HaystackAgent):
         result = {**exe_context.state.data}
         if msgs := result.get("messages"):
             result["last_message"] = msgs[-1]
+
+        # Write messages to ChatMessageStore if configured
+        if self._chat_message_writer:
+            writer_kwargs = _select_kwargs(self._chat_message_writer, chat_message_store_kwargs or {})
+            if "chat_history_id" in writer_kwargs:
+                self._chat_message_writer.run(messages=result["messages"], **writer_kwargs)
+
         return result
 
-    async def run_async(
+    async def run_async(  # type: ignore[override]
         self,
         messages: list[ChatMessage],
         streaming_callback: Optional[StreamingCallbackT] = None,
         *,
         generation_kwargs: Optional[dict[str, Any]] = None,
         break_point: Optional[AgentBreakpoint] = None,
-        snapshot: Optional[AgentSnapshot] = None,  # type: ignore[override]
+        snapshot: Optional[AgentSnapshot] = None,
         system_prompt: Optional[str] = None,
         tools: Optional[Union[ToolsType, list[str]]] = None,
+        confirmation_strategy_context: Optional[dict[str, Any]] = None,
+        chat_message_store_kwargs: Optional[dict[str, Any]] = None,
         **kwargs: Any,
     ) -> dict[str, Any]:
         """
@@ -501,6 +563,12 @@ class Agent(HaystackAgent):
             the relevant information to restart the Agent execution from where it left off.
         :param system_prompt: System prompt for the agent. If provided, it overrides the default system prompt.
         :param tools: Optional list of Tool objects, a Toolset, or list of tool names to use for this run.
+        :param confirmation_strategy_context: Optional dictionary for passing request-scoped resources
+            to confirmation strategies. Useful in web/server environments to provide per-request
+            objects (e.g., WebSocket connections, async queues, Redis pub/sub clients) that strategies
+            can use for non-blocking user interaction.
+        :param chat_message_store_kwargs: Optional dictionary of keyword arguments to pass to the ChatMessageStore.
+            For example, it can include the `chat_history_id` and `last_k` parameters for retrieving chat history.
         :param kwargs: Additional data to pass to the State schema used by the Agent.
             The keys must match the schema defined in the Agent's `state_schema`.
         :returns:
@@ -535,6 +603,7 @@ class Agent(HaystackAgent):
                 requires_async=True,
                 generation_kwargs=generation_kwargs,
                 tools=tools,
+                confirmation_strategy_context=confirmation_strategy_context,
             )
         else:
             exe_context = self._initialize_fresh_execution(
@@ -544,6 +613,8 @@ class Agent(HaystackAgent):
                 system_prompt=system_prompt,
                 generation_kwargs=generation_kwargs,
                 tools=tools,
+                confirmation_strategy_context=confirmation_strategy_context,
+                chat_message_store_kwargs=chat_message_store_kwargs,
                 **kwargs,
             )
 
@@ -581,8 +652,8 @@ class Agent(HaystackAgent):
 
                 # Apply confirmation strategies and update State and messages sent to ToolInvoker
                 try:
-                    # Run confirmation strategies to get updated tool call messages and modified chat history
-                    modified_tool_call_messages, new_chat_history = _process_confirmation_strategies(
+                    # Run confirmation strategies to get updated tool call messages and modified chat history (async)
+                    modified_tool_call_messages, new_chat_history = await _process_confirmation_strategies_async(
                         confirmation_strategies=self._confirmation_strategies,
                         messages_with_tool_calls=llm_messages,
                         execution_context=exe_context,
@@ -646,6 +717,13 @@ class Agent(HaystackAgent):
         result = {**exe_context.state.data}
         if msgs := result.get("messages"):
             result["last_message"] = msgs[-1]
+
+        # Write messages to ChatMessageStore if configured
+        if self._chat_message_writer:
+            writer_kwargs = _select_kwargs(self._chat_message_writer, chat_message_store_kwargs or {})
+            if "chat_history_id" in writer_kwargs:
+                self._chat_message_writer.run(messages=result["messages"], **writer_kwargs)
+
         return result
 
     def to_dict(self) -> dict[str, Any]:
@@ -660,6 +738,9 @@ class Agent(HaystackAgent):
             if self._confirmation_strategies
             else None
         )
+        data["init_parameters"]["chat_message_store"] = (
+            self._chat_message_store.to_dict() if self._chat_message_store is not None else None
+        )
         return data
 
     @classmethod
@@ -684,9 +765,31 @@ class Agent(HaystackAgent):
 
         if "confirmation_strategies" in init_params and init_params["confirmation_strategies"] is not None:
             for name, strategy_dict in init_params["confirmation_strategies"].items():
-                strategy_class = import_class_by_name(strategy_dict["type"])
+                try:
+                    strategy_class = import_class_by_name(strategy_dict["type"])
+                except ImportError as e:
+                    raise DeserializationError(f"Class '{strategy_dict['type']}' not correctly imported") from e
                 if not hasattr(strategy_class, "from_dict"):
-                    raise TypeError(f"{strategy_class} does not have from_dict method implemented.")
+                    raise DeserializationError(f"{strategy_class} does not have from_dict method implemented.")
                 init_params["confirmation_strategies"][name] = strategy_class.from_dict(strategy_dict)
 
+        if "chat_message_store" in init_params and init_params["chat_message_store"] is not None:
+            cms_data = init_params["chat_message_store"]
+            try:
+                cms_class = import_class_by_name(cms_data["type"])
+            except ImportError as e:
+                raise DeserializationError(f"Class '{cms_data['type']}' not correctly imported") from e
+            if not hasattr(cms_class, "from_dict"):
+                raise DeserializationError(f"{cms_class} does not have from_dict method implemented.")
+            init_params["chat_message_store"] = cms_class.from_dict(cms_data)
+
         return default_from_dict(cls, data)
+
+
+def _select_kwargs(obj: Any, source: dict) -> dict[str, Any]:
+    """
+    Select only those key-value pairs from source dict that are valid parameters for obj.run() method.
+    """
+    sig = inspect.signature(obj.run)
+    allowed = set(sig.parameters.keys())
+    return {k: v for k, v in source.items() if k in allowed}

haystack_experimental/components/agents/human_in_the_loop/strategies.py

@@ -47,7 +47,13 @@ class BlockingConfirmationStrategy:
         self.confirmation_ui = confirmation_ui
 
     def run(
-        self, tool_name: str, tool_description: str, tool_params: dict[str, Any], tool_call_id: Optional[str] = None
+        self,
+        *,
+        tool_name: str,
+        tool_description: str,
+        tool_params: dict[str, Any],
+        tool_call_id: Optional[str] = None,
+        confirmation_strategy_context: Optional[dict[str, Any]] = None,
     ) -> ToolExecutionDecision:
         """
         Run the human-in-the-loop strategy for a given tool and its parameters.
@@ -61,6 +67,10 @@ class BlockingConfirmationStrategy:
         :param tool_call_id:
             Optional unique identifier for the tool call. This can be used to track and correlate the decision with a
             specific tool invocation.
+        :param confirmation_strategy_context:
+            Optional dictionary for passing request-scoped resources. Useful in web/server environments
+            to provide per-request objects (e.g., WebSocket connections, async queues, Redis pub/sub clients)
+            that strategies can use for non-blocking user interaction.
 
         :returns:
             A ToolExecutionDecision indicating whether to execute the tool with the given parameters, or a
@@ -109,6 +119,40 @@ class BlockingConfirmationStrategy:
                 tool_name=tool_name, execute=True, tool_call_id=tool_call_id, final_tool_params=tool_params
             )
 
+    async def run_async(
+        self,
+        *,
+        tool_name: str,
+        tool_description: str,
+        tool_params: dict[str, Any],
+        tool_call_id: Optional[str] = None,
+        confirmation_strategy_context: Optional[dict[str, Any]] = None,
+    ) -> ToolExecutionDecision:
+        """
+        Async version of run. Calls the sync run() method by default.
+
+        :param tool_name:
+            The name of the tool to be executed.
+        :param tool_description:
+            The description of the tool.
+        :param tool_params:
+            The parameters to be passed to the tool.
+        :param tool_call_id:
+            Optional unique identifier for the tool call.
+        :param confirmation_strategy_context:
+            Optional dictionary for passing request-scoped resources.
+
+        :returns:
+            A ToolExecutionDecision indicating whether to execute the tool with the given parameters.
+        """
+        return self.run(
+            tool_name=tool_name,
+            tool_description=tool_description,
+            tool_params=tool_params,
+            tool_call_id=tool_call_id,
+            confirmation_strategy_context=confirmation_strategy_context,
+        )
+
     def to_dict(self) -> dict[str, Any]:
         """
         Serializes the BlockingConfirmationStrategy to a dictionary.
@@ -161,7 +205,13 @@ class BreakpointConfirmationStrategy:
         self.snapshot_file_path = snapshot_file_path
 
     def run(
-        self, tool_name: str, tool_description: str, tool_params: dict[str, Any], tool_call_id: Optional[str] = None
+        self,
+        *,
+        tool_name: str,
+        tool_description: str,
+        tool_params: dict[str, Any],
+        tool_call_id: Optional[str] = None,
+        confirmation_strategy_context: Optional[dict[str, Any]] = None,
     ) -> ToolExecutionDecision:
         """
         Run the breakpoint confirmation strategy for a given tool and its parameters.
@@ -175,6 +225,9 @@ class BreakpointConfirmationStrategy:
         :param tool_call_id:
             Optional unique identifier for the tool call. This can be used to track and correlate the decision with a
             specific tool invocation.
+        :param confirmation_strategy_context:
+            Optional dictionary for passing request-scoped resources. Not used by this strategy but included for
+            interface compatibility.
 
         :raises HITLBreakpointException:
             Always raises an `HITLBreakpointException` exception to signal that user confirmation is required.
@@ -189,6 +242,43 @@ class BreakpointConfirmationStrategy:
             snapshot_file_path=self.snapshot_file_path,
         )
 
+    async def run_async(
+        self,
+        *,
+        tool_name: str,
+        tool_description: str,
+        tool_params: dict[str, Any],
+        tool_call_id: Optional[str] = None,
+        confirmation_strategy_context: Optional[dict[str, Any]] = None,
+    ) -> ToolExecutionDecision:
+        """
+        Async version of run. Calls the sync run() method.
+
+        :param tool_name:
+            The name of the tool to be executed.
+        :param tool_description:
+            The description of the tool.
+        :param tool_params:
+            The parameters to be passed to the tool.
+        :param tool_call_id:
+            Optional unique identifier for the tool call.
+        :param confirmation_strategy_context:
+            Optional dictionary for passing request-scoped resources.
+
+        :raises HITLBreakpointException:
+            Always raises an `HITLBreakpointException` exception to signal that user confirmation is required.
+
+        :returns:
+            This method does not return; it always raises an exception.
+        """
+        return self.run(
+            tool_name=tool_name,
+            tool_description=tool_description,
+            tool_params=tool_params,
+            tool_call_id=tool_call_id,
+            confirmation_strategy_context=confirmation_strategy_context,
+        )
+
     def to_dict(self) -> dict[str, Any]:
         """
         Serializes the BreakpointConfirmationStrategy to a dictionary.
@@ -285,6 +375,46 @@ def _process_confirmation_strategies(
     return modified_tool_call_messages, new_chat_history
 
 
+async def _process_confirmation_strategies_async(
+    *,
+    confirmation_strategies: dict[str, ConfirmationStrategy],
+    messages_with_tool_calls: list[ChatMessage],
+    execution_context: "_ExecutionContext",
+) -> tuple[list[ChatMessage], list[ChatMessage]]:
+    """
+    Async version of _process_confirmation_strategies.
+
+    Run the confirmation strategies and return modified tool call messages and updated chat history.
+
+    :param confirmation_strategies: Mapping of tool names to their corresponding confirmation strategies
+    :param messages_with_tool_calls: Chat messages containing tool calls
+    :param execution_context: The current execution context of the agent
+    :returns:
+        Tuple of modified messages with confirmed tool calls and updated chat history
+    """
+    # Run confirmation strategies and get tool execution decisions (async version)
+    teds = await _run_confirmation_strategies_async(
+        confirmation_strategies=confirmation_strategies,
+        messages_with_tool_calls=messages_with_tool_calls,
+        execution_context=execution_context,
+    )
+
+    # Apply tool execution decisions to messages_with_tool_calls
+    rejection_messages, modified_tool_call_messages = _apply_tool_execution_decisions(
+        tool_call_messages=messages_with_tool_calls,
+        tool_execution_decisions=teds,
+    )
+
+    # Update the chat history with rejection messages and new tool call messages
+    new_chat_history = _update_chat_history(
+        chat_history=execution_context.state.get("messages"),
+        rejection_messages=rejection_messages,
+        tool_call_and_explanation_messages=modified_tool_call_messages,
+    )
+
+    return modified_tool_call_messages, new_chat_history
+
+
 def _run_confirmation_strategies(
     confirmation_strategies: dict[str, ConfirmationStrategy],
     messages_with_tool_calls: list[ChatMessage],
@@ -344,13 +474,100 @@ def _run_confirmation_strategies(
             # If not, run the confirmation strategy
             if not ted:
                 ted = confirmation_strategies[tool_name].run(
-                    tool_name=tool_name, tool_description=tool_to_invoke.description, tool_params=final_args
+                    tool_name=tool_name,
+                    tool_description=tool_to_invoke.description,
+                    tool_params=final_args,
+                    tool_call_id=tool_call.id,
+                    confirmation_strategy_context=execution_context.confirmation_strategy_context,
                 )
             teds.append(ted)
 
     return teds
 
 
+async def _run_confirmation_strategies_async(
+    confirmation_strategies: dict[str, ConfirmationStrategy],
+    messages_with_tool_calls: list[ChatMessage],
+    execution_context: "_ExecutionContext",
+) -> list[ToolExecutionDecision]:
+    """
+    Async version of _run_confirmation_strategies.
+
+    Run confirmation strategies for tool calls in the provided chat messages.
+
+    :param confirmation_strategies: Mapping of tool names to their corresponding confirmation strategies
+    :param messages_with_tool_calls: Messages containing tool calls to process
+    :param execution_context: The current execution context containing state and inputs
+    :returns:
+        A list of ToolExecutionDecision objects representing the decisions made for each tool call.
+    """
+    state = execution_context.state
+    tools_with_names = {tool.name: tool for tool in execution_context.tool_invoker_inputs["tools"]}
+    existing_teds = execution_context.tool_execution_decisions if execution_context.tool_execution_decisions else []
+    existing_teds_by_name = {ted.tool_name: ted for ted in existing_teds if ted.tool_name}
+    existing_teds_by_id = {ted.tool_call_id: ted for ted in existing_teds if ted.tool_call_id}
+
+    teds = []
+    for message in messages_with_tool_calls:
+        if not message.tool_calls:
+            continue
+
+        for tool_call in message.tool_calls:
+            tool_name = tool_call.tool_name
+            tool_to_invoke = tools_with_names[tool_name]
+
+            # Prepare final tool args
+            final_args = _prepare_tool_args(
+                tool=tool_to_invoke,
+                tool_call_arguments=tool_call.arguments,
+                state=state,
+                streaming_callback=execution_context.tool_invoker_inputs.get("streaming_callback"),
+                enable_streaming_passthrough=execution_context.tool_invoker_inputs.get(
+                    "enable_streaming_passthrough", False
+                ),
+            )
+
+            # Get tool execution decisions from confirmation strategies
+            # If no confirmation strategy is defined for this tool, proceed with execution
+            if tool_name not in confirmation_strategies:
+                teds.append(
+                    ToolExecutionDecision(
+                        tool_call_id=tool_call.id,
+                        tool_name=tool_name,
+                        execute=True,
+                        final_tool_params=final_args,
+                    )
+                )
+                continue
+
+            # Check if there's already a decision for this tool call in the execution context
+            ted = existing_teds_by_id.get(tool_call.id or "") or existing_teds_by_name.get(tool_name)
+
+            # If not, run the confirmation strategy (async version)
+            if not ted:
+                strategy = confirmation_strategies[tool_name]
+                # Use run_async if available, otherwise fall back to sync run
+                if hasattr(strategy, "run_async"):
+                    ted = await strategy.run_async(
+                        tool_name=tool_name,
+                        tool_description=tool_to_invoke.description,
+                        tool_params=final_args,
+                        tool_call_id=tool_call.id,
+                        confirmation_strategy_context=execution_context.confirmation_strategy_context,
+                    )
+                else:
+                    ted = strategy.run(
+                        tool_name=tool_name,
+                        tool_description=tool_to_invoke.description,
+                        tool_params=final_args,
+                        tool_call_id=tool_call.id,
+                        confirmation_strategy_context=execution_context.confirmation_strategy_context,
+                    )
+            teds.append(ted)
+
+    return teds
+
+
 def _apply_tool_execution_decisions(
     tool_call_messages: list[ChatMessage], tool_execution_decisions: list[ToolExecutionDecision]
 ) -> tuple[list[ChatMessage], list[ChatMessage]]: