xgae 0.1.12__py3-none-any.whl → 0.1.14__py3-none-any.whl

xgae/engine/mcp_tool_box.py

@@ -113,15 +113,20 @@ 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"McpToolBox call_tool: {error}")
@@ -195,7 +200,7 @@ if __name__ == "__main__":
     setup_logging()
 
     async def main():
-        ## Before Run Exec: uv run custom_fault_tools
+        ## Before Run Exec: uv run example-fault-tools
         mcp_tool_box = XGAMcpToolBox(custom_mcp_server_file="mcpservers/custom_servers.json")
         #mcp_tool_box = XGAMcpToolBox()
 

xgae/engine/responser/non_stream_responser.py

@@ -2,7 +2,7 @@ import logging
 
 from typing import List, Dict, Any, AsyncGenerator, override,Optional
 
-from xgae.utils import handle_error
+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
@@ -61,8 +61,7 @@ class NonStreamTaskResponser(TaskResponseProcessor):
                     parsing_details = parsed_xml_item['parsing_details']
                     assistant_msg_id = assistant_msg['message_id'] if assistant_msg else None
 
-                    tool_context = self._create_tool_context(tool_call, tool_index, assistant_msg_id, parsing_details)
-                    tool_context.result = tool_result
+                    tool_context = self._create_tool_context(tool_call, tool_index, assistant_msg_id, parsing_details, tool_result)
 
                     tool_start_msg = self._add_tool_start_message(tool_context)
                     yield format_for_yield(tool_start_msg)
@@ -88,11 +87,10 @@ class NonStreamTaskResponser(TaskResponseProcessor):
                 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"NonStreamResp: Process response llm_content: {llm_content}")
-            handle_error(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})
+                                 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)

xgae/engine/responser/responser_base.py

@@ -6,7 +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 handle_error
+from xgae.utils import log_trace
 from xgae.utils.json_helpers import safe_json_parse
 from xgae.utils.xml_tool_parser import XMLToolParser
 
@@ -29,6 +29,7 @@ class TaskResponserContext(TypedDict, total=False):
     max_xml_tool_calls: int             # LLM generate max_xml_tool limit, 0 is no limit
     use_assistant_chunk_msg: bool
     tool_execution_strategy: ToolExecutionStrategy
+    tool_execute_on_stream: bool
     xml_adding_strategy: XmlAddingStrategy
     add_response_msg_func: Callable
     create_response_msg_func: Callable
@@ -48,8 +49,8 @@ class ToolExecutionContext:
     """Context for a tool execution including call details, result, and display info."""
     tool_call: Dict[str, Any]
     tool_index: int
-    result: Optional[XGAToolResult] = None
     function_name: Optional[str] = None
+    result: Optional[XGAToolResult] = None
     xml_tag_name: Optional[str] = None
     error: Optional[Exception] = None
     assistant_message_id: Optional[str] = None
@@ -66,6 +67,7 @@ class TaskResponseProcessor(ABC):
         self.tool_execution_strategy = self.response_context.get("tool_execution_strategy", "parallel")
         self.xml_adding_strategy = self.response_context.get("xml_adding_strategy", "user_message")
         self.max_xml_tool_calls = self.response_context.get("max_xml_tool_calls", 0)
+        self.tool_execute_on_stream = response_context.get("tool_execute_on_stream", False)
 
         task_langfuse = response_context.get("task_langfuse")
         self.root_span = task_langfuse.root_span
@@ -174,10 +176,10 @@ class TaskResponseProcessor(ABC):
 
                     pos = max(pos + 1, current_pos)
         except Exception as e:
-            logging.error(f"TaskProcessor extract_xml_chunks: Error extracting XML chunks: {content}")
-            handle_error(e)
+            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})
+                                 status_message=f"Error extracting XML chunks: {e}",
+                                 metadata={"content": content, "trace": trace})
 
         return chunks
 
@@ -197,13 +199,13 @@ class TaskResponseProcessor(ABC):
 
                 if not parsed_calls:
                     logging.error(f"TaskProcessor parse_xml_tool_call: No tool calls found in XML chunk: {xml_chunk}")
-                    return
+                    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"TaskProcessor parse_xml_tool_call: xml_tool_call function name is empty: {xml_tool_call}")
-                    return
+                    return None
 
                 # Convert to the expected format
                 tool_call = {
@@ -222,10 +224,11 @@ class TaskResponseProcessor(ABC):
             # If not the expected <function_calls><invoke> format, 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"TaskProcessor parse_xml_tool_call: Error parsing XML chunk: {xml_chunk}")
-            handle_error(e)
+            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})
+                                 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]]:
         """Parse XML tool calls from content string.
@@ -247,10 +250,10 @@ class TaskResponseProcessor(ABC):
                         "parsing_details": parsing_details
                     })
         except Exception as e:
-            logging.warning(f"TaskProcessor parse_xml_tool_calls: Error parsing XML tool calls, xml_chunk: {xml_chunk}")
-            handle_error(e)
+            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})
+                             status_message=f"Error parsing XML tool calls: {e}",
+                                 metadata={"content": xml_chunk, "trace": trace})
 
         return parsed_data
 
@@ -261,313 +264,243 @@ class TaskResponseProcessor(ABC):
         exec_tool_span = self.root_span.span(name=f"execute_tool.{function_name}", input=tool_call["arguments"])
         try:
             arguments = tool_call["arguments"]
-
-            logging.info(f"TaskProcessor execute_tool: 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"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"TaskProcessor execute_tool: 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"TaskProcessor execute_tool: Error executing tool {function_name}")
+            trace = log_trace(e, f"TaskProcessor execute_tool: Executing tool {function_name}")
 
             exec_tool_span.update(status_message="task_process_tool_exec_error", level="ERROR",
-                                  output=f"Error executing tool {function_name}, error: {str(e)}")
+                                  output=f"Error executing tool {function_name}, error: {str(e)}",
+                                  metadata={"trace": trace})
+
             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"Executing {len(tool_calls)} tools with strategy: {execution_strategy}")
 
+    async def _execute_tools(self, tool_calls: List[Dict[str, Any]],
+                             execution_strategy: ToolExecutionStrategy = "sequential"
+                             ) -> List[Tuple[Dict[str, Any], XGAToolResult]]:
         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]]:
+
+    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
         before starting the next one. This is useful when tools have dependencies on each other.
 
-        Args:
-            tool_calls: List of tool calls to execute
-
         Returns:
             List of tuples containing the original tool call and its result
         """
         if not tool_calls:
+            logging.warning("TaskProcessor execute_tools_sequentially: tool_calls is empty")
             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="task_process_executing_tools_sequentially", level="DEFAULT",
