xgae 0.1.15__py3-none-any.whl → 0.1.17__py3-none-any.whl

xgae/cli_app.py

@@ -56,7 +56,7 @@ async def cli() -> None:
         trace_id = langfuse.trace(name="xgae_cli").trace_id
 
         final_result = await engine.run_task_with_final_answer(
-            task_message={"role": "user", "content": user_message},
+            task_message={'role': "user", 'content': user_message},
             trace_id=trace_id
         )
 
@@ -65,7 +65,7 @@ async def cli() -> None:
             print(f"\n📌 ASK INFO: {final_result['content']}")
             user_message = get_user_message("Enter ASK information (or 'exit' to quit)")
             final_result = await engine.run_task_with_final_answer(
-                task_message={"role": "user", "content": user_message},
+                task_message={'role': "user", 'content': user_message},
                 trace_id=trace_id
             )
 

xgae/engine/mcp_tool_box.py

@@ -78,7 +78,7 @@ class XGAMcpToolBox(XGAToolBox):
     async def destroy_task_tool_box(self, task_id: str):
         tool_schemas = self.get_task_tool_schemas(task_id, type="general_tool")
         if len(tool_schemas) > 0:
-            await self.call_tool(task_id, "end_task", {"task_id": task_id})
+            await self.call_tool(task_id, "end_task", {'task_id': task_id})
         self.task_tool_schemas.pop(task_id, None)
 
     @override
@@ -118,7 +118,7 @@ class XGAMcpToolBox(XGAToolBox):
             if mcp_tool:
                 tool_args = args or {}
                 if server_name == self.GENERAL_MCP_SERVER_NAME:
-                    tool_args = dict({"task_id": task_id}, **tool_args)
+                    tool_args = dict({'task_id': task_id}, **tool_args)
                     is_general_tool = True
 
                 try:
@@ -152,9 +152,9 @@ class XGAMcpToolBox(XGAToolBox):
                         input_schema['properties'].pop("task_id", None)
                         if 'task_id' in input_schema['required']:
                             input_schema['required'].remove('task_id')
-                        params_properties = input_schema.get("properties", {})
+                        params_properties = input_schema.get('properties', {})
                         for param_properties in params_properties.values():
