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

xgae/engine/responser/stream_responser.py

@@ -3,7 +3,7 @@ import asyncio
 from typing import List, Dict, Any, Optional, AsyncGenerator, override
 
 from xgae.utils import log_trace
-from xgae.utils.json_helpers import format_for_yield
+
 from xgae.engine.responser.responser_base import TaskResponseProcessor, TaskResponserContext, TaskRunContinuousState
 
 
@@ -17,27 +17,30 @@ class StreamTaskResponser(TaskResponseProcessor):
                                prompt_messages: List[Dict[str, Any]],
                                continuous_state: TaskRunContinuousState
                                ) -> AsyncGenerator[Dict[str, Any], None]:
-        accumulated_content = continuous_state.get('accumulated_content', "")
-        auto_continue_count = continuous_state.get('auto_continue_count', 0)
-        can_auto_continue = continuous_state.get("auto_continue", False)
-        use_assistant_chunk_msg = self.response_context.get("use_assistant_chunk_msg")
+        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
-        sequence = continuous_state.get('assistant_msg_sequence', 0)
 
         pending_tool_executions = []
         yielded_tool_indices = set()  # Track which tool statuses have been yielded
         tool_results_buffer = []  # Store (tool_call, result, tool_index, context)
         tool_index = 0
+        
         current_xml_content = accumulated_content  # Track XML content for streaming detection
 
-        logging.info(f"=== StreamResp：tool_execute_on_stream={self.tool_execute_on_stream}, auto_continue_count={auto_continue_count}, accumulated_content_len={len(accumulated_content)}")
+        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
+                        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:
@@ -52,13 +55,16 @@ class StreamTaskResponser(TaskResponseProcessor):
                         if self.max_xml_tool_calls <= 0 or xml_tool_call_count < self.max_xml_tool_calls:
                             if use_assistant_chunk_msg:
                                 message_data = {"role": "assistant", "content": chunk_content}
-                                metadata = {"sequence": sequence}
-                                assistant_chunk_msg = self.create_response_message(type="assistant_chunk",content=message_data,
-                                                                                   is_llm_message=True,metadata=metadata)
+                                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_execute_on_stream:
+                            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)
@@ -71,45 +77,48 @@ class StreamTaskResponser(TaskResponseProcessor):
 
                                         # Yield tool start status immediately
                                         tool_start_msg = self._add_tool_start_message(tool_context)
-                                        if tool_start_msg:
-                                            yield format_for_yield(tool_start_msg)
-                                            yielded_tool_indices.add(tool_index)
+                                        yield tool_start_msg
+                                        yielded_tool_indices.add(tool_index)
 
                                         # Create async execution task
                                         execution_task = asyncio.create_task(self._execute_tool(tool_call))
-                                        pending_tool_executions.append({"task": execution_task,"tool_call": tool_call,"tool_index": tool_index,
-                                                                        "context": tool_context,"parsing_details": parsing_details})
+                                        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
-
-                            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
+            # 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"Waiting for {len(pending_tool_executions)} pending streamed 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]
+                pending_tasks = [execution['task'] for execution in pending_tool_executions]
                 done, _ = await asyncio.wait(pending_tasks)
 
-                for execution in pending_tool_executions:
-                    tool_idx = execution.get("tool_index", -1)
-                    context = execution["context"]
+                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 execution["task"].done():
-                            result = execution["task"].result()
-                            context.result = result
-                            tool_results_buffer.append((execution["tool_call"],result,tool_idx,context))
+                        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"Task for tool index {tool_idx} not done after wait.")
+                            logging.warning(f"StreamResp: Task for tool index {pend_tool_index} is not done after wait.")
                     except Exception as e:
-                        logging.error(f"Error getting result for pending tool execution {tool_idx}: {str(e)}")
-                        context.error = e
+                        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)
@@ -124,9 +133,9 @@ class StreamTaskResponser(TaskResponseProcessor):
             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_execution_strategy}, "
-                                                f"parsed_xml_data_len={len(parsed_xml_data)}, accumulated_content={len(accumulated_content)}, "
-                                                f"should_auto_continue={should_auto_continue}, pending_executions={len(pending_tool_executions)}")
+                                 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:
@@ -139,19 +148,19 @@ class StreamTaskResponser(TaskResponseProcessor):
 
             # Update assistant_message_id for streaming tool contexts
             assistant_msg_id = assistant_msg['message_id'] if assistant_msg else None
