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

xgae/engine/task_engine.py

@@ -5,7 +5,7 @@ import os
 from typing import List, Any, Dict, Optional, AsyncGenerator, Union, Literal
 from uuid import uuid4
 
-from xgae.utils import handle_error
+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
 
@@ -46,6 +46,8 @@ class XGATaskEngine:
 
         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.tool_exec_parallel = True if tool_exec_parallel is None else tool_exec_parallel
 
         self.task_no = -1
@@ -67,7 +69,7 @@ class XGATaskEngine:
                 chunks.append(chunk)
 
             if len(chunks) > 0:
-                final_result = self._parse_final_result(chunks)
+                final_result = self.parse_final_result(chunks)
             else:
                 final_result = XGATaskResult(type="error", content="LLM Answer is Empty")
 
@@ -123,16 +125,16 @@ class XGATaskEngine:
 
 
     async def _run_task_auto(self) -> AsyncGenerator[Dict[str, Any], None]:
-        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: TaskRunContinuousState = {
             "accumulated_content": "",
             "auto_continue_count": 0,
             "auto_continue": False if self.max_auto_run <= 1 else True
         }
 
+        def update_continuous_state(_auto_continue_count,  _auto_continue):
+            continuous_state["auto_continue_count"] = _auto_continue_count
+            continuous_state["auto_continue"] = _auto_continue
+
         auto_continue_count = 0
         auto_continue = True
         while auto_continue and auto_continue_count < self.max_auto_run:
@@ -146,38 +148,44 @@ class XGATaskEngine:
                             content = json.loads(chunk.get('content', '{}'))
                             status_type = content.get('status_type', None)
                             if status_type == "error":
-                                logging.error(f"run_task_auto: task_response error: {chunk.get('message', 'Unknown error')}")
+                                logging.error(f"TaskEngine run_task_auto: task_response error: {chunk.get('message', 'Unknown error')}")
                                 auto_continue = False
                                 break
                             elif status_type == 'finish':
                                 finish_reason = content.get('finish_reason', None)
                                 if finish_reason == 'completed':
-                                    logging.info(f"run_task_auto: Detected finish_reason='completed', TASK_COMPLETE Success !")
+                                    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':
-                                    logging.warning(f"run_task_auto: Detected finish_reason='xml_tool_limit_reached', stop auto-continue")
+                                    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':
-                                    logging.warning(f"run_task_auto: Detected finish_reason='non_tool_call', stop auto-continue")
+                                    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
                                     auto_continue_count += 1
                                     update_continuous_state(auto_continue_count, auto_continue)
