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

xgae/engine/task_engine.py

@@ -7,7 +7,7 @@ from uuid import uuid4
 
 from xgae.utils import log_trace, to_bool
 from xgae.utils.llm_client import LLMClient, LLMConfig
-from xgae.utils.json_helpers import format_for_yield
+
 
 from xgae.engine.engine_base import XGAResponseMsgType, XGAResponseMessage, XGAToolBox, XGATaskResult
 from xgae.engine.task_langfuse import XGATaskLangFuse
@@ -28,32 +28,32 @@ class XGATaskEngine:
                  llm_config: Optional[LLMConfig] = None,
                  prompt_builder: Optional[XGAPromptBuilder] = None,
                  tool_box: Optional[XGAToolBox] = None):
-        self.task_id = task_id if task_id else f"xga_task_{uuid4()}"
-        self.agent_id = agent_id
+        self.task_id    = task_id if task_id else f"xga_task_{uuid4()}"
+        self.agent_id   = agent_id
         self.session_id = session_id
 
         self.llm_client = LLMClient(llm_config)
         self.model_name = self.llm_client.model_name
-        self.is_stream = self.llm_client.is_stream
+        self.is_stream  = self.llm_client.is_stream
 
-        self.prompt_builder = prompt_builder or XGAPromptBuilder(system_prompt)
-        self.tool_box: XGAToolBox = tool_box or XGAMcpToolBox()
-        self.task_langfuse: XGATaskLangFuse = None
+        self.prompt_builder                 = prompt_builder or XGAPromptBuilder(system_prompt)
+        self.tool_box: XGAToolBox           = tool_box or XGAMcpToolBox()
 
         self.general_tools:List[str] = general_tools
-        self.custom_tools:List[str] = custom_tools
-        self.task_response_msgs: List[XGAResponseMessage] = []
+        self.custom_tools:List[str]  = custom_tools
 
-        max_auto_run = max_auto_run if max_auto_run  else int(os.getenv("MAX_AUTO_RUN", 15))
+        max_auto_run = max_auto_run if max_auto_run  else int(os.getenv('MAX_AUTO_RUN', 15))
         self.max_auto_run: int = 1 if max_auto_run <= 1 else max_auto_run
 
-        self.use_assistant_chunk_msg = to_bool(os.getenv("USE_ASSISTANT_CHUNK_MSG", False))
+        self.use_assistant_chunk_msg = to_bool(os.getenv('USE_ASSISTANT_CHUNK_MSG', False))
         self.tool_exec_parallel = True if tool_exec_parallel is None else tool_exec_parallel
 
         self.task_no = -1
         self.task_run_id :str = None
         self.task_prompt :str = None
+        self.task_langfuse: XGATaskLangFuse = None
 
+        self.task_response_msgs: List[XGAResponseMessage] = []
 
     async def run_task_with_final_answer(self,
                                          task_message: Dict[str, Any],
@@ -126,14 +126,15 @@ class XGATaskEngine:
 
     async def _run_task_auto(self) -> AsyncGenerator[Dict[str, Any], None]:
         continuous_state: TaskRunContinuousState = {
-            "accumulated_content": "",
-            "auto_continue_count": 0,
-            "auto_continue": False if self.max_auto_run <= 1 else True
+            'accumulated_content'   : "",
+            'auto_continue_count'   : 0,
+            'auto_continue'         : False if self.max_auto_run <= 1 else True,
+            'assistant_msg_sequence': 0
         }
 
         def update_continuous_state(_auto_continue_count,  _auto_continue):
-            continuous_state["auto_continue_count"] = _auto_continue_count
-            continuous_state["auto_continue"] = _auto_continue
+            continuous_state['auto_continue_count'] = _auto_continue_count
+            continuous_state['auto_continue'] = _auto_continue
 
         auto_continue_count = 0
         auto_continue = True
@@ -144,30 +145,30 @@ class XGATaskEngine:
                 async for chunk in self._run_task_once(continuous_state):
                     yield chunk
                     try:
-                        if chunk.get("type") == "status":
-                            content = json.loads(chunk.get('content', '{}'))
-                            status_type = content.get('status_type', None)
+                        if chunk['type'] == "status":
+                            status_content = chunk['content']
+                            status_type = status_content['status_type']
                             if status_type == "error":
-                                logging.error(f"TaskEngine run_task_auto: task_response error: {chunk.get('message', 'Unknown error')}")
+                                logging.error(f"TaskEngine run_task_auto: task_response error: {chunk.get('message')}")
                                 auto_continue = False
                                 break
-                            elif status_type == 'finish':
-                                finish_reason = content.get('finish_reason', None)
-                                if finish_reason == 'completed':
+                            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 !")
                                     auto_continue = False
                                     break
-                                elif finish_reason == 'xml_tool_limit_reached':
+                                elif finish_reason == "xml_tool_limit_reached":
                                     logging.warning(f"TaskEngine run_task_auto: Detected finish_reason='xml_tool_limit_reached', stop auto-continue")
                                     auto_continue = False
                                     break
-                                elif finish_reason == 'non_tool_call':
+                                elif finish_reason == "non_tool_call":
                                     logging.warning(f"TaskEngine run_task_auto: Detected finish_reason='non_tool_call', stop auto-continue")
                                     auto_continue = False
                                     break
-                                elif finish_reason == 'stop' or finish_reason == 'length': # 'length' never occur
-                                    auto_continue = True
+                                elif finish_reason in ["stop", "length"]: # 'length'  occur on some LLM
                                     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:
@@ -176,18 +177,18 @@ class XGATaskEngine:
                                              status_message=f"Task Engine parse chunk error: {parse_error}",
                                              metadata={"content": chunk, "trace": trace})
 