-                              status_message=(f"Executing {len(tool_calls)} tools sequentially: {tool_names}"))
+        tool_num = len(tool_calls)
+        if tool_num > 1:
+            logging.info(f"TaskProcessor execute_tools_sequentially: Executing {tool_num} tools sequentially: {tool_names}")
+            self.root_span.event(name="task_process_execute_tools_sequentially", level="DEFAULT",
+                                  status_message=f"Executing {len(tool_calls)} tools sequentially: {tool_names}")
 
         results = []
         for index, tool_call in enumerate(tool_calls):
             tool_name = tool_call.get('function_name', 'unknown')
-            logging.debug(f"Executing tool {index + 1}/{len(tool_calls)}: {tool_name}")
-
-            try:
-                result = await self._execute_tool(tool_call)
-                results.append((tool_call, result))
-                logging.debug(f"Completed tool {tool_name} with success={result.success}")
-
-                # Check if this is a terminating tool (ask or complete)
-                if tool_name in ['ask', 'complete']:
-                    logging.info(f"Terminating tool '{tool_name}' executed. Stopping further tool execution.")
-                    # self.root_span.event(name="terminating_tool_executed",
-                    #                       level="DEFAULT", status_message=(f"Terminating tool '{tool_name}' executed. Stopping further tool execution."))
-                    break  # Stop executing remaining tools
-
-            except Exception as e:
-                logging.error(f"Error executing tool {tool_name}: {str(e)}")
-                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))
-
-        logging.info(f"Sequential execution completed for {len(results)} tools (out of {len(tool_calls)} total)")
-        # self.root_span.event(name="sequential_execution_completed", level="DEFAULT",
-        #                       status_message=(f"Sequential execution completed for {len(results)} tools (out of {len(tool_calls)} total)"))
+            logging.info(f"TaskProcessor execute_tools_sequentially: Executing tool '{tool_name}', sequence={index + 1}/{tool_num}")
+            result = await self._execute_tool(tool_call)
+            results.append((tool_call, result))
+
+            # Check if this is a terminating tool (ask or complete)
+            if tool_name in ['ask', 'complete']:
+                if len(results) < tool_num:
+                    logging.info(f"TaskProcessor execute_tools_sequentially: Terminating tool '{tool_name}' executed, Stopping further tool execution.")
+                    self.root_span.event(name="task_process_terminate_tool_executed", level="DEFAULT",
+                                         status_message=f"Terminating tool '{tool_name}' executed, Stopping further tool execution.")
+                break
+
+        logging.info(f"TaskProcessor execute_tools_sequentially: Execution completed for {len(results)} tools, total {tool_num} tools)")
         return results
 
 
     async def _execute_tools_in_parallel(self, tool_calls: List[Dict[str, Any]]) -> List[Tuple[Dict[str, Any], XGAToolResult]]:
+        """Execute tool calls in parallel and return results.
+
+        This method executes all tool calls simultaneously using asyncio.gather, which
+        can significantly improve performance when executing multiple independent tools.
+
+        Returns:
+            List of tuples containing the original tool call and its result
+        """
         if not tool_calls:
+            logging.warning("TaskProcessor execute_tools_in_parallel: tool_calls is empty")
             return []
 
-        try:
-            tool_names = [t.get('function_name', 'unknown') for t in tool_calls]
-            logging.info(f"Executing {len(tool_calls)} tools in parallel: {tool_names}")
-            # self.root_span.event(name="executing_tools_in_parallel", level="DEFAULT",
-            #                  status_message=(f"Executing {len(tool_calls)} tools in parallel: {tool_names}"))
-
-            # Create tasks for all tool calls
-            tasks = [self._execute_tool(tool_call) for tool_call in tool_calls]
-
-            # Execute all tasks concurrently with error handling
-            results = await asyncio.gather(*tasks, return_exceptions=True)
-
-            # Process results and handle any exceptions
-            processed_results = []
-            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="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)}")
-                    processed_results.append((tool_call, error_result))
-                else:
-                    processed_results.append((tool_call, result))
-
-            logging.info(f"Parallel execution completed for {len(tool_calls)} tools")
-            # self.root_span.event(name="parallel_execution_completed", level="DEFAULT",
-            #                  status_message=(f"Parallel execution completed for {len(tool_calls)} tools"))
-            return processed_results
+        tool_names = [t.get('function_name', 'unknown') for t in tool_calls]
+        tool_num = len(tool_calls)
+        if tool_num > 1:
+            logging.info(f"TaskProcessor execute_tools_in_parallel: Executing {tool_num} tools sequentially: {tool_names}")
+            self.root_span.event(name="task_process_execute_tools_parallel", level="DEFAULT",
+                                  status_message=f"Executing {len(tool_calls)} tools parallelly: {tool_names}")
 
-        except Exception as e:
-            logging.error(f"Error in parallel tool execution: {str(e)}", exc_info=True)
-            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)}"))
-                    for tool_call in tool_calls]
-
-    def _add_tool_messsage(
-            self,
-            tool_call: Dict[str, Any],
-            result: XGAToolResult,
-            strategy: XmlAddingStrategy = "assistant_message",
-            assistant_message_id: Optional[str] = None,
-            parsing_details: Optional[Dict[str, Any]] = None
-    ) -> Optional[Dict[str, Any]]:  # Return the full message object
-        try:
-            message_obj = None  # Initialize message_obj
-
-            # Create metadata with assistant_message_id if provided
-            metadata = {}
-            if assistant_message_id:
-                metadata["assistant_message_id"] = assistant_message_id
-                logging.info(f"Linking tool result to assistant message: {assistant_message_id}")
-
-            # --- Add parsing details to metadata if available ---
-            if parsing_details:
-                metadata["parsing_details"] = parsing_details
-                logging.info("Adding parsing_details to tool result metadata")
-
-            # For XML and other non-native tools, use the new structured format
-            # Determine message role based on strategy
-            result_role = "user" if strategy == "user_message" else "assistant"
-
-            # Create two versions of the structured result
-            # 1. Rich version for the frontend
-            structured_result_for_frontend = self._create_structured_tool_result(tool_call, result, parsing_details,
-                                                                                 for_llm=False)
-            # 2. Concise version for the LLM
-            structured_result_for_llm = self._create_structured_tool_result(tool_call, result, parsing_details,
-                                                                            for_llm=True)
-
-            # Add the message with the appropriate role to the conversation history
-            # This allows the LLM to see the tool result in subsequent interactions
-            result_message_for_llm = {
-                "role": result_role,
-                "content": json.dumps(structured_result_for_llm)
-            }
+        # Execute all tasks concurrently with error handling
+        tasks = [self._execute_tool(tool_call) for tool_call in tool_calls]
+        results = await asyncio.gather(*tasks, return_exceptions=True)
 
