xgae 0.1.6__py3-none-any.whl → 0.1.7__py3-none-any.whl

xgae/engine/mcp_tool_box.py

@@ -46,6 +46,12 @@ class XGAMcpToolBox(XGAToolBox):
                     task_tool_schemas[tool_schema.tool_name] = tool_schema
         task_tool_schemas.pop("end_task", None)
 
+        if len(custom_tools) == 1 and custom_tools[0] == "*":
+            custom_tools = []
+            for server_name in self.mcp_server_names:
+                if server_name != XGAMcpToolBox.GENERAL_MCP_SERVER_NAME:
+                    custom_tools.append(f"{server_name}.*")
+
         for server_tool_name in custom_tools:
             parts = server_tool_name.split(".")
             if len(parts) != 2:

xgae/engine/prompt_builder.py

@@ -3,7 +3,7 @@ import datetime
 
 from typing import Optional, List
 
-from engine_base import XGAToolSchema, XGAError
+from xgae.engine.engine_base import XGAToolSchema, XGAError
 from xgae.utils.misc import read_file, format_file_with_args
 
 

xgae/engine/responser/non_stream_responser.py

@@ -24,8 +24,8 @@ class NonStreamTaskResponser(TaskResponseProcessor):
                     finish_reason = llm_response.choices[0].finish_reason
                     logging.info(f"NonStreamTask：LLM response finish_reason={finish_reason}")
 
-                    langfuse.create_event(trace_context=self.trace_context, name="non_streaming_finish_reason", level="DEFAULT",
-                                     status_message=(f"Non-streaming finish_reason: {finish_reason}"))
+                    langfuse.create_event(trace_context=self.trace_context, name="non_stream_processor_start", level="DEFAULT",
+                                     status_message=(f"finish_reason={finish_reason}, tool_exec_strategy={self.tool_execution_strategy}"))
 
                 response_message = llm_response.choices[0].message if hasattr(llm_response.choices[0], 'message') else None
                 if response_message:
@@ -54,8 +54,6 @@ class NonStreamTaskResponser(TaskResponseProcessor):
             tool_calls_to_execute = [item['tool_call'] for item in parsed_xml_data]
             if  len(tool_calls_to_execute) > 0:
                 logging.info(f"NonStreamTask：Executing {len(tool_calls_to_execute)} tools with strategy: {self.tool_execution_strategy}")
-                langfuse.create_event(trace_context=self.trace_context, name="executing_tools_with_strategy", level="DEFAULT", status_message=(
-                    f"NonStreamTask Executing {len(tool_calls_to_execute)} tools with strategy: {self.tool_execution_strategy}"))
 
                 tool_results = await self._execute_tools(tool_calls_to_execute, self.tool_execution_strategy)
 

xgae/engine/responser/responser_base.py

@@ -22,6 +22,7 @@ class TaskResponserContext(TypedDict, total=False):
     task_id: str
     task_run_id: str
     trace_id: str
+    root_span_id: str
     model_name: str
     max_xml_tool_calls: int             # LLM generate max_xml_tool limit, 0 is no limit
     add_response_msg_func: Callable
@@ -34,7 +35,7 @@ class TaskRunContinuousState(TypedDict, total=False):
     accumulated_content: str
     auto_continue_count: int
     auto_continue: bool
-    max_auto_run: int
+
 
 @dataclass
 class ToolExecutionContext:
@@ -61,7 +62,7 @@ class TaskResponseProcessor(ABC):
 
         self.trace_context = {
             "trace_id": self.response_context.get("trace_id"),
-            "parent_span_id": None
+            "parent_span_id": self.response_context.get("root_span_id"),
         }
 
         self.add_response_message = response_context.get("add_response_msg_func")
@@ -257,38 +258,36 @@ class TaskResponseProcessor(ABC):
 
     async def _execute_tool(self, tool_call: Dict[str, Any]) -> XGAToolResult:
         """Execute a single tool call and return the result."""