-                        content = {"role": "system", "status_type": "error", "message": "Parse response chunk Error"}
-                        error_msg = self.add_response_message(type="status", content=content, is_llm_message=False)
-                        yield format_for_yield(error_msg)
+                        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:
                 trace = log_trace(run_error, "TaskEngine run_task_auto: Call task_run_once")
                 self.task_langfuse.root_span.event(name="engine_task_run_once_error", level="ERROR",
                                                    status_message=f"Call task_run_once error: {run_error}",
                                                    metadata={"trace": trace})
 
-                content = {"role": "system", "status_type": "error", "message": "Call run_task_once error"}
-                error_msg = self.add_response_message(type="status", content=content, is_llm_message=False)
-                yield format_for_yield(error_msg)
+                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
 
 
     async def _run_task_once(self, continuous_state: TaskRunContinuousState) -> AsyncGenerator[Dict[str, Any], None]:
@@ -206,8 +207,6 @@ class XGATaskEngine:
         auto_count = continuous_state.get("auto_continue_count")
         langfuse_metadata = self.task_langfuse.create_llm_langfuse_meta(auto_count)
 
-        self.task_langfuse.root_span.event(name="engine_start_create_completion", level="DEFAULT",
-                                           status_message=(f"Task Engine start create_completion llm_messages len={len(llm_messages)}"))
         llm_response = await self.llm_client.create_completion(llm_messages, langfuse_metadata)
         response_processor = self._create_response_processer()
 
@@ -222,44 +221,45 @@ class XGATaskEngine:
         try:
             finish_reason = ''
             for chunk in reverse_chunks:
-                chunk_type = chunk.get("type")
+                chunk_type = chunk['type']
                 if chunk_type == "status":
-                    status_content = json.loads(chunk.get('content', '{}'))
-                    status_type = status_content.get('status_type', None)
+                    status_content = chunk['content']
+                    status_type = status_content['status_type']
                     if status_type == "error":
-                        error = status_content.get('message', 'Unknown error')
+                        error = status_content['message']
                         final_result = XGATaskResult(type="error", content=error)
                     elif status_type == "finish":
-                        finish_reason = status_content.get('finish_reason', None)
-                elif chunk_type == "tool" and finish_reason in ['completed', 'stop', 'xml_tool_limit_reached']:
-                    tool_content = json.loads(chunk.get('content', '{}'))
+                        finish_reason = status_content['finish_reason']
+                elif chunk_type == "tool" and finish_reason in ['completed', 'stop', 'xml_tool_limit_reached', 'length']:
+                    tool_content= chunk['content']
                     tool_execution = tool_content.get('tool_execution')
                     tool_name = tool_execution.get('function_name')
                     if tool_name == "complete":