-            # Add rich content to metadata for frontend use
-            if metadata is None:
-                metadata = {}
-            metadata['frontend_content'] = structured_result_for_frontend
-
-            message_obj =  self.add_response_message(
-                type="tool",
-                content=result_message_for_llm,  # Save the LLM-friendly version
-                is_llm_message=True,
-                metadata=metadata
-            )
-
-            # If the message was saved, modify it in-memory for the frontend before returning
-            if message_obj:
-                # The frontend expects the rich content in the 'content' field.
-                # The DB has the rich content in metadata.frontend_content.
-                # Let's reconstruct the message for yielding.
-                message_for_yield = message_obj.copy()
-                message_for_yield['content'] = structured_result_for_frontend
-                return message_for_yield
-
-            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="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,
-                                       "parsing_details": parsing_details})
-            # Fallback to a simple message
-            try:
-                fallback_message = {
-                    "role": "user",
-                    "content": str(result)
-                }
-                message_obj = self.add_response_message(
-                    type="tool",
-                    content=fallback_message,
-                    is_llm_message=True,
-                    metadata={"assistant_message_id": assistant_message_id} if assistant_message_id else {}
-                )
-                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="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,
-                                           "parsing_details": parsing_details})
-                return None  # Return None on error
-
-    def _create_structured_tool_result(self, tool_call: Dict[str, Any], result: XGAToolResult,
-                                       parsing_details: Optional[Dict[str, Any]] = None, for_llm: bool = False):
+        processed_results = []
+        for i, (tool_call, result) in enumerate(zip(tool_calls, results)):
+            processed_results.append((tool_call, result))
+
+        logging.info(f"TaskProcessor execute_tools_in_parallel: Execution completed for {len(results)} tools, total {tool_num} tools)")
+        return processed_results
+
+
+    def _add_tool_messsage(self,
+                           tool_call: Dict[str, Any],
+                           result: XGAToolResult,
+                           strategy: XmlAddingStrategy = "assistant_message",
+                           assistant_message_id: Optional[str] = None,
+                           parsing_details: Optional[Dict[str, Any]] = None
+                           ) -> Optional[Dict[str, Any]]:  # Return the full message object
+        tool_message = None
+
+        metadata = {}
+        if assistant_message_id:
+            metadata["assistant_message_id"] = assistant_message_id
+
+        if parsing_details:
+            metadata["parsing_details"] = parsing_details
+
+        role = "user" if strategy == "user_message" else "assistant"
+
+        # Create two versions of the structured result
+        # Rich version for the frontend
+        result_for_frontend = self._create_structured_tool_result(tool_call, result, parsing_details, for_llm=False)
+        # Concise version for the LLM
+        result_for_llm = self._create_structured_tool_result(tool_call, result, parsing_details, for_llm=True)
+
+        # Add the message with the appropriate role to the conversation history
+        # This allows the LLM to see the tool result in subsequent interactions
+        content = {
+            "role": role,
+            "content": json.dumps(result_for_llm)
+        }
+
+        metadata['frontend_content'] = result_for_frontend
+
+        tool_message =  self.add_response_message(
+            type="tool",
+            content=content,
+            is_llm_message=True,
+            metadata=metadata
+        )
+
+        # Let's reconstruct the message for yielding.
+        yield_message = tool_message.copy()
+        yield_message['content'] = result_for_frontend
+
+        return yield_message
+
+
+    def _create_structured_tool_result(self,
+                                       tool_call: Dict[str, Any],
+                                       result: XGAToolResult,
+                                       parsing_details: Optional[Dict[str, Any]] = None,
+                                       for_llm: bool = False) -> Dict[str, Any]:
         function_name = tool_call.get("function_name", "unknown")
         xml_tag_name = tool_call.get("xml_tag_name")
         arguments = tool_call.get("arguments", {})
         tool_call_id = tool_call.get("id")
 
         # Process the output - if it's a JSON string, parse it back to an object
-        output = result.output if hasattr(result, 'output') else str(result)
-        if isinstance(output, str):
-            try:
-                # Try to parse as JSON to provide structured data to frontend
-                parsed_output = safe_json_parse(output)
-                # If parsing succeeded and we got a dict/list, use the parsed version
-                if isinstance(parsed_output, (dict, list)):
-                    output = parsed_output
-                # Otherwise keep the original string
-            except Exception:
-                # If parsing fails, keep the original string
-                pass
+        output = result.output
+        parsed_output = safe_json_parse(output)
+        if isinstance(parsed_output, (dict, list)):
+            output = parsed_output
 
         output_to_use = output
         # If this is for the LLM and it's an edit_file tool, create a concise output
         if for_llm and function_name == 'edit_file' and isinstance(output, dict):
             # The frontend needs original_content and updated_content to render diffs.
             # The concise version for the LLM was causing issues.
-            # We will now pass the full output, and rely on the ContextManager to truncate if needed.
+            # @todo We will now pass the full output, and rely on the ContextManager to truncate if needed.
             output_to_use = output
 
