xgae 0.1.17__tar.gz → 0.1.18__tar.gz

{xgae-0.1.17 → xgae-0.1.18}/PKG-INFO

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

{xgae-0.1.17 → xgae-0.1.18}/mcpservers/custom_servers.json

@@ -3,6 +3,10 @@
         "bomc_fault": {
             "url": "http://localhost:17070/sse",
             "transport": "sse"
+        },
+        "_@_equip_fault_cause": {
+            "url": "http://localhost:21010/sse",
+            "transport": "sse"
         }
     }
 }

{xgae-0.1.17 → xgae-0.1.18}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "xgae"
-version = "0.1.17"
+version = "0.1.18"
 description = "Extreme General Agent Engine"
 readme = "README.md"
 requires-python = ">=3.13"
@@ -24,3 +24,4 @@ exclude = ["log/*", ".idea/*"]
 xgae = "xgae.cli_app:main"
 xgae-tools = "xgae.tools.without_general_tools_app:main"
 example-fault-tools = "examples.tools.custom_fault_tools_app:main"
+example-a2a-tools = "examples.tools.simu_a2a_tools_app:main"

{xgae-0.1.17 → xgae-0.1.18}/release.md

@@ -1,4 +1,9 @@
 # Release Changelog
+## [0.1.18] - 2025-9-3
+### Added
+- Support Agent tools
+
+
 ## [0.1.17] - 2025-9-1
 ### Target
 - Saved for XGATaskEngine base version

xgae-0.1.18/src/examples/agent/langgraph/react/final_result_agent.py

@@ -0,0 +1,59 @@
+import json
+import logging
+import re
+from typing import Any, Dict, List
+
+from xgae.utils.misc import read_file
+from xgae.utils.llm_client import LLMClient, LangfuseMetadata
+
+class FinalResultAgent:
+    def __init__(self):
+        self.model_client = LLMClient()
+        self.prompt_template: str = read_file("templates/example/final_result_template.txt")
+
+
+    async def final_result(self, user_request: str, task_results: str, langfuse_metadata:LangfuseMetadata=None)-> Dict[str, Any]:
+        prompt = self.prompt_template.replace("{user_request}", user_request)
+        prompt = prompt.replace("{task_results}", task_results)
+
+        messages = [{"role": "user", "content": prompt}]
+
+        response_text: str = ""
+        response = await self.model_client.create_completion(
+            messages,
+            langfuse_metadata
+        )
+        if self.model_client.is_stream:
+            async for chunk in response:
+                choices = chunk.get("choices", [{}])
+                if not choices:
+                    continue
+                delta = choices[0].get("delta", {})
+                content = delta.get("content", "")
+                if content:
+                    response_text += content
+        else:
+            response_text = response.choices[0].message.content
+
+        cleaned_text = re.sub(r'^\s*```json|```\s*$', '', response_text, flags=re.MULTILINE).strip()
+        final_result = json.loads(cleaned_text)
+        return final_result
+
+
+if __name__ == "__main__":
+    import asyncio
+    from xgae.utils.setup_env import setup_logging
+    setup_logging()
+
+    async def main():
+        final_result_agent = FinalResultAgent()
+
+        user_input = "locate 10.2.3.4 fault and solution"
+        answer = ("Task Summary: The fault for IP 10.2.3.4 was identified as a Business Recharge Fault (Code: F01), "
+                  "caused by a Phone Recharge Application Crash. The solution applied was to restart the application. "
+                  "Key Deliverables: Fault diagnosis and resolution steps. Impact Achieved: Service restored.")
+        return await final_result_agent.final_result(user_input, answer)
+
+
+    final_result = asyncio.run(main())
+    print(f"FINAL_RESULT：   {final_result} ")

{xgae-0.1.17 → xgae-0.1.18}/src/examples/agent/langgraph/react/react_agent.py

@@ -40,32 +40,32 @@ class XGAReactAgent:
             graph_builder = StateGraph(TaskState)
 
             # Add nodes
