xgae 0.1.17__py3-none-any.whl → 0.1.19__py3-none-any.whl

xgae/__init__.py

@@ -1,4 +1,4 @@
 if __name__ == "__main__":
-    from xgae.cli_app import main
+    from xgae.engine_cli_app import main
 
     main()

xgae/engine/engine_base.py

@@ -21,9 +21,12 @@ class XGATaskResult(TypedDict, total=False):
     content: str
     attachments: Optional[List[str]]
 
+XGAToolType = Literal["general", "custom",  "agent"]
+
 @dataclass
 class XGAToolSchema:
     tool_name: str
+    tool_type: XGAToolType
     server_name: str
     description: str
     input_schema: Dict[str, Any]
@@ -46,7 +49,7 @@ class XGAToolBox(ABC):
         pass
 
     @abstractmethod
-    def get_task_tool_schemas(self, task_id: str, type: Literal["general_tool",  "custom_tool"]) -> List[XGAToolSchema]:
+    def get_task_tool_schemas(self, task_id: str, type: XGAToolType) -> List[XGAToolSchema]:
         pass
 
     @abstractmethod

xgae/engine/mcp_tool_box.py

@@ -7,10 +7,11 @@ from typing import List, Any, Dict, Optional, Literal, override
 from langchain_mcp_adapters.client import MultiServerMCPClient
 from langchain_mcp_adapters.tools import load_mcp_tools
 
-from xgae.engine.engine_base import XGAError, XGAToolSchema, XGAToolBox, XGAToolResult
+from xgae.engine.engine_base import XGAError, XGAToolSchema, XGAToolBox, XGAToolResult, XGAToolType
 
 class XGAMcpToolBox(XGAToolBox):
     GENERAL_MCP_SERVER_NAME = "xga_general"