-        # Create the structured result
-        structured_result_v1 = {
+        structured_result = {
             "tool_execution": {
                 "function_name": function_name,
                 "xml_tag_name": xml_tag_name,
                 "tool_call_id": tool_call_id,
                 "arguments": arguments,
                 "result": {
-                    "success": result.success if hasattr(result, 'success') else True,
-                    "output": output_to_use,  # This will be either rich or concise based on `for_llm`
-                    "error": getattr(result, 'error', None) if hasattr(result, 'error') else None
+                    "success": result.success,
+                    "output": output_to_use,
+                    "error": None if result.success else result.output
                 },
             }
         }
 
-        return structured_result_v1
+        return structured_result
+
 
-    def _create_tool_context(self, tool_call: Dict[str, Any], tool_index: int,
+    def _create_tool_context(self,
+                             tool_call: Dict[str, Any],
+                             tool_index: int,
                              assistant_message_id: Optional[str] = None,
-                             parsing_details: Optional[Dict[str, Any]] = None) -> ToolExecutionContext:
+                             parsing_details: Optional[Dict[str, Any]] = None,
+                             result: Optional[XGAToolResult] = None,
+                             ) -> ToolExecutionContext:
         """Create a tool execution context with display name and parsing details populated."""
-        context = ToolExecutionContext(
+        return ToolExecutionContext(
+            function_name=tool_call.get("function_name"),
             tool_call=tool_call,
             tool_index=tool_index,
             assistant_message_id=assistant_message_id,
-            parsing_details=parsing_details
+            parsing_details=parsing_details,
+            xml_tag_name=tool_call.get("xml_tag_name"),
+            result=result,
         )
 
-        # Set function_name and xml_tag_name fields
-        context.xml_tag_name = tool_call["xml_tag_name"]
-        context.function_name = tool_call["function_name"]
-
-        return context
 
     def _add_tool_start_message(self, context: ToolExecutionContext) -> Optional[Dict[str, Any]]:
         """Formats, saves, and returns a tool started status message."""
         tool_name = context.xml_tag_name or context.function_name
         content = {
-            "role": "assistant", "status_type": "tool_started",
-            "function_name": context.function_name, "xml_tag_name": context.xml_tag_name,
-            "message": f"Starting execution of {tool_name}", "tool_index": context.tool_index # Include tool_call ID if native
+            "status_type": "tool_started",
+            "role": "assistant",
+            "function_name": context.function_name,
+            "xml_tag_name": context.xml_tag_name,
+            "message": f"Starting execution of {tool_name}",
+            "tool_index": context.tool_index
         }
 
-        return  self.add_response_message(
-             type="status", content=content, is_llm_message=False
-        )
+        return  self.add_response_message(type="status", content=content, is_llm_message=False)
 
     def _add_tool_completed_message(self, context: ToolExecutionContext, tool_message_id: Optional[str]) -> Optional[Dict[str, Any]]:
         """Formats, saves, and returns a tool completed/failed status message."""
         if not context.result:
-            # Delegate to error saving if result is missing (e.g., execution failed)
             return  self._add_tool_error_message(context)
 
         tool_name = context.xml_tag_name or context.function_name
@@ -575,42 +508,38 @@ class TaskResponseProcessor(ABC):
         message_text = f"Tool {tool_name} {'completed successfully' if context.result.success else 'failed'}"
 
         content = {
-            "role": "assistant", "status_type": status_type,
-            "function_name": context.function_name, "xml_tag_name": context.xml_tag_name,
-            "message": message_text, "tool_index": context.tool_index,
+            "status_type": status_type,
+            "role": "assistant",
+            "function_name": context.function_name,
+            "xml_tag_name": context.xml_tag_name,
+            "message": message_text,
+            "tool_index": context.tool_index,
             "tool_call_id": context.tool_call.get("id")
         }
+
         metadata = {}
         # Add the *actual* tool result message ID to the metadata if available and successful
         if context.result.success and tool_message_id:
             metadata["linked_tool_result_message_id"] = tool_message_id
 
-        # <<< ADDED: Signal if this is a terminating tool >>>
         if context.function_name in ['ask', 'complete']:
             metadata["agent_should_terminate"] = "true"
-            logging.info(f"Marking tool status for '{context.function_name}' with termination signal.")
-            # self.root_span.event(name="marking_tool_status_for_termination", level="DEFAULT", status_message=(
-            #     f"Marking tool status for '{context.function_name}' with termination signal."))
-        # <<< END ADDED >>>
 
-        return  self.add_response_message(
-             type="status", content=content, is_llm_message=False, metadata=metadata
-        )
+        return  self.add_response_message(type="status", content=content, is_llm_message=False, metadata=metadata)
 
     def _add_tool_error_message(self, context: ToolExecutionContext) -> Optional[Dict[str, Any]]:
         """Formats, saves, and returns a tool error status message."""
         error_msg = str(context.error) if context.error else "Unknown error during tool execution"
         tool_name = context.xml_tag_name or context.function_name
         content = {
-            "role": "assistant", "status_type": "tool_error",
-            "function_name": context.function_name, "xml_tag_name": context.xml_tag_name,
+            "status_type": "tool_error",
+            "role": "assistant",
+            "function_name": context.function_name,
+            "xml_tag_name": context.xml_tag_name,
             "message": f"Error executing tool {tool_name}: {error_msg}",
             "tool_index": context.tool_index,
             "tool_call_id": context.tool_call.get("id")
         }
 
-        # Save the status message with is_llm_message=False
-        return  self.add_response_message(
-            type="status", content=content, is_llm_message=False
-        )
+        return  self.add_response_message(type="status", content=content, is_llm_message=False)
 

xgae/engine/responser/stream_responser.py

@@ -1,9 +1,8 @@
 import logging
-
+import asyncio
 from typing import List, Dict, Any, Optional, AsyncGenerator, override
-from importlib_metadata import metadata
 
-from xgae.utils import handle_error
+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
 
@@ -22,14 +21,21 @@ class StreamTaskResponser(TaskResponseProcessor):
         auto_continue_count = continuous_state.get('auto_continue_count', 0)
         can_auto_continue = continuous_state.get("auto_continue", False)
         use_assistant_chunk_msg = self.response_context.get("use_assistant_chunk_msg")
-        
+
         finish_reason = None
         should_auto_continue = False
         sequence = continuous_state.get('assistant_msg_sequence', 0)
-        
+
+        pending_tool_executions = []
+        yielded_tool_indices = set()  # Track which tool statuses have been yielded
+        tool_results_buffer = []  # Store (tool_call, result, tool_index, context)
+        tool_index = 0
+        current_xml_content = accumulated_content  # Track XML content for streaming detection
+
+        logging.info(f"=== StreamResp：tool_execute_on_stream={self.tool_execute_on_stream}, auto_continue_count={auto_continue_count}, accumulated_content_len={len(accumulated_content)}")
         try:
             async for llm_chunk in llm_response:
-                if hasattr(llm_chunk, 'choices') and llm_chunk.choices and hasattr(llm_chunk.choices[0], 'finish_reason'):
+                if hasattr(llm_chunk, 'choices') and llm_chunk.choices and hasattr(llm_chunk.choices[0],'finish_reason'):
                     if llm_chunk.choices[0].finish_reason:
                         finish_reason = llm_chunk.choices[0].finish_reason
                         logging.info(f"StreamResp：LLM chunk response finish_reason={finish_reason}")
@@ -40,24 +46,71 @@ class StreamTaskResponser(TaskResponseProcessor):
                     if llm_chunk_msg and hasattr(llm_chunk_msg, 'content') and llm_chunk_msg.content:
                         chunk_content = llm_chunk_msg.content
                         accumulated_content += chunk_content
+                        current_xml_content += chunk_content  #Track streaming XML content
 
                         xml_tool_call_count = len(self._extract_xml_chunks(accumulated_content))
                         if self.max_xml_tool_calls <= 0 or xml_tool_call_count < self.max_xml_tool_calls:
                             if use_assistant_chunk_msg:
                                 message_data = {"role": "assistant", "content": chunk_content}
                                 metadata = {"sequence": sequence}
-                                assistant_chunk_msg = self.create_response_message(type="assistant_chunk", content=message_data,
-                                                                                   is_llm_message=True, metadata=metadata)
+                                assistant_chunk_msg = self.create_response_message(type="assistant_chunk",content=message_data,
+                                                                                   is_llm_message=True,metadata=metadata)
                                 yield assistant_chunk_msg
 
+                            #Process XML tool calls during streaming
+                            if self.tool_execute_on_stream:
+                                xml_chunks = self._extract_xml_chunks(current_xml_content)
+                                for xml_chunk in xml_chunks:
+                                    current_xml_content = current_xml_content.replace(xml_chunk, "", 1)
+                                    result = self._parse_xml_tool_call(xml_chunk)
+                                    if result:
+                                        tool_call, parsing_details = result
+
+                                        # Create tool context for streaming execution
+                                        tool_context = self._create_tool_context(tool_call, tool_index, None, parsing_details)
+
+                                        # Yield tool start status immediately
+                                        tool_start_msg = self._add_tool_start_message(tool_context)
+                                        if tool_start_msg:
+                                            yield format_for_yield(tool_start_msg)
+                                            yielded_tool_indices.add(tool_index)
+
+                                        # Create async execution task
+                                        execution_task = asyncio.create_task(self._execute_tool(tool_call))
+                                        pending_tool_executions.append({"task": execution_task,"tool_call": tool_call,"tool_index": tool_index,
+                                                                        "context": tool_context,"parsing_details": parsing_details})
+                                        tool_index += 1
+
                             sequence += 1
                         else:
                             finish_reason = "xml_tool_limit_reached"
                             break
 
-            if  len(accumulated_content) == 0:
+            if len(accumulated_content) == 0:
                 logging.warning(f"StreamResp: LLM response_message content is empty")
 
+            # Wait for pending tool executions from streaming phase
+            if pending_tool_executions:
+                logging.info(f"Waiting for {len(pending_tool_executions)} pending streamed tool executions")
+
+                pending_tasks = [execution["task"] for execution in pending_tool_executions]
+                done, _ = await asyncio.wait(pending_tasks)
+
+                for execution in pending_tool_executions:
+                    tool_idx = execution.get("tool_index", -1)
+                    context = execution["context"]
+
+                    try:
+                        if execution["task"].done():
+                            result = execution["task"].result()
+                            context.result = result
+                            tool_results_buffer.append((execution["tool_call"],result,tool_idx,context))
+                        else:
+                            logging.warning(f"Task for tool index {tool_idx} not done after wait.")
+                    except Exception as e:
+                        logging.error(f"Error getting result for pending tool execution {tool_idx}: {str(e)}")
+                        context.error = e
+
             if finish_reason == "xml_tool_limit_reached":
                 xml_chunks = self._extract_xml_chunks(accumulated_content)
                 if len(xml_chunks) > self.max_xml_tool_calls:
@@ -66,51 +119,109 @@ class StreamTaskResponser(TaskResponseProcessor):
                         last_chunk = limited_chunks[-1]
                         last_chunk_pos = accumulated_content.find(last_chunk) + len(last_chunk)
                         accumulated_content = accumulated_content[:last_chunk_pos]
-            parsed_xml_data = self._parse_xml_tool_calls(accumulated_content)
 
+            parsed_xml_data = self._parse_xml_tool_calls(accumulated_content)
             should_auto_continue = (can_auto_continue and finish_reason == 'length')
 
-            self.root_span.event(name=f"stream_processor_start[{self.task_no}]({auto_continue_count})",level="DEFAULT",
+            self.root_span.event(name=f"stream_processor_start[{self.task_no}]({auto_continue_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)}, accumulated_content={len(accumulated_content)}, "
-                                                f"should_auto_continue={should_auto_continue}")
+                                                f"should_auto_continue={should_auto_continue}, pending_executions={len(pending_tool_executions)}")
 
             assistant_msg = None
             if accumulated_content and not should_auto_continue:
                 message_data = {"role": "assistant", "content": accumulated_content}
-                assistant_msg = self.add_response_message(type="assistant", content=message_data,
-                                                          is_llm_message=True)
+                assistant_msg = self.add_response_message(type="assistant", content=message_data, is_llm_message=True)
                 yield assistant_msg
 
+            # Process results from both streaming and non-streaming executions
             tool_calls_to_execute = [item['tool_call'] for item in parsed_xml_data]
-            if len(tool_calls_to_execute) > 0:
-                tool_results = await self._execute_tools(tool_calls_to_execute, self.tool_execution_strategy)
 
-                tool_index = 0
-                for i, (returned_tool_call, tool_result) in enumerate(tool_results):
-                    parsed_xml_item = parsed_xml_data[i]
-                    tool_call = parsed_xml_item['tool_call']
-                    parsing_details = parsed_xml_item['parsing_details']
-                    assistant_msg_id = assistant_msg['message_id'] if assistant_msg else None
+            # Update assistant_message_id for streaming tool contexts
+            assistant_msg_id = assistant_msg['message_id'] if assistant_msg else None
+            for execution in pending_tool_executions:
+                if not execution["context"].assistant_message_id:
+                    execution["context"].assistant_message_id = assistant_msg_id
 
-                    tool_context = self._create_tool_context(tool_call, tool_index, assistant_msg_id, parsing_details)
-                    tool_context.result = tool_result
+            if len(tool_calls_to_execute) > 0:
+                if self.tool_execute_on_stream:
+                    # Handle results from streaming executions + any remaining tools
+                    remaining_tools = []
+                    streamed_tool_indices = set()
+
+                    # Identify which tools were already executed during streaming by index
+                    for execution in pending_tool_executions:
+                        streamed_tool_indices.add(execution["tool_index"])
+
+                    # Find remaining tools that weren't executed during streaming
+                    for i, parsed_item in enumerate(parsed_xml_data):
+                        tool_call = parsed_item['tool_call']
+                        tool_identifier = (tool_call.get('function_name', ''), str(tool_call.get('arguments', {})))
+
+                        # Check if this tool was already executed during streaming
+                        already_executed = False
+                        for execution in pending_tool_executions:
+                            exec_tool_call = execution["tool_call"]
+                            exec_identifier = (exec_tool_call.get('function_name', ''),str(exec_tool_call.get('arguments', {})))
+                            if tool_identifier == exec_identifier:
+                                already_executed = True
+                                break
+
+                        if not already_executed:
+                            remaining_tools.append((parsed_item['tool_call'], parsed_item['parsing_details'], tool_index))
+                            tool_index += 1
+
+                    # Execute remaining tools if any
+                    if remaining_tools:
+                        for tool_call, parsing_details, t_idx in remaining_tools:
+                            tool_context = self._create_tool_context(tool_call, t_idx, assistant_msg_id,parsing_details)
+
+                            tool_start_msg = self._add_tool_start_message(tool_context)
+                            yield format_for_yield(tool_start_msg)
+
+                            result = await self._execute_tool(tool_call)
+                            tool_context.result = result
+                            tool_results_buffer.append((tool_call, result, t_idx, tool_context))
+
+                    # Process all tool results
+                    for tool_call, result, t_idx, context in tool_results_buffer:
+                        tool_message = self._add_tool_messsage(tool_call, result, self.xml_adding_strategy,assistant_msg_id,
+                                                               getattr(context, 'parsing_details', None))
+
+                        tool_completed_msg = self._add_tool_completed_message(context,tool_message['message_id'] if tool_message else None)
+                        yield format_for_yield(tool_completed_msg)
+
+                        if tool_message:
+                            yield format_for_yield(tool_message)
+
+                        if tool_completed_msg["metadata"].get("agent_should_terminate") == "true":
+                            finish_reason = "completed"
+                            break
+                else: # non-streaming execution
+                    tool_results = await self._execute_tools(tool_calls_to_execute, self.tool_execution_strategy)
+                    tool_index = 0
+                    for i, (returned_tool_call, tool_result) in enumerate(tool_results):
+                        parsed_xml_item = parsed_xml_data[i]
+                        tool_call = parsed_xml_item['tool_call']
+                        parsing_details = parsed_xml_item['parsing_details']
 
-                    tool_start_msg = self._add_tool_start_message(tool_context)
-                    yield format_for_yield(tool_start_msg)
+                        tool_context = self._create_tool_context(tool_call, tool_index, assistant_msg_id,parsing_details, tool_result)
 
-                    tool_message = self._add_tool_messsage(tool_call, tool_result, self.xml_adding_strategy, assistant_msg_id, parsing_details)
+                        tool_start_msg = self._add_tool_start_message(tool_context)
+                        yield format_for_yield(tool_start_msg)
 
-                    tool_completed_msg = self._add_tool_completed_message(tool_context, tool_message['message_id'])
-                    yield format_for_yield(tool_completed_msg)
+                        tool_message = self._add_tool_messsage(tool_call, tool_result, self.xml_adding_strategy,assistant_msg_id, parsing_details)
 
-                    yield format_for_yield(tool_message)
+                        tool_completed_msg = self._add_tool_completed_message(tool_context, tool_message['message_id'])
+                        yield format_for_yield(tool_completed_msg)
 
-                    if tool_completed_msg["metadata"].get("agent_should_terminate") == "true":
-                        finish_reason = "completed"
-                        break
+                        yield format_for_yield(tool_message)
+
+                        if tool_completed_msg["metadata"].get("agent_should_terminate") == "true":
+                            finish_reason = "completed"
+                            break
 
-                    tool_index += 1
+                        tool_index += 1
             else:
                 finish_reason = "non_tool_call"
                 logging.warning(f"StreamResp: tool_calls is empty, No Tool need to call !")
@@ -120,11 +231,10 @@ class StreamTaskResponser(TaskResponseProcessor):
                 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"StreamResp: Process response llm_content: {accumulated_content}")
-            handle_error(e)
+            trace = log_trace(e, f"StreamResp: Process response accumulated_content:\n {accumulated_content}")
             self.root_span.event(name="stream_response_process_error", level="ERROR",
                                  status_message=f"Process streaming response error: {e}",
-                                 metadata={"content": accumulated_content})
+                                 metadata={"content": accumulated_content, "trace": trace})
 
             content = {"role": "system", "status_type": "error", "message": f"Process streaming response error: {e}"}
             error_msg = self.add_response_message(type="status", content=content, is_llm_message=False)
