xgae 0.3.2__tar.gz → 0.3.4__tar.gz

{xgae-0.3.2 → xgae-0.3.4}/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [0.3.4] - 2025-11-1
+- GAIA2 ARE Example:  XGAArePromptBuilder, Use MCP tool format general tool construct prompt
+### Modified
+- GAIA2 ARE Example: Refact code struct and class name
+- GAIA2 ARE Example: Optimize prompt template 
+- ARETaskEngine: add prompt_builder init parameter
+
+
+## [0.3.3] - 2025-10-30
+### Added
+- GAIA2 ARE Scenario:  scenario_bomc_fault
+- GAIA2 ARE MCP: Support Custom MCP Apps, example_mcp_apps.json
+
+
 ## [0.3.2] - 2025-10-24
 ### Added
 - GAIA2 ARE Example:  XGAAreAgent, XGAAreToolBox

{xgae-0.3.2 → xgae-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xgae
-Version: 0.3.2
+Version: 0.3.4
 Summary: Extreme General Agent Engine
 Requires-Python: >=3.11
 Requires-Dist: colorlog>=6.9.0
@@ -19,7 +19,7 @@ Description-Content-Type: text/markdown
 - Support Custom prompt and external MCP Tools
 - Support Langfuse
 - Support Langgraph
-- Support GAIA2 ARE agent
+- Support GAIA2 ARE agent and Custom MCP Apps
 - Support Human-in-Loop in agent
 - Can Use A2A protocol call A2A Agent as tool by 'xgaproxy' project
 - Can Use E2B or Daytona Sandbox of 'xgatools' project

{xgae-0.3.2 → xgae-0.3.4}/README.md

@@ -3,7 +3,7 @@
 - Support Custom prompt and external MCP Tools
 - Support Langfuse
 - Support Langgraph
-- Support GAIA2 ARE agent
+- Support GAIA2 ARE agent and Custom MCP Apps
 - Support Human-in-Loop in agent
 - Can Use A2A protocol call A2A Agent as tool by 'xgaproxy' project
 - Can Use E2B or Daytona Sandbox of 'xgatools' project

xgae-0.3.4/examples/agent/are/README.md

@@ -0,0 +1,44 @@
+## GAIA2 ARE Support
+### How to add XGAE to ARE Project
+- add xgae==0.3.2 to ARE requirements.txt
+- uv pip install -r requirements.txt
+- modify ARE 'AgentBuilder' and 'AgentConfigBuilder' class, add "xga" type agent :
+  ```
+  File: agent_builder.py
+      class AgentBuilder:
+        def list_agents(self) -> list[str]:
+          return ["default", "xga"]
+            
+        def build():
+            ...
+            agent_name = agent_config.get_agent_name()
+            if agent_name in ["default", "xga"]:
+                # add xga agent code
+      
+  File: agent_config_builder.py
+    class AgentConfigBuilder:
+        def build():
+            if agent_name in["default", "xga"]:
+  ```
+- modify ARE 'MCPApp' :
+    ```
+    File: mcp_app.py
+        class MCPApp:
+            def _call_tool(self, tool_name: str, **kwargs) -> str:
+                try:
+                    ...
+                    from are.simulation.agents.xga.mcp_tool_executor import call_mcp_tool
+                    result = call_mcp_tool(self.server_url, tool_name, kwargs, 10)
+                    return str(result)
+                    
+    
+    ```
+
+
+- modify ARE .env, add XGAE .env config, refer to env.example 
+- copy XGAE package 'mcpservers' and 'templates' directory to ARE project root  
+
+### Run XGA Agent in ARE
+  ```
+uv run are-run -e -s scenario_find_image_file -a xga --model openai/qwen3-235b-a22b --provider llama-api --output_dir ./output
+  ```

xgae-0.3.2/examples/agent/are/simulation/agents/xga/xga_agent.py → xgae-0.3.4/examples/agent/are/are/simulation/agents/xga/are_agent.py

@@ -1,4 +1,5 @@
 import re
+import asyncio
 from typing import List, Dict, Any
 from typing_extensions import override
 
@@ -23,8 +24,8 @@ from are.simulation.agents.default_agent.base_agent import (
 
 from xgae.utils.llm_client import LLMConfig
 from xgae.gaia2.are_engine import ARETaskEngine
-from agent.are.simulation.agents.xga.xga_tool_box import XGAAreToolBox
-
+from are.simulation.agents.xga.are_tool_box import XGAAreToolBox
+from are.simulation.agents.xga.are_prompt_builder import XGAArePromptBuilder
 
 def pre_run_task_check(agent, iterations: int, llm_messages: List[Dict[str, Any]]):
     try:
@@ -165,10 +166,11 @@ class XGAAreAgent(BaseAgent):
         _system_prompt = "\n\n".join(prompt for prompt in self.init_system_prompts.values())
         pattern = r'<general_instructions>(.*?)</general_instructions>'
         prompt_are_general = re.search(pattern, _system_prompt, re.DOTALL)
+        prompt_header = "#CORE IDENTITY & CAPABILITIES\n"
         if prompt_are_general:
-            prompt_are_general = prompt_are_general.group(1).strip()
+            prompt_are_general = prompt_header + prompt_are_general.group(1).strip() + "\n\n"
         else:
-            prompt_are_general = _system_prompt
+            prompt_are_general = prompt_header + _system_prompt  + "\n\n"
 
         model_config = self.llm_engine.model_config
         llm_config = LLMConfig(
@@ -176,6 +178,9 @@ class XGAAreAgent(BaseAgent):
             api_key     = model_config.api_key,
             api_base    = model_config.endpoint
         )
+
+        prompt_builder = XGAArePromptBuilder(prompt_are_general)
+
         self.task_engine =  ARETaskEngine(
             agent               = self,
             agent_id            = self.agent_id,
@@ -183,6 +188,7 @@ class XGAAreAgent(BaseAgent):
             max_auto_run        = self.max_iterations,
             llm_config          = llm_config,
             tool_box            = tool_box,
+            prompt_builder      = prompt_builder,
             pre_run_task_fn     = pre_run_task_check,
             post_run_task_fn    = post_run_task_check,
             terminate_task_fn   = terminate_task_check,
@@ -205,8 +211,8 @@ class XGAAreAgent(BaseAgent):
 
     @override
     def execute_agent_loop(self) -> str | None | MMObservation:
-        import asyncio
-        asyncio.run(self.async_execute_agent_loop())
+        with asyncio.Runner() as runner:
+            runner.run(self.async_execute_agent_loop())
 
         # We have reached a termination condition, execute the termination method
         if self.termination_step.function is not None and not self.stop_event.is_set():
@@ -235,15 +241,18 @@ class XGAAreAgent(BaseAgent):
                             agent_id    = self.agent_id,
                         )
                     )
-                elif status_type == "tool_started":
-                    function_name = status_content['function_name']
-                    self.append_agent_log(
-                        ThoughtLog(
-                            content     = f"To complete task, should call '{function_name}' tool",
-                            timestamp   = self.make_timestamp(),
-                            agent_id    = self.agent_id,
+            elif chunk_type == "assistant":
+                llm_content  = chunk['content']['content']
+                if "<thought>" in llm_content:
+                    thought_content = re.search(r'<thought>(.*?)</thought>', llm_content, re.DOTALL).group(1).strip()
+                    if thought_content:
+                        self.append_agent_log(
+                            ThoughtLog(
+                                content     = thought_content,
+                                timestamp   = self.make_timestamp(),
+                                agent_id    = self.agent_id,
+                            )
                         )
-                    )
             elif chunk_type == "tool":
                 tool_content = chunk['content']
                 tool_execution = tool_content.get('tool_execution')

xgae-0.3.2/examples/agent/are/simulation/agents/xga/xga_agent_factory.py → xgae-0.3.4/examples/agent/are/are/simulation/agents/xga/are_agent_factory.py

@@ -4,7 +4,7 @@ from are.simulation.agents.default_agent.termination_methods.are_simulation impo
 from are.simulation.agents.default_agent.tools.json_action_executor import JsonActionExecutor
 from are.simulation.agents.llm.llm_engine import LLMEngine
 
-from agent.are.simulation.agents.xga.xga_agent import XGAAreAgent
+from are.simulation.agents.xga.are_agent import XGAAreAgent
 
 
 def xga_simulation_react_xml_agent(

xgae-0.3.4/examples/agent/are/are/simulation/agents/xga/are_prompt_builder.py

@@ -0,0 +1,19 @@
+from typing_extensions import override
+from typing import Optional, List
+
+from xgae.engine.engine_base import XGAToolSchema
+from xgae.engine.prompt_builder import XGAPromptBuilder
+
+class XGAArePromptBuilder(XGAPromptBuilder):
+    def __init__(self, system_prompt: Optional[str] = None):
+        super().__init__(system_prompt)
+
+
+    @override
+    def build_general_tool_prompt(self, tool_schemas: List[XGAToolSchema]) -> str:
+        tool_prompt = self.build_mcp_tool_prompt("templates/general_tool_prompt_template.txt", tool_schemas)
+        return tool_prompt
+
+
+
+

xgae-0.3.2/examples/agent/are/simulation/agents/xga/xga_tool_box.py → xgae-0.3.4/examples/agent/are/are/simulation/agents/xga/are_tool_box.py

@@ -1,7 +1,7 @@
 import json
 import logging
 
-from typing import List, Any, Dict, Optional
+from typing import Any, Dict, Optional
 from typing_extensions import override
 
 from langchain_mcp_adapters.tools import load_mcp_tools
@@ -10,6 +10,7 @@ from xgae.engine.engine_base import XGAError, XGAToolSchema, XGAToolResult, XGAT
 from xgae.engine.mcp_tool_box import XGAMcpToolBox
 
 from are.simulation.tools import Tool
+from are.simulation.agents.xga.mcp_tool_executor import convert_mcp_tool_result
 
 class XGAAreToolBox(XGAMcpToolBox):
     def __init__(self, are_tools: Dict[str, Tool]):
@@ -41,11 +42,11 @@ class XGAAreToolBox(XGAMcpToolBox):
 
             try:
                 tool_result = self.are_tools[full_tool_name](**args)
-                result = XGAToolResult(success=True, output=str(tool_result))
+                result = convert_mcp_tool_result(str(tool_result))
             except Exception as e:
                 error = f"Call ARE Tool '{tool_name}' error: {str(e)}"
                 logging.error(f"AreToolBox call_are_tool: {error}")
-                result = XGAToolResult(success=False, output=error)
+                result = XGAToolResult(success=False, output=str(e))
         else:
             async with self._mcp_client.session(server_name) as session:
                 tools = await load_mcp_tools(session)

xgae-0.3.4/examples/agent/are/are/simulation/agents/xga/mcp_tool_executor.py

@@ -0,0 +1,134 @@
+import asyncio
+import json
+import threading
+import time
+
+from concurrent.futures import Future as ConcurrentFuture
+from typing import Any, Optional, Coroutine, List, Dict
+
+from mcp.client.session import ClientSession
+from mcp.client.sse import sse_client
+
+from xgae.engine.engine_base import  XGAToolResult
+
+
+class AsyncToolExecutor:
+    _instance = None
+    _loop = None
+    _thread = None
+    _lock = threading.Lock()
+
+    def __new__(cls):
+        with cls._lock:
+            if cls._instance is None:
+                cls._instance = super().__new__(cls)
+                cls._init_event_loop()
+            return cls._instance
+
+
+    @classmethod
+    def _init_event_loop(cls):
+        if cls._loop is None or cls._loop.is_closed():
+            cls._loop = asyncio.new_event_loop()
+
+        def start_loop(loop):
+            asyncio.set_event_loop(loop)
+            try:
+                loop.run_forever()
+            finally:
+                if not loop.is_closed():
+                    loop.close()
+
+        cls._thread = threading.Thread(target=start_loop, args=(cls._loop,), daemon=True)
+        cls._thread.start()
+
+        time.sleep(0.1)
+
+    @classmethod
+    def submit(cls, coro: Coroutine) -> ConcurrentFuture:
+        if cls._loop is None or cls._loop.is_closed():
+            cls._init_event_loop()
+
+        return asyncio.run_coroutine_threadsafe(coro, cls._loop)
+
+    @classmethod
+    def run_and_wait(cls, coro: Coroutine, timeout: Optional[float] = None) -> Any:
+        future = cls.submit(coro)
+        return future.result(timeout=timeout)
+
+    @classmethod
+    def get_loop(cls):
+        if cls._loop is None or cls._loop.is_closed():
+            cls._init_event_loop()
+        return cls._loop
+
+    @classmethod
+    def shutdown(cls):
+        if cls._loop is not None and not cls._loop.is_closed():
+            cls._loop.call_soon_threadsafe(cls._loop.stop)
+
+from mcp.types import CallToolResult
+
+async def _mcp_sse_tool_call(url: str, tool_name: str, arguments: dict[str, Any]) -> CallToolResult:
+    async with sse_client(url, sse_read_timeout=5) as streams:
+        async with ClientSession(*streams) as session:
+            await session.initialize()
+            return  await session.call_tool(tool_name, arguments)
+
+
+def call_mcp_tool(url: str, tool_name: str, arguments: dict[str, Any], timeout: Optional[float] = None) -> Any:
+    future = AsyncToolExecutor.submit(_mcp_sse_tool_call(url, tool_name, arguments))
+    mcp_result:CallToolResult =  future.result(timeout=timeout)
+    result = {
+        'isError': mcp_result.isError,
+    }
+    if mcp_result.isError:
+        result['content'] = mcp_result.content[0].text
+    else:
+        result['content'] = mcp_result.structuredContent['result']
+
+    return  json.dumps(result)
+
+
+def convert_mcp_tool_result(org_result: str)->XGAToolResult:
+    result = XGAToolResult(success=True, output=str(org_result))
+
+    if org_result and isinstance(org_result, str) and "isError" in org_result:
+        try:
+            _result:dict = json.loads(org_result)
+            content = _result.get('content', None)
+            isError = _result.get('isError', None)
+
+            if content and isError:
+                success = not bool(isError)
+                result = XGAToolResult(success=bool(success), output=str(content))
+        except:
+            pass
+
+    return result
+
+
+if __name__ == "__main__":
+    async def sample_task(name, duration):
+        print(f"Task '{name}' Begin，time = {duration} ")
+        await asyncio.sleep(duration)
+        return f"Task '{name}' Finished"
+
+    async def main():
+        try:
+            # result = AsyncToolExecutor.run_and_wait(sample_task("mytool", 1))
+            # print(f"Result1: {result}")
+
+            result = call_mcp_tool("http://localhost:17070/sse", "get_alarm", {"ip":"13.0.0.13"})
+            result = convert_mcp_tool_result(result)
+            print(f"Result2: {result}")
+
+            result = call_mcp_tool("http://localhost:17070/sse", "get_alarm1", {"ip":"13.0.0.13"})
+            result = convert_mcp_tool_result(result)
+            print(f"Result3: {result}")
+
+        except Exception as e:
+            print(f"Thread Fail: {e}")
+
+    with asyncio.Runner() as runner:
+            runner.run(main())

xgae-0.3.4/examples/agent/are/are/simulation/scenarios/scenario_bomc_fault/scenario.py

@@ -0,0 +1,184 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the terms described in the LICENSE file in
+# the root directory of this source tree.
+
+
+import datetime
+import json
+import logging
+import os
+from typing import Any
+
+from dotenv import load_dotenv
+from are.simulation.apps.agent_user_interface import AgentUserInterface
+from are.simulation.apps.mcp.mcp_app import MCPApp
+from are.simulation.scenarios.scenario import Scenario, ScenarioValidationResult
+from are.simulation.scenarios.utils.env_utils import expand_env_vars
+
+from are.simulation.scenarios.utils.registry import register_scenario
+from are.simulation.types import EventRegisterer, event_registered
+
+# Set up logger
+logger = logging.getLogger(__name__)
+
+# Load environment variables from .env file
+load_dotenv()
+
+
+
+@register_scenario("scenario_bomc_fault")
+class ScenarioBomcFault(Scenario):
+    start_time: float | None = datetime.datetime.now().timestamp()
+    duration: float | None = None
+
+    def init_and_populate_apps(self, *args, **kwargs) -> None:
+
+        # get apps from the demo
+        agui = AgentUserInterface()
+        self.apps = [agui]
+
+        # form task from universe params
+        self.start_time = datetime.datetime.now().timestamp()
+
+        # Load additional MCP apps from JSON file if specified
+        self._load_mcp_apps_from_json()
+
+
+    def build_events_flow(self) -> None:
+        """Define the sequence of events that will occur during the scenario"""
+
+        agui = self.get_typed_app(AgentUserInterface)
+
+        with EventRegisterer.capture_mode():
+            # User event: User requests task creation
+            event1 = agui.send_message_to_agent(
+                content="locate 10.0.0.1 fault and solution",
+            ).depends_on(None, delay_seconds=2)
+
+            oracle1 = (
+                agui.send_message_to_user(
+                    content="Fault Cause: Phone Recharge Application Crash; Solution: Restart Phone Recharge Application",
+                )
+                .oracle()
+                .depends_on(event1, delay_seconds=10)
+            )
+
+
+        self.events = [event1]
+
+
+    def validate(self, env) -> ScenarioValidationResult:
+        """
+        Validate that the scenario completed successfully.
+
+        Check that the agent properly interacted with our custom app.
+        """
+        try:
+            aui = env.get_app("AgentUserInterface")
+            msg = aui.get_last_message_from_agent()
+            content = msg.content
+            if "Phone Recharge Application Crash" in content:
+                return ScenarioValidationResult(success=True)
+            else:
+                return ScenarioValidationResult(success=False)
+        except Exception as e:
+            return ScenarioValidationResult(success=False, exception=e)
+
+
+    def _load_mcp_apps_from_json(self) -> None:
+        """
+        Load additional MCP apps from a JSON file specified in the environment variables.
+
+        The JSON file should follow the Claude MCP definition format with a ``mcpServers``
+        key containing server configurations. Environment variables in the JSON are
+        expanded using the current environment.
+
+        :return: None
+        """
+        # Get the JSON file path from environment variables
+        mcp_apps_json_path = os.environ.get("MCP_APPS_JSON_PATH")
+
+        if not mcp_apps_json_path:
+            return
+
+        # Ensure self.apps is initialized
+        if not hasattr(self, "apps") or self.apps is None:
+            self.apps = []
+
+        try:
+            with open(mcp_apps_json_path, "r") as f:
+                mcp_config = json.load(f)
+
+            if "mcpServers" not in mcp_config:
+                logger.warning(
+                    f"No 'mcpServers' key found in MCP apps JSON file: {mcp_apps_json_path}"
+                )
+                return
+
+            # Create MCP apps from the JSON configuration
+            for server_name, server_config in mcp_config["mcpServers"].items():
+                mcp_app = self._create_mcp_app(server_name, server_config)
+                if mcp_app:
+                    self.apps.append(mcp_app)
+                    logger.info(f"Added MCP app: {server_name}")
+
+        except Exception as e:
+            logger.error(f"Error loading MCP apps from JSON: {e}", exc_info=True)
+
+    def _create_mcp_app(self, name: str, config: dict[str, Any]) -> MCPApp | None:
+        """
+        Create an MCPApp instance from a server configuration.
+
+        Supports two types of MCP servers:
+
+        1. Local servers with command and arguments
+        2. Remote SSE servers with URL and headers
+
+        Environment variables in the configuration are expanded before creating the app.
+
+        :param name: The name of the MCP app
+        :type name: str
+        :param config: The server configuration from the JSON file
+        :type config: dict[str, Any]
+        :return: An MCPApp instance or None if creation fails
+        :rtype: MCPApp | None
+        """
+        try:
+            # Expand environment variables in the configuration
+            expanded_config = expand_env_vars(config, allowed=["HF_TOKEN"])
+
+            # Handle SSE remote servers
+            if expanded_config.get("type") == "sse" or "url" in expanded_config:
+                return MCPApp(
+                    name=name,
+                    server_url=expanded_config.get("url"),
+                    sse_headers=expanded_config.get("headers", {}),
+                )
+
+            # Handle local servers with command and args
+            elif "command" in expanded_config:
+                return MCPApp(
+                    name=name,
+                    server_command=expanded_config.get("command"),
+                    server_args=expanded_config.get("args", []),
+                    server_env=expanded_config.get("env", {}),
+                )
+
+            else:
+                logger.warning(f"Unsupported MCP server configuration for {name}")
+                return None
+
+        except Exception as e:
+            logger.error(f"Error creating MCP app {name}: {e}", exc_info=True)
+            return None
+
+
+# Before Run Scenario, should xage project , execute command:
+# 1. Vailid Success: uv run example-fault-tools
+# 2. Vailid Fail: uv run example-fault-tools --alarmtype 2
+if __name__ == "__main__":
+    from are.simulation.scenarios.utils.cli_utils import run_and_validate
+
+    run_and_validate(ScenarioBomcFault())

{xgae-0.3.2/examples/agent/are/simulation/agents/xga → xgae-0.3.4/examples/agent/are}/env.example

@@ -22,6 +22,7 @@ ALL_MODELS=""
 
 DEMO_FS_PATH="hf://datasets/meta-agents-research-environments/gaia2_filesystem/demo_filesystem"
 
+MCP_APPS_JSON_PATH=/Users/sharkystar/DevProjects/are/mcpservers/example_mcp_apps.json
 
 ###     XGA ENV        ###
 # LOG

xgae-0.3.4/examples/agent/are/mcpservers/example_mcp_apps.json

@@ -0,0 +1,11 @@
+{
+  "mcpServers": {
+    "BomcFault": {
+      "type": "sse",
+      "url": "http://localhost:17070/sse",
+      "headers": {
+        "Authorization": "Bearer YOURLONGLIVEDTOKENS"
+      }
+    }
+  }
+}

xgae-0.3.4/examples/agent/are/templates/custom_tool_prompt_template.txt

@@ -0,0 +1,24 @@
+# AVAILABLE MCP TOOLS 
+You have access to external MCP (Model Context Protocol) server tools.
+MCP tools can be called directly using their native function names in the standard function calling format:
+
+## MCP TOOL SCHEMAS
+{tool_schemas}
+
+## CRITICAL MCP TOOL RULES
+When you use ANY MCP (Model Context Protocol) tools:
+1. Never call a MCP tool not in 'Available MCP tools' list
+2. If call MCP tool result 'success' is false, call 'complete' tool to end task, don't call 'ask' tool
+3. ALWAYS read and use the EXACT results returned by the MCP tool
+4. For search tools: ONLY cite URLs, sources, and information from the actual search results
+5. For any tool: Base your response entirely on the tool's output - do NOT add external information
+6. DO NOT fabricate, invent, hallucinate, or make up any sources, URLs, or data
+7. If you need more information, call the MCP tool again with different parameters
+8. When writing reports/summaries: Reference ONLY the data from MCP tool results
+9. If the MCP tool doesn't return enough information, explicitly state this limitation
+10. Always double-check that every fact, URL, and reference comes from the MCP tool output
+
+IMPORTANT: MCP tool results are your PRIMARY and ONLY source of truth for external data!
+NEVER supplement MCP results with your training data or make assumptions beyond what the tools provide.
+
+

xgae-0.3.4/examples/agent/are/templates/general_tool_prompt_template.txt

@@ -0,0 +1,51 @@
+# FUNDAMENTAL RULES FOR TASK EXECUTION
+1. COMMUNICATION: Only message the user when completely done or if the task is impossible.
+2. EXECUTION: Work silently, complete tasks fully, no progress updates.
+3. COMPLIANCE: Follow user instructions exactly, ask for clarification only if the environment does not provide enough information.
+4. PROBLEM SOLVING: Try alternative approaches before reporting failure.
+5. INFORMATION: Use available tools to gather missing information before asking user.
+6. AMBIGUITY: Execute all clear and unambiguous parts of a request immediately. When you encounter ambiguities, contradictions, or impossible elements, finish unambiguous subtasks and then stop and explicitly ask the user for clarification before proceeding with those specific parts.
+
+
+# FORMAT SPECIFICATION
+## RESPONSE FORMAT SPECIFICATION
+<thought>
+[Your reasoning in plain text]
+</thought>
+
+<function_calls>
+<invoke name="function_name">
+<parameter name="param_name">param_value</parameter>
+...
+</invoke>
+</function_calls>
+
+String and scalar parameters should be specified as-is, while lists and objects should use JSON format.
+
+## THOUGHT RULES
+- Always explain your reasoning in natural language before the Action.
+- Never include tool call details inside the Thought, only in the Action.
+
+##  RESPONSE EXAMPLE
+<thought>
+I need to look up the current weather before answering, so I will call the weather tool with the city name.
+<thought>
+
+<function_calls>
+<invoke name="query_weather">
+<parameter name="city_name">Beijing</parameter>
+</invoke>
+<function_calls>
+
+
+# AVAILABLE SYSTEM TOOLS
+
+## SYSTEM TOOL SCHEMAS:
+{tool_schemas}
+## CRITICAL GENERAL TOOL RULES
+- Use the exact function names from  schema above
+- Include all required parameters as specified in the schema
+- Format complex data (objects, arrays) as JSON strings within the parameter tags
+- Boolean values should be "true" or "false" (lowercase)
+- If 'ask' tool answer is not match, call 'complete' tool end task, never call 'ask' tool again
+

xgae-0.3.4/mcpservers/xga_server.json

@@ -0,0 +1,11 @@
+{
+    "mcpServers":{
+        "xga_general": {
+      		"command": "uv",
+      		"args": [
+        		"run",
+        		"xgae-tools"
+      		]
+        }
+    }
+}

{xgae-0.3.2 → xgae-0.3.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "xgae"
-version = "0.3.2"
+version = "0.3.4"
 description = "Extreme General Agent Engine"
 readme = "README.md"
 requires-python = ">=3.11"

{xgae-0.3.2 → xgae-0.3.4}/uv.lock

@@ -3008,7 +3008,7 @@ wheels = [
 
 [[package]]
 name = "xgae"
-version = "0.3.2"
+version = "0.3.3"
 source = { editable = "." }
 dependencies = [
     { name = "colorlog" },

{xgae-0.3.2 → xgae-0.3.4}/xgae/gaia2/are_engine.py

@@ -4,6 +4,7 @@ from typing_extensions import override
 
 from xgae.engine.engine_base import XGAToolBox
 from xgae.engine.task_engine import XGATaskEngine
+from xgae.engine.prompt_builder import XGAPromptBuilder
 from xgae.utils.llm_client import LLMConfig
 
 
@@ -15,6 +16,7 @@ class ARETaskEngine(XGATaskEngine):
                  max_auto_run: int,
                  llm_config: Optional[LLMConfig] = None,
                  tool_box: Optional[XGAToolBox] = None,
+                 prompt_builder: Optional[XGAPromptBuilder] = None,
                  pre_run_task_fn : Callable[[Any, int, List[Dict[str, Any]]], Any] = None,
                  post_run_task_fn : Callable[[Any, int, Dict[str, Any]], Any] = None,
                  terminate_task_fn : Callable[[Any, int], bool] = None,
@@ -26,6 +28,7 @@ class ARETaskEngine(XGATaskEngine):
                          max_auto_run   = max_auto_run,
                          llm_config     = llm_config,
                          tool_box       = tool_box,
+                         prompt_builder = prompt_builder,
                          )
         self.agent = agent
         self.pre_run_task_fn = pre_run_task_fn

xgae-0.3.2/examples/agent/are/simulation/agents/xga/README.md

@@ -1,30 +0,0 @@
-## GAIA2 ARE Support
-### How to add XGAE to ARE Project
-- add xgae==0.3.2 to ARE requirements.txt
-  - uv pip install -r requirements.txt
-    - modify ARE 'AgentBuilder' and 'AgentConfigBuilder' class, add "xga" type agent
-      ```
-      File: agent_builder.py
-          class AgentBuilder:
-            def list_agents(self) -> list[str]:
-              return ["default", "xga"]
-            
-            def build():
-                ...
-                agent_name = agent_config.get_agent_name()
-                if agent_name in ["default", "xga"]:
-                    # add xga agent code
-      
-      File: agent_config_builder.py
-        class AgentConfigBuilder:
-            def build():
-                if agent_name in["default", "xga"]:
-      ```
-
-- modify ARE .env, add XGAE .env config, refer to env.example 
-- copy XGAE package 'mcpservers' and 'templates' directory to ARE project root  
-
-### Run XGA Agent in ARE
-  ```
-uv run are-run -e -s scenario_find_image_file -a xga --model openai/qwen3-235b-a22b --provider llama-api --output_dir ./output
-  ```