-        span = langfuse.start_span(trace_context=self.trace_context, name=f"execute_tool.{tool_call['function_name']}", input=tool_call["arguments"])
-        self.trace_context["parent_span_id"] = span.id
-        try:
-            function_name = tool_call["function_name"]
-            arguments = tool_call["arguments"]
-
-            logging.info(f"Executing tool: {function_name} with arguments: {arguments}")
-            langfuse.create_event(trace_context=self.trace_context, name="executing_tool", level="DEFAULT",
-                             status_message=(f"Executing tool: {function_name} with arguments: {arguments}"))
-
-            if isinstance(arguments, str):
-                try:
-                    arguments = safe_json_parse(arguments)
-                except json.JSONDecodeError:
-                    arguments = {"text": arguments} # @todo modify
-
-            result = None
-            available_tool_names = self.tool_box.get_task_tool_names(self.task_id)
-            if function_name in available_tool_names:
-                result = await self.tool_box.call_tool(self.task_id, function_name, arguments)
-            else:
-                logging.error(f"Tool function '{function_name}' not found in registry")
-                result = XGAToolResult(success=False, output=f"Tool function '{function_name}' not found")
-            logging.info(f"Tool execution complete: {function_name} -> {result}")
-            langfuse.update_current_span(status_message="tool_executed", output=result)
-
-            return result
-        except Exception as e:
-            logging.error(f"Error executing tool {tool_call['function_name']}: {str(e)}", exc_info=True)
+        with langfuse.start_as_current_span(trace_context=self.trace_context, name=f"execute_tool.{tool_call['function_name']}", input=tool_call["arguments"]
+                                            ) as exec_tool_span:
+            try:
+                function_name = tool_call["function_name"]
+                arguments = tool_call["arguments"]
+
+                logging.info(f"Executing tool: {function_name} with arguments: {arguments}")
+
+                if isinstance(arguments, str):
+                    try:
+                        arguments = safe_json_parse(arguments)
+                    except json.JSONDecodeError:
+                        arguments = {"text": arguments} # @todo modify
+
+                result = None
+                available_tool_names = self.tool_box.get_task_tool_names(self.task_id)
+                if function_name in available_tool_names:
+                    result = await self.tool_box.call_tool(self.task_id, function_name, arguments)
+                else:
+                    logging.error(f"Tool function '{function_name}' not found in registry")
+                    result = XGAToolResult(success=False, output=f"Tool function '{function_name}' not found")
+                logging.info(f"Tool execution complete: {function_name} -> {result}")
+                exec_tool_span.update(status_message="tool_executed", output=result)
+
+                return result
+            except Exception as e:
+                logging.error(f"Error executing tool {tool_call['function_name']}: {str(e)}", exc_info=True)
 
-            langfuse.update_current_span(status_message="tool_execution_error", output=f"Error executing tool: {str(e)}", level="ERROR")
-            return XGAToolResult(success=False, output=f"Error executing tool: {str(e)}")
+                exec_tool_span.update(status_message="tool_execution_error", output=f"Error executing tool: {str(e)}", level="ERROR")
+                return XGAToolResult(success=False, output=f"Error executing tool: {str(e)}")
 
     async def _execute_tools(
             self,
@@ -296,8 +295,6 @@ class TaskResponseProcessor(ABC):
             execution_strategy: ToolExecutionStrategy = "sequential"
     ) -> List[Tuple[Dict[str, Any], XGAToolResult]]:
         logging.info(f"Executing {len(tool_calls)} tools with strategy: {execution_strategy}")
-        langfuse.create_event(trace_context=self.trace_context, name="executing_tools_with_strategy", level="DEFAULT",
-                         status_message=(f"Executing {len(tool_calls)} tools with strategy: {execution_strategy}"))
 
         if execution_strategy == "sequential":
             return await self._execute_tools_sequentially(tool_calls)
@@ -340,9 +337,8 @@ class TaskResponseProcessor(ABC):
                 # Check if this is a terminating tool (ask or complete)
                 if tool_name in ['ask', 'complete']:
                     logging.info(f"Terminating tool '{tool_name}' executed. Stopping further tool execution.")
-                    langfuse.create_event(trace_context=self.trace_context, name="terminating_tool_executed",
-                                          level="DEFAULT", status_message=(
-                            f"Terminating tool '{tool_name}' executed. Stopping further tool execution."))
+                    # langfuse.create_event(trace_context=self.trace_context, name="terminating_tool_executed",
+                    #                       level="DEFAULT", status_message=(f"Terminating tool '{tool_name}' executed. Stopping further tool execution."))
                     break  # Stop executing remaining tools
 
             except Exception as e:
@@ -353,9 +349,8 @@ class TaskResponseProcessor(ABC):
                 results.append((tool_call, error_result))
 
         logging.info(f"Sequential execution completed for {len(results)} tools (out of {len(tool_calls)} total)")
-        langfuse.create_event(trace_context=self.trace_context, name="sequential_execution_completed", level="DEFAULT",
-                              status_message=(
-                                  f"Sequential execution completed for {len(results)} tools (out of {len(tool_calls)} total)"))
+        # langfuse.create_event(trace_context=self.trace_context, name="sequential_execution_completed", level="DEFAULT",
+        #                       status_message=(f"Sequential execution completed for {len(results)} tools (out of {len(tool_calls)} total)"))
         return results
 
 