@@ -135,4 +245,5 @@ class StreamTaskResponser(TaskResponseProcessor):
             if should_auto_continue:
                 continuous_state['accumulated_content'] = accumulated_content
                 continuous_state['assistant_msg_sequence'] = sequence
-                logging.warning(f"StreamResp: Updated continuous state for auto-continue with {len(accumulated_content)} chars")
+                logging.warning(
+                    f"StreamResp: Updated continuous state for auto-continue with {len(accumulated_content)} chars")

xgae/engine/task_engine.py

@@ -5,7 +5,7 @@ import os
 from typing import List, Any, Dict, Optional, AsyncGenerator, Union, Literal
 from uuid import uuid4
 
-from xgae.utils import handle_error, to_bool
+from xgae.utils import log_trace, to_bool
 from xgae.utils.llm_client import LLMClient, LLMConfig
 from xgae.utils.json_helpers import format_for_yield
 
@@ -171,20 +171,19 @@ class XGATaskEngine:
                                     update_continuous_state(auto_continue_count, auto_continue)
                                     logging.info(f"TaskEngine run_task_auto: Detected finish_reason='{finish_reason}', auto-continuing ({auto_continue_count}/{self.max_auto_run})")
                     except Exception as parse_error:
-                        logging.error(f"TaskEngine run_task_auto: Parse chunk error, chunk: {chunk}")
-                        handle_error(parse_error)
+                        trace = log_trace(parse_error,f"TaskEngine run_task_auto: Parse chunk error, chunk: {chunk}")
                         self.task_langfuse.root_span.event(name="engine_parse_chunk_error", level="ERROR",
-                                             status_message=(f"Task Engine parse chunk error: {parse_error}"),
-                                             metadata={"content": chunk})
+                                             status_message=f"Task Engine parse chunk error: {parse_error}",
+                                             metadata={"content": chunk, "trace": trace})
 
                         content = {"role": "system", "status_type": "error", "message": "Parse response chunk Error"}
                         error_msg = self.add_response_message(type="status", content=content, is_llm_message=False)
                         yield format_for_yield(error_msg)
             except Exception as run_error:
-                logging.error(f"TaskEngine run_task_auto: Call task_run_once error: {run_error}")
-                handle_error(run_error)
+                trace = log_trace(run_error, "TaskEngine run_task_auto: Call task_run_once")
                 self.task_langfuse.root_span.event(name="engine_task_run_once_error", level="ERROR",
-                                                   status_message=(f"Call task_run_once error: {run_error}"))
+                                                   status_message=f"Call task_run_once error: {run_error}",
+                                                   metadata={"trace": trace})
 
                 content = {"role": "system", "status_type": "error", "message": "Call run_task_once error"}
                 error_msg = self.add_response_message(type="status", content=content, is_llm_message=False)
@@ -268,11 +267,10 @@ class XGATaskEngine:
                 logging.warning(f"❌ FINAL_RESULT: LLM Result is EMPTY, finish_reason={finish_reason}")
                 final_result = XGATaskResult(type="error", content="LLM has no answer")
         except Exception as e:
-            logging.error(f"TaskEngine parse_final_result: Parse message chunk error, chunk: {chunk}")
-            handle_error(e)
+            trace = log_trace(e, f"TaskEngine parse_final_result: Parse message chunk error, chunk: {chunk}")
             self.task_langfuse.root_span.event(name="engine_parse_final_result_error", level="ERROR",
-                                               status_message=(f"Task Engine parse final result error: {e}"),
-                                               metadata={"content": chunk})
+                                               status_message=f"Task Engine parse final result error: {e}",
+                                               metadata={"content": chunk, "trace": trace})
 
             final_result = XGATaskResult(type="error", content="Parse final result failed!")
 
