xgae 0.1.1__tar.gz

xgae-0.1.1/.env

@@ -0,0 +1,21 @@
+# LOG
+LOG_LEVEL=INFO
+LOG_FILE=log/xgae.log
+
+# LANGFUSE
+LANGFUSE_PUBLIC_KEY=
+LANGFUSE_SECRET_KEY=
+LANGFUSE_HOST=https://cloud.langfuse.com
+
+# LLM
+LLM_MODEL=openai/qwen3-235b-a22b
+LLM_API_BASE=https://dashscope.aliyuncs.com/compatible-mode/v1
+LLM_API_KEY=
+LLM_MAX_TOKENS=16384
+LLM_TEMPERATURE=0.7
+LLM_MAX_RETRIES=2
+
+
+
+
+

xgae-0.1.1/.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

xgae-0.1.1/.idea/inspectionProfiles/Project_Default.xml

@@ -0,0 +1,15 @@
+<component name="InspectionProjectProfileManager">
+  <profile version="1.0">
+    <option name="myName" value="Project Default" />
+    <inspection_tool class="PyCompatibilityInspection" enabled="true" level="WARNING" enabled_by_default="true">
+      <option name="ourVersions">
+        <value>
+          <list size="2">
+            <item index="0" class="java.lang.String" itemvalue="3.8" />
+            <item index="1" class="java.lang.String" itemvalue="3.11" />
+          </list>
+        </value>
+      </option>
+    </inspection_tool>
+  </profile>
+</component>

xgae-0.1.1/.idea/inspectionProfiles/profiles_settings.xml

@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <settings>
+    <option name="USE_PROJECT_PROFILE" value="false" />
+    <version value="1.0" />
+  </settings>
+</component>

xgae-0.1.1/.idea/misc.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="Black">
+    <option name="sdkName" value="Python 3.13 (xgae)" />
+  </component>
+  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.13 virtualenv at ~/DevelopSpace/xgae/.venv" project-jdk-type="Python SDK" />
+</project>

xgae-0.1.1/.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/xgae.iml" filepath="$PROJECT_DIR$/.idea/xgae.iml" />
+    </modules>
+  </component>
+</project>

xgae-0.1.1/.idea/vcs.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings" defaultProject="true" />
+</project>

xgae-0.1.1/.idea/workspace.xml