@@ -366,8 +361,8 @@ class TaskResponseProcessor(ABC):
         try:
             tool_names = [t.get('function_name', 'unknown') for t in tool_calls]
             logging.info(f"Executing {len(tool_calls)} tools in parallel: {tool_names}")
-            langfuse.create_event(trace_context=self.trace_context, name="executing_tools_in_parallel", level="DEFAULT",
-                             status_message=(f"Executing {len(tool_calls)} tools in parallel: {tool_names}"))
+            # langfuse.create_event(trace_context=self.trace_context, name="executing_tools_in_parallel", level="DEFAULT",
+            #                  status_message=(f"Executing {len(tool_calls)} tools in parallel: {tool_names}"))
 
             # Create tasks for all tool calls
             tasks = [self._execute_tool(tool_call) for tool_call in tool_calls]
@@ -389,8 +384,8 @@ class TaskResponseProcessor(ABC):
                     processed_results.append((tool_call, result))
 
             logging.info(f"Parallel execution completed for {len(tool_calls)} tools")
-            langfuse.create_event(trace_context=self.trace_context, name="parallel_execution_completed", level="DEFAULT",
-                             status_message=(f"Parallel execution completed for {len(tool_calls)} tools"))
+            # langfuse.create_event(trace_context=self.trace_context, name="parallel_execution_completed", level="DEFAULT",
+            #                  status_message=(f"Parallel execution completed for {len(tool_calls)} tools"))
             return processed_results
 
         except Exception as e:
@@ -417,16 +412,11 @@ class TaskResponseProcessor(ABC):
             if assistant_message_id:
                 metadata["assistant_message_id"] = assistant_message_id
                 logging.info(f"Linking tool result to assistant message: {assistant_message_id}")
-                langfuse.create_event(trace_context=self.trace_context, name="linking_tool_result_to_assistant_message", level="DEFAULT",
-                                 status_message=(f"Linking tool result to assistant message: {assistant_message_id}"))
 
             # --- Add parsing details to metadata if available ---
             if parsing_details:
                 metadata["parsing_details"] = parsing_details
                 logging.info("Adding parsing_details to tool result metadata")
-                langfuse.create_event(trace_context=self.trace_context, name="adding_parsing_details_to_tool_result_metadata", level="DEFAULT",
-                                 status_message=(f"Adding parsing_details to tool result metadata"),
-                                 metadata={"parsing_details": parsing_details})
 
             # For XML and other non-native tools, use the new structured format
             # Determine message role based on strategy
@@ -599,8 +589,8 @@ class TaskResponseProcessor(ABC):
         if context.function_name in ['ask', 'complete']:
             metadata["agent_should_terminate"] = "true"
             logging.info(f"Marking tool status for '{context.function_name}' with termination signal.")
