xgae 0.1.15__tar.gz → 0.1.17__tar.gz

{xgae-0.1.15 → xgae-0.1.17}/.env

@@ -1,5 +1,5 @@
 # LOG
-LOG_LEVEL=DEBUG
+LOG_LEVEL=INFO
 LOG_FILE=log/xgae.log
 LOG_ENABLE=True
 
@@ -16,7 +16,7 @@ LLM_API_BASE=https://dashscope.aliyuncs.com/compatible-mode/v1
 LLM_API_KEY=
 LLM_MAX_TOKENS=16384
 LLM_TEMPERATURE=0
-LLM_MAX_RETRIES=2
+LLM_MAX_RETRIES=1
 LLM_STREAM=True
 LLM_ENABLE_THINKING=False
 

{xgae-0.1.15 → xgae-0.1.17}/PKG-INFO

@@ -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.15 → xgae-0.1.17}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "xgae"
-version = "0.1.15"
+version = "0.1.17"
 description = "Extreme General Agent Engine"
 readme = "README.md"
 requires-python = ">=3.13"

xgae-0.1.17/release.md

@@ -0,0 +1,34 @@
+# Release Changelog
+## [0.1.17] - 2025-9-1
+### Target
+- Saved for XGATaskEngine base version
+### Changed
+- Delete StreamTaskResponser tool_exec_on_stream model code
+
+
+## [0.1.15] - 2025-9-1
+### Target
+- Saved for StreamResponser tool_exec_on_stream mode, next release will be abolished
+### Changed
+- Refact TaskResponseProcessor, XGATaskEngine
+### Fixed
+- Fix finish_reason judge logic
+
+
+## [0.1.14] - 2025-8-31
+### Target
+- First complete version is merged 
+### Changed
+- StreamTaskResponser first version
+
+## [0.1.10] - 2025-8-28
+### Target
+- NonStream mode release is completed
+### Changed
+- StreamTaskResponser is original
+- NonStreamTaskResponser first version is completed 
+- Langfuse use 2.x, match for LiteLLM package
+
+## [0.1.7] - 2025-8-25
+### Target
+- Langfuse use 3.x package

{xgae-0.1.15 → xgae-0.1.17}/src/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-0.1.15 → xgae-0.1.17}/src/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-0.1.15 → xgae-0.1.17}/src/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-0.1.15 → xgae-0.1.17}/src/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-0.1.15 → xgae-0.1.17}/src/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-0.1.17/src/xgae/engine/responser/stream_responser.py

@@ -0,0 +1,137 @@
+import logging
+import asyncio
+from typing import List, Dict, Any, Optional, AsyncGenerator, override
+
+from xgae.utils import log_trace
+
+from xgae.engine.responser.responser_base import TaskResponseProcessor, TaskResponserContext, TaskRunContinuousState
+
+
+class StreamTaskResponser(TaskResponseProcessor):
+    def __init__(self, response_context: TaskResponserContext):
+        super().__init__(response_context)
+
+    @override
+    async def process_response(self,
+                               llm_response: AsyncGenerator,
+                               prompt_messages: List[Dict[str, Any]],
+                               continuous_state: TaskRunContinuousState
+                               ) -> AsyncGenerator[Dict[str, Any], None]:
+        accumulated_content = continuous_state['accumulated_content']
+        auto_continue_count = continuous_state['auto_continue_count']
+        can_auto_continue   = continuous_state['auto_continue']
+        msg_sequence        = continuous_state['assistant_msg_sequence']
+
+        use_assistant_chunk_msg = self.response_context["use_assistant_chunk_msg"]
+
+        finish_reason = None
+        should_auto_continue = False
+
+        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:
+                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 # LLM finish reason: ‘stop' , 'length'
+                        logging.info(f"StreamResp：LLM chunk response finish_reason={finish_reason}")
+
+                if hasattr(llm_chunk, 'choices') and llm_chunk.choices:
+                    llm_chunk_msg = llm_chunk.choices[0].delta if hasattr(llm_chunk.choices[0], 'delta') else None
+
+                    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
+
+                        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": msg_sequence}
+                                assistant_chunk_msg = self.create_response_message(type="assistant_chunk",
+                                                                                   content=message_data,
+                                                                                   is_llm_message=True,
+                                                                                   metadata=metadata)
+                                yield assistant_chunk_msg
+                                msg_sequence += 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
+
+            if finish_reason == "xml_tool_limit_reached":
+                xml_chunks = self._extract_xml_chunks(accumulated_content)
+                if len(xml_chunks) > self.max_xml_tool_calls:
+                    limited_chunks = xml_chunks[:self.max_xml_tool_calls]
+                    if limited_chunks:
+                        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)
+            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",
+                                 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}")
+
+            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)
+                yield assistant_msg
+
+            assistant_msg_id = assistant_msg['message_id'] if assistant_msg else None
+
+            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_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_completed_msg = self._add_tool_completed_message(tool_context, tool_message['message_id'])
+                    yield tool_completed_msg
+
+                    yield tool_message
+
+                    if tool_context.function_name in ['ask', 'complete']:
+                        finish_reason = "completed"
+                        break
+
+                    tool_index += 1
+            else:
+                finish_reason = "non_tool_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_msg = self.add_response_message(type="status", content=finish_content, is_llm_message=False)
+                yield finish_msg
+        except Exception as 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, "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)
+            yield error_msg
+
+            raise  # Use bare 'raise' to preserve the original exception with its traceback
+        finally:
+            if should_auto_continue:
+                continuous_state['accumulated_content'] = accumulated_content
+                continuous_state['assistant_msg_sequence'] = msg_sequence
+                logging.warning(f"StreamResp: Updated continuous state for auto-continue with {len(accumulated_content)} chars")