@@ -0,0 +1,128 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="AutoImportSettings">
+    <option name="autoReloadType" value="SELECTIVE" />
+  </component>
+  <component name="ChangeListManager">
+    <list default="true" id="0f1352ac-e106-4041-9704-6775ec0c7096" name="Changes" comment="" />
+    <option name="SHOW_DIALOG" value="false" />
+    <option name="HIGHLIGHT_CONFLICTS" value="true" />
+    <option name="HIGHLIGHT_NON_ACTIVE_CHANGELIST" value="false" />
+    <option name="LAST_RESOLUTION" value="IGNORE" />
+  </component>
+  <component name="FileTemplateManagerImpl">
+    <option name="RECENT_TEMPLATES">
+      <list>
+        <option value="Python Script" />
+      </list>
+    </option>
+  </component>
+  <component name="ProjectColorInfo">{
+  &quot;associatedIndex&quot;: 7
+}</component>
+  <component name="ProjectId" id="31InXSONOzq9VTdmbkoD0F0ho9q" />
+  <component name="ProjectViewState">
+    <option name="hideEmptyMiddlePackages" value="true" />
+    <option name="showLibraryContents" value="true" />
+  </component>
+  <component name="PropertiesComponent">{
+  &quot;keyToString&quot;: {
+    &quot;ModuleVcsDetector.initialDetectionPerformed&quot;: &quot;true&quot;,
+    &quot;Python.llm_client.executor&quot;: &quot;Run&quot;,
+    &quot;Python.utils.executor&quot;: &quot;Run&quot;,
+    &quot;Python.xga_mcp_tool_box.executor&quot;: &quot;Run&quot;,
+    &quot;RunOnceActivity.ShowReadmeOnStart&quot;: &quot;true&quot;,
+    &quot;last_opened_file_path&quot;: &quot;/Users/goosezzy/DevelopSpace/xgae&quot;,
+    &quot;node.js.detected.package.eslint&quot;: &quot;true&quot;,
+    &quot;node.js.detected.package.tslint&quot;: &quot;true&quot;,
+    &quot;node.js.selected.package.eslint&quot;: &quot;(autodetect)&quot;,
+    &quot;node.js.selected.package.tslint&quot;: &quot;(autodetect)&quot;,
+    &quot;nodejs_package_manager_path&quot;: &quot;npm&quot;,
+    &quot;settings.editor.selected.configurable&quot;: &quot;preferences.general&quot;,
+    &quot;vue.rearranger.settings.migration&quot;: &quot;true&quot;
+  }
+}</component>
+  <component name="RecentsManager">
+    <key name="MoveFile.RECENT_KEYS">
+      <recent name="$PROJECT_DIR$/src/xgae/engine/responser" />
+    </key>
+  </component>
+  <component name="RunManager">
+    <configuration default="true" type="PythonConfigurationType" factoryName="Python">
+      <module name="xgae" />
+      <option name="ENV_FILES" value="" />
+      <option name="INTERPRETER_OPTIONS" value="" />
+      <option name="PARENT_ENVS" value="true" />
+      <envs>
+        <env name="PYTHONUNBUFFERED" value="1" />
+      </envs>
+      <option name="SDK_HOME" value="" />
+      <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$" />
+      <option name="IS_MODULE_SDK" value="false" />
+      <option name="ADD_CONTENT_ROOTS" value="true" />
+      <option name="ADD_SOURCE_ROOTS" value="true" />
+      <EXTENSION ID="PythonCoverageRunConfigurationExtension" runner="coverage.py" />
+      <EXTENSION ID="net.ashald.envfile">
+        <option name="IS_ENABLED" value="false" />
+        <option name="IS_SUBST" value="false" />
+        <option name="IS_PATH_MACRO_SUPPORTED" value="false" />
+        <option name="IS_IGNORE_MISSING_FILES" value="false" />
+        <option name="IS_ENABLE_EXPERIMENTAL_INTEGRATIONS" value="false" />
+        <ENTRIES>
+          <ENTRY IS_ENABLED="true" PARSER="runconfig" IS_EXECUTABLE="false" />
+        </ENTRIES>
+      </EXTENSION>
+      <option name="SCRIPT_NAME" value="" />
+      <option name="PARAMETERS" value="" />
+      <option name="SHOW_COMMAND_LINE" value="false" />
+      <option name="EMULATE_TERMINAL" value="false" />
+      <option name="MODULE_MODE" value="false" />
+      <option name="REDIRECT_INPUT" value="false" />
+      <option name="INPUT_FILE" value="" />
+      <method v="2" />
+    </configuration>
+  </component>
+  <component name="SharedIndexes">
+    <attachedChunks>
+      <set>
+        <option value="bundled-js-predefined-d6986cc7102b-09060db00ec0-JavaScript-PY-251.26927.90" />
+        <option value="bundled-python-sdk-41e8cd69c857-64d779b69b7a-com.jetbrains.pycharm.pro.sharedIndexes.bundled-PY-251.26927.90" />
+      </set>
+    </attachedChunks>
+  </component>
+  <component name="TaskManager">
+    <task active="true" id="Default" summary="Default task">
+      <changelist id="0f1352ac-e106-4041-9704-6775ec0c7096" name="Changes" comment="" />
+      <created>1755220495138</created>
+      <option name="number" value="Default" />
+      <option name="presentableId" value="Default" />
+      <updated>1755220495138</updated>
+      <workItem from="1755220497295" duration="14755000" />
+      <workItem from="1755239458855" duration="4586000" />
+      <workItem from="1755244406907" duration="6284000" />
+      <workItem from="1755262332599" duration="306000" />
+      <workItem from="1755270285722" duration="12068000" />
+      <workItem from="1755283728206" duration="1511000" />
+      <workItem from="1755286552901" duration="3130000" />
+      <workItem from="1755307767865" duration="337000" />
+      <workItem from="1755308113420" duration="2825000" />
+      <workItem from="1755321931380" duration="8531000" />
+      <workItem from="1755330830188" duration="229000" />
+      <workItem from="1755396985976" duration="6435000" />
+      <workItem from="1755415614018" duration="461000" />
+      <workItem from="1755416476555" duration="256000" />
+      <workItem from="1755419142521" duration="150000" />
+      <workItem from="1755429851003" duration="290000" />
+      <workItem from="1755430331676" duration="21000" />
+    </task>
+    <servers />
+  </component>
+  <component name="TypeScriptGeneratedFilesManager">
+    <option name="version" value="3" />
+  </component>
+  <component name="com.intellij.coverage.CoverageDataManagerImpl">
+    <SUITE FILE_PATH="coverage/xgae$xga_mcp_tool_box.coverage" NAME="xga_mcp_tool_box Coverage Results" MODIFIED="1755430037796" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
+    <SUITE FILE_PATH="coverage/xgae$llm_client.coverage" NAME="llm_client Coverage Results" MODIFIED="1755247632274" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
+    <SUITE FILE_PATH="coverage/xgae$utils.coverage" NAME="utils Coverage Results" MODIFIED="1755226923439" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
+  </component>
+</project>

