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

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

@@ -114,10 +114,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")
-
-            self.task_prompt = self.prompt_builder.build_task_prompt(self.model_name, general_tool_schemas, custom_tool_schemas)
+            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,
+                                                                     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}")

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.16.dist-info → xgae-0.1.18.dist-info}/METADATA

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

xgae-0.1.18.dist-info/RECORD

@@ -0,0 +1,21 @@
+xgae/__init__.py,sha256=OEUd9y9AoGBd3xYerdTTpz9xl4NWkmXeq1a2eil7Qro,72
+xgae/cli_app.py,sha256=ieTaS0b532P_8g9Mz2xda8TOZwYD2hKGnNZiarADAM0,3000
+xgae/engine/engine_base.py,sha256=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=_GfIpWGBd83jf2xnS0vDvgyQR0mqQSb6ZrGoBFFrMt4,21249
+xgae/engine/task_langfuse.py,sha256=n2bajsHq2Zt3jetel8cSlN2lo42mZgTmbR4Zbx9JvsM,2416
+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.18.dist-info/METADATA,sha256=zMbJrDIxmWY79uRRluq-HuNOtxdE7jOQELEcRvVB57w,310
+xgae-0.1.18.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+xgae-0.1.18.dist-info/entry_points.txt,sha256=KdL6b_heFPyb1XIq5_L8Rgydpn64VDExFZafU_Qd9ow,222
+xgae-0.1.18.dist-info/RECORD,,

{xgae-0.1.16.dist-info → xgae-0.1.18.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-tools = xgae.tools.without_general_tools_app:main

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