-            langfuse.create_event(trace_context=self.trace_context, name="marking_tool_status_for_termination", level="DEFAULT", status_message=(
-                f"Marking tool status for '{context.function_name}' with termination signal."))
+            # langfuse.create_event(trace_context=self.trace_context, name="marking_tool_status_for_termination", level="DEFAULT", status_message=(
+            #     f"Marking tool status for '{context.function_name}' with termination signal."))
         # <<< END ADDED >>>
 
         return  self.add_response_message(

xgae/engine/task_engine.py

@@ -1,6 +1,7 @@
 
 import logging
 import json
+import os
 
 from typing import List, Any, Dict, Optional, AsyncGenerator, Union, Literal
 from uuid import uuid4
@@ -12,16 +13,19 @@ from xgae.utils import langfuse, handle_error
 from xgae.utils.llm_client import LLMClient, LLMConfig
 
 from xgae.utils.json_helpers import format_for_yield
-from prompt_builder import XGAPromptBuilder
-from mcp_tool_box import XGAMcpToolBox
+from xgae.engine.prompt_builder import XGAPromptBuilder
+from xgae.engine.mcp_tool_box import XGAMcpToolBox
 
 class XGATaskEngine:
     def __init__(self,
                  session_id: Optional[str] = None,
                  task_id: Optional[str] = None,
                  agent_id: Optional[str] = None,
-                 trace_id: Optional[str] = None,
+                 general_tools: Optional[List[str]] = None,
+                 custom_tools: Optional[List[str]] = None,
                  system_prompt: Optional[str] = None,
+                 max_auto_run: Optional[int] = None,
+                 tool_exec_parallel: Optional[bool] = None,
                  llm_config: Optional[LLMConfig] = None,
                  prompt_builder: Optional[XGAPromptBuilder] = None,
                  tool_box: Optional[XGAToolBox] = None):
@@ -34,125 +38,109 @@ class XGATaskEngine:
         self.is_stream = self.llm_client.is_stream
 
         self.prompt_builder = prompt_builder or XGAPromptBuilder(system_prompt)
-        self.tool_box = tool_box or XGAMcpToolBox()
+        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.task_no = -1
-        self.task_run_id = f"{self.task_id}[{self.task_no}]"
-        self.trace_id :str = trace_id or langfuse.create_trace_id()
-
-    async def _post_init_(self, general_tools:List[str], custom_tools: List[str]) -> None:
-        await  self.tool_box.load_mcp_tools_schema()
-        await self.tool_box.creat_task_tool_box(self.task_id, general_tools, custom_tools)
-        general_tool_schemas = self.tool_box.get_task_tool_schemas(self.task_id, "general_tool")
-        custom_tool_schemas = self.tool_box.get_task_tool_schemas(self.task_id, "custom_tool")
 
-        self.task_prompt = self.prompt_builder.build_task_prompt(self.model_name, general_tool_schemas, custom_tool_schemas)
+        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.tool_exec_parallel = True if tool_exec_parallel is None else tool_exec_parallel
 
-    @classmethod
-    async def create(cls,
-                     session_id: Optional[str] = None,
-                     task_id: Optional[str] = None,
-                     agent_id: Optional[str] = None,
-                     trace_id: Optional[str] = None,
-                     system_prompt: Optional[str] = None,
-                     general_tools: Optional[List[str]] = None,
-                     custom_tools: Optional[List[str]] = None,
-                     llm_config: Optional[LLMConfig] = None,
-                     prompt_builder: Optional[XGAPromptBuilder] = None,
-                     tool_box: Optional[XGAToolBox] = None) -> 'XGATaskEngine':
-        engine: XGATaskEngine = cls(session_id=session_id,
-                                    task_id=task_id,
-                                    agent_id=agent_id,
-                                    trace_id=trace_id,
-                                    system_prompt=system_prompt,
-                                    llm_config=llm_config,
-                                    prompt_builder=prompt_builder,
-                                    tool_box=tool_box)
+        self.task_no = -1
+        self.task_run_id :str = None
 
-        general_tools = general_tools or ["complete", "ask"]
-        if "*" not in general_tools:
-            if "complete" not in general_tools:
-                general_tools.append("complete")
-            elif "ask" not in general_tools:
-                general_tools.append("ask")
+        self.task_prompt :str = None
+        self.trace_id :str = None
+        self.root_span_id :str = None
 
-        custom_tools = custom_tools or []
-        await engine._post_init_(general_tools, custom_tools)
+    async def run_task_with_final_answer(self,
+                                         task_message: Dict[str, Any],
+                                         trace_id: Optional[str] = None) -> XGATaskResult:
+        self.trace_id = trace_id or langfuse.create_trace_id()
+        with langfuse.start_as_current_span(trace_context={"trace_id": self.trace_id},
+                                            name="run_task_with_final_answer",
+                                            input=task_message,
+                                            metadata={"task_id": self.task_id},
+                                            ) as root_span:
+            self.root_span_id = root_span.id
+
+            chunks = []
+            async for chunk in self.run_task(task_message=task_message, trace_id=trace_id):
+                chunks.append(chunk)
+
+            if len(chunks) > 0:
+                final_result = self._parse_final_result(chunks)
+            else:
+                final_result = XGATaskResult(type="error", content="LLM Answer is Empty")
 
-        logging.info("*"*30 + f"   XGATaskEngine Task'{engine.task_id}' Initialized   " + "*"*30)
-        logging.info(f"model_name={engine.model_name}, is_stream={engine.is_stream}, trace_id={engine.trace_id}")
-        logging.info(f"general_tools={general_tools}, custom_tools={custom_tools}")
+            root_span.update(output=final_result)
+            return final_result
 
-        return engine
-
-    async def run_task_with_final_answer(self,
-                       task_message: Dict[str, Any],
-                       max_auto_run: int = 25,
-                       trace_id: Optional[str] = None) -> XGATaskResult:
-        chunks = []
-        async for chunk in self.run_task(task_message=task_message, max_auto_run=max_auto_run, trace_id=trace_id):
-            chunks.append(chunk)
-        if len(chunks) > 0:
-            final_result = self._parse_final_result(chunks)
-        else:
-            final_result = XGATaskResult(type="error", content="LLM Answer is Empty")
-        return final_result
 
     async def run_task(self,
                        task_message: Dict[str, Any],
-                       max_auto_run: int = 25,
                        trace_id: Optional[str] = None) -> AsyncGenerator[Dict[str, Any], None]:
         try:
-            self.trace_id = trace_id or self.trace_id or langfuse.create_trace_id()
+            await self._init_task()
+            if self.root_span_id is None:
+                self.trace_id = trace_id or langfuse.create_trace_id()
+                with langfuse.start_as_current_span(trace_context={"trace_id": self.trace_id},
+                                                    name="run_task",
+                                                    input=task_message
+                                                    ) as root_span:
+                    self.root_span_id = root_span.id
 
-            self.task_no += 1
-            self.task_run_id = f"{self.task_id}[{self.task_no}]"
 
             self.add_response_message(type="user", content=task_message, is_llm_message=True)
 
             continuous_state: TaskRunContinuousState = {
                 "accumulated_content": "",
                 "auto_continue_count": 0,
-                "auto_continue": False if max_auto_run <= 1 else True,
-                "max_auto_run": max_auto_run
+                "auto_continue": False if self.max_auto_run <= 1 else True
             }
             async for chunk in self._run_task_auto(continuous_state):
                 yield chunk
         finally:
             await self.tool_box.destroy_task_tool_box(self.task_id)
+            self.root_span_id = None
 
-    async def _run_task_once(self, continuous_state: TaskRunContinuousState) -> AsyncGenerator[Dict[str, Any], None]:
-        llm_messages = [{"role": "system", "content": self.task_prompt}]
-        cxt_llm_contents = self.get_history_llm_messages()
-        llm_messages.extend(cxt_llm_contents)
 
-        partial_content = continuous_state.get('accumulated_content', '')
-        if partial_content:
-            temp_assistant_message = {
-                "role": "assistant",
-                "content": partial_content
-            }
-            llm_messages.append(temp_assistant_message)
+    async def _init_task(self) -> None:
+        self.task_no = self.task_no + 1
+        self.task_run_id = f"{self.task_id}[{self.task_no}]"
 
-        llm_response = await self.llm_client.create_completion(llm_messages)
-        response_processor = self._create_response_processer()
+        general_tools = self.general_tools or ["complete", "ask"]
+        if "*" not in general_tools:
+            if "complete" not in general_tools:
+                general_tools.append("complete")
+            elif "ask" not in general_tools:
+                general_tools.append("ask")
 
-        async for chunk in response_processor.process_response(llm_response, llm_messages, continuous_state):
-            self._logging_reponse_chunk(chunk)
-            yield chunk
+        custom_tools = self.custom_tools or []
+        if isinstance(self.tool_box, XGAMcpToolBox):
+            await  self.tool_box.load_mcp_tools_schema()
 
-    async def _run_task_auto(self, continuous_state: TaskRunContinuousState) -> AsyncGenerator[Dict[str, Any], None]:
-        max_auto_run = continuous_state['max_auto_run']
-        max_auto_run = max_auto_run if max_auto_run > 0 else 1
+        await self.tool_box.creat_task_tool_box(self.task_id, general_tools, custom_tools)
+        general_tool_schemas = self.tool_box.get_task_tool_schemas(self.task_id, "general_tool")
+        custom_tool_schemas = self.tool_box.get_task_tool_schemas(self.task_id, "custom_tool")
+
+        self.task_prompt = self.prompt_builder.build_task_prompt(self.model_name, general_tool_schemas, custom_tool_schemas)
 
+        logging.info("*" * 30 + f"   XGATaskEngine Task'{self.task_id}' Initialized   " + "*" * 30)
+        logging.info(f"model_name={self.model_name}, is_stream={self.is_stream}, trace_id={self.trace_id}")
+        logging.info(f"general_tools={general_tools}, custom_tools={custom_tools}")
+
+
+    async def _run_task_auto(self, continuous_state: TaskRunContinuousState) -> 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
 
         auto_continue_count = 0
         auto_continue = True
-        while auto_continue and auto_continue_count < max_auto_run:
+        while auto_continue and auto_continue_count < self.max_auto_run:
             auto_continue = False
 
             try:
@@ -180,7 +168,7 @@ class XGATaskEngine:
                                     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}/{max_auto_run})")
