xgae 0.1.10__py3-none-any.whl → 0.1.13__py3-none-any.whl

xgae/cli_app.py

@@ -3,7 +3,7 @@ import sys
 
 from xgae.engine.mcp_tool_box import XGAMcpToolBox
 from xgae.engine.task_engine import XGATaskEngine
-from xgae.utils.llm_client import LLMConfig
+
 from xgae.utils.misc import read_file
 
 from xgae.utils.setup_env import setup_langfuse, setup_env_logging
@@ -50,9 +50,7 @@ async def cli() -> None:
         engine = XGATaskEngine(tool_box=tool_box,
                                general_tools=general_tools,
                                custom_tools=custom_tools,
-                               llm_config=LLMConfig(stream=False),
-                               system_prompt=system_prompt,
-                               max_auto_run=8)
+                               system_prompt=system_prompt)
 
         # Two task run in same langfuse trace
         trace_id = langfuse.trace(name="xgae_cli").trace_id

xgae/engine/engine_base.py

@@ -6,14 +6,14 @@ class XGAError(Exception):
     """Custom exception for errors in the XGA system."""
     pass
 
-XGAMsgStatusType = Literal["error", "finish", "tool_error", "tool_started", "tool_completed", "tool_failed", "thread_run_start", "thread_run_end", "assistant_response_start", "assistant_response_end"]
-XGAResponseMsgType = Literal["user", "status",  "tool", "assistant", "assistant_complete"]
+XGAMsgStatusType = Literal["error", "finish", "tool_started", "tool_completed", "tool_error", "tool_failed"]
+XGAResponseMsgType = Literal["user", "status",  "tool", "assistant", "assistant_chunk"]
 
 class XGAResponseMessage(TypedDict, total=False):
     message_id: str
     type: XGAResponseMsgType
     is_llm_message: bool
-    content: Union[Dict[str, Any], List[Any], str]
+    content: Union[Dict[str, Any], str]
     metadata: Dict[str, Any]
 
 class XGATaskResult(TypedDict, total=False):

xgae/engine/mcp_tool_box.py

@@ -113,22 +113,27 @@ class XGAMcpToolBox(XGAToolBox):
         async with self._mcp_client.session(server_name) as session:
             tools = await load_mcp_tools(session)
             mcp_tool = next((t for t in tools if t.name == tool_name), None)
-
+            is_general_tool = False
             if mcp_tool:
                 tool_args = args or {}
                 if server_name == self.GENERAL_MCP_SERVER_NAME:
                     tool_args = dict({"task_id": task_id}, **tool_args)
+                    is_general_tool = True
 
                 try:
                     tool_result = await mcp_tool.arun(tool_args)
-                    result = XGAToolResult(success=True, output=str(tool_result))
+                    if is_general_tool:
+                        tool_result = json.loads(tool_result)
+                        result = XGAToolResult(success=tool_result['success'], output=str(tool_result['output']))
+                    else:
+                        result = XGAToolResult(success=True, output=str(tool_result))
                 except Exception as e:
                     error = f"Call mcp tool '{tool_name}' error: {str(e)}"
-                    logging.error(f"XGAMcpToolBox.call_tool: {error}")
+                    logging.error(f"McpToolBox call_tool: {error}")
                     result = XGAToolResult(success=False, output=error)
             else:
                 error = f"No MCP tool found with name: {tool_name}"
-                logging.info(f"XGAMcpToolBox.call_tool: error={error}")
+                logging.info(f"McpToolBox call_tool: error={error}")
                 result =  XGAToolResult(success=False, output=error)
 
             return result
@@ -179,11 +184,11 @@ class XGAMcpToolBox(XGAToolBox):
 
                     return server_config
             else:
-                logging.warning("MCP servers config file not found at: %s", mcp_config_path)
+                logging.warning(f"McpToolBox load_mcp_servers_config: MCP servers config file not found at: {mcp_config_path}")
                 return {"mcpServers": {}}
 
         except Exception as e:
-            logging.error("Failed to load MCP servers config: %s", str(e))
+            logging.error(f"McpToolBox load_mcp_servers_config: Failed to load MCP servers config: {e}")
             return {"mcpServers": {}}
 
 

xgae/engine/responser/non_stream_responser.py

@@ -1,6 +1,8 @@
 import logging
 
 from typing import List, Dict, Any, AsyncGenerator, override,Optional
