xgae 0.3.1__tar.gz → 0.3.2__tar.gz

{xgae-0.3.1 → 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.1 → xgae-0.3.2}/pyproject.toml

@@ -1,15 +1,15 @@
 [project]
 name = "xgae"
-version = "0.3.1"
+version = "0.3.2"
 description = "Extreme General Agent Engine"
 readme = "README.md"
 requires-python = ">=3.11"
 dependencies = [
-    "colorlog==6.9.0",
-    "litellm==1.71.1",
-    "mcp==1.11.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.1 → xgae-0.3.2}/uv.lock

@@ -3008,7 +3008,7 @@ wheels = [
 
 [[package]]
 name = "xgae"
-version = "0.3.1"
+version = "0.3.2"
 source = { editable = "." }
 dependencies = [
     { name = "colorlog" },
@@ -3028,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.71.1" },
-    { name = "mcp", specifier = "==1.11.0" },
+    { name = "litellm", specifier = ">=1.71.1" },
+    { name = "mcp", specifier = ">=1.11.0" },
 ]
 provides-extras = ["examples"]
 

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

@@ -167,12 +167,14 @@ 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_mcp_tool_schemas = True

{xgae-0.3.1 → 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.1 → 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.1/PKG-INFO

@@ -1,14 +0,0 @@
-Metadata-Version: 2.4
-Name: xgae
-Version: 0.3.1
-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'