-                                    logging.info(f"run_task_auto: Detected finish_reason='{finish_reason}', auto-continuing ({auto_continue_count}/{self.max_auto_run})")
+                                    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:
-                        logging.error(f"run_task_auto: Error in parse chunk: {str(parse_error)}")
+                        trace = log_trace(parse_error,f"TaskEngine run_task_auto: Parse chunk error, chunk: {chunk}")
+                        self.task_langfuse.root_span.event(name="engine_parse_chunk_error", level="ERROR",
+                                             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"}
-                        handle_error(parse_error)
                         error_msg = self.add_response_message(type="status", content=content, is_llm_message=False)
                         yield format_for_yield(error_msg)
             except Exception as run_error:
-                logging.error(f"run_task_auto: Call task_run_once error: {str(run_error)}")
-                content = {"role": "system", "status_type": "error", "message": "Call task_run_once error"}
-                handle_error(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)
 
@@ -198,6 +206,8 @@ 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()
 
@@ -205,11 +215,13 @@ class XGATaskEngine:
             self._logging_reponse_chunk(chunk, auto_count)
             yield chunk
 
-    def _parse_final_result(self, chunks: List[Dict[str, Any]]) -> XGATaskResult:
+    def parse_final_result(self, chunks: List[Dict[str, Any]]) -> XGATaskResult:
         final_result: XGATaskResult = None
+        reverse_chunks = reversed(chunks)
+        chunk = None
         try:
             finish_reason = ''
-            for chunk in reversed(chunks):
+            for chunk in reverse_chunks:
                 chunk_type = chunk.get("type")
                 if chunk_type == "status":
                     status_content = json.loads(chunk.get('content', '{}'))
@@ -219,10 +231,7 @@ class XGATaskEngine:
                         final_result = XGATaskResult(type="error", content=error)
                     elif status_type == "finish":
                         finish_reason = status_content.get('finish_reason', None)
-                        if finish_reason == 'xml_tool_limit_reached':
-                            error = "Completed due to over task max_auto_run limit !"
-                            final_result = XGATaskResult(type="error", content=error)
-                elif chunk_type == "tool" and finish_reason in ['completed', 'stop']:
+                elif chunk_type == "tool" and finish_reason in ['completed', 'stop', 'xml_tool_limit_reached']:
                     tool_content = json.loads(chunk.get('content', '{}'))
                     tool_execution = tool_content.get('tool_execution')
                     tool_name = tool_execution.get('function_name')
@@ -242,12 +251,12 @@ class XGATaskEngine:
                             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_complete" and finish_reason == 'non_tool_call':
+                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")
                     final_result = XGATaskResult(type="answer", content=result_content)
 
-                if final_result is not None:
+                if final_result:
                     break
 
             if final_result and finish_reason == "completed":
@@ -258,14 +267,16 @@ class XGATaskEngine:
                 logging.warning(f"❌ FINAL_RESULT: LLM Result is EMPTY, finish_reason={finish_reason}")
                 final_result = XGATaskResult(type="error", content="LLM has no answer")
         except Exception as e:
-            logging.error(f"parse_final_result: Final result pass error: {str(e)}")
+            trace = log_trace(e, f"TaskEngine parse_final_result: Parse message chunk error, chunk: {chunk}")
+            self.task_langfuse.root_span.event(name="engine_parse_final_result_error", level="ERROR",
+                                               status_message=f"Task Engine parse final result error: {e}",
+                                               metadata={"content": chunk, "trace": trace})
+
             final_result = XGATaskResult(type="error", content="Parse final result failed!")
-            handle_error(e)
 
         return final_result
 
-
-    def add_response_message(self, type: XGAResponseMsgType,
+    def create_response_message(self, type: XGAResponseMsgType,
                              content: Union[Dict[str, Any], List[Any], str],
                              is_llm_message: bool,
                              metadata: Optional[Dict[str, Any]]=None)-> XGAResponseMessage:
@@ -283,10 +294,17 @@ class XGATaskEngine:
             content = content,
             metadata = metadata
         )
-        self.task_response_msgs.append(message)
 
         return message
 
+    def add_response_message(self, type: XGAResponseMsgType,
+                             content: Union[Dict[str, Any], List[Any], str],
+                             is_llm_message: bool,
+                             metadata: Optional[Dict[str, Any]]=None)-> XGAResponseMessage:
+        message = self.create_response_message(type, content, is_llm_message, metadata)
+        self.task_response_msgs.append(message)
+        return message
+
     def get_history_llm_messages (self) -> List[Dict[str, Any]]:
         llm_messages = []
         for message in self.task_response_msgs:
@@ -296,14 +314,12 @@ class XGATaskEngine:
         response_llm_contents = []
         for llm_message in llm_messages:
             content = llm_message["content"]
-            # @todo content List type
             if isinstance(content, str):
                 try:
                     _content = json.loads(content)
                     response_llm_contents.append(_content)
                 except json.JSONDecodeError as e:
-                    logging.error(f"get_context_llm_contents: Failed to decode json, content=:{content}")
-                    handle_error(e)
+                    pass
             else:
                 response_llm_contents.append(content)
 
@@ -327,9 +343,11 @@ class XGATaskEngine:
             "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",  # ,
             "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,
         }
@@ -340,21 +358,34 @@ class XGATaskEngine:
         return XGATaskLangFuse(self.session_id, self.task_id, self.task_run_id, self.task_no, self.agent_id)
 
 
-    def _logging_reponse_chunk(self, chunk, auto_count: int) -> None:
-        chunk_type = chunk.get('type')
-        prefix = ""
-
-        if chunk_type == 'status':
-            content = json.loads(chunk.get('content', '{}'))
-            status_type = content.get('status_type', "empty")
-            prefix = "-" + status_type
-        elif chunk_type == 'tool':
-            tool_content = json.loads(chunk.get('content', '{}'))
-            tool_execution = tool_content.get('tool_execution')
-            tool_name = tool_execution.get('function_name')
-            prefix = "-" + tool_name
+    def _logging_reponse_chunk(self, chunk, auto_count: int)-> None:
+        try:
+            chunk_type = chunk.get('type', 'unknown')
+            prefix = ""
+            if chunk_type == 'status':
+                content = json.loads(chunk.get('content', '{}'))
+                status_type = 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', '{}'))
+                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)
+
+            if chunk_type == "assistant_chunk":
+                logging.debug(f"TASK_RESP_CHUNK[{auto_count}]<{chunk_type}{prefix}> content: {pretty_content}")
+            else:
+                logging.info(f"TASK_RESP_CHUNK[{auto_count}]<{chunk_type}{prefix}> content: {pretty_content}")
+        except Exception as e:
+            logging.error(f"TaskEngine logging_reponse_chunk: Decorate chunk={chunk}, error: {e}")
 