xgae-0.1.1/.idea/xgae.iml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+      <excludeFolder url="file://$MODULE_DIR$/.venv" />
+    </content>
+    <orderEntry type="jdk" jdkName="Python 3.13 virtualenv at ~/DevelopSpace/xgae/.venv" jdkType="Python SDK" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

xgae-0.1.1/.python-version

@@ -0,0 +1 @@
+3.13

xgae-0.1.1/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: xgae
+Version: 0.1.1
+Summary: Extreme General Agent Engine
+Requires-Python: >=3.13
+Requires-Dist: colorlog>=6.9.0
+Requires-Dist: langchain-mcp-adapters>=0.1.4
+Requires-Dist: langfuse>=2.60.5
+Requires-Dist: langgraph>=0.3.21
+Requires-Dist: litellm>=1.74.8
+Requires-Dist: mcp>=1.12.1

xgae-0.1.1/mcpservers/custom_servers.json

@@ -0,0 +1,8 @@
+{
+    "mcpServers":{
+        "bomc_fault": {
+            "url": "http://localhost:17070/sse",
+            "transport": "sse"
+        }
+    }
+}

xgae-0.1.1/mcpservers/xga_server.json

@@ -0,0 +1,8 @@
+{
+    "mcpServers":{
+        "xga_general": {
+            "url": "http://localhost:16060/sse",
+            "transport": "sse"
+        }
+    }
+}

xgae-0.1.1/pyproject.toml

@@ -0,0 +1,23 @@
+[project]
+name = "xgae"
+version = "0.1.1"
+description = "Extreme General Agent Engine"
+readme = "README.md"
+requires-python = ">=3.13"
+dependencies = [
+    "colorlog>=6.9.0",
+    "langchain-mcp-adapters>=0.1.4",
+    "langgraph>=0.3.21",
+    "litellm>=1.74.8",
+    "mcp>=1.12.1",
+    "langfuse>=2.60.5",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build]
+exclude = ["log/*"]
+
+[project.scripts]

xgae-0.1.1/src/xgae/engine/xga_base.py

@@ -0,0 +1,46 @@
+from typing import Union, Optional, Dict, List, Any, Literal
+from dataclasses import dataclass
+from abc import ABC, abstractmethod
+
+
+
+@dataclass
+class XGAMessage:
+    message_id: str
+    type: Literal["status",  "tool", "assistant", "assistant_response_end"]
+    is_llm_message: bool
+    content: Union[Dict[str, Any], List[Any], str]
+    metadata: Optional[Dict[str, Any]]
+    session_id: Optional[str]
+    agent_id: Optional[str]
+    task_id: Optional[str]
+
+@dataclass
+class XGAToolSchema:
+    tool_name: str
+    server_name: str
+    description: str
+    input_schema: Optional[str]
+
+
+@dataclass
+class XGAToolResult:
+    success: bool
+    output: str
+
+class XGAToolBox(ABC):
+    @abstractmethod
+    async def creat_task_tool_box(self, task_id: str, general_tools: List[str], custom_tools: List[str]):
+        pass
+
+    @abstractmethod
+    async def destroy_task_tool_box(self, task_id: str):
+        pass
+
+    @abstractmethod
+    def get_task_tool_schemas(self, task_id: str, type: Literal["general_tool",  "custom_tool"]) -> List[XGAToolSchema]:
+        pass
+
+    @abstractmethod
+    async def call_tool(self, task_id: str, tool_name: str, args: Optional[Dict[str, Any]] = None) -> XGAToolResult:
+        pass

xgae-0.1.1/src/xgae/engine/xga_engine.py