+
+from xgae.utils import log_trace
 from xgae.utils.json_helpers import format_for_yield
 
 from xgae.engine.responser.responser_base import TaskResponseProcessor, TaskResponserContext, TaskRunContinuousState
@@ -11,22 +13,20 @@ class NonStreamTaskResponser(TaskResponseProcessor):
         super().__init__(response_context)
 
     @override
-    async def process_response(self,llm_response: Any,prompt_messages: List[Dict[str, Any]],
-                               continuous_state: Optional[TaskRunContinuousState] = None) -> AsyncGenerator[Dict[str, Any], None]:
+    async def process_response(self,
+                               llm_response: Any,prompt_messages: List[Dict[str, Any]],
+                               continuous_state: TaskRunContinuousState
+                               ) -> AsyncGenerator[Dict[str, Any], None]:
         llm_content = ""
         parsed_xml_data = []
         finish_reason = None
         llm_count = continuous_state.get("auto_continue_count")
 
         try:
-            # Extract finish_reason, content, tool calls
             if hasattr(llm_response, 'choices') and llm_response.choices:
                 if hasattr(llm_response.choices[0], 'finish_reason'):
                     finish_reason = llm_response.choices[0].finish_reason
-                    logging.info(f"NonStreamTask：LLM response finish_reason={finish_reason}")
-
-                    self.root_span.event(name=f"non_stream_processor_start[{self.task_no}]({llm_count})", level="DEFAULT",
-                                     status_message=(f"finish_reason={finish_reason}, tool_exec_strategy={self.tool_execution_strategy}"))
+                    logging.info(f"NonStreamResp: LLM response finish_reason={finish_reason}")
 
                 response_message = llm_response.choices[0].message if hasattr(llm_response.choices[0], 'message') else None
                 if response_message:
@@ -35,27 +35,23 @@ class NonStreamTaskResponser(TaskResponseProcessor):
                         
                         parsed_xml_data = self._parse_xml_tool_calls(llm_content)
                         if self.max_xml_tool_calls > 0 and len(parsed_xml_data) > self.max_xml_tool_calls:
-                            logging.warning(f"NonStreamTask：Truncate content, parsed_xml_data length {len(parsed_xml_data)} limit over max_xml_tool_calls={self.max_xml_tool_calls}")
-                            xml_chunks = self._extract_xml_chunks(llm_content)[:self.max_xml_tool_calls]
-                            if xml_chunks:
-                                last_chunk = xml_chunks[-1]
-                                last_chunk_pos = llm_content.find(last_chunk)
-                                if last_chunk_pos >= 0:
-                                    llm_content = llm_content[:last_chunk_pos + len(last_chunk)]
+                            logging.warning(f"NonStreamResp: Truncate content, parsed_xml_data length={len(parsed_xml_data)} limit over max_xml_tool_calls={self.max_xml_tool_calls}")
                             parsed_xml_data = parsed_xml_data[:self.max_xml_tool_calls]
                             finish_reason = "xml_tool_limit_reached"
-                            logging.info(f"NonStreamTask：LLM response finish_reason={finish_reason}")
-                else:
-                    logging.warning(f"NonStreamTask：LLM response_message is empty")
 
-            message_data = {"role": "assistant", "content": llm_content} # index=-1, full llm_content
-            assistant_msg = self.add_response_message(type="assistant_complete", content=message_data, is_llm_message=True)
+            self.root_span.event(name=f"non_stream_processor_start[{self.task_no}]({llm_count})", level="DEFAULT",
+                             status_message=f"finish_reason={finish_reason}, tool_exec_strategy={self.tool_execution_strategy}, "
+                                            f"parsed_xml_data_len={len(parsed_xml_data)}, llm_content_len={len(llm_content)}")
+
+            if  len(llm_content) == 0:
+                logging.warning(f"NonStreamResp: LLM response_message llm_content is empty")
+
+            message_data = {"role": "assistant", "content": llm_content}
+            assistant_msg = self.add_response_message(type="assistant", content=message_data, is_llm_message=True)
             yield assistant_msg
 
             tool_calls_to_execute = [item['tool_call'] for item in parsed_xml_data]
             if  len(tool_calls_to_execute) > 0:
-                logging.info(f"NonStreamTask：Executing {len(tool_calls_to_execute)} tools with strategy: {self.tool_execution_strategy}")
-
                 tool_results = await self._execute_tools(tool_calls_to_execute, self.tool_execution_strategy)
 
                 tool_index = 0
@@ -81,31 +77,26 @@ class NonStreamTaskResponser(TaskResponseProcessor):
                     if tool_completed_msg["metadata"].get("agent_should_terminate") == "true":
                         finish_reason = "completed"
                         break
+
                     tool_index += 1
             else:
                 finish_reason = "non_tool_call"
-                logging.warning(f"NonStreamTask: tool_calls is empty, No Tool need to call !")
+                logging.warning(f"NonStreamResp:  tool_calls is empty, No Tool need to call !")
 
             if finish_reason:
                 finish_content = {"status_type": "finish", "finish_reason": finish_reason}
-                finish_msg_obj = self.add_response_message(type="status", content=finish_content, is_llm_message=False)
-                if finish_msg_obj:
-                    yield format_for_yield(finish_msg_obj)
-
+                finish_msg = self.add_response_message(type="status", content=finish_content, is_llm_message=False)
+                yield format_for_yield(finish_msg)
         except Exception as e:
-            logging.error(f"NonStreamTask: Error processing non-streaming response: {llm_content}")
-            self.root_span.event(name="error_processing_non_streaming_response", level="ERROR",
-                             status_message=(f"Error processing non-streaming response: {str(e)}"))
-
-            content = {"role": "system", "status_type": "error", "message": str(e)}
-            err_msg = self.add_response_message(ype="status", content=content,is_llm_message=False)
-            if err_msg:
-                yield format_for_yield(err_msg)
-
-            # Re-raise the same exception (not a new one) to ensure proper error propagation
-            logging.critical(f"NonStreamTask: Re-raising error to stop further processing: {str(e)}")
-            self.root_span.event(name="re_raising_error_to_stop_further_processing", level="CRITICAL",
-                             status_message=(f"Re-raising error to stop further processing: {str(e)}"))
+            trace = log_trace(e, f"NonStreamResp: Process response llm_content:\n {llm_content}")
+            self.root_span.event(name="non_stream_process_response_error", level="ERROR",
+                                 status_message=f"Process non-streaming response error: {e}",
+                                 metadata={"content": llm_content, "trace": trace})
+
+            content = {"role": "system", "status_type": "error", "message": f"Process non-streaming response error: {e}"}
+            error_msg = self.add_response_message(type="status", content=content, is_llm_message=False)
+            yield format_for_yield(error_msg)
+
             raise  # Use bare 'raise' to preserve the original exception with its traceback
 
 

xgae/engine/responser/responser_base.py

@@ -6,6 +6,7 @@ from abc import ABC, abstractmethod
 from dataclasses import dataclass
 from typing import List, Dict, Any, Optional, Tuple, Union, Literal, Callable, TypedDict, AsyncGenerator
 
+from xgae.utils import log_trace
 from xgae.utils.json_helpers import safe_json_parse
 from xgae.utils.xml_tool_parser import XMLToolParser
 
@@ -26,9 +27,11 @@ class TaskResponserContext(TypedDict, total=False):
     task_no: int
     model_name: str
     max_xml_tool_calls: int             # LLM generate max_xml_tool limit, 0 is no limit
+    use_assistant_chunk_msg: bool
     tool_execution_strategy: ToolExecutionStrategy
     xml_adding_strategy: XmlAddingStrategy
     add_response_msg_func: Callable
+    create_response_msg_func: Callable
     tool_box: XGAToolBox
     task_langfuse: XGATaskLangFuse
 
@@ -37,6 +40,7 @@ class TaskRunContinuousState(TypedDict, total=False):
     accumulated_content: str
     auto_continue_count: int
     auto_continue: bool
+    assistant_msg_sequence: int
 
 
 @dataclass
@@ -66,6 +70,7 @@ class TaskResponseProcessor(ABC):
         task_langfuse = response_context.get("task_langfuse")
         self.root_span = task_langfuse.root_span
         self.add_response_message = response_context.get("add_response_msg_func")
+        self.create_response_message = response_context.get("create_response_msg_func")
 
         self.tool_box = response_context.get("tool_box")
         self.xml_parser = XMLToolParser()