-                            param_properties.pop("title", None)
+                            param_properties.pop('title', None)
 
                     metadata = tool.metadata or {}
                     tool_schema = XGAToolSchema(tool_name=tool.name,
@@ -173,10 +173,10 @@ class XGAMcpToolBox(XGAToolBox):
     def _load_mcp_servers_config(mcp_config_path: str) -> Dict[str, Any]:
         try:
             if os.path.exists(mcp_config_path):
-                with open(mcp_config_path, 'r', encoding='utf-8') as f:
+                with open(mcp_config_path, 'r', encoding="utf-8") as f:
                     server_config = json.load(f)
 
-                    for server_name, server_info in server_config["mcpServers"].items():
+                    for server_name, server_info in server_config['mcpServers'].items():
                         if "transport" not in server_info:
                             if "url" in server_info:
                                 server_info['transport'] = "streamable_http" if "mcp" in server_info['url'] else "sse"

xgae/engine/prompt_builder.py

@@ -40,7 +40,6 @@ class XGAPromptBuilder():
 
                 openai_function['name'] = tool_schema.tool_name
                 openai_function['description'] = tool_schema.description if tool_schema.description else 'No description available'
-
                 openai_parameters = {}
                 openai_function['parameters'] = openai_parameters
 
@@ -70,7 +69,7 @@ class XGAPromptBuilder():
             for tool_schema in tool_schemas:
                 description = tool_schema.description if tool_schema.description else 'No description available'
                 tool_info += f"- **{tool_schema.tool_name}**: {description}\n"
-                parameters = tool_schema.input_schema.get("properties", {})
+                parameters = tool_schema.input_schema.get('properties', {})
                 tool_info += f"  Parameters: {parameters}\n"
             tool_prompt = tool_prompt.replace("{tool_schemas}", tool_info)
 

xgae/engine/responser/non_stream_responser.py

@@ -20,7 +20,7 @@ class NonStreamTaskResponser(TaskResponseProcessor):
         llm_content = ""
         parsed_xml_data = []
         finish_reason = None
-        llm_count = continuous_state.get("auto_continue_count")
+        auto_continue_count = continuous_state['auto_continue_count']
 
         try:
             if hasattr(llm_response, 'choices') and llm_response.choices:
@@ -40,13 +40,10 @@ class NonStreamTaskResponser(TaskResponseProcessor):
                             parsed_xml_data = parsed_xml_data[:self.max_xml_tool_calls]
                             finish_reason = "xml_tool_limit_reached"
 
-            self.root_span.event(name=f"non_stream_processor_start[{self.task_no}]({llm_count})", level="DEFAULT",
+            self.root_span.event(name=f"non_stream_processor_start[{self.task_no}]({auto_continue_count})", level="DEFAULT",
                              status_message=f"finish_reason={finish_reason}, tool_exec_strategy={self.tool_exec_strategy}, "
                                             f"parsed_xml_data_len={len(parsed_xml_data)}, llm_content_len={len(llm_content)}")
 
-            if  len(llm_content) == 0:
-                logging.warning(f"NonStreamResp: LLM response_message llm_content is empty")
-
             message_data = {"role": "assistant", "content": llm_content}
             assistant_msg = self.add_response_message(type="assistant", content=message_data, is_llm_message=True)
             yield assistant_msg
@@ -81,10 +78,10 @@ class NonStreamTaskResponser(TaskResponseProcessor):
                     tool_index += 1
             else:
                 finish_reason = "non_tool_call"
-                logging.warning(f"NonStreamResp:  tool_calls is empty, No Tool need to call !")
+                logging.warning(f"NonStreamResp: finish_reason='non_tool_call', No Tool need to call !")
 
             if finish_reason:
-                finish_content = {"status_type": "finish", "finish_reason": finish_reason}
+                finish_content = {'status_type': "finish", 'finish_reason': finish_reason}
                 finish_msg = self.add_response_message(type="status", content=finish_content, is_llm_message=False)
                 yield finish_msg
         except Exception as e:
@@ -93,7 +90,7 @@ class NonStreamTaskResponser(TaskResponseProcessor):
                                  status_message=f"Process non-streaming response error: {e}",
                                  metadata={"content": llm_content, "trace": trace})
 
-            content = {"role": "system", "status_type": "error", "message": f"Process non-streaming response error: {e}"}
+            content = {'role': "system", 'status_type': "error", 'message': f"Process non-streaming response error: {e}"}
             error_msg = self.add_response_message(type="status", content=content, is_llm_message=False)
             yield error_msg
 

xgae/engine/responser/responser_base.py

@@ -29,7 +29,6 @@ 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_exec_strategy: ToolExecutionStrategy
-    tool_exec_on_stream: bool
     xml_adding_strategy: XmlAddingStrategy
     add_response_msg_func: Callable
     create_response_msg_func: Callable
@@ -65,7 +64,6 @@ class TaskResponseProcessor(ABC):
         self.task_run_id            = response_context['task_run_id']
         self.task_no                = response_context['task_no']
         self.tool_exec_strategy     = response_context['tool_exec_strategy']
-        self.tool_exec_on_stream    = response_context['tool_exec_on_stream']
         self.xml_adding_strategy    = response_context['xml_adding_strategy']
         self.max_xml_tool_calls     = response_context['max_xml_tool_calls']
 
@@ -265,7 +263,7 @@ class TaskResponseProcessor(ABC):
         function_name = tool_call['function_name']
         exec_tool_span = self.root_span.span(name=f"execute_tool.{function_name}", input=tool_call["arguments"])
         try:
-            arguments = tool_call["arguments"]
+            arguments = tool_call.get('arguments', {})
             if isinstance(arguments, str):
                 try:
                     arguments = safe_json_parse(arguments)
@@ -321,7 +319,7 @@ class TaskResponseProcessor(ABC):
             logging.warning("TaskProcessor execute_tools_sequentially: tool_calls is empty")
             return []
 
-        tool_names = [t.get('function_name', 'unknown') for t in tool_calls]
+        tool_names = [tc['function_name'] for tc in tool_calls]
         tool_num = len(tool_calls)
         if tool_num > 1:
             logging.info(f"TaskProcessor execute_tools_sequentially: Executing {tool_num} tools sequentially: {tool_names}")
@@ -336,7 +334,7 @@ class TaskResponseProcessor(ABC):
             results.append((tool_call, result))
 
             # Check if this is a terminating tool (ask or complete)
-            if tool_name in ['ask', '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",
@@ -360,7 +358,7 @@ class TaskResponseProcessor(ABC):
             logging.warning("TaskProcessor execute_tools_in_parallel: tool_calls is empty")
             return []
 
-        tool_names = [t['function_name'] for t in tool_calls]
+        tool_names = [tc['function_name'] for tc 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}")
@@ -402,10 +400,10 @@ class TaskResponseProcessor(ABC):
 
         metadata = {}
         if assistant_message_id:
-            metadata["assistant_message_id"] = assistant_message_id
+            metadata['assistant_message_id'] = assistant_message_id
 
         if parsing_details:
-            metadata["parsing_details"] = parsing_details
+            metadata['parsing_details'] = parsing_details
 
         metadata['frontend_content'] = result_for_frontend
 
@@ -424,9 +422,8 @@ class TaskResponseProcessor(ABC):
                                        parsing_details: Optional[Dict[str, Any]] = None,
                                        for_llm: bool = False) -> Dict[str, Any]:
         function_name = tool_call['function_name']
-        xml_tag_name = tool_call.get("xml_tag_name")
-        arguments = tool_call.get("arguments", {})
-        tool_call_id = tool_call.get("id")
+        xml_tag_name = tool_call['xml_tag_name']
+        arguments = tool_call.get('arguments', {})
 
         # Process the output - if it's a JSON string, parse it back to an object
         output = result.output
@@ -499,17 +496,17 @@ class TaskResponseProcessor(ABC):
         message_text = f"Tool {context.function_name} {'completed successfully' if context.result.success else 'failed'}"
 
         content = {
-            "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
+            '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
         }
 
         metadata = {}
         if tool_message_id:
-            metadata["tool_result_message_id"] = tool_message_id
+            metadata['tool_result_message_id'] = tool_message_id
 
         return  self.add_response_message(type="status", content=content, is_llm_message=False, metadata=metadata)
 
@@ -517,12 +514,12 @@ class TaskResponseProcessor(ABC):
         """Formats, saves, and returns a tool error status message."""
         error_msg = str(context.error) if context.error else "Tool execution unknown exception"
         content = {
-            "status_type"       : "tool_error",
-            "role"              : "assistant",
-            "function_name"     : context.function_name,
-            "xml_tag_name"      : context.xml_tag_name,
-            "message"           : f"Executing tool {context.function_name} exception: {error_msg}",
-            "tool_index"        : context.tool_index
+            'status_type'       : "tool_error",
+            'role'              : "assistant",
+            'function_name'     : context.function_name,
+            'xml_tag_name'      : context.xml_tag_name,
+            'message'           : f"Executing tool {context.function_name} exception: {error_msg}",
+            'tool_index'        : context.tool_index
         }
 
         return  self.add_response_message(type="status", content=content, is_llm_message=False)

xgae/engine/responser/stream_responser.py

@@ -27,14 +27,7 @@ class StreamTaskResponser(TaskResponseProcessor):
         finish_reason = None
         should_auto_continue = False
 
-        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_exec_on_stream={self.tool_exec_on_stream}, auto_continue_count={auto_continue_count}, "
+        logging.info(f"=== StreamResp：Start Process Response, assistant_msg_sequence={msg_sequence}, "
                      f"accumulated_content_len={len(accumulated_content)}")
         try:
             async for llm_chunk in llm_response:
@@ -49,10 +42,9 @@ 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 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": msg_sequence}
@@ -62,63 +54,11 @@ class StreamTaskResponser(TaskResponseProcessor):
                                                                                    metadata=metadata)
                                 yield assistant_chunk_msg
                                 msg_sequence += 1