@@ -0,0 +1,69 @@
+
+from typing import List, Any, Dict, Optional, AsyncGenerator
+from uuid import uuid4
+
+from xgae.engine.xga_base import XGAMessage, XGAToolSchema, XGAToolBox
+from xgae.utils.llm_client import LLMClient
+from xgae.utils.setup_env import langfuse
+from xga_prompt_builder import XGAPromptBuilder
+from xga_mcp_tool_box import XGAMcpToolBox
+
+class XGAEngine():
+    def __init__(self,
+                 session_id: Optional[str] = None,
+                 trace_id: Optional[str] = None,
+                 agent_id: Optional[str] = None,
+                 llm_config: Optional[Dict[str, Any]] = None,
+                 prompt_builder: Optional[XGAPromptBuilder] = None,
+                 tool_box: Optional[XGAToolBox] = None):
+        self.session_id = session_id if session_id else f"xga_sid_{uuid4()}"
+        self.agent_id = agent_id
+
+        self.messages: List[XGAMessage] = []
+        self.llm_client = LLMClient(llm_config)
+        self.model_name = self.llm_client.model_name
+        self.is_stream = self.llm_client.is_stream
+
+        self.prompt_builder = prompt_builder or XGAPromptBuilder()
+        self.tool_box = tool_box or XGAMcpToolBox()
+
+        self.task_id = None
+        self.trace_id = trace_id if trace_id else langfuse.create_trace_id()
+
+
+    async def run_task(self,
+                       task_messages: List[Dict[str, Any]],
+                       task_id: Optional[str],
+                       prompt_template: Optional[str] = None,
+                       general_tools: Optional[List[str]] = ["*"],
+                       custom_tools: Optional[List[str]] = []) -> AsyncGenerator:
+        try:
+            self.task_id = task_id if task_id else f"xga_task_{uuid4()}"
+            await self.tool_box.creat_task_tool_box(self.task_id, general_tools, custom_tools)
+            system_prompt = await self._build_system_prompt(prompt_template, general_tools, custom_tools)
+            yield system_prompt
+
+        finally:
+            await self.tool_box.destroy_task_tool_box(self.task_id)
+        
+
+    def _run_task_once(self):
+        pass
+
+    async def _build_system_prompt(self, prompt_template: str, general_tools: List[str], custom_tools: List[str]) -> str:
+        self.task_tool_schemas: Dict[str, XGAToolSchema] = {}
+        system_prompt = self.prompt_builder.build_system_prompt(self.model_name, prompt_template)
+
+        tool_schemas = await self.tool_box.get_task_tool_schemas(self.task_id, "general_tool")
+        system_prompt = self.prompt_builder.build_general_tool_prompt(self.model_name, system_prompt, tool_schemas)
+
+        tool_schemas = await self.tool_box.get_task_tool_schemas(self.task_id, "general_tool")
+        system_prompt = self.prompt_builder.build_custom_tool_prompt(self.model_name, system_prompt, tool_schemas)
+
+        return system_prompt
+
+    def add_message(self, message: XGAMessage):
+        message.message_id = f"xga_msg_{uuid4()}"
+        message.session_id = self.session_id
+        message.agent_id = self.agent_id
+        self.messages.append(message)

xgae-0.1.1/src/xgae/engine/xga_mcp_tool_box.py