@@ -75,7 +80,7 @@ class TaskResponseProcessor(ABC):
     async def process_response(self,
                                llm_response: AsyncGenerator,
                                prompt_messages: List[Dict[str, Any]],
-                               continuous_state: Optional[TaskRunContinuousState] = None
+                               continuous_state: TaskRunContinuousState
                                ) -> AsyncGenerator[Dict[str, Any], None]:
         pass
 
@@ -119,9 +124,8 @@ class TaskResponseProcessor(ABC):
 
                     # Find the earliest occurrence of any registered tool function name
                     # Check for available function names
-                    #available_functions = self.tool_registry.get_available_functions()
-                    available_functions = self.tool_box.get_task_tool_names(self.task_id)
-                    for func_name in available_functions:
+                    available_func_names = self.tool_box.get_task_tool_names(self.task_id)
+                    for func_name in available_func_names:
                         # Convert function name to potential tag name (underscore to dash)
                         tag_name = func_name.replace('_', '-')
                         start_pattern = f'<{tag_name}'
@@ -169,12 +173,11 @@ class TaskResponseProcessor(ABC):
                         break
 
                     pos = max(pos + 1, current_pos)
-
         except Exception as e:
-            logging.error(f"Error extracting XML chunks: {e}")
-            logging.error(f"Content was: {content}")
-            self.root_span.event(name="error_extracting_xml_chunks", level="ERROR",
-                              status_message=(f"Error extracting XML chunks: {e}"), metadata={"content": content})
+            trace = log_trace(e, f"TaskProcessor extract_xml_chunks: Error extracting XML chunks: {content}")
+            self.root_span.event(name="task_process_extract_xml_chunk_error", level="ERROR",
+                                 status_message=f"Error extracting XML chunks: {e}",
+                                 metadata={"content": content, "trace": trace})
 
         return chunks
 
@@ -193,13 +196,13 @@ class TaskResponseProcessor(ABC):
                 parsed_calls = self.xml_parser.parse_content(xml_chunk)
 
                 if not parsed_calls:
-                    logging.error(f"No tool calls found in XML chunk: {xml_chunk}")
+                    logging.error(f"TaskProcessor parse_xml_tool_call: No tool calls found in XML chunk: {xml_chunk}")
                     return None
 
                 # Take the first tool call (should only be one per chunk)
                 xml_tool_call = parsed_calls[0]
                 if not xml_tool_call.function_name:
-                    logging.error(f"xml_tool_call function name is empty: {xml_tool_call}")
+                    logging.error(f"TaskProcessor parse_xml_tool_call: xml_tool_call function name is empty: {xml_tool_call}")
                     return None
 
                 # Convert to the expected format
@@ -217,14 +220,12 @@ class TaskResponseProcessor(ABC):
                 return tool_call, parsing_details
 
             # If not the expected <function_calls><invoke> format, return None
-            logging.error(f"XML chunk does not contain expected <function_calls><invoke> format: {xml_chunk}")
-            return None
-
+            logging.error(f"TaskProcessor parse_xml_tool_call: XML chunk does not contain expected <function_calls><invoke> format: {xml_chunk}")
         except Exception as e:
-            logging.error(f"Error parsing XML chunk: {e}")
-            logging.error(f"XML chunk was: {xml_chunk}")
-            self.root_span.event(name="error_parsing_xml_chunk", level="ERROR",
-                              status_message=(f"Error parsing XML chunk: {e}"), metadata={"xml_chunk": xml_chunk})
+            trace = log_trace(e, f"TaskProcessor parse_xml_tool_call: Error parsing XML chunk: {xml_chunk}")
+            self.root_span.event(name="task_process_parsing_xml_chunk_error", level="ERROR",
+                                 status_message=f"Error parsing XML chunk: {e}",
+                                 metadata={"xml_chunk": xml_chunk, "trace": trace})
             return None
 
     def _parse_xml_tool_calls(self, content: str) -> List[Dict[str, Any]]:
@@ -234,7 +235,7 @@ class TaskResponseProcessor(ABC):
             List of dictionaries, each containing {'tool_call': ..., 'parsing_details': ...}
         """
         parsed_data = []
-
+        xml_chunk = None
         try:
             xml_chunks = self._extract_xml_chunks(content)
 
@@ -246,64 +247,65 @@ class TaskResponseProcessor(ABC):
                         "tool_call": tool_call,
                         "parsing_details": parsing_details
                     })
-
         except Exception as e:
-            logging.error(f"Error parsing XML tool calls: {e}", exc_info=True)
-            self.root_span.event(name="error_parsing_xml_tool_calls", level="ERROR",
-                             status_message=(f"Error parsing XML tool calls: {e}"), metadata={"content": content})
+            trace = log_trace(e, f"TaskProcessor parse_xml_tool_calls: Error parsing XML tool calls, xml_chunk: {xml_chunk}")
+            self.root_span.event(name="task_process_parse_xml_tool_calls_error", level="ERROR",
+                             status_message=f"Error parsing XML tool calls: {e}",
+                                 metadata={"content": xml_chunk, "trace": trace})
 
         return parsed_data
 
 
     async def _execute_tool(self, tool_call: Dict[str, Any]) -> XGAToolResult:
         """Execute a single tool call and return the result."""
-        exec_tool_span = self.root_span.span(name=f"execute_tool.{tool_call['function_name']}", input=tool_call["arguments"])
+        function_name = tool_call.get("function_name", "empty_function")
+        exec_tool_span = self.root_span.span(name=f"execute_tool.{function_name}", input=tool_call["arguments"])
         try:
-            function_name = tool_call["function_name"]
             arguments = tool_call["arguments"]
-
-            logging.info(f"Executing tool: {function_name} with arguments: {arguments}")
-
             if isinstance(arguments, str):
                 try:
                     arguments = safe_json_parse(arguments)
                 except json.JSONDecodeError:
-                    arguments = {"text": arguments} # @todo modify
+                    logging.warning(f"TaskProcessor execute_tool: Tool '{function_name}' arguments is not dict type, args={arguments}")
+                    arguments = {"text": arguments}  # useless
 
             result = None
             available_tool_names = self.tool_box.get_task_tool_names(self.task_id)
             if function_name in available_tool_names:
+                logging.info(f"TaskProcessor execute_tool: Tool '{function_name}' executing, args={arguments}")
                 result = await self.tool_box.call_tool(self.task_id, function_name, arguments)
             else:
-                logging.error(f"Tool function '{function_name}' not found in registry")
+                logging.error(f"TaskProcessor execute_tool: Tool function '{function_name}' not found in toolbox")
                 result = XGAToolResult(success=False, output=f"Tool function '{function_name}' not found")
-            logging.info(f"Tool execution complete: {function_name} -> {result}")
+
+            logging.info(f"TaskProcessor execute_tool: Tool '{function_name}' execution complete, result: {result}")
             exec_tool_span.update(status_message="tool_executed", output=result)
 
             return result
         except Exception as e:
-            logging.error(f"Error executing tool {tool_call['function_name']}: {str(e)}", exc_info=True)
+            trace = log_trace(e, f"TaskProcessor execute_tool: Executing tool {function_name}")
 
-            exec_tool_span.update(status_message="tool_execution_error", output=f"Error executing tool: {str(e)}", level="ERROR")
-            return XGAToolResult(success=False, output=f"Error executing tool: {str(e)}")
+            exec_tool_span.update(status_message="task_process_tool_exec_error", level="ERROR",
+                                  output=f"Error executing tool {function_name}, error: {str(e)}",
+                                  metadata={"trace": trace})
 
-    async def _execute_tools(
-            self,
-            tool_calls: List[Dict[str, Any]],
-            execution_strategy: ToolExecutionStrategy = "sequential"
-    ) -> List[Tuple[Dict[str, Any], XGAToolResult]]:
-        logging.info(f"Executing {len(tool_calls)} tools with strategy: {execution_strategy}")
+            return XGAToolResult(success=False, output=f"Executing tool {function_name}, error: {str(e)}")
+
+    async def _execute_tools(self, tool_calls: List[Dict[str, Any]],
+                             execution_strategy: ToolExecutionStrategy = "sequential"
+                             ) -> List[Tuple[Dict[str, Any], XGAToolResult]]:
+        logging.info(f"TaskProcessor execute_tools: Executing {len(tool_calls)} tools with strategy '{execution_strategy}'")
 
         if execution_strategy == "sequential":
             return await self._execute_tools_sequentially(tool_calls)
         elif execution_strategy == "parallel":
             return await self._execute_tools_in_parallel(tool_calls)
         else:
-            logging.warning(f"Unknown execution strategy: {execution_strategy}, falling back to sequential")
+            logging.warning(f"TaskProcessor execute_tools: Unknown execution strategy '{execution_strategy}', use sequential")
             return await self._execute_tools_sequentially(tool_calls)
 
-    async def _execute_tools_sequentially(self, tool_calls: List[Dict[str, Any]]) -> List[
-        Tuple[Dict[str, Any], XGAToolResult]]:
+    # @todo refact below code
+    async def _execute_tools_sequentially(self, tool_calls: List[Dict[str, Any]]) -> List[Tuple[Dict[str, Any], XGAToolResult]]:
         """Execute tool calls sequentially and return results.
 
         This method executes tool calls one after another, waiting for each tool to complete