+                                    logging.info(f"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)}")
                         content = {"role": "system", "status_type": "error", "message": "Parse response chunk Error"}
@@ -194,6 +182,28 @@ class XGATaskEngine:
                 error_msg = self.add_response_message(type="status", content=content, is_llm_message=False)
                 yield format_for_yield(error_msg)
 
+
+    async def _run_task_once(self, continuous_state: TaskRunContinuousState) -> AsyncGenerator[Dict[str, Any], None]:
+        llm_messages = [{"role": "system", "content": self.task_prompt}]
+        cxt_llm_contents = self.get_history_llm_messages()
+        llm_messages.extend(cxt_llm_contents)
+
+        partial_content = continuous_state.get('accumulated_content', '')
+        if partial_content:
+            temp_assistant_message = {
+                "role": "assistant",
+                "content": partial_content
+            }
+            llm_messages.append(temp_assistant_message)
+
+        llm_response = await self.llm_client.create_completion(llm_messages, self.trace_id)
+        response_processor = self._create_response_processer()
+
+        async for chunk in response_processor.process_response(llm_response, llm_messages, continuous_state):
+            self._logging_reponse_chunk(chunk)
+            yield chunk
+
+
     def _parse_final_result(self, chunks: List[Dict[str, Any]]) -> XGATaskResult:
         final_result: XGATaskResult = None
         try:
@@ -245,6 +255,7 @@ class XGATaskEngine:
 
         return final_result
 
+
     def add_response_message(self, type: XGAResponseMsgType,
                              content: Union[Dict[str, Any], List[Any], str],
                              is_llm_message: bool,
@@ -289,6 +300,7 @@ class XGATaskEngine:
 
         return response_llm_contents
 
+
     def _create_response_processer(self) -> TaskResponseProcessor:
         response_context = self._create_response_context()
         is_stream = response_context.get("is_stream", False)
@@ -305,11 +317,12 @@ class XGATaskEngine:
             "task_id": self.task_id,
             "task_run_id": self.task_run_id,
             "trace_id": self.trace_id,
+            "root_span_id": self.root_span_id,
             "model_name": self.model_name,
             "max_xml_tool_calls": 0,
             "add_response_msg_func": self.add_response_message,
             "tool_box": self.tool_box,
-            "tool_execution_strategy": "sequential" ,#"parallel",
+            "tool_execution_strategy": "parallel" if self.tool_exec_parallel else "sequential" ,#,
             "xml_adding_strategy": "user_message",
         }
         return response_context
@@ -338,23 +351,17 @@ if __name__ == "__main__":
 
     async def main():
         tool_box = XGAMcpToolBox(custom_mcp_server_file="mcpservers/custom_servers.json")
-        system_prompt = read_file("templates/scp_test_prompt.txt")
-        engine = await XGATaskEngine.create(tool_box=tool_box,
-                                            general_tools=[],
-                                            custom_tools=["bomc_fault.*"],
-                                            llm_config=LLMConfig(stream=False),
-                                            system_prompt=system_prompt)
-
-        final_result = await engine.run_task_with_final_answer(task_message={"role": "user", "content": "定位10.0.1.1故障"},max_auto_run=8)
+        system_prompt = read_file("templates/example_user_prompt.txt")
+        engine =  XGATaskEngine(tool_box=tool_box,
+                                    general_tools=[],
+                                    custom_tools=["*"],
+                                    llm_config=LLMConfig(stream=False),
+                                    system_prompt=system_prompt,
+                                    max_auto_run=8)
+
+        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)
 
-        # ====  test streaming response   ========
-        #chunks = []
-        # async for chunk in engine.run_task(task_message={"role": "user", "content": "定位10.0.0.1的故障"}, max_auto_run=8):
-        #     print(chunk)
 
-        # ====  test no tool call   ========
-        # engine = await XGATaskEngine.create(llm_config=LLMConfig(stream=False))
-        # final_result = await engine.run_task_with_final_answer(task_message={"role": "user", "content": "1+1"}, max_auto_run=2)
-        # print("FINAL RESULT:", final_result)
     asyncio.run(main())

xgae/tools/without_general_tools_app.py