@@ -321,8 +319,7 @@ class XGATaskEngine:
                     _content = json.loads(content)
                     response_llm_contents.append(_content)
                 except json.JSONDecodeError as e:
-                    logging.error(f"TaskEngine get_history_llm_messages: Failed to decode json, content: {content}")
-                    handle_error(e)
+                    pass
             else:
                 response_llm_contents.append(content)
 
@@ -347,7 +344,8 @@ class XGATaskEngine:
             "model_name": self.model_name,
             "max_xml_tool_calls": 0,
             "use_assistant_chunk_msg": self.use_assistant_chunk_msg,
-            "tool_execution_strategy": "parallel" if self.tool_exec_parallel else "sequential",  # ,
+            "tool_execution_strategy": "parallel" if self.tool_exec_parallel else "sequential",
+            "tool_execute_on_stream": False,
             "xml_adding_strategy": "user_message",
             "add_response_msg_func": self.add_response_message,
             "create_response_msg_func": self.create_response_message,
@@ -386,10 +384,9 @@ class XGATaskEngine:
                 logging.debug(f"TASK_RESP_CHUNK[{auto_count}]<{chunk_type}{prefix}> content: {pretty_content}")
             else:
                 logging.info(f"TASK_RESP_CHUNK[{auto_count}]<{chunk_type}{prefix}> content: {pretty_content}")
-
         except Exception as e:
-            logging.error(f"TaskEngine logging_reponse_chunk: Decorate chunk log error， chunk: {chunk}")
-            handle_error(e)
+            logging.error(f"TaskEngine logging_reponse_chunk: Decorate chunk={chunk}, error: {e}")
+
 
 
 if __name__ == "__main__":
@@ -400,7 +397,7 @@ if __name__ == "__main__":
     setup_logging()
 
     async def main():
-        # Before Run Exec: uv run custom_fault_tools
+        # Before Run Exec: uv run example-fault-tools
         tool_box = XGAMcpToolBox(custom_mcp_server_file="mcpservers/custom_servers.json")
         system_prompt = read_file("templates/example/fault_user_prompt.txt")
         engine =  XGATaskEngine(tool_box=tool_box,

xgae/tools/without_general_tools_app.py

@@ -3,6 +3,7 @@ from pydantic import Field
 
 from mcp.server.fastmcp import FastMCP
 
+from xgae.engine.engine_base import  XGAToolResult
 
 mcp = FastMCP(name="XGAE Message Tools")
 
@@ -16,7 +17,7 @@ async def complete(task_id: str,
                        description="Comma-separated list of final outputs. Use when: 1) Completion relates to files 2) User needs to review outputs 3) Deliverables in files")]
                    ):
     print(f"<XGAETools-complete>: task_id={task_id}, text={text}, attachments={attachments}")
-    return {"status": "complete"}
+    return XGAToolResult(success=True, output=str({"status": "complete"}))
 
 
 @mcp.tool(
@@ -29,7 +30,7 @@ async def ask(task_id: str,
                   description="Comma-separated list of files/URLs to attach. Use when: 1) Question relates to files/configs 2) User needs to review content 3) Options documented in files 4) Supporting evidence needed")]
               ):
     print(f"<XGAETools-ask>: task_id={task_id}, text={text}, attachments={attachments}")