-                        result_content = tool_execution["arguments"].get("text", "Task completed with no answer")
-                        attachments = tool_execution["arguments"].get("attachments", None)
+                        result_content = tool_execution['arguments'].get('text', "Task completed with no answer")
+                        attachments = tool_execution['arguments'].get('attachments', None)
                         final_result = XGATaskResult(type="answer", content=result_content, attachments=attachments)
                     elif tool_name == "ask":
                         result_content = tool_execution["arguments"].get("text", "Task ask for more info")
                         attachments = tool_execution["arguments"].get("attachments", None)
                         final_result = XGATaskResult(type="ask", content=result_content, attachments=attachments)
                     else:
+                        # 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")
-                            output = tool_result.get("output")
+                            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.get('content', {})
-                    result_content = assis_content.get("content", "LLM output is empty")
+                elif chunk_type == "assistant" and finish_reason == "non_tool_call":
+                    assis_content = chunk['content']
+                    result_content = assis_content.get('content', "LLM output is empty")
                     final_result = XGATaskResult(type="answer", content=result_content)
 
                 if final_result:
                     break
 
-            if final_result and finish_reason == "completed":
+            if final_result and (finish_reason == "completed" or finish_reason == "non_tool_call"):
                 logging.info(f"✅ FINAL_RESULT: finish_reason={finish_reason}, final_result={final_result}")
             elif final_result is not None:
                 logging.warning(f"⚠️ FINAL_RESULT: finish_reason={finish_reason}, final_result={final_result}")
@@ -281,18 +281,18 @@ class XGATaskEngine:
                              is_llm_message: bool,
                              metadata: Optional[Dict[str, Any]]=None)-> XGAResponseMessage:
         metadata = metadata or {}
-        metadata["task_id"] = self.task_id
+        metadata["task_id"]     = self.task_id
         metadata["task_run_id"] = self.task_run_id
-        metadata["trace_id"] = self.task_langfuse.trace_id
-        metadata["session_id"] = self.session_id
-        metadata["agent_id"] = self.agent_id
+        metadata["trace_id"]    = self.task_langfuse.trace_id
+        metadata["session_id"]  = self.session_id
+        metadata["agent_id"]    = self.agent_id
 
         message = XGAResponseMessage(
-            message_id = f"xga_msg_{uuid4()}",
-            type = type,
-            is_llm_message=is_llm_message,
-            content = content,
-            metadata = metadata
+            message_id      = f"xga_msg_{uuid4()}",
+            type            = type,
+            is_llm_message  = is_llm_message,
+            content         = content,
+            metadata        = metadata
         )
 
         return message
@@ -308,12 +308,12 @@ class XGATaskEngine:
     def get_history_llm_messages (self) -> List[Dict[str, Any]]:
         llm_messages = []
         for message in self.task_response_msgs:
-            if message["is_llm_message"]:
+            if message['is_llm_message']:
                 llm_messages.append(message)
 
         response_llm_contents = []
         for llm_message in llm_messages:
-            content = llm_message["content"]
+            content = llm_message['content']
             if isinstance(content, str):
                 try:
                     _content = json.loads(content)
@@ -327,7 +327,7 @@ class XGATaskEngine:
 
     def _create_response_processer(self) -> TaskResponseProcessor:
         response_context = self._create_response_context()
-        is_stream = response_context.get("is_stream", False)
+        is_stream = response_context['is_stream']
         if is_stream:
             from xgae.engine.responser.stream_responser import StreamTaskResponser
             return StreamTaskResponser(response_context)
@@ -337,20 +337,19 @@ class XGATaskEngine:
 
     def _create_response_context(self) -> TaskResponserContext:
         response_context: TaskResponserContext = {
-            "is_stream": self.is_stream,
-            "task_id": self.task_id,
-            "task_run_id": self.task_run_id,
-            "task_no": self.task_no,
-            "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_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,
-            "tool_box": self.tool_box,
-            "task_langfuse": self.task_langfuse,
+            'is_stream'                 : self.is_stream,
+            'task_id'                   : self.task_id,
+            'task_run_id'               : self.task_run_id,
+            'task_no'                   : self.task_no,
+            'model_name'                : self.model_name,
+            '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",
+            'xml_adding_strategy'       : "assistant_message", # user_message
+            'add_response_msg_func'     : self.add_response_message,
+            'create_response_msg_func'  : self.create_response_message,
+            'tool_box'                  : self.tool_box,
+            'task_langfuse'             : self.task_langfuse,
         }
         return response_context
 
