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

xgae/engine/mcp_tool_box.py

@@ -200,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

@@ -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)

xgae/engine/responser/responser_base.py

@@ -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
@@ -291,11 +293,10 @@ class TaskResponseProcessor(ABC):
 
             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":
@@ -304,271 +305,202 @@ class TaskResponseProcessor(ABC):
             logging.warning(f"TaskProcessor execute_tools: Unknown execution strategy '{execution_strategy}', use sequential")
             return await self._execute_tools_sequentially(tool_calls)
 
-    # @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
         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
@@ -576,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,5 +1,5 @@
 import logging
-
+import asyncio
 from typing import List, Dict, Any, Optional, AsyncGenerator, override
 
 from xgae.utils import log_trace
@@ -21,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}")
@@ -39,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:
@@ -65,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 !")
@@ -133,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

@@ -344,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,
@@ -396,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-0.1.13.dist-info → xgae-0.1.14.dist-info}/METADATA

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

{xgae-0.1.13.dist-info → xgae-0.1.14.dist-info}/RECORD

@@ -1,13 +1,13 @@
 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=eE4qGxTHaSMMNDDWWafNXFT-vj_YYof4AjVSsxKoq68,10413
+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=ZWxi292fceWvZuv501lwUGgb_PStktmfLFDzhDlsFfY,21011
+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=RS2fIP_XCWjZEVtFRSNDJ9wM1N66MuzA66wXm3Nz1Jg,5583
-xgae/engine/responser/responser_base.py,sha256=WsUMUfEE2cexAg5LzXA1yUECOkbs1ekh8HbJS5-R7f8,30813
-xgae/engine/responser/stream_responser.py,sha256=O6_wSwdbqjYO-XowiLvHZKuw-F6fvxyjWULhfkkF6ow,7830
+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
@@ -15,7 +15,7 @@ xgae/utils/llm_client.py,sha256=6e3kzx73QN6z2SYMQQFmrmODj2Rk-GPJYIxBcFZhMQE,1436
 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.13.dist-info/METADATA,sha256=8y0v909gMEo6oyUYTrY5ZjRP8ACB8U-BPHZTDd5uq4M,310
-xgae-0.1.13.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-xgae-0.1.13.dist-info/entry_points.txt,sha256=vClvL_WBJyF2x3wJCz5CNJ_BJG-dWUh7h2YbAoskHsc,162
-xgae-0.1.13.dist-info/RECORD,,
+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.13.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