-        logging.info(f"TASK_RESP_CHUNK[{auto_count}]<{chunk_type}{prefix}>: {chunk}")
 
 
 if __name__ == "__main__":
@@ -371,9 +402,7 @@ if __name__ == "__main__":
         engine =  XGATaskEngine(tool_box=tool_box,
                                     general_tools=[],
                                     custom_tools=["*"],
-                                    llm_config=LLMConfig(stream=False),
                                     system_prompt=system_prompt,
-                                    max_auto_run=8,
                                     session_id="session_1",
                                     agent_id="agent_1",)
 

xgae/utils/__init__.py

@@ -1,15 +1,27 @@
 import logging
 
-def handle_error(e: Exception) -> None:
+
+def log_trace(exception: Exception, error: str=None) -> str:
+    import traceback
+
+    if error:
+        logging.error(f"{error} , error: {exception}")
+
+    trace_info = traceback.format_exc()
+    logging.error("Trace Details:\n%s", traceback.format_exc())
+
+    return trace_info
+
+
+def get_trace() -> str:
     import traceback
 
-    logging.error("An error occurred: %s", str(e))
-    logging.error("Traceback details:\n%s", traceback.format_exc())
-    raise (e) from e
+    return traceback.format_exc()
 
 
-def to_bool(value: str) -> bool:
+def to_bool(value: any) -> bool:
     if value is None:
         return False
 
-    return value.lower() == "true"
+    return str(value).lower() == "true"
+

xgae/utils/json_helpers.py

@@ -159,10 +159,10 @@ def format_for_yield(message_object: Dict[str, Any]) -> Dict[str, Any]:
     
     # Ensure content is a JSON string
     if 'content' in formatted and not isinstance(formatted['content'], str):
-        formatted['content'] = json.dumps(formatted['content'])
+        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'])
+        formatted['metadata'] = json.dumps(formatted['metadata'], ensure_ascii=False, indent=2)
         
     return formatted 

xgae/utils/llm_client.py

@@ -19,8 +19,8 @@ class LLMConfig(TypedDict, total=False):
     api_base: str           # Optional API base URL, Override .env LLM_API_BASE
     temperature: float      # temperature: Optional Sampling temperature (0-1), Override .env LLM_TEMPERATURE
     max_tokens: int         # max_tokens: Optional Maximum tokens in the response, Override .env LLM_MAX_TOKENS
-    stream: bool            # stream: Optional whether to stream the response, default is True
-    enable_thinking: bool   # Optional whether to enable thinking, default is  False
+    stream: bool            # stream: Optional whether to stream the response, Override .env LLM_STREAM
+    enable_thinking: bool   # Optional whether to enable thinking, Override .env LLM_ENABLE_THINKING
     reasoning_effort: str   # Optional level of reasoning effort, default is  ‘low’
     response_format: str    # response_format: Optional desired format for the response, default is  None
     top_p: int              # Optional Top-p sampling parameter, default is None
@@ -58,6 +58,8 @@ class LLMClient:
         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),
@@ -67,8 +69,8 @@ class LLMClient:
             "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", True),
-            "enable_thinking":  llm_config.get("enable_thinking", False),
+            "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),
@@ -115,27 +117,27 @@ class LLMClient:
             # as it causes errors with inference profiles
             if model_name.startswith("bedrock/") and "claude-3-7" in model_name:
                 prepared_llm_params.pop("max_tokens")
-                logging.debug(f"prepare_llm_params: Remove 'max_tokens' param for model: {model_name}")
+                logging.debug(f"LLMClient prepare_llm_params: Remove 'max_tokens' param for model: {model_name}")
             else:
                 is_openai_o_series = 'o1' in model_name
                 is_openai_gpt5 = 'gpt-5' in model_name
                 param_name = "max_completion_tokens" if (is_openai_o_series or is_openai_gpt5) else "max_tokens"
                 if param_name == "max_completion_tokens":
                     prepared_llm_params[param_name] = max_tokens