@@ -361,24 +360,24 @@ class XGATaskEngine:
 
     def _logging_reponse_chunk(self, chunk, auto_count: int)-> None:
         try:
-            chunk_type = chunk.get('type', 'unknown')
+            chunk_type = chunk['type']
             prefix = ""
-            if chunk_type == 'status':
-                content = json.loads(chunk.get('content', '{}'))
-                status_type = content.get('status_type', "empty")
+            if chunk_type == "status":
+                status_content = chunk['content']
+                status_type = status_content.get('status_type', "empty")
                 if status_type in ["tool_started", "tool_completed"]:
                     return
                 prefix = "-" + status_type
-            elif chunk_type == 'tool':
-                tool_content = json.loads(chunk.get('content', '{}'))
+            elif chunk_type == "tool":
+                tool_content = chunk['content']
                 tool_execution = tool_content.get('tool_execution')
                 tool_name = tool_execution.get('function_name')
                 prefix = "-" + tool_name
 
-            content = chunk.get('content', '')
-            pretty_content = content
-            if isinstance(content, dict):
-                pretty_content = json.dumps(content, ensure_ascii=False, indent=2)
+            status_content = chunk['content']
+            pretty_content = status_content
+            if isinstance(status_content, dict):
+                pretty_content = json.dumps(status_content, ensure_ascii=False, indent=2)
 
             if chunk_type == "assistant_chunk":
                 logging.debug(f"TASK_RESP_CHUNK[{auto_count}]<{chunk_type}{prefix}> content: {pretty_content}")
@@ -401,15 +400,14 @@ if __name__ == "__main__":
         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,
-                                    general_tools=[],
-                                    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"})
-        print("FINAL RESULT:", final_result)
+                                custom_tools=["*"],
+                                system_prompt=system_prompt,
+                                session_id="session_1",
+                                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}")
 
 
     asyncio.run(main())

xgae/engine/task_langfuse.py

@@ -18,14 +18,14 @@ class XGATaskLangFuse:
         if XGATaskLangFuse.langfuse is None:
             XGATaskLangFuse.langfuse =  setup_langfuse()
 
-        self.session_id = session_id
-        self.task_id = task_id
-        self.task_run_id = task_run_id
-        self.task_no = task_no
-        self.agent_id = agent_id
+        self.session_id     = session_id
+        self.task_id        = task_id
+        self.task_run_id    = task_run_id
+        self.task_no        = task_no
+        self.agent_id       = agent_id
 
-        self.trace_id = None
-        self.root_span = None
+        self.trace_id       = None
+        self.root_span      = None
         self.root_span_name = None
 
 
@@ -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
 
@@ -58,8 +58,8 @@ class XGATaskLangFuse:
         generation_name = f"xga_task_engine_llm_completion[{self.task_no}]({llm_count})"
         generation_id = f"{self.task_run_id}({llm_count})"
         return LangfuseMetadata(
-            generation_name=generation_name,
-            generation_id=generation_id,
-            existing_trace_id=self.trace_id,
-            session_id=self.session_id,
+            generation_name     = generation_name,
+            generation_id       = generation_id,
+            existing_trace_id   = self.trace_id,
+            session_id          = self.session_id,
         )

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/json_helpers.py

@@ -137,32 +137,3 @@ def to_json_string(value: Any) -> str:
     # For all other types, convert to JSON
     return json.dumps(value)
 
-
-def format_for_yield(message_object: Dict[str, Any]) -> Dict[str, Any]:
-    """
-    Format a message object for yielding, ensuring content and metadata are JSON strings.
-    
-    This maintains backward compatibility with clients expecting JSON strings
-    while the database now stores proper objects.
-    
-    Args:
-        message_object: The message object from the database
-        
-    Returns:
-        Message object with content and metadata as JSON strings
-    """
-    if not message_object:
-        return message_object
-        
-    # Create a copy to avoid modifying the original
-    formatted = message_object.copy()
-    
-    # Ensure content is a JSON string
-    if 'content' in formatted and not isinstance(formatted['content'], str):
-        formatted['content'] = json.dumps(formatted['content'], ensure_ascii=False, indent=2)
-        
-    # Ensure metadata is a JSON string
-    if 'metadata' in formatted and not isinstance(formatted['metadata'], str):
-        formatted['metadata'] = json.dumps(formatted['metadata'], ensure_ascii=False, indent=2)
-        
-    return formatted 