+    AGENT_MCP_SERVER_PREFIX = "_@_"
 
     def __init__(self,
                  custom_mcp_server_file: Optional[str] = None,
@@ -37,7 +38,7 @@ class XGAMcpToolBox(XGAToolBox):
     @override
     async def creat_task_tool_box(self, task_id: str, general_tools: List[str], custom_tools: List[str]):
         task_tool_schemas = {}
-        general_tool_schemas = self.mcp_tool_schemas.get(XGAMcpToolBox.GENERAL_MCP_SERVER_NAME, {})
+        general_tool_schemas = self.mcp_tool_schemas.get(self.GENERAL_MCP_SERVER_NAME, {})
         if "*" in general_tools:
             task_tool_schemas = {tool_schema.tool_name: tool_schema for tool_schema in general_tool_schemas}
         else:
@@ -49,7 +50,7 @@ class XGAMcpToolBox(XGAToolBox):
         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:
+                if server_name != self.GENERAL_MCP_SERVER_NAME:
                     custom_tools.append(f"{server_name}.*")
 
         for server_tool_name in custom_tools:
@@ -76,7 +77,7 @@ class XGAMcpToolBox(XGAToolBox):
 
     @override
     async def destroy_task_tool_box(self, task_id: str):
-        tool_schemas = self.get_task_tool_schemas(task_id, type="general_tool")
+        tool_schemas = self.get_task_tool_schemas(task_id, "general")
         if len(tool_schemas) > 0:
             await self.call_tool(task_id, "end_task", {'task_id': task_id})
         self.task_tool_schemas.pop(task_id, None)
@@ -88,14 +89,12 @@ class XGAMcpToolBox(XGAToolBox):
         return task_tool_names
 
     @override
-    def get_task_tool_schemas(self, task_id: str, type: Literal["general_tool",  "custom_tool"]) -> List[XGAToolSchema]:
+    def get_task_tool_schemas(self, task_id: str, tool_type: XGAToolType) -> List[XGAToolSchema]:
         task_tool_schemas = []
 
         all_task_tool_schemas = self.task_tool_schemas.get(task_id, {})
         for tool_schema in all_task_tool_schemas.values():
-            if type == "general_tool" and tool_schema.server_name == self.GENERAL_MCP_SERVER_NAME:
-                task_tool_schemas.append(tool_schema)
-            elif type == "custom_tool" and tool_schema.server_name != self.GENERAL_MCP_SERVER_NAME:
+            if tool_schema.tool_type == tool_type:
                 task_tool_schemas.append(tool_schema)
 
         return task_tool_schemas
@@ -114,16 +113,16 @@ class XGAMcpToolBox(XGAToolBox):
         async with self._mcp_client.session(server_name) as session:
             tools = await load_mcp_tools(session)
             mcp_tool = next((t for t in tools if t.name == tool_name), None)
-            is_general_tool = False
+
             if mcp_tool:
                 tool_args = args or {}
-                if server_name == self.GENERAL_MCP_SERVER_NAME:
+                tool_type = self._get_tool_type(server_name)
+                if tool_type == "general" or tool_type == "agent":
                     tool_args = dict({'task_id': task_id}, **tool_args)
-                    is_general_tool = True
 
                 try:
                     tool_result = await mcp_tool.arun(tool_args)
-                    if is_general_tool:
+                    if tool_type == "general":
                         tool_result = json.loads(tool_result)
                         result = XGAToolResult(success=tool_result['success'], output=str(tool_result['output']))
                     else:
@@ -144,11 +143,17 @@ class XGAMcpToolBox(XGAToolBox):
         if not self.is_loaded_tool_schemas:
             for server_name in self.mcp_server_names:
                 self.mcp_tool_schemas[server_name] = []
-                mcp_tools = await self._mcp_client.get_tools(server_name=server_name)
+                try:
+                    mcp_tools = await self._mcp_client.get_tools(server_name=server_name)
+                except Exception as e:
+                    logging.error(f"### McpToolBox load_mcp_tools_schema: Langchain mcp get_tools failed, "
+                                  f"need start mcp server '{server_name}' !")
+                    continue
 
+                tool_type = self._get_tool_type(server_name)
                 for tool in mcp_tools:
                     input_schema = tool.args_schema
-                    if server_name == self.GENERAL_MCP_SERVER_NAME:
+                    if tool_type == "general" or tool_type == "agent":
                         input_schema['properties'].pop("task_id", None)
                         if 'task_id' in input_schema['required']:
                             input_schema['required'].remove('task_id')
@@ -158,6 +163,7 @@ class XGAMcpToolBox(XGAToolBox):
 
                     metadata = tool.metadata or {}
                     tool_schema = XGAToolSchema(tool_name=tool.name,
+                                                tool_type=tool_type,
                                                 server_name=server_name,
                                                 description=tool.description,
                                                 input_schema=input_schema,
@@ -169,8 +175,8 @@ class XGAMcpToolBox(XGAToolBox):
         self.is_loaded_tool_schemas = False
         await self.load_mcp_tools_schema()
 
-    @staticmethod
-    def _load_mcp_servers_config(mcp_config_path: str) -> Dict[str, Any]:
+
+    def _load_mcp_servers_config(self, mcp_config_path: str) -> Dict[str, Any]:
         try:
             if os.path.exists(mcp_config_path):
                 with open(mcp_config_path, 'r', encoding="utf-8") as f:
@@ -192,6 +198,13 @@ class XGAMcpToolBox(XGAToolBox):
             logging.error(f"McpToolBox load_mcp_servers_config: Failed to load MCP servers config: {e}")
             return {'mcpServers': {}}
 
+    def _get_tool_type(self, server_name: str) -> XGAToolType:
+        tool_type: XGAToolType = "custom"
+        if server_name == self.GENERAL_MCP_SERVER_NAME:
+            tool_type = "general"
+        elif server_name.startswith(self.AGENT_MCP_SERVER_PREFIX):
+            tool_type = "agent"
+        return tool_type
 
 if __name__ == "__main__":
     import asyncio
@@ -207,14 +220,14 @@ if __name__ == "__main__":
 
         task_id = "task1"
         await mcp_tool_box.load_mcp_tools_schema()
-        await mcp_tool_box.creat_task_tool_box(task_id=task_id, general_tools=["*"], custom_tools=["bomc_fault.*"])
-        tool_schemas = mcp_tool_box.get_task_tool_schemas(task_id, "general_tool")
+        await mcp_tool_box.creat_task_tool_box(task_id=task_id, general_tools=["*"], custom_tools=["*"])
+        tool_schemas = mcp_tool_box.get_task_tool_schemas(task_id, "general")
         print("general_tools_schemas" + "*"*50)
         for tool_schema in tool_schemas:
             print(asdict(tool_schema))
         print()
 
-        tool_schemas = mcp_tool_box.get_task_tool_schemas(task_id, "custom_tool")
+        tool_schemas = mcp_tool_box.get_task_tool_schemas(task_id, "custom")
         print("custom_tools_schemas" + "*" * 50)
         for tool_schema in tool_schemas:
             print(asdict(tool_schema))

xgae/engine/prompt_builder.py

@@ -11,7 +11,11 @@ class XGAPromptBuilder():
     def __init__(self, system_prompt: Optional[str] = None):
         self.system_prompt = system_prompt
 
-    def build_task_prompt(self, model_name: str, general_tool_schemas: List[XGAToolSchema], custom_tool_schemas: List[XGAToolSchema])-> str:
+    def build_task_prompt(self,
+                          model_name: str,
+                          general_tool_schemas: List[XGAToolSchema],
+                          custom_tool_schemas: List[XGAToolSchema],
+                          agent_tool_schemas: List[XGAToolSchema])-> str:
         if self.system_prompt is None:
             self.system_prompt = self._load_default_system_prompt(model_name)
 
@@ -23,6 +27,9 @@ class XGAPromptBuilder():
         tool_prompt = self.build_custom_tool_prompt(custom_tool_schemas)
         task_prompt = task_prompt + "\n" + tool_prompt
 
+        tool_prompt = self.build_agent_tool_prompt(agent_tool_schemas)
+        task_prompt = task_prompt + "\n" + tool_prompt
+
         return task_prompt
 
     def build_general_tool_prompt(self, tool_schemas:List[XGAToolSchema])-> str:
@@ -61,10 +68,18 @@ class XGAPromptBuilder():
 
 
     def build_custom_tool_prompt(self, tool_schemas:List[XGAToolSchema])-> str:
+        tool_prompt = self.build_mcp_tool_prompt("templates/custom_tool_prompt_template.txt", tool_schemas)
+        return tool_prompt
+
+    def build_agent_tool_prompt(self, tool_schemas:List[XGAToolSchema])-> str:
+        tool_prompt = self.build_mcp_tool_prompt("templates/agent_tool_prompt_template.txt", tool_schemas)
+        return tool_prompt
+
+    def build_mcp_tool_prompt(self, file_path: str, tool_schemas:List[XGAToolSchema])-> str:
         tool_prompt = ""
         tool_schemas = tool_schemas or []
         if len(tool_schemas) > 0:
-            tool_prompt = read_file("templates/custom_tool_prompt_template.txt")
+            tool_prompt = read_file(file_path)
             tool_info = ""
             for tool_schema in tool_schemas:
                 description = tool_schema.description if tool_schema.description else 'No description available'

xgae/engine/responser/non_stream_responser.py

@@ -64,7 +64,7 @@ class NonStreamTaskResponser(TaskResponseProcessor):
                     tool_start_msg = self._add_tool_start_message(tool_context)
                     yield tool_start_msg
 
-                    tool_message = self._add_tool_messsage(tool_call, tool_result, self.xml_adding_strategy, assistant_msg_id, parsing_details)
+                    tool_message = self._add_tool_messsage(tool_context, self.xml_adding_strategy)
 
                     tool_completed_msg = self._add_tool_completed_message(tool_context, tool_message['message_id'])
                     yield tool_completed_msg

xgae/engine/responser/responser_base.py

@@ -376,19 +376,31 @@ class TaskResponseProcessor(ABC):
         logging.info(f"TaskProcessor execute_tools_in_parallel: Execution completed for {len(results)} tools, total {tool_num} tools)")
         return processed_results
 
+    def _create_tool_context(self,
+                             tool_call: Dict[str, Any],
+                             tool_index: int,
+                             assistant_message_id: Optional[str] = None,
+                             parsing_details: Optional[Dict[str, Any]] = None,
+                             result: Optional[XGAToolResult] = None,
+                             ) -> ToolExecutionContext:
+        """Create a tool execution context with display name and parsing details populated."""
+        return ToolExecutionContext(
+            tool_call               = tool_call,
+            tool_index              = tool_index,
+            function_name           = tool_call['function_name'],
+            xml_tag_name            = tool_call['xml_tag_name'],
+            assistant_message_id    = assistant_message_id,
+            parsing_details         = parsing_details,
+            result                  = result
+        )
 
-    def _add_tool_messsage(self,
-                           tool_call: Dict[str, Any],
-                           result: XGAToolResult,
-                           strategy: XmlAddingStrategy = "assistant_message",
-                           assistant_message_id: Optional[str] = None,
-                           parsing_details: Optional[Dict[str, Any]] = None
-                           ) -> Optional[Dict[str, Any]]:  # Return the full message object
+
+    def _add_tool_messsage(self,context:ToolExecutionContext, strategy: XmlAddingStrategy) -> Optional[Dict[str, Any]]:  # Return the full message object
         # Create two versions of the structured result
         # Rich version for the frontend
-        result_for_frontend = self._create_structured_tool_result(tool_call, result, parsing_details, for_llm=False)
+        result_for_frontend = self._create_structured_tool_result(context.tool_call, context.result, context.parsing_details, for_llm=False)
         # Concise version for the LLM
-        result_for_llm = self._create_structured_tool_result(tool_call, result, parsing_details, for_llm=True)
+        result_for_llm = self._create_structured_tool_result(context.tool_call, context.result, context.parsing_details, for_llm=True)
 
         # Add the message with the appropriate role to the conversation history
         # This allows the LLM to see the tool result in subsequent interactions
@@ -399,11 +411,11 @@ class TaskResponseProcessor(ABC):
         }
 
         metadata = {}
-        if assistant_message_id:
-            metadata['assistant_message_id'] = assistant_message_id
+        if context.assistant_message_id:
+            metadata['assistant_message_id'] = context.assistant_message_id
 
-        if parsing_details:
-            metadata['parsing_details'] = parsing_details
+        if context.parsing_details:
+            metadata['parsing_details'] = context.parsing_details
 
         metadata['frontend_content'] = result_for_frontend
 
@@ -455,25 +467,6 @@ class TaskResponseProcessor(ABC):
         return structured_result
 
 
-    def _create_tool_context(self,
-                             tool_call: Dict[str, Any],
-                             tool_index: int,
-                             assistant_message_id: Optional[str] = None,
-                             parsing_details: Optional[Dict[str, Any]] = None,
-                             result: Optional[XGAToolResult] = None,
-                             ) -> ToolExecutionContext:
-        """Create a tool execution context with display name and parsing details populated."""
-        return ToolExecutionContext(
-            tool_call               = tool_call,
-            tool_index              = tool_index,
-            function_name           = tool_call['function_name'],
-            xml_tag_name            = tool_call['xml_tag_name'],
-            assistant_message_id    = assistant_message_id,
-            parsing_details         = parsing_details,
-            result                  = result
-        )
-
-
     def _add_tool_start_message(self, context: ToolExecutionContext) -> Optional[Dict[str, Any]]:
         """Formats, saves, and returns a tool started status message."""
         content = {

xgae/engine/responser/stream_responser.py

@@ -43,8 +43,9 @@ class StreamTaskResponser(TaskResponseProcessor):
                         chunk_content = llm_chunk_msg.content
                         accumulated_content += chunk_content
 
-                        xml_tool_call_count = len(self._extract_xml_chunks(accumulated_content))
-                        if self.max_xml_tool_calls <= 0 or xml_tool_call_count <= self.max_xml_tool_calls:
+                        xml_tool_chunks = self._extract_xml_chunks(accumulated_content)
+                        xml_tool_chunk_len = len(xml_tool_chunks)
+                        if self.max_xml_tool_calls <= 0 or xml_tool_chunk_len <= self.max_xml_tool_calls:
                             if use_assistant_chunk_msg:
                                 message_data = {"role": "assistant", "content": chunk_content}
                                 metadata = {"sequence": msg_sequence}
@@ -57,19 +58,13 @@ class StreamTaskResponser(TaskResponseProcessor):
                         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}")
+                                            f"xml_tool_chunk_len={xml_tool_chunk_len}")
                             break
 