{xgae-0.1.15 → xgae-0.1.17}/src/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-0.1.15 → xgae-0.1.17}/src/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-0.1.15 → xgae-0.1.17}/src/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-0.1.15 → xgae-0.1.17}/src/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 → xgae-0.1.17}/uv.lock

@@ -1257,7 +1257,7 @@ wheels = [
 
 [[package]]
 name = "xgae"
-version = "0.1.15"
+version = "0.1.16"
 source = { editable = "." }
 dependencies = [
     { name = "colorlog" },

xgae-0.1.15/release.md

@@ -1,12 +0,0 @@
-# Relese Changelog
-## [0.1.15] - 2025-9-1
-### Target
-- Saved for StreamResponser tool_exec_on_stream mode, next release will be abolished
-### Changed
-- Improve French translation (#377).
-### Fixed
-- Fix finish_reason judge logic
-
-## [0.1.15] - 2025-8-31
-### Target
-- First complete version 

xgae-0.1.15/src/xgae/engine/responser/stream_responser.py

@@ -1,256 +0,0 @@
-import logging
-import asyncio
-from typing import List, Dict, Any, Optional, AsyncGenerator, override
-
-from xgae.utils import log_trace
-
-from xgae.engine.responser.responser_base import TaskResponseProcessor, TaskResponserContext, TaskRunContinuousState
-
-
-class StreamTaskResponser(TaskResponseProcessor):
-    def __init__(self, response_context: TaskResponserContext):
-        super().__init__(response_context)
-
-    @override
-    async def process_response(self,
-                               llm_response: AsyncGenerator,
-                               prompt_messages: List[Dict[str, Any]],
-                               continuous_state: TaskRunContinuousState
-                               ) -> AsyncGenerator[Dict[str, Any], None]:
-        accumulated_content = continuous_state['accumulated_content']
-        auto_continue_count = continuous_state['auto_continue_count']
-        can_auto_continue   = continuous_state['auto_continue']
-        msg_sequence        = continuous_state['assistant_msg_sequence']
-
-        use_assistant_chunk_msg = self.response_context["use_assistant_chunk_msg"]
-
-        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}, "
-                     f"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 llm_chunk.choices[0].finish_reason:
-                        finish_reason = llm_chunk.choices[0].finish_reason # LLM finish reason: ‘stop' , 'length'
-                        logging.info(f"StreamResp：LLM chunk response finish_reason={finish_reason}")
-
-                if hasattr(llm_chunk, 'choices') and llm_chunk.choices:
-                    llm_chunk_msg = llm_chunk.choices[0].delta if hasattr(llm_chunk.choices[0], 'delta') else None
-
-                    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": msg_sequence}
-                                assistant_chunk_msg = self.create_response_message(type="assistant_chunk",
-                                                                                   content=message_data,
-                                                                                   is_llm_message=True,
-                                                                                   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)
-                if len(xml_chunks) > self.max_xml_tool_calls:
-                    limited_chunks = xml_chunks[:self.max_xml_tool_calls]
-                    if limited_chunks:
-                        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)
-            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",
-                                 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)}")
-
-            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)
-                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_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_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
-
-                        yield tool_message
-
-                        if tool_context.function_name in ['ask', 'complete']:
-                            finish_reason = "completed"
-                            break
-
-                        tool_index += 1
-            else:
-                finish_reason = "non_tool_call"
-                logging.warning(f"StreamResp: tool_calls is empty, No Tool need to call !")
-
-            if 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:
-            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, "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)
-            yield error_msg
-
-            raise  # Use bare 'raise' to preserve the original exception with its traceback
-        finally:
-            if should_auto_continue:
-                continuous_state['accumulated_content'] = accumulated_content
-                continuous_state['assistant_msg_sequence'] = msg_sequence
-                logging.warning(f"StreamResp: Updated continuous state for auto-continue with {len(accumulated_content)} chars")