@@ -317,9 +319,10 @@ class TaskResponseProcessor(ABC):
         """
         if not tool_calls:
             return []
+
         tool_names = [t.get('function_name', 'unknown') for t in tool_calls]
         logging.info(f"Executing {len(tool_calls)} tools sequentially: {tool_names}")
-        self.root_span.event(name="executing_tools_sequentially", level="DEFAULT",
+        self.root_span.event(name="task_process_executing_tools_sequentially", level="DEFAULT",
                               status_message=(f"Executing {len(tool_calls)} tools sequentially: {tool_names}"))
 
         results = []
@@ -341,7 +344,7 @@ class TaskResponseProcessor(ABC):
 
             except Exception as e:
                 logging.error(f"Error executing tool {tool_name}: {str(e)}")
-                self.root_span.event(name="error_executing_tool", level="ERROR",
+                self.root_span.event(name="task_process_error_executing_tool", level="ERROR",
                                       status_message=(f"Error executing tool {tool_name}: {str(e)}"))
                 error_result = XGAToolResult(success=False, output=f"Error executing tool: {str(e)}")
                 results.append((tool_call, error_result))
@@ -373,7 +376,7 @@ class TaskResponseProcessor(ABC):
             for i, (tool_call, result) in enumerate(zip(tool_calls, results)):
                 if isinstance(result, Exception):
                     logging.error(f"Error executing tool {tool_call.get('function_name', 'unknown')}: {str(result)}")
-                    self.root_span.event(name="error_executing_tool", level="ERROR", status_message=(
+                    self.root_span.event(name="task_process_error_executing_tool", level="ERROR", status_message=(
                         f"Error executing tool {tool_call.get('function_name', 'unknown')}: {str(result)}"))
                     # Create error result
                     error_result = XGAToolResult(success=False, output=f"Error executing tool: {str(result)}")
@@ -388,7 +391,7 @@ class TaskResponseProcessor(ABC):
 
         except Exception as e:
             logging.error(f"Error in parallel tool execution: {str(e)}", exc_info=True)
-            self.root_span.event(name="error_in_parallel_tool_execution", level="ERROR",
+            self.root_span.event(name="task_process_error_in_parallel_tool_execution", level="ERROR",
                              status_message=(f"Error in parallel tool execution: {str(e)}"))
             # Return error results for all tools if the gather itself fails
             return [(tool_call, XGAToolResult(success=False, output=f"Execution error: {str(e)}"))
@@ -459,7 +462,7 @@ class TaskResponseProcessor(ABC):
             return message_obj  # Return the modified message object
         except Exception as e:
             logging.error(f"Error adding tool result: {str(e)}", exc_info=True)
-            self.root_span.event(name="error_adding_tool_result", level="ERROR",
+            self.root_span.event(name="task_process_error_adding_tool_result", level="ERROR",
                              status_message=(f"Error adding tool result: {str(e)}"),
                              metadata={"tool_call": tool_call, "result": result, "strategy": strategy,
                                        "assistant_message_id": assistant_message_id,
@@ -479,7 +482,7 @@ class TaskResponseProcessor(ABC):
                 return message_obj  # Return the full message object
             except Exception as e2:
                 logging.error(f"Failed even with fallback message: {str(e2)}", exc_info=True)
-                self.root_span.event(name="failed_even_with_fallback_message", level="ERROR",
+                self.root_span.event(name="task_process_failed_even_with_fallback_message", level="ERROR",
                                  status_message=(f"Failed even with fallback message: {str(e2)}"),
                                  metadata={"tool_call": tool_call, "result": result, "strategy": strategy,
                                            "assistant_message_id": assistant_message_id,