xgae 0.3.0__tar.gz → 0.3.2__tar.gz

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

@@ -1,7 +1,13 @@
-## [0.3.0] - 2025-10-24
+## [0.3.2] - 2025-10-24
 ### Added
-- Support GAIA2 ARE Engine
+- GAIA2 ARE Example:  XGAAreAgent, XGAAreToolBox
+### Modified
+- ARETaskEngine
+
 
+## [0.3.0] - 2025-10-22
+### Added
+- Support GAIA2 ARE: ARETaskEngine
 
 
 ## [0.2.4] - 2025-9-23

xgae-0.3.2/PKG-INFO

@@ -0,0 +1,36 @@
+Metadata-Version: 2.4
+Name: xgae
+Version: 0.3.2
+Summary: Extreme General Agent Engine
+Requires-Python: >=3.11
+Requires-Dist: colorlog>=6.9.0
+Requires-Dist: langchain-mcp-adapters>=0.1.9
+Requires-Dist: langfuse==2.60.9
+Requires-Dist: litellm>=1.71.1
+Requires-Dist: mcp>=1.11.0
+Provides-Extra: examples
+Requires-Dist: chromadb==1.1.0; extra == 'examples'
+Requires-Dist: langchain-community==0.3.29; extra == 'examples'
+Requires-Dist: langgraph==0.6.5; extra == 'examples'
+Description-Content-Type: text/markdown
+
+## XGAE: Extreme General Agent Engine 
+### Functional Features
+- Support Custom prompt and external MCP Tools
+- Support Langfuse
+- Support Langgraph
+- Support GAIA2 ARE agent
+- 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
+
+### Non-Functional Features
+- Faster than SUNA Engine's speed
+- Architecture is lighter than SUNA Engine
+- Separate tools from Agent Engine
+
+### Examples
+- langgraph:  Build React mode Langgraph Agent by XGA Engine
+- are: Build GAIA2 ARE Agent by XGA Engine
+- engine: Use XGA Engine in various scenarios
+- tools: Simulation tools for example and test

xgae-0.3.2/README.md

@@ -0,0 +1,20 @@
+## XGAE: Extreme General Agent Engine 
+### Functional Features
+- Support Custom prompt and external MCP Tools
+- Support Langfuse
+- Support Langgraph
+- Support GAIA2 ARE agent
+- 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
+
+### Non-Functional Features
+- Faster than SUNA Engine's speed
+- Architecture is lighter than SUNA Engine
+- Separate tools from Agent Engine
+
+### Examples
+- langgraph:  Build React mode Langgraph Agent by XGA Engine
+- are: Build GAIA2 ARE Agent by XGA Engine
+- engine: Use XGA Engine in various scenarios
+- tools: Simulation tools for example and test

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