xgae/utils/llm_client.py

@@ -51,34 +51,34 @@ class LLMClient:
         self._init_langfuse()
 
         llm_config = llm_config or LLMConfig()
-        self.max_retries = int(os.getenv("LLM_MAX_RETRIES", 1))
+        self.max_retries = int(os.getenv('LLM_MAX_RETRIES', 1))
 
-        env_llm_model = os.getenv("LLM_MODEL", "openai/qwen3-235b-a22b")
-        env_llm_api_key = os.getenv("LLM_API_KEY")
-        env_llm_api_base = os.getenv("LLM_API_BASE", "https://dashscope.aliyuncs.com/compatible-mode/v1")
-        env_llm_max_tokens = int(os.getenv("LLM_MAX_TOKENS", 16384))
-        env_llm_temperature = float(os.getenv("LLM_TEMPERATURE", 0.7))
-        env_llm_stream = to_bool(os.getenv("LLM_STREAM", False))
-        env_llm_enable_thinking = to_bool(os.getenv("LLM_ENABLE_THINKING", False))
+        env_llm_model           = os.getenv('LLM_MODEL', "openai/qwen3-235b-a22b")
+        env_llm_api_key         = os.getenv('LLM_API_KEY')
+        env_llm_api_base        = os.getenv('LLM_API_BASE', "https://dashscope.aliyuncs.com/compatible-mode/v1")
+        env_llm_max_tokens      = int(os.getenv('LLM_MAX_TOKENS', 16384))
+        env_llm_temperature     = float(os.getenv('LLM_TEMPERATURE', 0.7))
+        env_llm_stream          = to_bool(os.getenv('LLM_STREAM', False))
+        env_llm_enable_thinking = to_bool(os.getenv('LLM_ENABLE_THINKING', False))
 
         llm_config_params = {
-            "model":            llm_config.get("model", env_llm_model),
-            "model_name":       llm_config.get("model_name", env_llm_model),
-            "model_id":         llm_config.get("model_id", None),
-            "api_key":          llm_config.get("api_key", env_llm_api_key),
-            "api_base":         llm_config.get("api_base", env_llm_api_base),
-            "temperature":      llm_config.get("temperature", env_llm_temperature),
-            "max_tokens":       llm_config.get("max_tokens", env_llm_max_tokens),
-            "stream":           llm_config.get("stream", env_llm_stream),
-            "enable_thinking":  llm_config.get("enable_thinking", env_llm_enable_thinking),
-            "reasoning_effort": llm_config.get("reasoning_effort", 'low'),
-            "response_format":  llm_config.get("response_format", None),
-            "top_p":            llm_config.get("top_p", None),
-            "tools":            None,
-            "tool_choice":      "none",
+            'model':            llm_config.get('model', env_llm_model),
+            'model_name':       llm_config.get('model_name', env_llm_model),
+            'model_id':         llm_config.get('model_id', None),
+            'api_key':          llm_config.get('api_key', env_llm_api_key),
+            'api_base':         llm_config.get('api_base', env_llm_api_base),
+            'temperature':      llm_config.get('temperature', env_llm_temperature),
+            'max_tokens':       llm_config.get('max_tokens', env_llm_max_tokens),
+            'stream':           llm_config.get('stream', env_llm_stream),
+            'enable_thinking':  llm_config.get('enable_thinking', env_llm_enable_thinking),
+            'reasoning_effort': llm_config.get('reasoning_effort', "low"),
+            'response_format':  llm_config.get('response_format', None),
+            'top_p':            llm_config.get('top_p', None),
+            'tools':            None,
+            'tool_choice':      'none',
         }
 
-        self.model_name = llm_config_params["model_name"]
+        self.model_name = llm_config_params['model_name']
         self.is_stream = llm_config_params['stream']
 
         self.lite_llm_params = self._prepare_llm_params(llm_config_params)

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
     
@@ -95,8 +95,8 @@ class XMLToolParser:
         """Parse a single invoke block into an XMLToolCall."""
         parameters = {}
         parsing_details = {
-            "function_name": function_name,
-            "raw_parameters": {}
+            'function_name': function_name,
+            'raw_parameters': {}
         }
 
         param_matches = self.PARAMETER_PATTERN.findall(invoke_content)