-                    logging.debug(f"prepare_llm_params: Add 'max_completion_tokens' param for model: {model_name}")
+                    logging.debug(f"LLMClient prepare_llm_params: Add 'max_completion_tokens' param for model: {model_name}")
 
         # # Add Claude-specific headers
         if "claude" in model_name.lower() or "anthropic" in model_name.lower():
             prepared_llm_params["extra_headers"] = {
                 "anthropic-beta": "output-128k-2025-02-19"
             }
-            logging.debug(f"prepare_llm_params: Add 'extra_headers' param for model: {model_name}")
+            logging.debug(f"LLMClient prepare_llm_params: Add 'extra_headers' param for model: {model_name}")
 
         # Add Bedrock-specific parameters
         if model_name.startswith("bedrock/"):
             if not model_id and "anthropic.claude-3-7-sonnet" in model_name:
                 prepared_llm_params["model_id"] = "arn:aws:bedrock:us-west-2:935064898258:inference-profile/us.anthropic.claude-3-7-sonnet-20250219-v1:0"
-                logging.debug(f"prepare_llm_params: Must Set 'model_id' param for model: {model_name}")
+                logging.debug(f"LLMClient prepare_llm_params: Must Set 'model_id' param for model: {model_name}")
 
         # Apply Anthropic prompt caching (minimal implementation)
         effective_model_name = llm_config_params.get("model", model_name)
@@ -143,14 +145,14 @@ class LLMClient:
         # OpenAI GPT-5: drop unsupported temperature param (only default 1 allowed)
         if "gpt-5" in effective_model_name and "temperature" in llm_config_params and llm_config_params["temperature"] != 1:
             prepared_llm_params.pop("temperature", None)
-            logging.debug(f"prepare_llm_params: Remove 'temperature' param for model: {model_name}")
+            logging.debug(f"LLMClient prepare_llm_params: Remove 'temperature' param for model: {model_name}")
 
         # OpenAI GPT-5: request priority service tier when calling OpenAI directly
         # Pass via both top-level and extra_body for LiteLLM compatibility
         if "gpt-5" in effective_model_name and not effective_model_name.startswith("openrouter/"):
             prepared_llm_params["service_tier"] = "priority"
             prepared_llm_params["extra_body"] = {"service_tier": "priority"}
-            logging.debug(f"prepare_llm_params: Add 'service_tier' and 'extra_body' param for model: {model_name}")
+            logging.debug(f"LLMClient prepare_llm_params: Add 'service_tier' and 'extra_body' param for model: {model_name}")
 
         # Add reasoning_effort for Anthropic models if enabled
         enable_thinking = llm_config_params.get("enable_thinking")
@@ -163,14 +165,14 @@ class LLMClient:
             prepared_llm_params["provider"] = {
                 "order": ["together/fp8", "novita/fp8", "baseten/fp8", "moonshotai", "groq"]
             }
-            logging.debug(f"prepare_llm_params: Add 'provider' param for model: {model_name}")
+            logging.debug(f"LLMClient prepare_llm_params: Add 'provider' param for model: {model_name}")
 
         reasoning_effort = llm_config_params.get("reasoning_effort")
         if is_anthropic and use_thinking:
             effort_level = reasoning_effort if reasoning_effort else 'low'
             prepared_llm_params["reasoning_effort"] = effort_level
             prepared_llm_params["temperature"] = 1.0  # Required by Anthropic when reasoning_effort is used
-            logging.debug(f"prepare_llm_params: Set 'temperature'=1.0 param for model: {model_name}")
+            logging.debug(f"LLMClient prepare_llm_params: Set 'temperature'=1.0 param for model: {model_name}")
 
         return prepared_llm_params
 
@@ -204,7 +206,7 @@ class LLMClient:
                         {"type": "text", "text": content, "cache_control": {"type": "ephemeral"}}
                     ]
                     cache_control_count += 1
-                    logging.debug(f"prepare_complete_params: Add 'cache_control' in message content, for model: {model_name}")
+                    logging.debug(f"LLMClient prepare_complete_params: Add 'cache_control' in message content, for model: {model_name}")
                 elif isinstance(content, list):
                     for item in content:
                         if cache_control_count >= max_cache_control_blocks:
@@ -212,7 +214,7 @@ class LLMClient:
                         if isinstance(item, dict) and item.get("type") == "text" and "cache_control" not in item:
                             item["cache_control"] = {"type": "ephemeral"}
                             cache_control_count += 1
-                            logging.debug(f"prepare_complete_params: Add 'cache_control' in message content list, for model: {model_name}")
+                            logging.debug(f"LLMClient prepare_complete_params: Add 'cache_control' in message content list, for model: {model_name}")
 
         return complete_params
 
@@ -232,18 +234,18 @@ class LLMClient:
         last_error = None
         for attempt in range(self.max_retries):
             try:
-                logging.info(f"*** create_completion ***: LLM '{self.model_name}' completion attempt {attempt + 1}/{self.max_retries}")
+                logging.info(f"*** LLMClient create_completion: LLM '{self.model_name}' completion attempt {attempt + 1}/{self.max_retries}")
                 response = await litellm.acompletion(**complete_params)
                 return response
             except (litellm.exceptions.RateLimitError, OpenAIError, json.JSONDecodeError) as e:
                 last_error = e
                 await self._handle_llm_error(e, attempt)
             except Exception as e:
-                logging.error(f"create_completion: Unexpected error during LLM completion: {str(e)}", exc_info=True)
-                raise LLMError(f"LLM completion failed: {e}")
+                logging.error(f"LLMClient create_completion: Unexpected error during LLM completion: {str(e)}", exc_info=True)
+                raise LLMError(f"LLMClient create completion failed: {e}")
 
-        logging.error(f"create_completion: LLM completion failed after {self.max_retries} attempts: {last_error}", exc_info=True)
-        raise LLMError(f"LLM completion failed after {self.max_retries} attempts !")
+        logging.error(f"LLMClient create_completion: LLM completion failed after {self.max_retries} attempts: {last_error}", exc_info=True)
+        raise LLMError(f"LLMClient create completion failed after {self.max_retries} attempts !")
 
 if __name__ == "__main__":
     from xgae.utils.setup_env import setup_logging

xgae/utils/misc.py

@@ -4,7 +4,6 @@ import sys
 
 from typing import Any, Dict
 
-from xgae.utils import handle_error
 
 def read_file(file_path: str) -> str:
     if not os.path.exists(file_path):
@@ -17,7 +16,7 @@ def read_file(file_path: str) -> str:
         return content
     except Exception as e:
         logging.error(f"Read file '{file_path}' failed")
-        handle_error(e)
+        raise
 
 def format_file_with_args(file_content:str, args: Dict[str, Any])-> str:
     from io import StringIO

xgae/utils/setup_env.py

@@ -60,6 +60,7 @@ def setup_env_logging():
     log_file = os.getenv("LOG_FILE", "log/xga.log")
     if log_enable :
         setup_logging(log_file, log_level)
+        setup_logging(log_file, log_level)
 
 def setup_langfuse() -> Langfuse:
     env_public_key = os.getenv("LANGFUSE_PUBLIC_KEY")

{xgae-0.1.10.dist-info → xgae-0.1.13.dist-info}/METADATA

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

xgae-0.1.13.dist-info/RECORD

@@ -0,0 +1,21 @@
+xgae/__init__.py,sha256=OEUd9y9AoGBd3xYerdTTpz9xl4NWkmXeq1a2eil7Qro,72
+xgae/cli_app.py,sha256=vKuCIJw0gwXdtkT-QNCZKt2dE53thvTFwQr7nTgvaPY,3000
+xgae/engine/engine_base.py,sha256=-QZqLRbQdwRUfbY4l3i7dFfMB-BL267a-wGZR9bMPLc,1662
+xgae/engine/mcp_tool_box.py,sha256=eE4qGxTHaSMMNDDWWafNXFT-vj_YYof4AjVSsxKoq68,10413
+xgae/engine/prompt_builder.py,sha256=X9bS7YIms6LYplCpNHeUmi74xFP5MwFXmXNqOt1Xz-Q,4356
+xgae/engine/task_engine.py,sha256=ZWxi292fceWvZuv501lwUGgb_PStktmfLFDzhDlsFfY,21011
+xgae/engine/task_langfuse.py,sha256=b0aJ_Di-WDcYzi0TFCvcKWxkBz7PYP2jx3N52OptQMs,2349
+xgae/engine/responser/non_stream_responser.py,sha256=RS2fIP_XCWjZEVtFRSNDJ9wM1N66MuzA66wXm3Nz1Jg,5583
+xgae/engine/responser/responser_base.py,sha256=WsUMUfEE2cexAg5LzXA1yUECOkbs1ekh8HbJS5-R7f8,30813
+xgae/engine/responser/stream_responser.py,sha256=O6_wSwdbqjYO-XowiLvHZKuw-F6fvxyjWULhfkkF6ow,7830
+xgae/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.13.dist-info/METADATA,sha256=8y0v909gMEo6oyUYTrY5ZjRP8ACB8U-BPHZTDd5uq4M,310
+xgae-0.1.13.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+xgae-0.1.13.dist-info/entry_points.txt,sha256=vClvL_WBJyF2x3wJCz5CNJ_BJG-dWUh7h2YbAoskHsc,162
+xgae-0.1.13.dist-info/RECORD,,