+            parsed_xml_data = self._parse_xml_tool_calls(accumulated_content)
             if finish_reason == "xml_tool_limit_reached":
-                xml_chunks = self._extract_xml_chunks(accumulated_content)
-                if len(xml_chunks) > self.max_xml_tool_calls:
-                    limited_chunks = xml_chunks[:self.max_xml_tool_calls]
-                    if limited_chunks:
-                        last_chunk = limited_chunks[-1]
-                        last_chunk_pos = accumulated_content.find(last_chunk) + len(last_chunk)
-                        accumulated_content = accumulated_content[:last_chunk_pos]
+                parsed_xml_data = parsed_xml_data[:self.max_xml_tool_calls]
 
-            parsed_xml_data = self._parse_xml_tool_calls(accumulated_content)
             should_auto_continue = (can_auto_continue and finish_reason == 'length')
 
             self.root_span.event(name=f"stream_processor_start[{self.task_no}]({auto_continue_count})", level="DEFAULT",
@@ -77,13 +72,12 @@ class StreamTaskResponser(TaskResponseProcessor):
                                                 f"parsed_xml_data_len={len(parsed_xml_data)}, accumulated_content_len={len(accumulated_content)}, "
                                                 f"should_auto_continue={should_auto_continue}")
 
-            assistant_msg = None
+            assistant_msg_id = None
             if accumulated_content and not should_auto_continue:
                 message_data = {"role": "assistant", "content": accumulated_content}
                 assistant_msg = self.add_response_message(type="assistant", content=message_data, is_llm_message=True)
                 yield assistant_msg