@@ -104,7 +104,7 @@ class XMLToolParser:
             param_value = param_value.strip()
             parsed_value = self._parse_parameter_value(param_value)
             parameters[param_name] = parsed_value
-            parsing_details["raw_parameters"][param_name] = param_value
+            parsing_details['raw_parameters'][param_name] = param_value
         
         # Extract the raw XML for this specific invoke
         invoke_pattern = re.compile(
@@ -115,10 +115,10 @@ class XMLToolParser:
         raw_xml = raw_xml_match.group(0) if raw_xml_match else f"<invoke name=\"{function_name}\">...</invoke>"
         
         return XMLToolCall(
-            function_name=function_name,
-            parameters=parameters,
-            raw_xml=raw_xml,
-            parsing_details=parsing_details
+            function_name   = function_name,
+            parameters      = parameters,
+            raw_xml         = raw_xml,
+            parsing_details = parsing_details
         )
     
     def _parse_parameter_value(self, value: str) -> Any:

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

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

xgae-0.1.16.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.16.dist-info/METADATA,sha256=i9XjQf1XQ-yOhFfVzz7tnOJwLPQOQFjF2gy1XmN7zmY,310
+xgae-0.1.16.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+xgae-0.1.16.dist-info/entry_points.txt,sha256=SWN01JNAncV0oApEvFzpH0wsXfnFlB1adCH4IrAJxGc,163
+xgae-0.1.16.dist-info/RECORD,,

xgae-0.1.14.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=ot1lpMw77e6VLe4UPCJw3TxcjIXBqzg_qphdmHmW2XQ,10414
-xgae/engine/prompt_builder.py,sha256=X9bS7YIms6LYplCpNHeUmi74xFP5MwFXmXNqOt1Xz-Q,4356
-xgae/engine/task_engine.py,sha256=ayv4DTwDArMRQ_CPBxt8tdk7E7JPB0Osb5jxlikMsxM,21052
-xgae/engine/task_langfuse.py,sha256=b0aJ_Di-WDcYzi0TFCvcKWxkBz7PYP2jx3N52OptQMs,2349
-xgae/engine/responser/non_stream_responser.py,sha256=_DkyBZ50N1Tm8K0W16MD5vgx2Eu_amt2LgfN_7Ej1Us,5542
-xgae/engine/responser/responser_base.py,sha256=mgioPh1atCd5PueumyxAN7eB87SB7wOSB_mLTI-6lIg,25250
-xgae/engine/responser/stream_responser.py,sha256=AVEs0pkLZNPzXcp5A1iFNjDb-aUy7_NWRqThCZqmIyQ,14852
-xgae/tools/without_general_tools_app.py,sha256=FGMV6njcOKwwfitc0j_nUov0RC-eWlhO1IP8_KHz1tQ,3788
-xgae/utils/__init__.py,sha256=ElaGS-zdeZeu6is41u3Ny7lkvhg7BDSK-jMNg9j6K5A,499
-xgae/utils/json_helpers.py,sha256=ubp-dOCeROnZv7JHARRdmDIO5Npdwzrt8AWo3SMv0kI,4705
-xgae/utils/llm_client.py,sha256=6e3kzx73QN6z2SYMQQFmrmODj2Rk-GPJYIxBcFZhMQE,14361
-xgae/utils/misc.py,sha256=aMWOvJ9VW52q-L9Lkjl1hvXqLwpJAmyxA-Z8jzqFG0U,907
-xgae/utils/setup_env.py,sha256=MqNG0c2QQBDFU1kI8frxr9kB5d08Mmi3QZ1OoorgIa0,2662
-xgae/utils/xml_tool_parser.py,sha256=I9xAZC_ElwBY19PNUq-WLXe9FSIJMeAv2Xs-VlajI7Y,4782
-xgae-0.1.14.dist-info/METADATA,sha256=WGVnO2sWvP3EM98tObwlafmkfIRHl2oSTUn5rBsZ3HM,310
-xgae-0.1.14.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-xgae-0.1.14.dist-info/entry_points.txt,sha256=SWN01JNAncV0oApEvFzpH0wsXfnFlB1adCH4IrAJxGc,163
-xgae-0.1.14.dist-info/RECORD,,