xgae-0.1.10.dist-info/RECORD

@@ -1,21 +0,0 @@
-xgae/__init__.py,sha256=OEUd9y9AoGBd3xYerdTTpz9xl4NWkmXeq1a2eil7Qro,72
-xgae/cli_app.py,sha256=ePis7gYYZrevEArnCQOhaN7z4C8Y5yJSOIov8z-lGBs,3157
-xgae/engine/engine_base.py,sha256=ioywuTpDMHEmyVcd6BInoU-vR70PhQStE2MVRWoEiJg,1768
-xgae/engine/mcp_tool_box.py,sha256=ZSCBSXRWhISwyZ1uEIbt3esjesM46g-ktv6CxvyPVDU,10030
-xgae/engine/prompt_builder.py,sha256=X9bS7YIms6LYplCpNHeUmi74xFP5MwFXmXNqOt1Xz-Q,4356
-xgae/engine/task_engine.py,sha256=LAo55FKmmO8Jbo5geEUYr8kFCaVigTb-Jm06XuYKYyY,19010
-xgae/engine/task_langfuse.py,sha256=b0aJ_Di-WDcYzi0TFCvcKWxkBz7PYP2jx3N52OptQMs,2349
-xgae/engine/responser/non_stream_responser.py,sha256=9YCCUedbotH-TPPbTh2Mv1qNVYvznHYFPgAnQB7NJSE,6510
-xgae/engine/responser/responser_base.py,sha256=8PcsvQHP68FEhu6v3dT9hDCc_rLKs38i4txWLcJD4ck,29851
-xgae/engine/responser/stream_responser.py,sha256=oPGtrT1nedGMjiBAwPzUlu6Z_rPWeVSODC1xQ6D8cTY,52055
-xgae/tools/without_general_tools_app.py,sha256=FGMV6njcOKwwfitc0j_nUov0RC-eWlhO1IP8_KHz1tQ,3788
-xgae/utils/__init__.py,sha256=_-TTNq5FanrA-jl_w3-4xp-BnRM7SLwfYQcFyvepcW0,332
-xgae/utils/json_helpers.py,sha256=6BkqiyEF3jV3Irb4Z6-wGY2_FNaLlxE1WKlMJHHT6E0,4645
-xgae/utils/llm_client.py,sha256=hvEDb4DBaWVQTXMjXOd6KrFwJFBcI-YXEQD4f_AhG7Q,14008
-xgae/utils/misc.py,sha256=M8lMXYp1pHiY6Ee8ZTUG88GpOAsE5fbYoRO_hcBFUCE,953
-xgae/utils/setup_env.py,sha256=HweQ-WAyxfV3KYjGYi-rRQAbI_SXoimduOLpQPbHfl8,2619
-xgae/utils/xml_tool_parser.py,sha256=I9xAZC_ElwBY19PNUq-WLXe9FSIJMeAv2Xs-VlajI7Y,4782
-xgae-0.1.10.dist-info/METADATA,sha256=SGnhZrr3DDZ600FDMep9ihERmhwFspEtUKRv1THqQsk,310
-xgae-0.1.10.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-xgae-0.1.10.dist-info/entry_points.txt,sha256=vClvL_WBJyF2x3wJCz5CNJ_BJG-dWUh7h2YbAoskHsc,162
-xgae-0.1.10.dist-info/RECORD,,