-            graph_builder.add_node("supervisor", self._supervisor_node)
-            graph_builder.add_node("select_tool", self._select_tool_node)
-            graph_builder.add_node("exec_task", self._exec_task_node)
-            graph_builder.add_node("final_result", self._final_result_node)
+            graph_builder.add_node('supervisor', self._supervisor_node)
+            graph_builder.add_node('select_tool', self._select_tool_node)
+            graph_builder.add_node('exec_task', self._exec_task_node)
+            graph_builder.add_node('final_result', self._final_result_node)
 
             # Add edges
-            graph_builder.add_edge(START, "supervisor")
+            graph_builder.add_edge(START, 'supervisor')
             graph_builder.add_conditional_edges(
-                "supervisor",
+                'supervisor',
                 self._next_condition,
                 {
-                    "select_tool": "select_tool",
-                    "exec_task": "exec_task",
-                    "end": END
+                    'select_tool': 'select_tool',
+                    'exec_task': 'exec_task',
+                    'end': END
                 }
             )
 
-            graph_builder.add_edge("select_tool", "exec_task")
-            graph_builder.add_edge("exec_task", "final_result")
+            graph_builder.add_edge('select_tool', 'exec_task')
+            graph_builder.add_edge('exec_task', 'final_result')
 
             graph_builder.add_conditional_edges(
-                "final_result",
+                'final_result',
                 self._next_condition,
                 {
-                    "supervisor": "supervisor",
-                    "end": END
+                    'supervisor': 'supervisor',
+                    'end': END
                 }
             )
             
@@ -91,10 +91,10 @@ class XGAReactAgent:
 
         next_node = "select_tool" if system_prompt else "exec_task"
         return {
-            "system_prompt" : system_prompt,
-            "next_node" : next_node,
-            "general_tools": general_tools,
-            "custom_tools": custom_tools,
+            'system_prompt' : system_prompt,
+            'next_node'     : next_node,
+            'general_tools' : general_tools,
+            'custom_tools'  : custom_tools,
         }
 
     def _select_custom_tools(self, system_prompt: str) -> list[str]:
@@ -102,20 +102,21 @@ class XGAReactAgent:
         return custom_tools
 
     async def _select_tool_node(self, state: TaskState) -> Dict[str, Any]:
-        system_prompt = state.get("system_prompt",None)
+        system_prompt = state.get('system_prompt',None)
         general_tools = []
         custom_tools = self._select_custom_tools(system_prompt)
         return {
-            "general_tools" : general_tools,
-            "custom_tools" : custom_tools,
+            'general_tools' : general_tools,
+            'custom_tools'  : custom_tools,
         }
 
     async def _exec_task_node(self, state: TaskState) -> Dict[str, Any]:
-        user_input = state.get("user_input", "")
-        system_prompt = state.get("system_prompt",None)
-        general_tools = state.get("general_tools",[])
-        custom_tools = state.get("custom_tools",[])
+        user_input = state['user_input']
+        system_prompt = state.get('system_prompt',None)
+        general_tools = state.get('general_tools',[])
+        custom_tools = state.get('custom_tools',[])
         is_system_prompt = True if system_prompt is not None else False