-    return {"status": "Awaiting user response..."}
+    return XGAToolResult(success=True, output=str({"status": "Awaiting user response..."}))
 
 @mcp.tool(
     description="end task, destroy sandbox"

xgae/utils/__init__.py

@@ -1,11 +1,22 @@
 import logging
 
-def handle_error(e: Exception) -> None:
+
+def log_trace(exception: Exception, error: str=None) -> str:
+    import traceback
+
+    if error:
+        logging.error(f"{error} , error: {exception}")
+
+    trace_info = traceback.format_exc()
+    logging.error("Trace Details:\n%s", traceback.format_exc())
+
+    return trace_info
+
+
+def get_trace() -> str:
     import traceback
 
-    logging.error("An error occurred: %s", str(e))
-    logging.error("Traceback details:\n%s", traceback.format_exc())
-    raise (e) from e
+    return traceback.format_exc()
 
 
 def to_bool(value: any) -> bool:
@@ -13,3 +24,4 @@ def to_bool(value: any) -> bool:
         return False
 
     return str(value).lower() == "true"
+

xgae/utils/misc.py

@@ -4,7 +4,6 @@ import sys
 
 from typing import Any, Dict
 
-from xgae.utils import handle_error
 
 def read_file(file_path: str) -> str:
     if not os.path.exists(file_path):
@@ -17,7 +16,7 @@ def read_file(file_path: str) -> str:
         return content
     except Exception as e:
         logging.error(f"Read file '{file_path}' failed")
-        handle_error(e)
+        raise
 
 def format_file_with_args(file_content:str, args: Dict[str, Any])-> str:
     from io import StringIO

{xgae-0.1.12.dist-info → xgae-0.1.14.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xgae
-Version: 0.1.12
+Version: 0.1.14
 Summary: Extreme General Agent Engine
 Requires-Python: >=3.13
 Requires-Dist: colorlog==6.9.0

xgae-0.1.14.dist-info/RECORD

@@ -0,0 +1,21 @@
+xgae/__init__.py,sha256=OEUd9y9AoGBd3xYerdTTpz9xl4NWkmXeq1a2eil7Qro,72
+xgae/cli_app.py,sha256=vKuCIJw0gwXdtkT-QNCZKt2dE53thvTFwQr7nTgvaPY,3000
+xgae/engine/engine_base.py,sha256=-QZqLRbQdwRUfbY4l3i7dFfMB-BL267a-wGZR9bMPLc,1662
+xgae/engine/mcp_tool_box.py,sha256=ot1lpMw77e6VLe4UPCJw3TxcjIXBqzg_qphdmHmW2XQ,10414
+xgae/engine/prompt_builder.py,sha256=X9bS7YIms6LYplCpNHeUmi74xFP5MwFXmXNqOt1Xz-Q,4356
+xgae/engine/task_engine.py,sha256=ayv4DTwDArMRQ_CPBxt8tdk7E7JPB0Osb5jxlikMsxM,21052
+xgae/engine/task_langfuse.py,sha256=b0aJ_Di-WDcYzi0TFCvcKWxkBz7PYP2jx3N52OptQMs,2349
+xgae/engine/responser/non_stream_responser.py,sha256=_DkyBZ50N1Tm8K0W16MD5vgx2Eu_amt2LgfN_7Ej1Us,5542
+xgae/engine/responser/responser_base.py,sha256=mgioPh1atCd5PueumyxAN7eB87SB7wOSB_mLTI-6lIg,25250
+xgae/engine/responser/stream_responser.py,sha256=AVEs0pkLZNPzXcp5A1iFNjDb-aUy7_NWRqThCZqmIyQ,14852
+xgae/tools/without_general_tools_app.py,sha256=FGMV6njcOKwwfitc0j_nUov0RC-eWlhO1IP8_KHz1tQ,3788
+xgae/utils/__init__.py,sha256=ElaGS-zdeZeu6is41u3Ny7lkvhg7BDSK-jMNg9j6K5A,499
+xgae/utils/json_helpers.py,sha256=ubp-dOCeROnZv7JHARRdmDIO5Npdwzrt8AWo3SMv0kI,4705
+xgae/utils/llm_client.py,sha256=6e3kzx73QN6z2SYMQQFmrmODj2Rk-GPJYIxBcFZhMQE,14361
+xgae/utils/misc.py,sha256=aMWOvJ9VW52q-L9Lkjl1hvXqLwpJAmyxA-Z8jzqFG0U,907
+xgae/utils/setup_env.py,sha256=MqNG0c2QQBDFU1kI8frxr9kB5d08Mmi3QZ1OoorgIa0,2662
+xgae/utils/xml_tool_parser.py,sha256=I9xAZC_ElwBY19PNUq-WLXe9FSIJMeAv2Xs-VlajI7Y,4782
+xgae-0.1.14.dist-info/METADATA,sha256=WGVnO2sWvP3EM98tObwlafmkfIRHl2oSTUn5rBsZ3HM,310
+xgae-0.1.14.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+xgae-0.1.14.dist-info/entry_points.txt,sha256=SWN01JNAncV0oApEvFzpH0wsXfnFlB1adCH4IrAJxGc,163
+xgae-0.1.14.dist-info/RECORD,,

{xgae-0.1.12.dist-info → xgae-0.1.14.dist-info}/entry_points.txt

@@ -1,4 +1,4 @@
 [console_scripts]
-custom_fault_tools = examples.tools.custom_fault_tools_app:main
+example-fault-tools = examples.tools.custom_fault_tools_app:main
 xgae = xgae.cli_app:main
 xgae-tools = xgae.tools.without_general_tools_app:main

xgae-0.1.12.dist-info/RECORD

@@ -1,21 +0,0 @@
-xgae/__init__.py,sha256=OEUd9y9AoGBd3xYerdTTpz9xl4NWkmXeq1a2eil7Qro,72
-xgae/cli_app.py,sha256=vKuCIJw0gwXdtkT-QNCZKt2dE53thvTFwQr7nTgvaPY,3000
-xgae/engine/engine_base.py,sha256=-QZqLRbQdwRUfbY4l3i7dFfMB-BL267a-wGZR9bMPLc,1662
-xgae/engine/mcp_tool_box.py,sha256=Vyku8uOsTZ4ElnwEEgaw0hiltTOlC-FvtC9Ox-iJYck,10089
-xgae/engine/prompt_builder.py,sha256=X9bS7YIms6LYplCpNHeUmi74xFP5MwFXmXNqOt1Xz-Q,4356
-xgae/engine/task_engine.py,sha256=J4hVAkRgmd24larSFjxoCaVh9r3fDZJ95fUGB-FICZ8,21174
-xgae/engine/task_langfuse.py,sha256=b0aJ_Di-WDcYzi0TFCvcKWxkBz7PYP2jx3N52OptQMs,2349
-xgae/engine/responser/non_stream_responser.py,sha256=za1-7b37jVcg1cgTadNNXljqUTbzA92168i80xV7zdw,5589
-xgae/engine/responser/responser_base.py,sha256=WA2oKqP-UhQZj2es2nIFKf6_XkOhIfqZMUcQzDhtc6Q,30424
-xgae/engine/responser/stream_responser.py,sha256=dXcj-l3jb8J0orZ7THdf0sOjw9M7aZbfjHQC0NwQizo,7868
-xgae/tools/without_general_tools_app.py,sha256=cza3aLVh-090QABYA_DakoXmlFmc9rxwrXQsQwveT9A,3655
-xgae/utils/__init__.py,sha256=6lZCuEzMj66SW5sXyWrIuLH2W-1mHpbLpIBq_qbnsiw,337
-xgae/utils/json_helpers.py,sha256=ubp-dOCeROnZv7JHARRdmDIO5Npdwzrt8AWo3SMv0kI,4705
-xgae/utils/llm_client.py,sha256=6e3kzx73QN6z2SYMQQFmrmODj2Rk-GPJYIxBcFZhMQE,14361
-xgae/utils/misc.py,sha256=M8lMXYp1pHiY6Ee8ZTUG88GpOAsE5fbYoRO_hcBFUCE,953
-xgae/utils/setup_env.py,sha256=MqNG0c2QQBDFU1kI8frxr9kB5d08Mmi3QZ1OoorgIa0,2662
-xgae/utils/xml_tool_parser.py,sha256=I9xAZC_ElwBY19PNUq-WLXe9FSIJMeAv2Xs-VlajI7Y,4782
-xgae-0.1.12.dist-info/METADATA,sha256=7bOOMvn3Ntj_v_tZy2hkfiNKyTABLhoZRKDb0CJkwpM,310
-xgae-0.1.12.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-xgae-0.1.12.dist-info/entry_points.txt,sha256=vClvL_WBJyF2x3wJCz5CNJ_BJG-dWUh7h2YbAoskHsc,162
-xgae-0.1.12.dist-info/RECORD,,