@@ -0,0 +1,192 @@
+import json
+import logging
+import os
+from typing import List, Any, Dict, Optional, Literal, override
+
+from langchain_mcp_adapters.client import MultiServerMCPClient
+from langchain_mcp_adapters.tools import load_mcp_tools
+
+from xgae.engine.xga_base import XGAToolSchema, XGAToolBox, XGAToolResult
+from xgae.utils.setup_env import XGAError
+
+
+class XGAMcpToolBox(XGAToolBox):
+    GENERAL_MCP_SERVER_NAME = "xga_general"
+
+    def __init__(self,
+                 custom_mcp_server_config: Optional[Dict[str, Any]] = None,
+                 custom_mcp_server_file: Optional[str] = None):
+        general_mcp_server_config = self._load_mcp_servers_config("mcpservers/xga_server.json")
+        tool_box_mcp_server_config = general_mcp_server_config.get("mcpServers", {})
+
+        if custom_mcp_server_config:
+            tool_box_mcp_server_config.update(custom_mcp_server_config)
+        elif custom_mcp_server_file:
+            custom_mcp_server_config = self._load_mcp_servers_config(custom_mcp_server_file)
+            custom_mcp_server_config = custom_mcp_server_config.get("mcpServers", {})
+            tool_box_mcp_server_config.update(custom_mcp_server_config)
+
+        self._mcp_client = MultiServerMCPClient(tool_box_mcp_server_config)
+        self.mcp_server_names: List[str] = [server_name for server_name in tool_box_mcp_server_config]
+        self.mcp_tool_schemas: Dict[str, List[XGAToolSchema]] = {}
+        self.task_tool_schemas: Dict[str, Dict[str,XGAToolSchema]] = {}
+
+    @override
+    async def creat_task_tool_box(self, task_id: str, general_tools: List[str], custom_tools: List[str]):
+        task_tool_schemas = {}
+        general_tool_schemas = self.mcp_tool_schemas.get(XGAMcpToolBox.GENERAL_MCP_SERVER_NAME, {})
+        if len(general_tools) > 0 and general_tools[0] == "*":
+            task_tool_schemas = {tool_schema.tool_name: tool_schema for tool_schema in general_tool_schemas}
+        else:
+            for tool_schema in general_tool_schemas:
+                if tool_schema.tool_name in general_tools:
+                    task_tool_schemas[tool_schema.tool_name] = tool_schema
+        task_tool_schemas.pop("end_task")
+
+        for server_tool_name in custom_tools:
+            parts = server_tool_name.split(".")
+            if len(parts) != 2:
+                continue
+            custom_server_name, custom_tool_name = parts
+            if (not custom_server_name ) or (not custom_tool_name):
+                continue
+
+            custom_tool_schemas = self.mcp_tool_schemas.get(custom_server_name, None)
+            if custom_tool_schemas is None:
+                continue
+            if custom_tool_name == "*":
+                custom_tool_schema_d = {tool_schema.tool_name: tool_schema for tool_schema in custom_tool_schemas}
+                task_tool_schemas.update(custom_tool_schema_d)
+            else:
+                for tool_schema in custom_tool_schemas:
+                    if custom_tool_name == tool_schema.tool_name:
+                        task_tool_schemas[custom_tool_name] = tool_schema
+
+
+        self.task_tool_schemas[task_id] = task_tool_schemas
+
+    @override
+    async def destroy_task_tool_box(self, task_id: str):
+        tool_schemas = self.get_task_tool_schemas(task_id, type="general_tool")
+        if len(tool_schemas) > 0:
+            await self.call_tool(task_id, "end_task", {"task_id": task_id})
+        self.task_tool_schemas.pop(task_id, None)
+
+    @override
+    def get_task_tool_schemas(self, task_id: str, type: Literal["general_tool",  "custom_tool"]) -> List[XGAToolSchema]:
+        task_tool_schemas = []
+
+        all_task_tool_schemas = self.task_tool_schemas.get(task_id, {})
+        for tool_schema in all_task_tool_schemas.values():
+            if type == "general_tool" and tool_schema.server_name == self.GENERAL_MCP_SERVER_NAME:
+                task_tool_schemas.append(tool_schema)
+            elif type == "custom_tool" and tool_schema.server_name != self.GENERAL_MCP_SERVER_NAME:
+                task_tool_schemas.append(tool_schema)
+
+        return task_tool_schemas
+
+    @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
+
+        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 server_name == self.GENERAL_MCP_SERVER_NAME:
+                    pass
+                    #tool_args["task_id"] = task_id #xga general tool, first param must be task_id
+                else:
+                    tool_args = args
+
+                try:
+                    tool_result = await mcp_tool.arun(tool_args)
+                    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"XGAMcpToolBox.call_tool: {error}")
+                    result = XGAToolResult(success=False, output=error)
+            else:
+                error = f"No MCP tool found with name: {tool_name}"
+                logging.info(f"XGAMcpToolBox.call_tool: error={error}")
+                result =  XGAToolResult(success=False, output=error)
+
+            return result
+
+    async def load_mcp_tools_schema(self)-> None:
+        for server_name in self.mcp_server_names:
+            self.mcp_tool_schemas[server_name] = []
+            mcp_tools = await self._mcp_client.get_tools(server_name=server_name)
+            for tool in mcp_tools:
+                input_schema = tool.args_schema
+                if server_name == self.GENERAL_MCP_SERVER_NAME:
+                    input_schema = str(tool.args_schema) # @todo remove task_id param
+                input_schema_str = str(input_schema) # @todo convert input tool.args_schema
+                tool_schema = XGAToolSchema(tool_name=tool.name,
+                                            server_name=server_name,
+                                            description=tool.description,
+                                            input_schema=input_schema_str)
+                self.mcp_tool_schemas[server_name].append(tool_schema)
+
+    @staticmethod
+    def _load_mcp_servers_config(mcp_config_path: str) -> Dict[str, Any]:
+        try:
+            if os.path.exists(mcp_config_path):
+                with open(mcp_config_path, 'r', encoding='utf-8') as f:
+                    server_config = json.load(f)
+
+                    for server_name, server_info in server_config["mcpServers"].items():
+                        if "transport" not in server_info:
+                            if "url" in server_info:
+                                server_info["transport"] = "streamable_http" if "mcp" in server_info["url"] else "sse"
+                            else:
+                                server_info["transport"] = "stdio"
+
+                    return server_config
+            else:
+                logging.warning("MCP servers config file not found at: %s", mcp_config_path)
+                return {"mcpServers": {}}
+
+        except Exception as e:
+            logging.error("Failed to load MCP servers config: %s", str(e))
+            return {"mcpServers": {}}
+
+
+if __name__ == "__main__":
+    import asyncio
+    from dataclasses import asdict
+    async def main():
+        task_id = "task1"
+        mcp_tool_box = XGAMcpToolBox(custom_mcp_server_file="mcpservers/custom_servers.json")
+        #mcp_tool_box = XGAMcpToolBox()
+        await mcp_tool_box.load_mcp_tools_schema()
+        await mcp_tool_box.creat_task_tool_box(task_id=task_id, general_tools=["*"], custom_tools=["bomc_fault.*"])
+        tool_schemas = mcp_tool_box.get_task_tool_schemas(task_id, "general_tool")
+        print("general_tools_schemas" + "*"*50)
+        for tool_schema in tool_schemas:
+            print(asdict(tool_schema))
+        print()
+
+        tool_schemas = mcp_tool_box.get_task_tool_schemas(task_id, "custom_tool")
+        print("custom_tools_schemas" + "*" * 50)
+        for tool_schema in tool_schemas:
+            print(asdict(tool_schema))
+        print()
+
+        result = await mcp_tool_box.call_tool(task_id=task_id, tool_name="web_search", args={"task_id": task_id, "query": "查询天津天气"})
+        print(f"call web_search result: {result}")
+
+        result = await mcp_tool_box.call_tool(task_id=task_id, tool_name="complete", args={"task_id": task_id})
+        print(f"call complete result: {result}")
+
+        await mcp_tool_box.destroy_task_tool_box(task_id)
+    asyncio.run(main())