-
-            assistant_msg_id = assistant_msg['message_id'] if assistant_msg else None
+                assistant_msg_id = assistant_msg['message_id']
 
             tool_calls_to_execute = [item['tool_call'] for item in parsed_xml_data]
             if len(tool_calls_to_execute) > 0 and not should_auto_continue:
@@ -94,12 +88,12 @@ class StreamTaskResponser(TaskResponseProcessor):
                     tool_call = parsed_xml_item['tool_call']
                     parsing_details = parsed_xml_item['parsing_details']
 
-                    tool_context = self._create_tool_context(tool_call, tool_index, assistant_msg_id,parsing_details, tool_result)
+                    tool_context = self._create_tool_context(tool_call, tool_index, assistant_msg_id, parsing_details, tool_result)
 
                     tool_start_msg = self._add_tool_start_message(tool_context)
                     yield tool_start_msg
 
-                    tool_message = self._add_tool_messsage(tool_call, tool_result, self.xml_adding_strategy,assistant_msg_id, parsing_details)
+                    tool_message = self._add_tool_messsage(tool_context, self.xml_adding_strategy)
 
                     tool_completed_msg = self._add_tool_completed_message(tool_context, tool_message['message_id'])
                     yield tool_completed_msg

xgae/engine/task_engine.py