-            for execution in pending_tool_executions:
-                if not execution["context"].assistant_message_id:
-                    execution["context"].assistant_message_id = assistant_msg_id
+            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_execute_on_stream:
+                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 execution in pending_tool_executions:
-                        streamed_tool_indices.add(execution["tool_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):
@@ -160,8 +169,8 @@ class StreamTaskResponser(TaskResponseProcessor):
 
                         # Check if this tool was already executed during streaming
                         already_executed = False
-                        for execution in pending_tool_executions:
-                            exec_tool_call = execution["tool_call"]
+                        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
@@ -177,28 +186,27 @@ class StreamTaskResponser(TaskResponseProcessor):
                             tool_context = self._create_tool_context(tool_call, t_idx, assistant_msg_id,parsing_details)
 
                             tool_start_msg = self._add_tool_start_message(tool_context)
-                            yield format_for_yield(tool_start_msg)
+                            yield tool_start_msg
 
                             result = await self._execute_tool(tool_call)
                             tool_context.result = result
                             tool_results_buffer.append((tool_call, result, t_idx, tool_context))
 
                     # Process all tool results
-                    for tool_call, result, t_idx, context in tool_results_buffer:
+                    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(context, 'parsing_details', None))
+                                                               getattr(pend_tool_context, 'parsing_details', None))
 
-                        tool_completed_msg = self._add_tool_completed_message(context,tool_message['message_id'] if tool_message else None)
-                        yield format_for_yield(tool_completed_msg)
+                        tool_completed_msg = self._add_tool_completed_message(pend_tool_context,tool_message['message_id'] if tool_message else None)
+                        yield tool_completed_msg
 
-                        if tool_message:
-                            yield format_for_yield(tool_message)
+                        yield tool_message
 
-                        if tool_completed_msg["metadata"].get("agent_should_terminate") == "true":
+                        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_execution_strategy)
+                    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]
@@ -208,16 +216,16 @@ class StreamTaskResponser(TaskResponseProcessor):
                         tool_context = self._create_tool_context(tool_call, tool_index, assistant_msg_id,parsing_details, tool_result)
 
                         tool_start_msg = self._add_tool_start_message(tool_context)
-                        yield format_for_yield(tool_start_msg)
+                        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 format_for_yield(tool_completed_msg)
+                        yield tool_completed_msg
 
-                        yield format_for_yield(tool_message)
+                        yield tool_message
 
-                        if tool_completed_msg["metadata"].get("agent_should_terminate") == "true":
+                        if tool_context.function_name in ['ask', 'complete']:
                             finish_reason = "completed"
                             break
 
@@ -229,7 +237,7 @@ class StreamTaskResponser(TaskResponseProcessor):
             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 format_for_yield(finish_msg)
+                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",
@@ -238,12 +246,11 @@ class StreamTaskResponser(TaskResponseProcessor):
 
             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 format_for_yield(error_msg)
+            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'] = sequence
-                logging.warning(
-                    f"StreamResp: Updated continuous state for auto-continue with {len(accumulated_content)} chars")
+                continuous_state['assistant_msg_sequence'] = msg_sequence
+                logging.warning(f"StreamResp: Updated continuous state for auto-continue with {len(accumulated_content)} chars")

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,28 +145,28 @@ 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':
+                                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
+                                elif finish_reason in ["stop", "length"]: # 'length'  occur on some LLM
                                     auto_continue = True
                                     auto_continue_count += 1
                                     update_continuous_state(auto_continue_count, auto_continue)
@@ -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.get('success')
+                            output = tool_result.get('output', '')
                             result_type = "answer" if success else "error"
                             result_content = f"Task execute '{tool_name}' {result_type}: {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,20 @@ 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",
+            '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,
+            'tool_box'                  : self.tool_box,
+            'task_langfuse'             : self.task_langfuse,
         }
         return response_context
 
@@ -361,24 +361,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 +401,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",)
+
+        final_result = await engine.run_task_with_final_answer(task_message={'role': "user",
+                                                                             'content': "locate 10.0.0.1 fault and solution"})
+        print(f"FINAL RESULT:{final_result}")
 
 
     asyncio.run(main())