xgae-0.1.1/src/xgae/engine/xga_prompt_builder.py

@@ -0,0 +1,38 @@
+import datetime
+
+from typing import Optional, List
+
+from xga_base import XGAToolSchema
+from xgae.utils.setup_env import read_file, XGAError
+
+
+class XGAPromptBuilder():
+    def __init__(self,
+                 prompt_template: Optional[str] = None,
+                 prompt_template_file: Optional[str] = None):
+        self.system_prompt_template = None
+        if prompt_template:
+            self.system_prompt_template = prompt_template
+        elif prompt_template_file:
+            self.system_prompt_template = read_file(prompt_template_file)
+        else:
+            _system_prompt_template = read_file("templates/system_prompt_template.txt")
+            self.system_prompt_template = _system_prompt_template.format(
+                current_date=datetime.datetime.now(datetime.timezone.utc).strftime('%Y-%m-%d'),
+                current_time=datetime.datetime.now(datetime.timezone.utc).strftime('%H:%M:%S'),
+                current_year=datetime.datetime.now(datetime.timezone.utc).strftime('%Y')
+            )
+
+
+    def build_system_prompt(self, model_name:str, prompt_template: Optional[str]=None)-> str:
+        system_prompt = prompt_template if prompt_template else self.system_prompt_template
+
+        return system_prompt
+
+
+    def build_general_tool_prompt(self, model_name:str, prompt_template: str, tool_schemas:List[XGAToolSchema])-> str:
+        pass
+
+
+    def build_custom_tool_prompt(self, model_name:str, prompt_template: str, tool_schemas:List[XGAToolSchema])-> str:
+        pass