-
-                            #Process XML tool calls during streaming
-                            if self.tool_exec_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)
-                                        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,
-                                                                        'tool_context': tool_context,
-                                                                        'parsing_details': parsing_details})
-                                        tool_index += 1
                         else:
                             finish_reason = "xml_tool_limit_reached"
                             logging.warning(f"StreamResp: Over XML Tool Limit, finish_reason='xml_tool_limit_reached', "
                                             f"xml_tool_call_count={xml_tool_call_count}")
                             break
-            # for chunk is end
-
-            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"StreamResp: 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 pend_tool_exec in pending_tool_executions:
-                    pend_tool_index = pend_tool_exec['tool_index']
-                    pend_tool_context = pend_tool_exec['tool_context']
-
-                    try:
-                        if pend_tool_exec["task"].done():
-                            result = pend_tool_exec['task'].result()
-                            pend_tool_context.result = result
-                            tool_results_buffer.append((pend_tool_exec["tool_call"], result, pend_tool_index, pend_tool_context))
-                        else:
-                            logging.warning(f"StreamResp: Task for tool index {pend_tool_index} is not done after wait.")
-                    except Exception as e:
-                        logging.error(f"StreamResp: Error getting result for pending tool execution {pend_tool_index}: {str(e)}")
-                        pend_tool_context.error = e
 
             if finish_reason == "xml_tool_limit_reached":
                 xml_chunks = self._extract_xml_chunks(accumulated_content)