@@ -0,0 +1,30 @@
+## 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
+  ```

xgae-0.3.2/examples/agent/are/simulation/agents/xga/env.example

@@ -0,0 +1,42 @@
+# Certificate paths may vary on different types of machines.
+ARE_SIMULATION_SSL_CERT_PATH=
+ARE_SIMULATION_SSL_KEY_PATH=
+
+# ARE_SIMULATION UI server.
+ARE_SIMULATION_SERVER_HOSTNAME=localhost
+ARE_SIMULATION_SERVER_PORT=8080
+
+# ARE_SIMULATION UI client.
+ARE_SIMULATION_CLIENT_HOSTNAME=localhost
+ARE_SIMULATION_CLIENT_PORT=8088
+ARE_SIMULATION_CLIENT_BACKEND_URL=https://${ARE_SIMULATION_SERVER_HOSTNAME}:${ARE_SIMULATION_SERVER_PORT}
+
+# Scenario discovery
+# Format: "dir1,dir2,dir3,..."
+# Example: "/path/to/custom/scenarios,/another/path"
+ARE_SCENARIO_DIRECTORIES="/Users/sharkystar/DevProjects/are"
+
+# Models.
+ALL_MODELS=""
+
+
+DEMO_FS_PATH="hf://datasets/meta-agents-research-environments/gaia2_filesystem/demo_filesystem"
+
+
+###     XGA ENV        ###
+# LOG
+LOG_LEVEL=INFO
+LOG_FILE=log/xgae.log
+LOG_ENABLE=True
+
+LLM_MAX_TOKENS=16384
+LLM_TEMPERATURE=0
+LLM_MAX_RETRIES=1
+LLM_STREAM=True
+LLM_ENABLE_THINKING=False
+
+LLM_LANGFUSE_ENABLE=False
+
+
+# TASK_ENGINE
+USE_ASSISTANT_CHUNK_MSG=False

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

@@ -0,0 +1,289 @@
+import re
+from typing import List, Dict, Any
+from typing_extensions import override
+
+from are.simulation.agents.are_simulation_agent import AgentStoppedException
+from are.simulation.agents.llm.types import MMObservation
+from are.simulation.agents.multimodal import Attachment, attachments_to_pil
+from are.simulation.agents.agent_log import (
+    LLMInputLog,
+    LLMOutputThoughtActionLog,
+    StepLog,
+    StopLog,
+    SystemPromptLog,
+    ThoughtLog,
+    ToolCallLog,
+    FinalAnswerLog
+)
+from are.simulation.agents.default_agent.base_agent import (
+    BaseAgent,
+    RunningState,
+    get_offset_from_time_config_mode
+)
+
+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
+
+
+def pre_run_task_check(agent, iterations: int, llm_messages: List[Dict[str, Any]]):
+    try:
+        agent.logger.info(f"\n\n------  Starting Run Task Iteration {iterations}...   ------")
+
+        if iterations == 0:
+            agent.system_prompt = agent.task_engine.task_prompt
+            agent.logger.info(f"------  SYSTEM_PROMPT   ------ \n{agent.system_prompt}\n")
+            agent.append_agent_log(
+                SystemPromptLog(
+                    content     = agent.system_prompt,
+                    timestamp   = agent.make_timestamp(),
+                    agent_id    = agent.agent_id,
+                )
+            )
+
+        agent.append_agent_log(
+            StepLog(
+                iteration   = agent.iterations,
+                timestamp   = agent.make_timestamp(),
+                agent_id    = agent.agent_id,
+            )
+        )
+
+        if agent.stop_event.is_set():
+            agent.logger.info(f"pre_run_task_check[{iterations}]: Recv Stop Event before condition, raise AgentStoppedException")
+            raise AgentStoppedException("Agent stopped.")
+
+        # Execute a pre_step() function if it exists
+        for conditional_step in agent.conditional_pre_steps:
+            if conditional_step.condition is None or conditional_step.condition(agent):
+                conditional_step.function(agent)
+
+        if agent.stop_event.is_set():
+            agent.logger.info(f"pre_run_task_check[{iterations}]: Recv Stop Event after condition, raise AgentStoppedException")
+            raise AgentStoppedException("Agent stopped.")
+
+        # Begin step()
+        agent.append_agent_log(
+            LLMInputLog(
+                content     = llm_messages,
+                timestamp   = agent.make_timestamp(),
+                agent_id    = agent.agent_id
+            )
+        )
+
+        if agent.simulated_generation_time_config is not None:
+            if agent.pause_env is None:
+                raise ValueError("pause_env is not set")
+            agent.pause_env()
+    except Exception as e:
+        agent.log_error(e)
+        agent.logger.info(f"pre_run_task_check[{iterations}]: Exception Occur, Stop task")
+        agent.task_engine.stop_task()
+
+
+def post_run_task_check(agent, iterations: int, llm_response: Dict[str, Any]):
+    try:
+        agent.logger.info(f"------  LLM Response Iteration [{iterations}]   ------ \n{llm_response}\n")
+
+        llm_output = str(llm_response)
+
+        # Resume the environment after the generation of a thought/action if needed
+        if agent.simulated_generation_time_config is not None:
+            if agent.resume_env is None:
+                raise ValueError("resume_env is not set")
+
+            offset = get_offset_from_time_config_mode(
+                time_config = agent.simulated_generation_time_config,
+                completion_duration = 0,
+            )
+            agent.logger.info(f"post_run_task_check[{iterations}]: Resuming environment with {offset} offset")
+            agent.resume_env(offset)
+
+        metadata = {}
+        agent.append_agent_log(
+            LLMOutputThoughtActionLog(
+                content             = llm_output,
+                timestamp           = agent.make_timestamp(),
+                agent_id            = agent.agent_id,
+                prompt_tokens       = metadata.get("prompt_tokens", 0),
+                completion_tokens   = metadata.get("completion_tokens", 0),
+                total_tokens        = metadata.get("total_tokens", 0),
+                reasoning_tokens    = metadata.get("reasoning_tokens", 0),
+                completion_duration = metadata.get("completion_duration", 0),
+            )
+        )
+        # end step()
+
+        if agent.stop_event.is_set():
+            agent.logger.info(f"post_run_task_check[{iterations}]: Recv Stop Event, raise AgentStoppedException")
+            raise AgentStoppedException("Agent stopped.")
+
+        # Execute a post_step() function if it exists (polling the Meta Agents Research Environments notifications for example)
+        for conditional_step in agent.conditional_post_steps:
+            if conditional_step.condition is None or conditional_step.condition(agent):
+                conditional_step.function(agent)
+    except Exception as e:
+        agent.log_error(e)
+        agent.logger.info(f"post_run_task_check[{iterations}]: Exception Occur, Stop task")
+        agent.task_engine.stop_task()
+    finally:
+        if agent.simulated_generation_time_config and agent.resume_env:
+            agent.resume_env(0.0)  # Resume without advancing time
+
+        agent.iterations += 1
+        agent.planning_counter += 1
+
+
+def terminate_task_check(agent, iterations: int) -> bool:
+    is_terminate_task = False
+
+    try:
+        if agent.termination_step.condition:
+            is_terminate_task = agent.termination_step.condition(agent)
+            if is_terminate_task:
+                agent.logger.info(f"terminate_task_check[{iterations}]: termination_step.condition is True")
+    except Exception as e:
+        agent.log_error(e)
+
+    return is_terminate_task
+
+
+class XGAAreAgent(BaseAgent):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.task_engine: ARETaskEngine = None
+
+
+    @override
+    def initialize(self, attachments: list[Attachment] | None = None, **kwargs) -> None:
+        self.logs = []
+        self.iterations = 0
+        self.planning_counter = 0
+
+        tool_box = XGAAreToolBox(self.tools)
+
+        _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)
+        if prompt_are_general:
+            prompt_are_general = prompt_are_general.group(1).strip()
+        else:
+            prompt_are_general = _system_prompt
+
+        model_config = self.llm_engine.model_config
+        llm_config = LLMConfig(
+            model       = model_config.model_name,
+            api_key     = model_config.api_key,
+            api_base    = model_config.endpoint
+        )
+        self.task_engine =  ARETaskEngine(
+            agent               = self,
+            agent_id            = self.agent_id,
+            system_prompt       = prompt_are_general,
+            max_auto_run        = self.max_iterations,
+            llm_config          = llm_config,
+            tool_box            = tool_box,
+            pre_run_task_fn     = pre_run_task_check,
+            post_run_task_fn    = post_run_task_check,
+            terminate_task_fn   = terminate_task_check,
+        )
+
+        # Reload the agent state if logs are provided
+        start_logs = kwargs.pop("start_logs", [])
+        if start_logs:
+            self.replay(start_logs)
+
+        # Include additional image PILs directly into state stack.
+        if attachments:
+            images = attachments_to_pil(attachments)
+            self.action_executor.inject_state({f"image_{i}": image for i, image in enumerate(images)})
+            self.logger.debug(f"XGAAreAgent initialize: Injecting images into states for {len(images)} images")
+            self.logger.debug(f"XGAAreAgent initialize: New Keys {','.join(self.action_executor.state.keys())}")
+
+        self.initialized = True
+
+
+    @override
+    def execute_agent_loop(self) -> str | None | MMObservation:
+        import asyncio
+        asyncio.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():
+            return self.termination_step.function(self)
+
+
+    async def async_execute_agent_loop(self) -> str | None | MMObservation:
+        chunks = []
+        async for chunk in self.task_engine.run_task(task_input={"role": "user", "content": self.task}):
+            chunks.append(chunk)
+            chunk_type = chunk['type']
+            if chunk_type== "status":
+                status_content = chunk['content']
+                status_type = status_content['status_type']
+                if status_type == "error":
+                    error_msg = chunk.get('message')
+                    self.logger.warning(f"XGAAreAgent execute_agent_loop: Fatal error - {error_msg}")
+                    self.log_error(error_msg)
+                elif status_type == "stop":
+                    error_msg = chunk.get('message')
+                    self.logger.warning("XGAAreAgent execute_agent_loop: Agent stopped.")
+                    self.append_agent_log(
+                        StopLog(
+                            content     = f"Agent stopped - {error_msg}",
+                            timestamp   = self.make_timestamp(),
+                            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 == "tool":
+                tool_content = chunk['content']
+                tool_execution = tool_content.get('tool_execution')
+                self.append_agent_log(
+                    ToolCallLog(
+                        tool_name       = tool_execution.get('function_name'),
+                        tool_arguments  = tool_execution.get('arguments'),
+                        timestamp       = self.make_timestamp(),
+                        agent_id        = self.agent_id,
+                    )
+                )
+            #print(chunk)
+
+        final_result = self.task_engine.parse_final_result(chunks)
+        print(f"\n\nFINAL_RESULT: {final_result}")
+
+        # Send Final Result to user
+        args = {
+            'content': final_result['content']
+        }
+        self.tools['AgentUserInterface__send_message_to_user'](**args)
+        self.append_agent_log(
+            ToolCallLog(
+                tool_name       = 'AgentUserInterface__send_message_to_user',
+                tool_arguments  = args,
+                timestamp       = self.make_timestamp(),
+                agent_id        = self.agent_id,
+            )
+        )
+
+        # Return Final Result
+        if final_result['type'] == "error":
+            self.custom_state["running_state"] = RunningState.FAILED
+        else:
+            self.custom_state["running_state"] = RunningState.TERMINATED
+
+        self.append_agent_log(
+            FinalAnswerLog(
+                content     = final_result['content'],
+                timestamp   = self.make_timestamp(),
+                agent_id    = self.agent_id
+            )
+        )

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

@@ -0,0 +1,26 @@
+from are.simulation.agents.are_simulation_agent_config import ARESimulationReactBaseAgentConfig
+from are.simulation.agents.default_agent.steps.are_simulation import get_are_simulation_update_pre_step
+from are.simulation.agents.default_agent.termination_methods.are_simulation import get_gaia2_termination_step
+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
+
+
+def xga_simulation_react_xml_agent(
+    llm_engine: LLMEngine, base_agent_config: ARESimulationReactBaseAgentConfig
+):
+    return XGAAreAgent(
+        llm_engine=llm_engine,
+        tools={},
+        system_prompts={
+            "system_prompt": str(base_agent_config.system_prompt),
+        },
+        termination_step=get_gaia2_termination_step(),
+        max_iterations=base_agent_config.max_iterations,
+        action_executor=JsonActionExecutor(  # Just for compatible BaseAgent， useless
+            use_custom_logger=base_agent_config.use_custom_logger
+        ),
+        conditional_pre_steps=[get_are_simulation_update_pre_step()],
+        use_custom_logger=base_agent_config.use_custom_logger,
+    )

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

@@ -0,0 +1,109 @@
+import json
+import logging
+
+from typing import List, Any, Dict, Optional
+from typing_extensions import override
+
+from langchain_mcp_adapters.tools import load_mcp_tools
+
+from xgae.engine.engine_base import XGAError, XGAToolSchema, XGAToolResult, XGAToolType
+from xgae.engine.mcp_tool_box import XGAMcpToolBox
+
+from are.simulation.tools import Tool
+
+class XGAAreToolBox(XGAMcpToolBox):
+    def __init__(self, are_tools: Dict[str, Tool]):
+        super().__init__()
+        self.are_tools = are_tools
+        self._is_loaded_are_tool_schemas = False
+
+
+    @override
+    async def init_tool_schemas(self):
+        await self._load_mcp_tools_schema()
+        self._load_are_tools_schema()
+
+
+    @override
+    async def call_tool(self, task_id: str, tool_name: str, args: Optional[Dict[str, Any]] = None) -> XGAToolResult:
+        if tool_name == "end_task":
+            server_name = self.GENERAL_MCP_SERVER_NAME
+        else:
+            task_tool_schemas = self.task_tool_schemas.get(task_id, {})
+            tool_schema = task_tool_schemas.get(tool_name, None)
+            if tool_schema is None:
+                raise XGAError(f"MCP tool not found: '{tool_name}'")
+            server_name = tool_schema.server_name
+
+        tool_type = self._get_tool_type(server_name)
+        if tool_type == "custom":  # ARE Tools
+            full_tool_name = server_name + "__" + tool_name
+
+            try:
+                tool_result = self.are_tools[full_tool_name](**args)
+                result = XGAToolResult(success=True, output=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)
+        else:
+            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)
+
+                if mcp_tool:
+                    tool_args = args or {}
+
+                    if tool_type == "general" or tool_type == "agent":
+                        tool_args = dict({'task_id': task_id}, **tool_args)
+
+                    try:
+                        tool_result = await mcp_tool.arun(tool_args)
+                        if tool_type == "general":
+                            tool_result = json.loads(tool_result)
+                            result = XGAToolResult(success=tool_result['success'], output=str(tool_result['output']))
+                        else:
+                            result = XGAToolResult(success=True, output=str(tool_result))
+                    except Exception as e:
+                        error = f"Call MCP Tool '{tool_name}' error: {str(e)}"
+                        logging.error(f"AreToolBox call_mcp_tool: {error}")
+                        result = XGAToolResult(success=False, output=error)
+                else:
+                    error = f"No MCP tool found with name: {tool_name}"
+                    logging.info(f"AreToolBox call_mcp_tool: error={error}")
+                    result =  XGAToolResult(success=False, output=error)
+
+        return result
+
+
+    async def reload_mcp_tools_schema(self) -> None:
+        self._is_loaded_mcp_tool_schemas = False
+        self._is_loaded_are_tool_schemas = False
+        await self.init_tool_schemas()
+
+
+    def _load_are_tools_schema(self) -> None:
+        if not self._is_loaded_are_tool_schemas:
+            for are_tool in self.are_tools.values():
+                full_tool_name = are_tool.name
+                server_name , tool_name = full_tool_name.split("__")
+                tool_type :XGAToolType = "custom"
+                input_schema = {
+                    'properties': are_tool.inputs,
+                    'required': []
+                }
+
+                tool_schema = XGAToolSchema(tool_name       = tool_name,
+                                            tool_type       = tool_type,
+                                            server_name     = server_name,
+                                            description     = are_tool.description,
+                                            input_schema    = input_schema,
+                                            metadata        = {}
+                                            )
+                if server_name not in self.mcp_tool_schemas:
+                    self.mcp_tool_schemas[server_name] = []
+                self.mcp_tool_schemas[server_name].append(tool_schema)
+                if server_name not in self.mcp_server_names:
+                    self.mcp_server_names.append(server_name)
+
+        self._is_loaded_are_tool_schemas = True

{xgae-0.3.0 → xgae-0.3.2}/examples/agent/langgraph/reflection/custom_prompt_rag.py

@@ -1,6 +1,7 @@
 import logging
 import os
-from typing import override, List
+from typing import  List
+from typing_extensions import override
 
 from langchain_core.documents import Document
 from langchain_core.embeddings import Embeddings

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

@@ -1,15 +1,15 @@
 [project]
 name = "xgae"
-version = "0.3.0"
+version = "0.3.2"
 description = "Extreme General Agent Engine"
 readme = "README.md"
 requires-python = ">=3.11"
 dependencies = [
-    "colorlog==6.9.0",
-    "litellm==1.74.15",
-    "mcp==1.13.0",
+    "colorlog>=6.9.0",
+    "litellm>=1.71.1",
+    "mcp>=1.11.0",
     "langfuse==2.60.9",
-    "langchain-mcp-adapters==0.1.9",
+    "langchain-mcp-adapters>=0.1.9",
 ]
 
 

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

@@ -733,6 +733,19 @@ wheels = [
     { url = "https://pypi.tuna.tsinghua.edu.cn/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" },
 ]
 
+[[package]]
+name = "httpx-aiohttp"
+version = "0.1.9"
+source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" }
+dependencies = [
+    { name = "aiohttp" },
+    { name = "httpx" },
+]
+sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d8/f2/9a86ce9bc48cf57dabb3a3160dfed26d8bbe5a2478a51f9d1dbf89f2f1fc/httpx_aiohttp-0.1.9.tar.gz", hash = "sha256:4ee8b22e6f2e7c80cd03be29eff98bfe7d89bd77f021ce0b578ee76b73b4bfe6", size = 206023, upload-time = "2025-10-15T08:52:57.475Z" }
+wheels = [
+    { url = "https://pypi.tuna.tsinghua.edu.cn/packages/a1/db/5cfa8254a86c34a1ab7fe0dbec9f81bb5ebd831cbdd65aa4be4f37027804/httpx_aiohttp-0.1.9-py3-none-any.whl", hash = "sha256:3dc2845568b07742588710fcf3d72db2cbcdf2acc93376edf85f789c4d8e5fda", size = 6180, upload-time = "2025-10-15T08:52:56.521Z" },
+]
+
 [[package]]
 name = "httpx-sse"
 version = "0.4.1"
@@ -1125,12 +1138,13 @@ wheels = [
 
 [[package]]
 name = "litellm"
-version = "1.74.15"
+version = "1.71.1"
 source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" }
 dependencies = [
     { name = "aiohttp" },
     { name = "click" },
     { name = "httpx" },
+    { name = "httpx-aiohttp" },
     { name = "importlib-metadata" },
     { name = "jinja2" },
     { name = "jsonschema" },
@@ -1140,9 +1154,9 @@ dependencies = [
     { name = "tiktoken" },
     { name = "tokenizers" },
 ]
-sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/4b/13/90865340f76d54c1c2709074f882bf8ef3be0ac612a2164da5eed07ebe11/litellm-1.74.15.tar.gz", hash = "sha256:530a4b3918c02f87079ca7efb77eaf13d31f281218863f65b2da4bd863790677", size = 9748743, upload-time = "2025-08-02T21:49:08.631Z" }
+sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/8d/f7/1d51b81e608543c6a79b275a4e2b43f6b4b7f32588566b303102014b725d/litellm-1.71.1.tar.gz", hash = "sha256:c20e5917fdbe771ba4b6d1862b3d38d6e89cfba53e85bb337013f848256566eb", size = 7935681, upload-time = "2025-05-25T14:24:10.744Z" }
 wheels = [
-    { url = "https://pypi.tuna.tsinghua.edu.cn/packages/b9/9c/f4dd62d790d65c924699450d8789df437e63c8d99229e95bd7467ce7b82a/litellm-1.74.15-py3-none-any.whl", hash = "sha256:bf3db744dee982e53196cb688097ba76e2867004e39ad201b3761c5de9e3265b", size = 8835438, upload-time = "2025-08-02T21:49:05.817Z" },
+    { url = "https://pypi.tuna.tsinghua.edu.cn/packages/34/0e/328e077a66726dc1d4cfee37c67548b151a33a6d196a32737c85a034712b/litellm-1.71.1-py3-none-any.whl", hash = "sha256:9b94e250c58fba3c87c6ebb77e33c1cc8aa9110cee99dfdc37b368a11cec57c7", size = 7921387, upload-time = "2025-05-25T14:24:08.205Z" },
 ]
 
 [[package]]
@@ -1219,7 +1233,7 @@ wheels = [
 
 [[package]]
 name = "mcp"
-version = "1.13.0"
+version = "1.11.0"
 source = { registry = "https://pypi.tuna.tsinghua.edu.cn/simple" }
 dependencies = [
     { name = "anyio" },
@@ -1234,9 +1248,9 @@ dependencies = [
     { name = "starlette" },
     { name = "uvicorn", marker = "sys_platform != 'emscripten'" },
 ]
-sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/d3/a8/564c094de5d6199f727f5d9f5672dbec3b00dfafd0f67bf52d995eaa5951/mcp-1.13.0.tar.gz", hash = "sha256:70452f56f74662a94eb72ac5feb93997b35995e389b3a3a574e078bed2aa9ab3", size = 434709, upload-time = "2025-08-14T15:03:58.58Z" }
+sdist = { url = "https://pypi.tuna.tsinghua.edu.cn/packages/3a/f5/9506eb5578d5bbe9819ee8ba3198d0ad0e2fbe3bab8b257e4131ceb7dfb6/mcp-1.11.0.tar.gz", hash = "sha256:49a213df56bb9472ff83b3132a4825f5c8f5b120a90246f08b0dac6bedac44c8", size = 406907, upload-time = "2025-07-10T16:41:09.388Z" }
 wheels = [
-    { url = "https://pypi.tuna.tsinghua.edu.cn/packages/8b/6b/46b8bcefc2ee9e2d2e8d2bd25f1c2512f5a879fac4619d716b194d6e7ccc/mcp-1.13.0-py3-none-any.whl", hash = "sha256:8b1a002ebe6e17e894ec74d1943cc09aa9d23cb931bf58d49ab2e9fa6bb17e4b", size = 160226, upload-time = "2025-08-14T15:03:56.641Z" },
+    { url = "https://pypi.tuna.tsinghua.edu.cn/packages/92/9c/c9ca79f9c512e4113a5d07043013110bb3369fc7770040c61378c7fbcf70/mcp-1.11.0-py3-none-any.whl", hash = "sha256:58deac37f7483e4b338524b98bc949b7c2b7c33d978f5fafab5bde041c5e2595", size = 155880, upload-time = "2025-07-10T16:41:07.935Z" },
 ]
 
 [[package]]
@@ -2994,7 +3008,7 @@ wheels = [
 
 [[package]]
 name = "xgae"
-version = "0.3.0"
+version = "0.3.2"
 source = { editable = "." }
 dependencies = [
     { name = "colorlog" },
@@ -3014,13 +3028,13 @@ examples = [
 [package.metadata]
 requires-dist = [
     { name = "chromadb", marker = "extra == 'examples'", specifier = "==1.1.0" },
-    { name = "colorlog", specifier = "==6.9.0" },
+    { name = "colorlog", specifier = ">=6.9.0" },
     { name = "langchain-community", marker = "extra == 'examples'", specifier = "==0.3.29" },
-    { name = "langchain-mcp-adapters", specifier = "==0.1.9" },
+    { name = "langchain-mcp-adapters", specifier = ">=0.1.9" },
     { name = "langfuse", specifier = "==2.60.9" },
     { name = "langgraph", marker = "extra == 'examples'", specifier = "==0.6.5" },
-    { name = "litellm", specifier = "==1.74.15" },
-    { name = "mcp", specifier = "==1.13.0" },
+    { name = "litellm", specifier = ">=1.71.1" },
+    { name = "mcp", specifier = ">=1.11.0" },
 ]
 provides-extras = ["examples"]
 

{xgae-0.3.0 → xgae-0.3.2}/xgae/engine/engine_base.py

@@ -6,7 +6,7 @@ class XGAError(Exception):
     """Custom exception for errors in the XGA system."""
     pass
 
-XGAMsgStatusType = Literal["error", "finish", "tool_started", "tool_completed", "tool_error", "tool_failed"]
+XGAMsgStatusType = Literal["error", "stop", "finish", "tool_started", "tool_completed", "tool_error", "tool_failed"]
 XGAResponseMsgType = Literal["user", "status",  "tool", "assistant", "assistant_chunk"]
 
 class XGAResponseMessage(TypedDict, total=False):
@@ -40,6 +40,10 @@ class XGAToolResult:
 
 
 class XGAToolBox(ABC):
+    @abstractmethod
+    async def init_tool_schemas(self):
+        pass
+
     @abstractmethod
     async def creat_task_tool_box(self, task_id: str, general_tools: List[str], custom_tools: List[str]):
         pass

{xgae-0.3.0 → xgae-0.3.2}/xgae/engine/mcp_tool_box.py

@@ -2,7 +2,8 @@ import json
 import logging
 import os
 
-from typing import List, Any, Dict, Optional, Literal, override
+from typing import List, Any, Dict, Optional, Literal
+from typing_extensions import override
 
 from langchain_mcp_adapters.client import MultiServerMCPClient
 from langchain_mcp_adapters.tools import load_mcp_tools
@@ -33,7 +34,11 @@ class XGAMcpToolBox(XGAToolBox):
         self.mcp_tool_schemas: Dict[str, List[XGAToolSchema]] = {}
         self.task_tool_schemas: Dict[str, Dict[str,XGAToolSchema]] = {}
 
-        self.is_loaded_tool_schemas = False
+        self._is_loaded_mcp_tool_schemas = False
+
+    @override
+    async def init_tool_schemas(self):
+        await self._load_mcp_tools_schema()
 
     @override
     async def creat_task_tool_box(self, task_id: str, general_tools: List[str], custom_tools: List[str]):
@@ -139,8 +144,8 @@ class XGAMcpToolBox(XGAToolBox):
             return result
 
 
-    async def load_mcp_tools_schema(self)-> None:
-        if not self.is_loaded_tool_schemas:
+    async def _load_mcp_tools_schema(self)-> None:
+        if not self._is_loaded_mcp_tool_schemas:
             for server_name in self.mcp_server_names:
                 self.mcp_tool_schemas[server_name] = []
                 try:
@@ -162,18 +167,21 @@ class XGAMcpToolBox(XGAToolBox):
                             param_properties.pop('title', None)
 
                     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,
-                                                metadata=metadata)
+                    tool_schema = XGAToolSchema(
+                        tool_name       = tool.name,
+                        tool_type       = tool_type,
+                        server_name     = server_name,
+                        description     = tool.description,
+                        input_schema    = input_schema,
+                        metadata        = metadata
+                    )
                     self.mcp_tool_schemas[server_name].append(tool_schema)
-            self.is_loaded_tool_schemas = True
+
+            self._is_loaded_mcp_tool_schemas = True
 
     async def reload_mcp_tools_schema(self) -> None:
-        self.is_loaded_tool_schemas = False
-        await self.load_mcp_tools_schema()
+        self._is_loaded_mcp_tool_schemas = False
+        await self.init_tool_schemas()
 
 
     def _load_mcp_servers_config(self, mcp_config_path: str) -> Dict[str, Any]:
@@ -219,7 +227,7 @@ if __name__ == "__main__":
         #mcp_tool_box = XGAMcpToolBox()
 
         task_id = "task1"
-        await mcp_tool_box.load_mcp_tools_schema()
+        await mcp_tool_box.init_tool_schemas()
         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)

{xgae-0.3.0 → xgae-0.3.2}/xgae/engine/prompt_builder.py

@@ -83,9 +83,10 @@ class XGAPromptBuilder():
             tool_info = ""
             for tool_schema in tool_schemas:
                 description = tool_schema.description if tool_schema.description else 'No description available'
-                tool_info += f"- **{tool_schema.tool_name}**: {description}\n"
+                tool_info += f"- {tool_schema.tool_name}: {description}\n"
                 parameters = tool_schema.input_schema.get('properties', {})
-                tool_info += f"  Parameters: {parameters}\n"
+                tool_info += f"   Parameters: {parameters}\n"
+                tool_info += "\n"
             tool_prompt = tool_prompt.replace("{tool_schemas}", tool_info)
 
         return tool_prompt

{xgae-0.3.0 → xgae-0.3.2}/xgae/engine/responser/non_stream_responser.py

@@ -1,6 +1,7 @@
 import logging
 
-from typing import List, Dict, Any, AsyncGenerator, override,Optional
+from typing import List, Dict, Any, AsyncGenerator,Optional
+from typing_extensions import override
 
 from xgae.utils import log_trace
 

{xgae-0.3.0 → xgae-0.3.2}/xgae/engine/responser/stream_responser.py

@@ -1,6 +1,7 @@
 import logging
-import asyncio
-from typing import List, Dict, Any, Optional, AsyncGenerator, override
+
+from typing import List, Dict, Any, Optional, AsyncGenerator
+from typing_extensions import override
 
 from xgae.utils import log_trace
 

{xgae-0.3.0 → xgae-0.3.2}/xgae/engine/task_engine.py

@@ -116,8 +116,7 @@ class XGATaskEngine:
                     general_tools.append("ask")
 
             custom_tools = self.custom_tools or []
-            if isinstance(self.tool_box, XGAMcpToolBox):
-                await  self.tool_box.load_mcp_tools_schema()
+            await  self.tool_box.init_tool_schemas()
 
             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")
@@ -201,6 +200,9 @@ class XGATaskEngine:
                 yield error_msg
             finally:
                 if not self.running_task_checkpoint("termination_check", iterations):
+                    status_content = {'status_type': "stop", 'role': "system", 'message': "Task is termiated by Stop Command"}
+                    error_msg = self.add_response_message(type="status", content=status_content, is_llm_message=False)
+                    yield error_msg
                     break
 
     async def _run_task_once(self, continuous_state: TaskRunContinuousState) -> AsyncGenerator[Dict[str, Any], None]:
@@ -239,8 +241,8 @@ class XGATaskEngine:
         reverse_chunks = reversed(chunks)
         chunk = None
 
-        if self.terminate_task:
-            return XGATaskResult(type="error", content="LLM Task is terminated !")
+        # if self.terminate_task:
+        #     return XGATaskResult(type="error", content="LLM Task is terminated !")
 
         try:
             finish_reason = ''
@@ -249,7 +251,7 @@ class XGATaskEngine:
                 if chunk_type == "status":
                     status_content = chunk['content']
                     status_type = status_content['status_type']
-                    if status_type == "error":
+                    if status_type == "error" or  status_type == "stop":
                         error = status_content['message']
                         final_result = XGATaskResult(type="error", content=error)
                     elif status_type == "finish":

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

@@ -1,5 +1,6 @@
 import logging
-from typing import Any, Optional, override, Callable, Literal, Dict, List
+from typing import Any, Optional, Callable, Literal, Dict, List
+from typing_extensions import override
 
 from xgae.engine.engine_base import XGAToolBox
 from xgae.engine.task_engine import XGATaskEngine
@@ -81,12 +82,12 @@ if __name__ == "__main__":
 
     def terminate_task(agent, iterations: int) -> bool:
         logging.info(f"terminate_task: iterations={iterations}")
-        return iterations > 6 # can test terminate by > 3
+        return iterations > 3 # can test terminate by > 3
 
 
     async def main():
         # Before Run Exec: uv run example-fault-tools
-        # LLAMA_API_KEY ,
+        # LLAMA_API_KEY , LLAMA_API_BASE
         tool_box = XGAMcpToolBox(custom_mcp_server_file="mcpservers/custom_servers.json")
         system_prompt = read_file("templates/example/fault_user_prompt.txt")
         llm_config = LLMConfig(

{xgae-0.3.0 → xgae-0.3.2}/xgae/utils/llm_client.py

@@ -51,6 +51,9 @@ class LLMClient:
         self._init_langfuse()
 
         llm_config = llm_config or LLMConfig()
+        if llm_config.get('model') and llm_config.get('model_name') is None:
+            llm_config['model_name'] = llm_config.get('model')
+
         self.max_retries = int(os.getenv('LLM_MAX_RETRIES', 1))
 
         env_llm_model           = os.getenv('LLM_MODEL', "openai/qwen3-235b-a22b")

xgae-0.3.0/PKG-INFO

@@ -1,14 +0,0 @@
-Metadata-Version: 2.4
-Name: xgae
-Version: 0.3.0
-Summary: Extreme General Agent Engine
-Requires-Python: >=3.11
-Requires-Dist: colorlog==6.9.0
-Requires-Dist: langchain-mcp-adapters==0.1.9
-Requires-Dist: langfuse==2.60.9
-Requires-Dist: litellm==1.74.15
-Requires-Dist: mcp==1.13.0
-Provides-Extra: examples
-Requires-Dist: chromadb==1.1.0; extra == 'examples'
-Requires-Dist: langchain-community==0.3.29; extra == 'examples'
-Requires-Dist: langgraph==0.6.5; extra == 'examples'