@@ -0,0 +1,48 @@
+from typing import Annotated, Optional
+from pydantic import Field
+
+from mcp.server.fastmcp import FastMCP
+
+from xgae.engine.engine_base import  XGAToolResult
+
+mcp = FastMCP(name="XGAE Message Tools")
+
+@mcp.tool(
+    description="""A special tool to indicate you have completed all tasks and are about to enter complete state. Use ONLY when: 1) All tasks in todo.md are marked complete [x], 2) The user's original request has been fully addressed, 3) There are no pending actions or follow-ups required, 4) You've delivered all final outputs and results to the user. IMPORTANT: This is the ONLY way to properly terminate execution. Never use this tool unless ALL tasks are complete and verified. Always ensure you've provided all necessary outputs and references before using this tool. Include relevant attachments when the completion relates to specific files or resources."""
+)
+async def complete(task_id: str,
+                   text: Annotated[Optional[str], Field(default=None,
+                       description="Completion summary. Include: 1) Task summary 2) Key deliverables 3) Next steps 4) Impact achieved")],
+                   attachments: Annotated[Optional[str], Field(default=None,
+                       description="Comma-separated list of final outputs. Use when: 1) Completion relates to files 2) User needs to review outputs 3) Deliverables in files")]
+                   ):
+    print(f"<XGAETools-complete>: task_id={task_id}, text={text}, attachments={attachments}")
+    return XGAToolResult(success=True, output=str({"status": "complete"}))
+
+
+@mcp.tool(
+    description="""Ask user a question and wait for response. Use for: 1) Requesting clarification on ambiguous requirements, 2) Seeking confirmation before proceeding with high-impact changes, 3) Gathering additional information needed to complete a task, 4) Offering options and requesting user preference, 5) Validating assumptions when critical to task success, 6) When encountering unclear or ambiguous results during task execution, 7) When tool results don't match expectations, 8) For natural conversation and follow-up questions, 9) When research reveals multiple entities with the same name, 10) When user requirements are unclear or could be interpreted differently. IMPORTANT: Use this tool when user input is essential to proceed. Always provide clear context and options when applicable. Use natural, conversational language that feels like talking with a helpful friend. Include relevant attachments when the question relates to specific files or resources. CRITICAL: When you discover ambiguity (like multiple people with the same name), immediately stop and ask for clarification rather than making assumptions."""
+)
+async def ask(task_id: str,
+              text: Annotated[str, Field(
+                  description="Question text to present to user. Include: 1) Clear question/request 2) Context why input is needed 3) Available options 4) Impact of choices 5) Relevant constraints")],
+              attachments: Annotated[Optional[str], Field(default=None,
+                  description="Comma-separated list of files/URLs to attach. Use when: 1) Question relates to files/configs 2) User needs to review content 3) Options documented in files 4) Supporting evidence needed")]
+              ):
+    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}")
+
+
+
+def main():
+    #print("="*20 + "   XGAE Message Tools Sever Started in Stdio mode   " + "="*20)
+    mcp.run(transport="stdio")
+
+if __name__ == "__main__":
+    main()

xgae/utils/llm_client.py