@@ -135,7 +75,7 @@ class StreamTaskResponser(TaskResponseProcessor):
             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_exec_strategy}, "
                                                 f"parsed_xml_data_len={len(parsed_xml_data)}, accumulated_content_len={len(accumulated_content)}, "
-                                                f"should_auto_continue={should_auto_continue}, pending_executions_len={len(pending_tool_executions)}")
+                                                f"should_auto_continue={should_auto_continue}")
 
             assistant_msg = None
             if accumulated_content and not should_auto_continue:
@@ -143,99 +83,40 @@ class StreamTaskResponser(TaskResponseProcessor):
                 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]
-
-            # Update assistant_message_id for streaming tool contexts
             assistant_msg_id = assistant_msg['message_id'] if assistant_msg else None
-            for pend_tool_exec in pending_tool_executions:
-                if not pend_tool_exec["tool_context"].assistant_message_id:
-                    pend_tool_exec["tool_context"].assistant_message_id = assistant_msg_id
-
-            if len(tool_calls_to_execute) > 0:
-                if self.tool_exec_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 pend_tool_exec in pending_tool_executions:
-                        streamed_tool_indices.add(pend_tool_exec["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 pend_tool_exec in pending_tool_executions:
-                            exec_tool_call = pend_tool_exec["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 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, pend_tool_context in tool_results_buffer:
-                        tool_message = self._add_tool_messsage(tool_call, result, self.xml_adding_strategy,assistant_msg_id,
-                                                               getattr(pend_tool_context, 'parsing_details', None))
-
-                        tool_completed_msg = self._add_tool_completed_message(pend_tool_context,tool_message['message_id'] if tool_message else None)
-                        yield tool_completed_msg
-
-                        yield tool_message
-
-                        if pend_tool_context.function_name in ['ask', 'complete']:
-                            finish_reason = "completed"
-                            break
-                else: # non-streaming execution
-                    tool_results = await self._execute_tools(tool_calls_to_execute, self.tool_exec_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_calls_to_execute = [item['tool_call'] for item in parsed_xml_data]
+            if len(tool_calls_to_execute) > 0 and not should_auto_continue:
+                tool_results = await self._execute_tools(tool_calls_to_execute, self.tool_exec_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_context = self._create_tool_context(tool_call, tool_index, assistant_msg_id,parsing_details, 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 tool_start_msg
+                    tool_start_msg = self._add_tool_start_message(tool_context)
+                    yield tool_start_msg
 
-                        tool_message = self._add_tool_messsage(tool_call, tool_result, self.xml_adding_strategy,assistant_msg_id, parsing_details)
+                    tool_message = self._add_tool_messsage(tool_call, tool_result, self.xml_adding_strategy,assistant_msg_id, parsing_details)
 
-                        tool_completed_msg = self._add_tool_completed_message(tool_context, tool_message['message_id'])
-                        yield tool_completed_msg
+                    tool_completed_msg = self._add_tool_completed_message(tool_context, tool_message['message_id'])
+                    yield tool_completed_msg
 
-                        yield tool_message
+                    yield tool_message
 
-                        if tool_context.function_name in ['ask', 'complete']:
-                            finish_reason = "completed"
-                            break
+                    if tool_context.function_name in ['ask', 'complete']:
+                        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 !")
+                logging.warning(f"StreamResp: finish_reason='non_tool_call', No Tool need to call !")
 
             if finish_reason:
-                finish_content = {"status_type": "finish", "finish_reason": finish_reason}
+                finish_content = {'status_type': "finish", 'finish_reason': finish_reason}
                 finish_msg = self.add_response_message(type="status", content=finish_content, is_llm_message=False)
                 yield finish_msg
         except Exception as e:
@@ -244,7 +125,7 @@ class StreamTaskResponser(TaskResponseProcessor):
                                  status_message=f"Process streaming response error: {e}",
                                  metadata={"content": accumulated_content, "trace": trace})
 
-            content = {"role": "system", "status_type": "error", "message": f"Process streaming response error: {e}"}
+            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)
             yield error_msg
 

xgae/engine/task_engine.py

@@ -152,7 +152,7 @@ class XGATaskEngine:
                                 logging.error(f"TaskEngine run_task_auto: task_response error: {chunk.get('message')}")
                                 auto_continue = False
                                 break
-                            elif status_type == 'finish':
+                            elif status_type == "finish":
                                 finish_reason = status_content['finish_reason']
                                 if finish_reason == "completed":
                                     logging.info(f"TaskEngine run_task_auto: Detected finish_reason='completed', TASK_COMPLETE Success !")
@@ -167,8 +167,8 @@ class XGATaskEngine:
                                     auto_continue = False
                                     break
                                 elif finish_reason in ["stop", "length"]: # 'length'  occur on some LLM
-                                    auto_continue = True
                                     auto_continue_count += 1
+                                    auto_continue = True if auto_continue_count < self.max_auto_run else False
                                     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:
@@ -177,7 +177,7 @@ class XGATaskEngine:
                                              status_message=f"Task Engine parse chunk error: {parse_error}",
                                              metadata={"content": chunk, "trace": trace})
 
-                        status_content = {"status_type": "error", "role": "system", "message": "Parse response chunk Error"}
+                        status_content = {'status_type': "error", 'role': "system", 'message': "Parse response chunk Error"}
                         error_msg = self.add_response_message(type="status", content=status_content, is_llm_message=False)
                         yield error_msg
             except Exception as run_error:
@@ -186,7 +186,7 @@ class XGATaskEngine:
                                                    status_message=f"Call task_run_once error: {run_error}",
                                                    metadata={"trace": trace})
 
-                status_content = {"status_type": "error", "role": "system", "message": "Call run_task_once error"}
+                status_content = {'status_type': "error", 'role': "system", 'message': "Call run_task_once error"}
                 error_msg = self.add_response_message(type="status", content=status_content, is_llm_message=False)
                 yield error_msg
 
@@ -246,10 +246,10 @@ class XGATaskEngine:
                         # finish reason 1) 'stop': auto run reach max_auto_run limit 2) 'xml_tool_limit_reached' 3) 'length': occur on some LLM
                         tool_result = tool_execution.get("result", None)
                         if tool_result is not None:
-                            success = tool_result.get('success')
+                            success = tool_result['success']
                             output = tool_result.get('output', '')
                             result_type = "answer" if success else "error"
-                            result_content = f"Task execute '{tool_name}' {result_type}: {output}"
+                            result_content = output
                             final_result = XGATaskResult(type=result_type, content=result_content)
                 elif chunk_type == "assistant" and finish_reason == "non_tool_call":
                     assis_content = chunk['content']
@@ -345,7 +345,6 @@ class XGATaskEngine:
             'max_xml_tool_calls'        : 0,
             'use_assistant_chunk_msg'   : self.use_assistant_chunk_msg,
             'tool_exec_strategy'        : "parallel" if self.tool_exec_parallel else "sequential",
-            'tool_exec_on_stream'       : True,
             'xml_adding_strategy'       : "assistant_message", # user_message
             'add_response_msg_func'     : self.add_response_message,
             'create_response_msg_func'  : self.create_response_message,
@@ -404,10 +403,10 @@ if __name__ == "__main__":
                                 custom_tools=["*"],
                                 system_prompt=system_prompt,
                                 session_id="session_1",
-                                agent_id="agent_1",)
-
-        final_result = await engine.run_task_with_final_answer(task_message={'role': "user",
-                                                                             'content': "locate 10.0.0.1 fault and solution"})
+                                agent_id="agent_1"
+                                )
+        user_input = "locate 10.0.0.1 fault and solution"
+        final_result = await engine.run_task_with_final_answer(task_message={'role': "user", 'content': user_input})
         print(f"FINAL RESULT:{final_result}")
 
 