+        
         try:
             logging.info(f"🔥 XGATaskEngine: run_task_with_final_answer: user_input={user_input}, general_tools={general_tools}, custom_tools={custom_tools}, is_system_prompt={is_system_prompt}")
             engine = XGATaskEngine(tool_box=self.tool_box,
@@ -129,24 +130,25 @@ class XGAReactAgent:
             logging.error("Failed to execute task: %s", str(e))
             task_result = XGATaskResult(type="error", content="Failed to execute task")
 
-        iteration_count = state.get("iteration_count", 0) + 1
+        iteration_count = state.get('iteration_count', 0) + 1
         return {
-            "task_result" : task_result,
-            "iteration_count": iteration_count,
+            'task_result' : task_result,
+            'iteration_count': iteration_count,
         }
 
     async def _final_result_node(self, state: TaskState) -> Dict[str, Any]:
-        iteration_count = state.get("iteration_count")
-        task_result = state.get("task_result")
+        iteration_count = state['iteration_count']
+        task_result = state['task_result']
         next_node = "end"
         if iteration_count < self.MAX_TASK_RETRY and task_result["type"] == "error":
             next_node = "supervisor"
+            
         return {
-            "next_node" : next_node
+            'next_node' : next_node
         }
 
     def _next_condition(self, state: TaskState) -> str:
-        next_node = state.get("next_node")
+        next_node = state['next_node']
         return next_node
 
 
@@ -161,24 +163,26 @@ class XGAReactAgent:
 
             # Initialize state
             initial_state = {
-                "messages": [HumanMessage(content=f"information for: {user_input}")],
-                "user_input": user_input,
-                "next_node": None,
-                "agent_context": {},
-                "iteration_count": 0
+                'messages'          : [HumanMessage(content=f"information for: {user_input}")],
+                'user_input'        : user_input,
+                'next_node'         : None,
+                'agent_context'     : {},
+                'iteration_count'   : 0
             }
 
             # Run the retrieval graph with proper configuration
-            config = {"recursion_limit": 100,
-                      "configurable": {"thread_id": "manager_async_generate_thread"}}
+            config = {'recursion_limit': 100,
+                      'configurable': {
+                          'thread_id': "manager_async_generate_thread"
+                      }}
             final_state = await self.graph.ainvoke(initial_state, config=config)
 
             # Parse and return formatted results
             result = final_state["task_result"]
 
             logging.info("=" * 100)
-            logging.info("User question: %s", user_input)
-            logging.info("User answer: %s", result)
+            logging.info(f"USER QUESTION: {user_input}")
+            logging.info(f"LLM ANSWER: {result}")
             logging.info("=" * 100)
 
             return result
@@ -194,8 +198,8 @@ if __name__ == "__main__":
     async def main():
         agent = XGAReactAgent()
         user_inputs = [
-                        #"locate 10.2.3.4 fault and solution",
-                        "5+5",
+                        "locate 10.2.3.4 fault and solution",
+                        #"5+5",
                     ]
         for user_input in user_inputs:
             result = await agent.generate(user_input)

xgae-0.1.18/src/examples/engine/run_custom_and_agent_tools.py

@@ -0,0 +1,42 @@
+import asyncio
+
+from xgae.engine.mcp_tool_box import XGAMcpToolBox
+from xgae.engine.task_engine import XGATaskEngine
+from xgae.utils.misc import read_file
+
+from xgae.utils.setup_env import setup_logging
+
+
+is_stream = False
+if is_stream:
+    setup_logging(log_level="ERROR") # only show chunk
+else:
+    setup_logging()
+
+async def main() -> None:
+    tool_box = XGAMcpToolBox(custom_mcp_server_file="mcpservers/custom_servers.json")
+    system_prompt = read_file("templates/example/fault_user_prompt.txt")
+
+    engine = XGATaskEngine(tool_box=tool_box,
+                           general_tools=[],
+                           custom_tools=["*"],
+                           system_prompt=system_prompt)
+
+
+    user_input =  "locate 10.2.3.4 fault and solution"
+    global is_stream
+    if is_stream:
+        chunks = []
+        async for chunk in engine.run_task(task_message={"role": "user", "content": user_input}):
+            chunks.append(chunk)
+            print(chunk)
+
+        final_result = engine.parse_final_result(chunks)
+        print(f"\n\nFINAL_RESULT: {final_result}")
+    else:
+        final_result = await engine.run_task_with_final_answer(task_message={"role": "user", "content": user_input})
+        print(f"\n\nFINAL_RESULT: {final_result}")
+
+
+ # Before Run Exec: uv run example-fault-tools --alarmtype=2  , uv run example-a2a-tools
+asyncio.run(main())

{xgae-0.1.17 → xgae-0.1.18}/src/examples/tools/custom_fault_tools_app.py

@@ -1,8 +1,7 @@
 import click
 import logging
 
-from typing import Annotated
-from typing import Dict, Any
+from typing import Annotated, Dict, Any
 from pydantic import Field
 
 from mcp.server.fastmcp import FastMCP
@@ -65,19 +64,19 @@ async def get_busi_fault_cause(fault_code: Annotated[str, Field(description="Fau
     return  fault_cause
 
 
-@mcp.tool(
-    description="Get Equipment Type Fault Solution and Cause",
-)
-async def get_equip_fault_cause(fault_code: Annotated[str, Field(description="Fault Code")]) -> str:
-    logging.info(f"get_equip_fault_cause: faultCode={fault_code}")
-
-    fault_cause = ""
-    if (fault_code == 'F01'):
-        fault_cause = "Host Fault, Fault Cause is 'Host Disk is Damaged' ，Solution is 'Change Host Disk'"
-    else:
-        fault_cause = f"FaultCode '{fault_code}' is not Equipment Type"
-
-    return  fault_cause
+# @mcp.tool(
+#     description="Get Equipment Type Fault Solution and Cause",
+# )
+# async def query_equip_fault_cause(fault_code: Annotated[str, Field(description="Fault Code")]) -> str:
+#     logging.info(f"get_equip_fault_cause: faultCode={fault_code}")
+#
+#     fault_cause = ""
+#     if (fault_code == 'F02'):
+#         fault_cause = "Host Fault, Fault Cause is 'Host Disk is Damaged' ，Solution is 'Change Host Disk'"
+#     else:
+#         fault_cause = f"FaultCode '{fault_code}' is not Equipment Type"
+#
+#     return  fault_cause
 
 
 @click.command()

xgae-0.1.18/src/examples/tools/simu_a2a_tools_app.py

@@ -0,0 +1,59 @@
+import click
+import logging
+
+from typing import Annotated, Optional, Dict, List, Any, Literal, TypedDict
+from pydantic import Field
+
+from mcp.server.fastmcp import FastMCP
+
+mcp = FastMCP(name="Simulate A2A MCP Proxy")
+
+# XGA agent tool must return {type, content, attachments} like XGAAgentResult class
+class XGAAgentResult(TypedDict, total=False):
+    type: Literal["ask", "answer", "error"]
+    content: str
+    attachments: Optional[List[str]]
+
+
+@mcp.tool(
+    description="Get Equipment Type Fault Solution and Cause",
+)
+# XGA agent tool, must have 2 parameter, first parameter must be task_id, second parameter must be str type
+def query_equip_fault_cause(task_id:str, input: Annotated[str, Field(description="Fault Code")]):
+    logging.info(f"get_equip_fault_cause: task_id={task_id}, faultCode={input}")
+
+    fault_cause:XGAAgentResult = None
+    if 'F02' in input:
+        fault_cause:XGAAgentResult = {
+            'type': "answer",
+            'content': "Host Fault, Fault Cause is 'Host Disk is Damaged' ，Solution is 'Change Host Disk'"
+        }
+    else:
+        fault_cause:XGAAgentResult = {
+            'type': "ask",
+            'content': f"FaultCode '{input}' is not Equipment Type"
+        }
+
+    return  fault_cause
+
+
+@click.command()
+@click.option("--transport", type=click.Choice(["stdio", "sse"]), default="sse", help="Transport type")
+@click.option("--host", default="0.0.0.0", help="Host to listen on for SSE")
+@click.option("--port", default=21010, help="Port to listen on for SSE")
+def main(transport: str, host: str, port: int):
+    if transport != "stdio":
+        from xgae.utils.setup_env import setup_logging
+        setup_logging()
+        logging.info("=" * 10 + f"   Simulate A2A MCP Proxy Sever Started   " + "=" * 10)
+        logging.info(f"=== transport={transport}, host={host}, port={port}")
+
+
+    mcp.settings.host = host
+    mcp.settings.port = port
+
+    mcp.run(transport=transport)
+
+
+if __name__ == '__main__':
+    main()

{xgae-0.1.17 → xgae-0.1.18}/src/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-0.1.17 → xgae-0.1.18}/src/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-0.1.17 → xgae-0.1.18}/src/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-0.1.17 → xgae-0.1.18}/src/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