@@ -17,8 +17,9 @@ from xgae.engine.responser.responser_base import TaskResponserContext, TaskRespo
 
 class XGATaskEngine:
     def __init__(self,
-                 session_id: Optional[str] = None,
                  task_id: Optional[str] = None,
+                 session_id: Optional[str] = None,
+                 user_id: Optional[str] = None,
                  agent_id: Optional[str] = None,
                  general_tools: Optional[List[str]] = None,
                  custom_tools: Optional[List[str]] = None,
@@ -29,8 +30,9 @@ class XGATaskEngine:
                  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.session_id = session_id
+        self.user_id    = user_id
+        self.agent_id   = agent_id
 
         self.llm_client = LLMClient(llm_config)
         self.model_name = self.llm_client.model_name
@@ -56,16 +58,16 @@ class XGATaskEngine:
         self.task_response_msgs: List[XGAResponseMessage] = []
 
     async def run_task_with_final_answer(self,
-                                         task_message: Dict[str, Any],
+                                         task_input: Dict[str, Any],
                                          trace_id: Optional[str] = None) -> XGATaskResult:
-        final_result:XGATaskResult = None
+        final_result: XGATaskResult = None
         try:
             await self._init_task()
 
-            self.task_langfuse.start_root_span("run_task_with_final_answer", task_message, trace_id)
+            self.task_langfuse.start_root_span("run_task_with_final_answer", task_input, trace_id)
 
             chunks = []
-            async for chunk in self.run_task(task_message=task_message, trace_id=trace_id):
+            async for chunk in self.run_task(task_input, trace_id):
                 chunks.append(chunk)
 
             if len(chunks) > 0:
@@ -79,14 +81,14 @@ class XGATaskEngine:
 
 
     async def run_task(self,
-                       task_message: Dict[str, Any],
+                       task_input: Dict[str, Any],
                        trace_id: Optional[str] = None) -> AsyncGenerator[Dict[str, Any], None]:
         try:
             await self._init_task()
 
-            self.task_langfuse.start_root_span("run_task", task_message, trace_id)
+            self.task_langfuse.start_root_span("run_task", task_input, trace_id)
 
-            self.add_response_message(type="user", content=task_message, is_llm_message=True)
+            self.add_response_message(type="user", content=task_input, is_llm_message=True)
 
             async for chunk in self._run_task_auto():
                 yield chunk
@@ -114,10 +116,14 @@ class XGATaskEngine:
                 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")
+            general_tool_schemas = self.tool_box.get_task_tool_schemas(self.task_id, "general")
+            custom_tool_schemas = self.tool_box.get_task_tool_schemas(self.task_id, "custom")
+            agent_tool_schemas = self.tool_box.get_task_tool_schemas(self.task_id, "agent")
 
-            self.task_prompt = self.prompt_builder.build_task_prompt(self.model_name, general_tool_schemas, custom_tool_schemas)
+            self.task_prompt = self.prompt_builder.build_task_prompt(self.model_name,
+                                                                     general_tool_schemas,
+                                                                     custom_tool_schemas,
+                                                                     agent_tool_schemas)
 
             logging.info("*" * 10 + f"   XGATaskEngine Task'{self.task_id}' Initialized   " + "*" * 10)
             logging.info(f"model_name={self.model_name}, is_stream={self.is_stream}")
@@ -149,30 +155,30 @@ class XGATaskEngine:
                             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')}")
+                                logging.error(f"XGATaskEngine run_task_auto: task_response error: {chunk.get('message')}")
                                 auto_continue = False
                                 break
                             elif status_type == "finish":
                                 finish_reason = status_content['finish_reason']
                                 if finish_reason == "completed":
-                                    logging.info(f"TaskEngine run_task_auto: Detected finish_reason='completed', TASK_COMPLETE Success !")
+                                    logging.info(f"XGATaskEngine run_task_auto: Detected finish_reason='completed', TASK_COMPLETE Success !")
                                     auto_continue = False
                                     break
                                 elif finish_reason == "xml_tool_limit_reached":
-                                    logging.warning(f"TaskEngine run_task_auto: Detected finish_reason='xml_tool_limit_reached', stop auto-continue")
+                                    logging.warning(f"XGATaskEngine 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"TaskEngine run_task_auto: Detected finish_reason='non_tool_call', stop auto-continue")
+                                    logging.warning(f"XGATaskEngine run_task_auto: Detected finish_reason='non_tool_call', stop auto-continue")
                                     auto_continue = False
                                     break
                                 elif finish_reason in ["stop", "length"]: # 'length'  occur on some LLM
                                     auto_continue_count += 1
                                     auto_continue = True if auto_continue_count < self.max_auto_run else False
                                     update_continuous_state(auto_continue_count, auto_continue)
-                                    logging.info(f"TaskEngine run_task_auto: Detected finish_reason='{finish_reason}', auto-continuing ({auto_continue_count}/{self.max_auto_run})")
+                                    logging.info(f"XGATaskEngine run_task_auto: Detected finish_reason='{finish_reason}', auto-continuing ({auto_continue_count}/{self.max_auto_run})")
                     except Exception as parse_error:
-                        trace = log_trace(parse_error,f"TaskEngine run_task_auto: Parse chunk error, chunk: {chunk}")
+                        trace = log_trace(parse_error,f"XGATaskEngine 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})
@@ -181,7 +187,7 @@ class XGATaskEngine:
                         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")
+                trace = log_trace(run_error, "XGATaskEngine 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})
@@ -267,7 +273,7 @@ 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:
-            trace = log_trace(e, f"TaskEngine parse_final_result: Parse message chunk error, chunk: {chunk}")
+            trace = log_trace(e, f"XGATaskEngine 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})
@@ -281,11 +287,12 @@ class XGATaskEngine:
                              is_llm_message: bool,
                              metadata: Optional[Dict[str, Any]]=None)-> XGAResponseMessage:
         metadata = metadata or {}
-        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['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['user_id']     = self.user_id
+        metadata['agent_id']    = self.agent_id
 
         message = XGAResponseMessage(
             message_id      = f"xga_msg_{uuid4()}",
@@ -355,7 +362,14 @@ class XGATaskEngine:
 
 
     def _create_task_langfuse(self)-> XGATaskLangFuse:
-        return XGATaskLangFuse(self.session_id, self.task_id, self.task_run_id, self.task_no, self.agent_id)
+        return XGATaskLangFuse(
+            task_id      = self.task_id,
+            task_run_id  = self.task_run_id,
+            task_no      = self.task_no,
+            session_id   = self.session_id,
+            agent_id     = self.agent_id,
+            user_id      = self.user_id
+        )
 
 
     def _logging_reponse_chunk(self, chunk, auto_count: int)-> None:
@@ -380,11 +394,11 @@ class XGATaskEngine:
                 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}")
+                logging.debug(f"TASK_RESP_CHUNK[{self.task_no}]({auto_count})<{chunk_type}{prefix}> content: {pretty_content}")
             else:
-                logging.info(f"TASK_RESP_CHUNK[{auto_count}]<{chunk_type}{prefix}> content: {pretty_content}")
+                logging.info(f"TASK_RESP_CHUNK[{self.task_no}]({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.error(f"XGATaskEngine logging_reponse_chunk: Decorate chunk={chunk}, error: {e}")
 
 
 
@@ -406,7 +420,7 @@ if __name__ == "__main__":
                                 agent_id="agent_1"
                                 )
         user_input = "locate 10.0.0.1 fault and solution"
-        final_result = await engine.run_task_with_final_answer(task_message={'role': "user", 'content': user_input})
+        final_result = await engine.run_task_with_final_answer(task_input={'role': "user", 'content': user_input})
         print(f"FINAL RESULT:{final_result}")
 
 

xgae/engine/task_langfuse.py

@@ -1,4 +1,4 @@
-
+import logging
 from typing import Any, Dict, Optional
 from langfuse import Langfuse
 
@@ -10,10 +10,11 @@ class XGATaskLangFuse:
     langfuse: Langfuse = None
 
     def __init__(self,
-                 session_id: str,
                  task_id:str,
                  task_run_id: str,
                  task_no: int,
+                 session_id: str,
+                 user_id: str,
                  agent_id: str) -> None:
         if XGATaskLangFuse.langfuse is None:
             XGATaskLangFuse.langfuse =  setup_langfuse()
@@ -22,6 +23,7 @@ class XGATaskLangFuse:
         self.task_id        = task_id
         self.task_run_id    = task_run_id
         self.task_no        = task_no
+        self.user_id        = user_id
         self.agent_id       = agent_id
 
         self.trace_id       = None
@@ -31,7 +33,7 @@ class XGATaskLangFuse:
 
     def start_root_span(self,
                         root_span_name: str,
-                        task_message: Dict[str, Any],
+                        task_input: Dict[str, Any],
                         trace_id: Optional[str] = None):
         if self.root_span is None:
             trace = None
@@ -39,13 +41,23 @@ class XGATaskLangFuse:
                 self.trace_id = trace_id
                 trace = XGATaskLangFuse.langfuse.trace(id=trace_id)
             else:
-                trace = XGATaskLangFuse.langfuse.trace(name="xga_task_engine")
+                trace = XGATaskLangFuse.langfuse.trace(name="xga_task_engine", session_id=self.session_id)
                 self.trace_id = trace.id
 
-            metadata = {'task_id': self.task_id, 'session_id': self.session_id, 'agent_id': self.agent_id}
-            self.root_span = trace.span(id=self.task_run_id, name=root_span_name, input=task_message,metadata=metadata)
+            metadata = {
+                'task_id'       : self.task_id,
+                'session_id'    : self.session_id,
+                'user_id'       : self.user_id,
+                'agent_id'      : self.agent_id
+            }
+
+            self.root_span = trace.span(id=self.task_run_id,
+                                        name=f"{root_span_name}[{self.task_no}]",
+                                        input=task_input,
+                                        metadata=metadata)
             self.root_span_name = root_span_name
 
+            logging.info(f"{root_span_name} TASK_INPUT: {task_input}")
 
     def end_root_span(self, root_span_name:str, output: Optional[XGATaskResult]=None):
         if self.root_span and self.root_span_name == root_span_name:
@@ -55,7 +67,7 @@ class XGATaskLangFuse:
 
 
     def create_llm_langfuse_meta(self, llm_count:int)-> LangfuseMetadata:
-        generation_name = f"xga_task_engine_llm_completion[{self.task_no}]({llm_count})"
+        generation_name = f"xga_engine_llm_completion[{self.task_no}]({llm_count})"
         generation_id = f"{self.task_run_id}({llm_count})"
         return LangfuseMetadata(
             generation_name     = generation_name,

xgae/{cli_app.py → engine_cli_app.py}

@@ -14,7 +14,7 @@ langfuse = setup_langfuse()
 def get_user_message(question)-> str:
     while True:
         user_message = input(f"\n💬 {question}: ")
-        if user_message.lower() == 'exit':
+        if user_message.lower() == 'exit' or user_message.lower() == 'quit':
             print("\n====== Extreme General Agent Engine CLI EXIT ======")
             sys.exit()
 
@@ -44,7 +44,7 @@ async def cli() -> None:
         general_tools = ["*"]
 
     while True:
-        user_message = get_user_message("Enter your message (or 'exit' to quit)")
+        user_message = get_user_message("Enter your task input message (or 'exit' to quit)")
 
         print("\n🔄 Running XGA Engine ...\n")
         engine = XGATaskEngine(tool_box=tool_box,
@@ -54,27 +54,24 @@ async def cli() -> None:
 
         # Two task run in same langfuse trace
         trace_id = langfuse.trace(name="xgae_cli").trace_id
-
-        final_result = await engine.run_task_with_final_answer(
-            task_message={'role': "user", 'content': user_message},
-            trace_id=trace_id
-        )
-
-        if final_result["type"] == "ask":
-            await asyncio.sleep(1)
-            print(f"\n📌 ASK INFO: {final_result['content']}")
-            user_message = get_user_message("Enter ASK information (or 'exit' to quit)")
+        auto_continue = True
+        while auto_continue:
+            auto_continue = False
             final_result = await engine.run_task_with_final_answer(
-                task_message={'role': "user", 'content': user_message},
+                task_input={'role': "user", 'content': user_message},
                 trace_id=trace_id
             )
 
-        await asyncio.sleep(1)
-        result_prefix = "✅" if final_result["type"] == "answer" else "❌"
-        if final_result["type"] == "ask":
-            print("\n *** IMPORTANT: XGA CLI only support showing ONE TURN ASK !")
-            result_prefix = "⚠️"
-        print(f"\n {result_prefix} FINAL RESULT: {final_result['content']}")
+            if final_result["type"] == "ask":
+                await asyncio.sleep(1)
+                print(f"\n📌 ASK INFO: {final_result['content']}")
+                user_message = get_user_message("Enter ASK information (or 'exit' to quit)")
+                auto_continue = True
+                continue
+
+            await asyncio.sleep(1)
+            result_prefix = "✅" if final_result["type"] == "answer" else "❌"
+            print(f"\n {result_prefix} FINAL RESULT: {final_result['content']}")
 
 
 def main():

xgae/tools/without_general_tools_app.py

@@ -10,7 +10,7 @@ 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,
+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,
@@ -23,7 +23,7 @@ async def complete(task_id: str,
 @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,
+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,
@@ -36,7 +36,7 @@ async def ask(task_id: str,
 @mcp.tool(
     description="end task, destroy sandbox"
 )
-async def end_task(task_id: str) :
+def end_task(task_id: str) :
     print(f"<XGAETools-end_task> task_id: {task_id}")
     return XGAToolResult(success=True, output="")
 

{xgae-0.1.17.dist-info → xgae-0.1.19.dist-info}/METADATA

@@ -1,10 +1,11 @@
 Metadata-Version: 2.4
 Name: xgae
-Version: 0.1.17
+Version: 0.1.19
 Summary: Extreme General Agent Engine
 Requires-Python: >=3.13
 Requires-Dist: colorlog==6.9.0
 Requires-Dist: langchain-mcp-adapters==0.1.9
+Requires-Dist: langchain==0.3.27
 Requires-Dist: langfuse==2.60.9
 Requires-Dist: langgraph==0.6.5
 Requires-Dist: litellm==1.74.15

xgae-0.1.19.dist-info/RECORD

@@ -0,0 +1,21 @@
+xgae/__init__.py,sha256=oBX_YzTliM-343BAlR-sD7BUZmsCJ7PY2oYrGBhsdLM,79
+xgae/engine_cli_app.py,sha256=FdmIpq8KDsgyZNfwCDgNX7FEZFeRFyGOt_H1oZF8aKs,2890
+xgae/engine/engine_base.py,sha256=RR1em2wHiM2jP-peHt77SKdHWjnYOjdIIzN93zT61cA,1715
+xgae/engine/mcp_tool_box.py,sha256=G4hKIMguwg1cO4Us2NMfdloYim8kuikVyVTIPucJr7o,10903
+xgae/engine/prompt_builder.py,sha256=6I5rjgvNJ27QJ8DDuBTplutoPZdGs9LYFv3TSgT7zmc,5045
+xgae/engine/task_engine.py,sha256=7B7nbERTh9HDgDH4lXS_s4KTsVU41AgR7rnN4jKLozQ,21588
+xgae/engine/task_langfuse.py,sha256=J9suOhlIGSJor-mZsggPZf3XQld9dTkfpHAS2fVirvM,2859
+xgae/engine/responser/non_stream_responser.py,sha256=zEJjqCgZVe2B8gkHYRFU7tmBV834f7w2a4Ws25P1N-c,5289
+xgae/engine/responser/responser_base.py,sha256=jhl1Bdz1Fs3KofGEymThNXlQuCORFTTkTAR_U47krds,24403
+xgae/engine/responser/stream_responser.py,sha256=cv4UGcxj8OksEogW7DUGTCvSJabu-DF6GceFyUwaXI4,7627
+xgae/tools/without_general_tools_app.py,sha256=KqsdhxD3hvTpiygaGUVHysRFjvv_1A8zOwMKN1J0J0U,3821
+xgae/utils/__init__.py,sha256=ElaGS-zdeZeu6is41u3Ny7lkvhg7BDSK-jMNg9j6K5A,499
+xgae/utils/json_helpers.py,sha256=WD4G5U9Dh8N6J9O0L5wGyqj-NHi09kcXHGdLD_26nlc,3607
+xgae/utils/llm_client.py,sha256=mWRtvtSMk_8NuzFReT9x52ayHlCNVZMZAltD6TQ-xZ8,14404
+xgae/utils/misc.py,sha256=aMWOvJ9VW52q-L9Lkjl1hvXqLwpJAmyxA-Z8jzqFG0U,907
+xgae/utils/setup_env.py,sha256=MqNG0c2QQBDFU1kI8frxr9kB5d08Mmi3QZ1OoorgIa0,2662
+xgae/utils/xml_tool_parser.py,sha256=Mb0d8kBrfyAEvUwW1Nqir-3BgxZRr0ZX3WymQouuFSo,4859
+xgae-0.1.19.dist-info/METADATA,sha256=MHUqZkPIWB9Tn_sLyFkFBw4XZKPAQqC_z0QudI1s5hk,343
+xgae-0.1.19.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+xgae-0.1.19.dist-info/entry_points.txt,sha256=wmvgtMQbtzTbDPETS-tbQJD7jVlcs4hp0w6wOB0ooCc,229
+xgae-0.1.19.dist-info/RECORD,,

{xgae-0.1.17.dist-info → xgae-0.1.19.dist-info}/entry_points.txt

@@ -1,4 +1,5 @@
 [console_scripts]
+example-a2a-tools = examples.tools.simu_a2a_tools_app:main
 example-fault-tools = examples.tools.custom_fault_tools_app:main
-xgae = xgae.cli_app:main
+xgae = xgae.engine_cli_app:main
 xgae-tools = xgae.tools.without_general_tools_app:main

xgae-0.1.17.dist-info/RECORD

@@ -1,21 +0,0 @@
-xgae/__init__.py,sha256=OEUd9y9AoGBd3xYerdTTpz9xl4NWkmXeq1a2eil7Qro,72
-xgae/cli_app.py,sha256=ieTaS0b532P_8g9Mz2xda8TOZwYD2hKGnNZiarADAM0,3000
-xgae/engine/engine_base.py,sha256=-QZqLRbQdwRUfbY4l3i7dFfMB-BL267a-wGZR9bMPLc,1662
-xgae/engine/mcp_tool_box.py,sha256=iAWUWP_goHAEeYYMUvTKiMkR2VkEOoRtNmjLV9HaIUg,10415
-xgae/engine/prompt_builder.py,sha256=dqv0xcB-UWQhqISbMCYCTM1ANtthY6xUe7sJ9vPRqQ4,4364
-xgae/engine/task_engine.py,sha256=oEyDORfDqHn7MzodeLrbhITd8TIIZrDIouF09j0twf0,20940
-xgae/engine/task_langfuse.py,sha256=n2bajsHq2Zt3jetel8cSlN2lo42mZgTmbR4Zbx9JvsM,2416
-xgae/engine/responser/non_stream_responser.py,sha256=HkmeFBIoxORhnFVh6XT0i6ixfF5vNzvN7B_BP6FzPVM,5334
-xgae/engine/responser/responser_base.py,sha256=eQ4E1p_PoQISrIOLmjapGRH_RRX-7LOY1P2SrDjvyTM,24624
-xgae/engine/responser/stream_responser.py,sha256=P6IkPniGli8XNq_BVciHeMCJiE0k3lNokTvX1GqRRbc,8046
-xgae/tools/without_general_tools_app.py,sha256=H3JrwA0u7BIKW69yYBPLDpPesklY5quQIMaSVyvJ4s8,3839
-xgae/utils/__init__.py,sha256=ElaGS-zdeZeu6is41u3Ny7lkvhg7BDSK-jMNg9j6K5A,499
-xgae/utils/json_helpers.py,sha256=WD4G5U9Dh8N6J9O0L5wGyqj-NHi09kcXHGdLD_26nlc,3607
-xgae/utils/llm_client.py,sha256=mWRtvtSMk_8NuzFReT9x52ayHlCNVZMZAltD6TQ-xZ8,14404
-xgae/utils/misc.py,sha256=aMWOvJ9VW52q-L9Lkjl1hvXqLwpJAmyxA-Z8jzqFG0U,907
-xgae/utils/setup_env.py,sha256=MqNG0c2QQBDFU1kI8frxr9kB5d08Mmi3QZ1OoorgIa0,2662
-xgae/utils/xml_tool_parser.py,sha256=Mb0d8kBrfyAEvUwW1Nqir-3BgxZRr0ZX3WymQouuFSo,4859
-xgae-0.1.17.dist-info/METADATA,sha256=mdr1LUj6EQejsp3BWcl8_RKvtg5kLwpS4jlW-wi2_1k,310
-xgae-0.1.17.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-xgae-0.1.17.dist-info/entry_points.txt,sha256=SWN01JNAncV0oApEvFzpH0wsXfnFlB1adCH4IrAJxGc,163
-xgae-0.1.17.dist-info/RECORD,,