@@ -47,6 +47,7 @@ class LLMClient:
             reasoning_effort: Optional level of reasoning effort, default is  ‘low’
             top_p: Optional Top-p sampling parameter, default is None
         """
+
         llm_config = llm_config or LLMConfig()
         litellm.modify_params = True
         litellm.drop_params = True
@@ -205,9 +206,10 @@ class LLMClient:
             logging.debug(f"LLMClient: Waiting {delay} seconds before retry llm completion...")
             await asyncio.sleep(delay)
 
-
-    async def create_completion(self, messages: List[Dict[str, Any]]) -> Union[ModelResponse, CustomStreamWrapper]:
+    async def create_completion(self, messages: List[Dict[str, Any]], trace_id: Optional[str]=None) -> Union[ModelResponse, CustomStreamWrapper]:
         complete_params = self._prepare_complete_params(messages)
+        if trace_id:
+            complete_params["litellm_trace_id"] = trace_id
 
         last_error = None
         for attempt in range(self.max_retries):
@@ -226,10 +228,13 @@ class LLMClient:
         raise LLMError(f"LLM completion failed after {self.max_retries} attempts !")
 
 if __name__ == "__main__":
+    from xgae.utils import langfuse
+
     async def llm_completion():
         llm_client = LLMClient(LLMConfig(stream=False))
         messages = [{"role": "user", "content": "今天是2025年8月15日，北京本周每天温度"}]
-        response = await llm_client.create_completion(messages)
+        trace_id = langfuse.create_trace_id()
+        response = await llm_client.create_completion(messages, trace_id)
         if llm_client.is_stream:
             async for chunk in response:
                 choices = chunk.get("choices", [{}])

xgae/utils/setup_env.py

@@ -64,6 +64,7 @@ def setup_langfuse() -> Langfuse:
                             public_key=env_public_key,
                             secret_key=env_secret_key,
                             host=env_host)
+
         logging.info("Langfuse initialized Successfully by Key !")
     else:
         _langfuse = Langfuse(tracing_enabled=False)
@@ -74,5 +75,6 @@ def setup_langfuse() -> Langfuse:
 
 if __name__ == "__main__":
         from xgae.utils import langfuse
+
         trace_id = langfuse.create_trace_id()
         logging.warning(f"trace_id={trace_id}")

{xgae-0.1.6.dist-info → xgae-0.1.7.dist-info}/METADATA

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

xgae-0.1.7.dist-info/RECORD

@@ -0,0 +1,19 @@
+xgae/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+xgae/engine/engine_base.py,sha256=ySERuLy1YWsf-3s0NFKcyTnXQ4g69wR-cQhtnG0OFmU,1747
+xgae/engine/mcp_tool_box.py,sha256=iBfCLWXvbkKWd1JnSgBLA1T1KdSdpEZCrROkC_cXp7g,10132
+xgae/engine/prompt_builder.py,sha256=8_rNRJksn2QLV_K98S0x0qNeHcmxhU0kB_53IZJTGOU,4366
+xgae/engine/task_engine.py,sha256=mjS7oDlJH-1wBohzz1FfFng2nE_K0xL-QaNZDuQss3A,17986
+xgae/engine/responser/non_stream_responser.py,sha256=kOP9kDEhHtrDKMyVnBPWEx0yO-xTvVacfXGJJqFtONU,6395
+xgae/engine/responser/responser_base.py,sha256=rn3-LkS_alZUwdIxPfDGC_zAH_CncSQ2I-euYA6a45w,30524
+xgae/engine/responser/stream_responser.py,sha256=5KzCHApiPplZ-zN_sbbEbSvj2rtvKWBshJKe_-x7RDI,52927
+xgae/tools/without_general_tools_app.py,sha256=QknIF4OW9xvOad8gx-F_sCBwQYXqMalnNFvYvZXkQ_I,3789
+xgae/utils/__init__.py,sha256=jChvD-p_p5gsrCZUVYPUGJs4CS9gIdNFcSOpkRpcM4Y,317
+xgae/utils/json_helpers.py,sha256=K1ja6GJCatrAheW9bEWAYSQbDI42__boBCZgtsv1gtk,4865
+xgae/utils/llm_client.py,sha256=RvID4bL9yZon096uvuoFZPlqAPiHhET9-9qYp6sUERc,12605
+xgae/utils/misc.py,sha256=EK94YesZp8AmRUqWfN-CjTxyEHPWdIIWpFNO17dzm9g,915
+xgae/utils/setup_env.py,sha256=EVk0KG92Sk6ejBxXZbDDr_dc3KM8GFMofMA4HvXqSfM,2409
+xgae/utils/xml_tool_parser.py,sha256=EJ6BjpD4CSdmS_LqViUJ6P8H9GY2R1e4Dh8rLCR6nSE,7474
+xgae-0.1.7.dist-info/METADATA,sha256=AbGuJUOv4574WF9a2nQNaTxuOKEN2K_U7RaACci2PME,309
+xgae-0.1.7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+xgae-0.1.7.dist-info/entry_points.txt,sha256=rhQ9Vksnu8nA78lPTjiJxOCZ5k6sH6s5YNMR68y7C-A,73
+xgae-0.1.7.dist-info/RECORD,,

xgae-0.1.7.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+xgae-tools = xgae.tools.without_general_tools_app:main

xgae-0.1.6.dist-info/RECORD

@@ -1,17 +0,0 @@
-xgae/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-xgae/engine/engine_base.py,sha256=ySERuLy1YWsf-3s0NFKcyTnXQ4g69wR-cQhtnG0OFmU,1747
-xgae/engine/mcp_tool_box.py,sha256=6mdvu9-aquyLJEwebTtpa_bfGmgT1jPszKE90NIpR5c,9852
-xgae/engine/prompt_builder.py,sha256=ygFAIc4p3opIMyl6g1JeBuSiMjNVxwRloKeF2eX8R5I,4354
-xgae/engine/task_engine.py,sha256=xxAWtPfKgSpf6L7wOc243U-7YP8AC2WYoCI-FUdDpOc,18132
-xgae/engine/responser/non_stream_responser.py,sha256=QEFE4JGYVaIbFeMUMJa1Mt1uBblU_hAOywAhyp9V1k4,6634
-xgae/engine/responser/responser_base.py,sha256=aHKJ880B1ezfBWzyHoOSNVDb-CJY4ujH2MGm61aJLy8,31468
-xgae/engine/responser/stream_responser.py,sha256=5KzCHApiPplZ-zN_sbbEbSvj2rtvKWBshJKe_-x7RDI,52927
-xgae/utils/__init__.py,sha256=jChvD-p_p5gsrCZUVYPUGJs4CS9gIdNFcSOpkRpcM4Y,317
-xgae/utils/json_helpers.py,sha256=K1ja6GJCatrAheW9bEWAYSQbDI42__boBCZgtsv1gtk,4865
-xgae/utils/llm_client.py,sha256=mgzn8heUyRm92HTLEYGdfsGEpFtD-xLFr39P98_JP0s,12402
-xgae/utils/misc.py,sha256=EK94YesZp8AmRUqWfN-CjTxyEHPWdIIWpFNO17dzm9g,915
-xgae/utils/setup_env.py,sha256=Nc0HCQOnK-EGNLTWCQ9-iYysNRdIvwGhcHdqpNeV910,2407
-xgae/utils/xml_tool_parser.py,sha256=EJ6BjpD4CSdmS_LqViUJ6P8H9GY2R1e4Dh8rLCR6nSE,7474
-xgae-0.1.6.dist-info/METADATA,sha256=Q5OiPe5W3H7ym2TDPaM1x3k6jSTIol3QDyWI0dsQetw,309
-xgae-0.1.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-xgae-0.1.6.dist-info/RECORD,,