xgae/engine/task_langfuse.py

@@ -42,7 +42,7 @@ class XGATaskLangFuse:
                 trace = XGATaskLangFuse.langfuse.trace(name="xga_task_engine")
                 self.trace_id = trace.id
 
-            metadata = {"task_id": self.task_id, "session_id": self.session_id, "agent_id": self.agent_id}
+            metadata = {'task_id': self.task_id, 'session_id': self.session_id, 'agent_id': self.agent_id}
             self.root_span = trace.span(id=self.task_run_id, name=root_span_name, input=task_message,metadata=metadata)
             self.root_span_name = root_span_name
 

xgae/tools/without_general_tools_app.py

@@ -32,11 +32,13 @@ async def ask(task_id: str,
     print(f"<XGAETools-ask>: task_id={task_id}, text={text}, attachments={attachments}")
     return XGAToolResult(success=True, output=str({"status": "Awaiting user response..."}))
 
+
 @mcp.tool(
     description="end task, destroy sandbox"
 )
 async def end_task(task_id: str) :
     print(f"<XGAETools-end_task> task_id: {task_id}")
+    return XGAToolResult(success=True, output="")
 
 
 

xgae/utils/xml_tool_parser.py

@@ -6,11 +6,11 @@ the XML format with structured function_calls blocks.
 """
 
 import json
-import logging
 import re
 from dataclasses import dataclass
 from typing import List, Dict, Any, Optional, Tuple
 
+from xgae.utils import log_trace
 
 @dataclass
 class XMLToolCall:
@@ -82,7 +82,7 @@ class XMLToolParser:
                     if tool_call:
                         tool_calls.append(tool_call)
                 except Exception as e:
-                    logging.error(f"Error parsing invoke block for {function_name}: {e}")
+                    log_trace(e, f"XMLToolParser: Error parsing function={function_name}, invoke_content:\n{invoke_content}")
         
         return tool_calls
     

{xgae-0.1.15.dist-info → xgae-0.1.17.dist-info}/METADATA

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

xgae-0.1.17.dist-info/RECORD

@@ -0,0 +1,21 @@
+xgae/__init__.py,sha256=OEUd9y9AoGBd3xYerdTTpz9xl4NWkmXeq1a2eil7Qro,72
+xgae/cli_app.py,sha256=ieTaS0b532P_8g9Mz2xda8TOZwYD2hKGnNZiarADAM0,3000
+xgae/engine/engine_base.py,sha256=-QZqLRbQdwRUfbY4l3i7dFfMB-BL267a-wGZR9bMPLc,1662
+xgae/engine/mcp_tool_box.py,sha256=iAWUWP_goHAEeYYMUvTKiMkR2VkEOoRtNmjLV9HaIUg,10415
+xgae/engine/prompt_builder.py,sha256=dqv0xcB-UWQhqISbMCYCTM1ANtthY6xUe7sJ9vPRqQ4,4364
+xgae/engine/task_engine.py,sha256=oEyDORfDqHn7MzodeLrbhITd8TIIZrDIouF09j0twf0,20940
+xgae/engine/task_langfuse.py,sha256=n2bajsHq2Zt3jetel8cSlN2lo42mZgTmbR4Zbx9JvsM,2416
+xgae/engine/responser/non_stream_responser.py,sha256=HkmeFBIoxORhnFVh6XT0i6ixfF5vNzvN7B_BP6FzPVM,5334
+xgae/engine/responser/responser_base.py,sha256=eQ4E1p_PoQISrIOLmjapGRH_RRX-7LOY1P2SrDjvyTM,24624
+xgae/engine/responser/stream_responser.py,sha256=P6IkPniGli8XNq_BVciHeMCJiE0k3lNokTvX1GqRRbc,8046
+xgae/tools/without_general_tools_app.py,sha256=H3JrwA0u7BIKW69yYBPLDpPesklY5quQIMaSVyvJ4s8,3839
+xgae/utils/__init__.py,sha256=ElaGS-zdeZeu6is41u3Ny7lkvhg7BDSK-jMNg9j6K5A,499
+xgae/utils/json_helpers.py,sha256=WD4G5U9Dh8N6J9O0L5wGyqj-NHi09kcXHGdLD_26nlc,3607
+xgae/utils/llm_client.py,sha256=mWRtvtSMk_8NuzFReT9x52ayHlCNVZMZAltD6TQ-xZ8,14404
+xgae/utils/misc.py,sha256=aMWOvJ9VW52q-L9Lkjl1hvXqLwpJAmyxA-Z8jzqFG0U,907
+xgae/utils/setup_env.py,sha256=MqNG0c2QQBDFU1kI8frxr9kB5d08Mmi3QZ1OoorgIa0,2662
+xgae/utils/xml_tool_parser.py,sha256=Mb0d8kBrfyAEvUwW1Nqir-3BgxZRr0ZX3WymQouuFSo,4859
+xgae-0.1.17.dist-info/METADATA,sha256=mdr1LUj6EQejsp3BWcl8_RKvtg5kLwpS4jlW-wi2_1k,310
+xgae-0.1.17.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+xgae-0.1.17.dist-info/entry_points.txt,sha256=SWN01JNAncV0oApEvFzpH0wsXfnFlB1adCH4IrAJxGc,163
+xgae-0.1.17.dist-info/RECORD,,

xgae-0.1.15.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=ohlSN8NLoZR-tQyldoE3gX3cPoAUhmp5-ih0vSk4haM,10415
-xgae/engine/prompt_builder.py,sha256=nw9BEROI6IbmNMLgggUTegfqN8FjbSO2lixTbpho3I4,4365
-xgae/engine/task_engine.py,sha256=6YsibsPkZI526YzqGzRkAT0NoRZBU_NzUXjKZFAm-Ww,20999
-xgae/engine/task_langfuse.py,sha256=86KRHpLs1cVh2b9PfcHzYGGmfxLZ37URI1cMZxKiGis,2416
-xgae/engine/responser/non_stream_responser.py,sha256=5K1FwhlX4-21Z-BJKTqvZo-RdHaG0zqcpgC7t_5_ibI,5442
-xgae/engine/responser/responser_base.py,sha256=UPXFOCT1HWBlyGeRMRE0yBwQgmd67OwIJYMUPZB7lBg,24782
-xgae/engine/responser/stream_responser.py,sha256=1IpOkGWYKSb-RU_tJlxE_RkzOcH_M41qK_WwyuDubdw,15367
-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=WD4G5U9Dh8N6J9O0L5wGyqj-NHi09kcXHGdLD_26nlc,3607
-xgae/utils/llm_client.py,sha256=mWRtvtSMk_8NuzFReT9x52ayHlCNVZMZAltD6TQ-xZ8,14404
-xgae/utils/misc.py,sha256=aMWOvJ9VW52q-L9Lkjl1hvXqLwpJAmyxA-Z8jzqFG0U,907
-xgae/utils/setup_env.py,sha256=MqNG0c2QQBDFU1kI8frxr9kB5d08Mmi3QZ1OoorgIa0,2662
-xgae/utils/xml_tool_parser.py,sha256=wWtmir64xPq39oGF_fe9JRJuhFocSJ0xyG-gMuflKOc,4805
-xgae-0.1.15.dist-info/METADATA,sha256=KiVg_6tDTUNlymMa-ZgyqE6XjADFm8MbwOU_cLCepxE,310
-xgae-0.1.15.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-xgae-0.1.15.dist-info/entry_points.txt,sha256=SWN01JNAncV0oApEvFzpH0wsXfnFlB1adCH4IrAJxGc,163
-xgae-0.1.15.dist-info/RECORD,,