xgae 0.1.6__tar.gz → 0.1.7__tar.gz

{xgae-0.1.6 → xgae-0.1.7}/.env

@@ -15,6 +15,8 @@ LLM_MAX_TOKENS=16384
 LLM_TEMPERATURE=0.7
 LLM_MAX_RETRIES=2
 
+# TASK
+MAX_AUTO_RUN = 15
 
 
 

{xgae-0.1.6 → xgae-0.1.7}/.idea/misc.xml

@@ -3,5 +3,5 @@
   <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" />
+  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.13 virtualenv at ~/DevProjects/xga/xgae/.venv" project-jdk-type="Python SDK" />
 </project>

{xgae-0.1.6 → xgae-0.1.7}/.idea/workspace.xml

@@ -25,26 +25,34 @@
     <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.run_xga_engine.executor&quot;: &quot;Run&quot;,
-    &quot;Python.setup_env.executor&quot;: &quot;Run&quot;,
-    &quot;Python.utils.executor&quot;: &quot;Run&quot;,
-    &quot;Python.xga_engine.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.pluginManager&quot;,
-    &quot;vue.rearranger.settings.migration&quot;: &quot;true&quot;
+  <component name="PropertiesComponent"><![CDATA[{
+  "keyToString": {
+    "ModuleVcsDetector.initialDetectionPerformed": "true",
+    "Python.llm_client.executor": "Run",
+    "Python.message_tools_app.executor": "Run",
+    "Python.responser_base.executor": "Run",
+    "Python.run_engine_with_human_in_loop.executor": "Run",
+    "Python.run_simple.executor": "Run",
+    "Python.run_task_engine.executor": "Run",
+    "Python.run_user_prompt.executor": "Run",
+    "Python.run_xga_engine.executor": "Run",
+    "Python.setup_env.executor": "Run",
+    "Python.task_engine.executor": "Run",
+    "Python.utils.executor": "Run",
+    "Python.xga_engine.executor": "Run",
+    "Python.xga_mcp_tool_box.executor": "Debug",
+    "Python.xga_prompt_builder.executor": "Debug",
+    "RunOnceActivity.ShowReadmeOnStart": "true",
+    "last_opened_file_path": "/Users/sharkystar/DevProjects/xga/xgae",
+    "node.js.detected.package.eslint": "true",
+    "node.js.detected.package.tslint": "true",
+    "node.js.selected.package.eslint": "(autodetect)",
+    "node.js.selected.package.tslint": "(autodetect)",
+    "nodejs_package_manager_path": "npm",
+    "settings.editor.selected.configurable": "com.intellij.pycharm.community.ide.impl.configuration.PythonContentEntriesConfigurable",
+    "vue.rearranger.settings.migration": "true"
   }
-}</component>
+}]]></component>
   <component name="RecentsManager">
     <key name="MoveFile.RECENT_KEYS">
       <recent name="$PROJECT_DIR$/src/xgae/engine/responser" />
@@ -60,6 +68,7 @@
         <env name="PYTHONUNBUFFERED" value="1" />
       </envs>
       <option name="SDK_HOME" value="" />
+      <option name="SDK_NAME" value="Python 3.13 virtualenv at ~/DevProjects/xga/xgae/.venv" />
       <option name="WORKING_DIRECTORY" value="$PROJECT_DIR$" />
       <option name="IS_MODULE_SDK" value="false" />
       <option name="ADD_CONTENT_ROOTS" value="true" />
@@ -84,7 +93,7 @@
       <option name="INPUT_FILE" value="" />
       <method v="2" />
     </configuration>
-    <configuration name="run_xga_engine" type="PythonConfigurationType" factoryName="Python" temporary="true">
+    <configuration name="run_task_engine" type="PythonConfigurationType" factoryName="Python">
       <module name="xgae" />
       <option name="ENV_FILES" value="" />
       <option name="INTERPRETER_OPTIONS" value="" />
@@ -117,11 +126,6 @@
       <option name="INPUT_FILE" value="" />
       <method v="2" />
     </configuration>
-    <recent_temporary>
-      <list>
-        <item itemvalue="Python.run_xga_engine" />
-      </list>
-    </recent_temporary>
   </component>
   <component name="SharedIndexes">
     <attachedChunks>
@@ -145,46 +149,48 @@
       <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" />
-      <workItem from="1755529583730" duration="1643000" />
-      <workItem from="1755609955702" duration="37000" />
-      <workItem from="1755612319869" duration="621000" />
-      <workItem from="1755690345086" duration="6847000" />
-      <workItem from="1755781193226" duration="485000" />
-      <workItem from="1755781685826" duration="38000" />
-      <workItem from="1755781735460" duration="170000" />
-      <workItem from="1755817545372" duration="285000" />
-      <workItem from="1755862006389" duration="1051000" />
-      <workItem from="1755863094184" duration="553000" />
-      <workItem from="1755863979826" duration="4236000" />
-      <workItem from="1755875255916" duration="2308000" />
-      <workItem from="1755877576514" duration="2000" />
-      <workItem from="1755878805800" duration="3590000" />
-      <workItem from="1755904284653" duration="7803000" />
-      <workItem from="1755912586948" duration="1553000" />
-      <workItem from="1755915353109" duration="5872000" />
-      <workItem from="1755997335603" duration="7550000" />
+      <workItem from="1755409529770" duration="670000" />
+      <workItem from="1755478595168" duration="20000" />
+      <workItem from="1755479257156" duration="16895000" />
+      <workItem from="1755525531052" duration="13030000" />
+      <workItem from="1755585869510" duration="5796000" />
+      <workItem from="1755593112104" duration="786000" />
+      <workItem from="1755611972189" duration="13340000" />
+      <workItem from="1755668525673" duration="14877000" />
+      <workItem from="1755700523844" duration="24000" />
+      <workItem from="1755737435202" duration="48139000" />
+      <workItem from="1756044658912" duration="1248000" />
+      <workItem from="1756082326044" duration="23338000" />
     </task>
     <servers />
   </component>
   <component name="TypeScriptGeneratedFilesManager">
     <option name="version" value="3" />
   </component>
+  <component name="XDebuggerManager">
+    <breakpoint-manager>
+      <default-breakpoints>
+        <breakpoint type="python-exception">
+          <properties notifyOnTerminate="true" exception="BaseException">
+            <option name="notifyOnTerminate" value="true" />
+          </properties>
+        </breakpoint>
+      </default-breakpoints>
+    </breakpoint-manager>
+  </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="1755864064753" 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$setup_env.coverage" NAME="setup_env Coverage Results" MODIFIED="1755876041210" 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$run_xga_engine.coverage" NAME="run_xga_engine Coverage Results" MODIFIED="1756003050644" 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$xga_engine.coverage" NAME="xga_engine Coverage Results" MODIFIED="1755876180376" 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$xga_engine.coverage" NAME="xga_engine Coverage Results" MODIFIED="1755580277172" 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$run_simple.coverage" NAME="run_simple Coverage Results" MODIFIED="1756111714718" 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$run_xga_engine.coverage" NAME="run_task_engine Coverage Results" MODIFIED="1756111613459" 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$message_tools_app.coverage" NAME="message_tools_app Coverage Results" MODIFIED="1756094157566" 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$run_engine_with_human_in_loop.coverage" NAME="run_engine_with_human_in_loop Coverage Results" MODIFIED="1756089269027" 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$xga_prompt_builder.coverage" NAME="xga_prompt_builder Coverage Results" MODIFIED="1755587456555" 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$responser_base.coverage" NAME="responser_base Coverage Results" MODIFIED="1756103040764" 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$" />
+    <SUITE FILE_PATH="coverage/xgae$setup_env.coverage" NAME="setup_env Coverage Results" MODIFIED="1755657717310" 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$run_user_prompt.coverage" NAME="run_user_prompt Coverage Results" MODIFIED="1756089624828" 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$xga_mcp_tool_box.coverage" NAME="xga_mcp_tool_box Coverage Results" MODIFIED="1755583099719" 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$task_engine.coverage" NAME="task_engine Coverage Results" MODIFIED="1756102942600" 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="1756112044142" 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.6 → xgae-0.1.7}/.idea/xgae.iml

@@ -5,7 +5,7 @@
       <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="jdk" jdkName="Python 3.13 virtualenv at ~/DevProjects/xga/xgae/.venv" jdkType="Python SDK" />
     <orderEntry type="sourceFolder" forTests="false" />
   </component>
 </module>

{xgae-0.1.6 → xgae-0.1.7}/PKG-INFO

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

xgae-0.1.7/mcpservers/xga_server.json

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

{xgae-0.1.6 → xgae-0.1.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "xgae"
-version = "0.1.6"
+version = "0.1.7"
 description = "Extreme General Agent Engine"
 readme = "README.md"
 requires-python = ">=3.13"
@@ -21,3 +21,4 @@ build-backend = "hatchling.build"
 exclude = ["log/*"]
 
 [project.scripts]
+xgae-tools = "xgae.tools.without_general_tools_app:main"

xgae-0.1.7/src/examples/run_human_in_loop.py

@@ -0,0 +1,29 @@
+import asyncio
+
+from xgae.engine.mcp_tool_box import XGAMcpToolBox
+from xgae.engine.task_engine import XGATaskEngine
+from xgae.utils.llm_client import LLMConfig
+from xgae.utils.misc import read_file
+
+
+async def main() -> None:
+    tool_box = XGAMcpToolBox(custom_mcp_server_file="mcpservers/custom_servers.json")
+    system_prompt = read_file("templates/example_user_prompt.txt")
+    engine = XGATaskEngine(tool_box=tool_box,
+                           general_tools=[],
+                           custom_tools=["*"],
+                           llm_config=LLMConfig(stream=False),
+                           system_prompt=system_prompt,
+                           max_auto_run=8)
+
+    user_input =  "locate fault and solution"
+    final_result = await engine.run_task_with_final_answer(task_message={"role": "user", "content": user_input})
+    print("FINAL RESULT:", final_result)
+
+    if final_result["type"] == "ask":
+        print("====== Wait for user input ... ======")
+        user_input = "ip=10.0.1.1"
+        final_result = await engine.run_task_with_final_answer(task_message={"role": "user", "content": user_input})
+        print("FINAL RESULT:", final_result)
+
+asyncio.run(main())

xgae-0.1.7/src/examples/run_simple.py

@@ -0,0 +1,12 @@
+import asyncio
+
+from xgae.engine.task_engine import XGATaskEngine
+from xgae.utils.llm_client import LLMConfig
+
+
+async def main() -> None:
+    engine =  XGATaskEngine(llm_config=LLMConfig(stream=False), max_auto_run=1)
+    final_result = await engine.run_task_with_final_answer(task_message={"role": "user", "content": "1+1"})
+    print("FINAL RESULT:", final_result)
+
+asyncio.run(main())

xgae-0.1.7/src/examples/run_user_prompt.py

@@ -0,0 +1,30 @@
+import asyncio
+
+from xgae.engine.mcp_tool_box import XGAMcpToolBox
+from xgae.engine.task_engine import XGATaskEngine
+from xgae.utils.llm_client import LLMConfig
+from xgae.utils.misc import read_file
+
+
+async def main() -> None:
+    tool_box = XGAMcpToolBox(custom_mcp_server_file="mcpservers/custom_servers.json")
+    system_prompt = read_file("templates/example_user_prompt.txt")
+    engine = XGATaskEngine(tool_box=tool_box,
+                           general_tools=[],
+                           custom_tools=["*"],
+                           llm_config=LLMConfig(stream=False),
+                           system_prompt=system_prompt,
+                           max_auto_run=8)
+
+    user_input =  "locate 10.2.3.4 fault and solution"
+    is_final_result = False
+
+    if is_final_result:
+        final_result = await engine.run_task_with_final_answer(task_message={"role": "user", "content": user_input})
+        print("FINAL RESULT:", final_result)
+    else:
+        # Get All Task Process Message
+        async for chunk in engine.run_task(task_message={"role": "user", "content": user_input}):
+            print(chunk)
+
+asyncio.run(main())

{xgae-0.1.6 → xgae-0.1.7}/src/xgae/engine/mcp_tool_box.py

@@ -46,6 +46,12 @@ class XGAMcpToolBox(XGAToolBox):
                     task_tool_schemas[tool_schema.tool_name] = tool_schema
         task_tool_schemas.pop("end_task", None)
 
+        if len(custom_tools) == 1 and custom_tools[0] == "*":
+            custom_tools = []
+            for server_name in self.mcp_server_names:
+                if server_name != XGAMcpToolBox.GENERAL_MCP_SERVER_NAME:
+                    custom_tools.append(f"{server_name}.*")
+
         for server_tool_name in custom_tools:
             parts = server_tool_name.split(".")
             if len(parts) != 2:

{xgae-0.1.6 → xgae-0.1.7}/src/xgae/engine/prompt_builder.py

@@ -3,7 +3,7 @@ import datetime
 
 from typing import Optional, List
 
-from engine_base import XGAToolSchema, XGAError
+from xgae.engine.engine_base import XGAToolSchema, XGAError
 from xgae.utils.misc import read_file, format_file_with_args
 
 

{xgae-0.1.6 → xgae-0.1.7}/src/xgae/engine/responser/non_stream_responser.py

@@ -24,8 +24,8 @@ class NonStreamTaskResponser(TaskResponseProcessor):
                     finish_reason = llm_response.choices[0].finish_reason
                     logging.info(f"NonStreamTask：LLM response finish_reason={finish_reason}")
 
-                    langfuse.create_event(trace_context=self.trace_context, name="non_streaming_finish_reason", level="DEFAULT",
-                                     status_message=(f"Non-streaming finish_reason: {finish_reason}"))
+                    langfuse.create_event(trace_context=self.trace_context, name="non_stream_processor_start", level="DEFAULT",
+                                     status_message=(f"finish_reason={finish_reason}, tool_exec_strategy={self.tool_execution_strategy}"))
 
                 response_message = llm_response.choices[0].message if hasattr(llm_response.choices[0], 'message') else None
                 if response_message:
@@ -54,8 +54,6 @@ class NonStreamTaskResponser(TaskResponseProcessor):
             tool_calls_to_execute = [item['tool_call'] for item in parsed_xml_data]
             if  len(tool_calls_to_execute) > 0:
                 logging.info(f"NonStreamTask：Executing {len(tool_calls_to_execute)} tools with strategy: {self.tool_execution_strategy}")
-                langfuse.create_event(trace_context=self.trace_context, name="executing_tools_with_strategy", level="DEFAULT", status_message=(
-                    f"NonStreamTask Executing {len(tool_calls_to_execute)} tools with strategy: {self.tool_execution_strategy}"))
 
                 tool_results = await self._execute_tools(tool_calls_to_execute, self.tool_execution_strategy)
 

{xgae-0.1.6 → xgae-0.1.7}/src/xgae/engine/responser/responser_base.py

@@ -22,6 +22,7 @@ class TaskResponserContext(TypedDict, total=False):
     task_id: str
     task_run_id: str
     trace_id: str
+    root_span_id: str
     model_name: str
     max_xml_tool_calls: int             # LLM generate max_xml_tool limit, 0 is no limit
     add_response_msg_func: Callable
@@ -34,7 +35,7 @@ class TaskRunContinuousState(TypedDict, total=False):
     accumulated_content: str
     auto_continue_count: int
     auto_continue: bool
-    max_auto_run: int
+
 
 @dataclass
 class ToolExecutionContext:
@@ -61,7 +62,7 @@ class TaskResponseProcessor(ABC):
 
         self.trace_context = {
             "trace_id": self.response_context.get("trace_id"),
-            "parent_span_id": None
+            "parent_span_id": self.response_context.get("root_span_id"),
         }
 
         self.add_response_message = response_context.get("add_response_msg_func")
@@ -257,38 +258,36 @@ class TaskResponseProcessor(ABC):
 
     async def _execute_tool(self, tool_call: Dict[str, Any]) -> XGAToolResult:
         """Execute a single tool call and return the result."""
-        span = langfuse.start_span(trace_context=self.trace_context, name=f"execute_tool.{tool_call['function_name']}", input=tool_call["arguments"])
-        self.trace_context["parent_span_id"] = span.id
-        try:
-            function_name = tool_call["function_name"]
-            arguments = tool_call["arguments"]
-
-            logging.info(f"Executing tool: {function_name} with arguments: {arguments}")
-            langfuse.create_event(trace_context=self.trace_context, name="executing_tool", level="DEFAULT",
-                             status_message=(f"Executing tool: {function_name} with arguments: {arguments}"))
-
-            if isinstance(arguments, str):
-                try:
-                    arguments = safe_json_parse(arguments)
-                except json.JSONDecodeError:
-                    arguments = {"text": arguments} # @todo modify
-
-            result = None
-            available_tool_names = self.tool_box.get_task_tool_names(self.task_id)
-            if function_name in available_tool_names:
-                result = await self.tool_box.call_tool(self.task_id, function_name, arguments)
-            else:
-                logging.error(f"Tool function '{function_name}' not found in registry")
-                result = XGAToolResult(success=False, output=f"Tool function '{function_name}' not found")
-            logging.info(f"Tool execution complete: {function_name} -> {result}")
-            langfuse.update_current_span(status_message="tool_executed", output=result)
-
-            return result
-        except Exception as e:
-            logging.error(f"Error executing tool {tool_call['function_name']}: {str(e)}", exc_info=True)
+        with langfuse.start_as_current_span(trace_context=self.trace_context, name=f"execute_tool.{tool_call['function_name']}", input=tool_call["arguments"]
+                                            ) as exec_tool_span:
+            try:
+                function_name = tool_call["function_name"]
+                arguments = tool_call["arguments"]
+
+                logging.info(f"Executing tool: {function_name} with arguments: {arguments}")
+
+                if isinstance(arguments, str):
+                    try:
+                        arguments = safe_json_parse(arguments)
+                    except json.JSONDecodeError:
+                        arguments = {"text": arguments} # @todo modify
+
+                result = None
+                available_tool_names = self.tool_box.get_task_tool_names(self.task_id)
+                if function_name in available_tool_names:
+                    result = await self.tool_box.call_tool(self.task_id, function_name, arguments)
+                else:
+                    logging.error(f"Tool function '{function_name}' not found in registry")
+                    result = XGAToolResult(success=False, output=f"Tool function '{function_name}' not found")
+                logging.info(f"Tool execution complete: {function_name} -> {result}")
+                exec_tool_span.update(status_message="tool_executed", output=result)
+
+                return result
+            except Exception as e:
+                logging.error(f"Error executing tool {tool_call['function_name']}: {str(e)}", exc_info=True)
 
-            langfuse.update_current_span(status_message="tool_execution_error", output=f"Error executing tool: {str(e)}", level="ERROR")
-            return XGAToolResult(success=False, output=f"Error executing tool: {str(e)}")
+                exec_tool_span.update(status_message="tool_execution_error", output=f"Error executing tool: {str(e)}", level="ERROR")
+                return XGAToolResult(success=False, output=f"Error executing tool: {str(e)}")
 
     async def _execute_tools(
             self,
@@ -296,8 +295,6 @@ class TaskResponseProcessor(ABC):
             execution_strategy: ToolExecutionStrategy = "sequential"
     ) -> List[Tuple[Dict[str, Any], XGAToolResult]]:
         logging.info(f"Executing {len(tool_calls)} tools with strategy: {execution_strategy}")
-        langfuse.create_event(trace_context=self.trace_context, name="executing_tools_with_strategy", level="DEFAULT",
-                         status_message=(f"Executing {len(tool_calls)} tools with strategy: {execution_strategy}"))
 
         if execution_strategy == "sequential":
             return await self._execute_tools_sequentially(tool_calls)
@@ -340,9 +337,8 @@ class TaskResponseProcessor(ABC):
                 # Check if this is a terminating tool (ask or complete)
                 if tool_name in ['ask', 'complete']:
                     logging.info(f"Terminating tool '{tool_name}' executed. Stopping further tool execution.")
-                    langfuse.create_event(trace_context=self.trace_context, name="terminating_tool_executed",
-                                          level="DEFAULT", status_message=(
-                            f"Terminating tool '{tool_name}' executed. Stopping further tool execution."))
+                    # langfuse.create_event(trace_context=self.trace_context, name="terminating_tool_executed",
+                    #                       level="DEFAULT", status_message=(f"Terminating tool '{tool_name}' executed. Stopping further tool execution."))
                     break  # Stop executing remaining tools
 
             except Exception as e:
@@ -353,9 +349,8 @@ class TaskResponseProcessor(ABC):
                 results.append((tool_call, error_result))
 
         logging.info(f"Sequential execution completed for {len(results)} tools (out of {len(tool_calls)} total)")
-        langfuse.create_event(trace_context=self.trace_context, name="sequential_execution_completed", level="DEFAULT",
-                              status_message=(
-                                  f"Sequential execution completed for {len(results)} tools (out of {len(tool_calls)} total)"))
+        # langfuse.create_event(trace_context=self.trace_context, name="sequential_execution_completed", level="DEFAULT",
+        #                       status_message=(f"Sequential execution completed for {len(results)} tools (out of {len(tool_calls)} total)"))
         return results
 
 
@@ -366,8 +361,8 @@ class TaskResponseProcessor(ABC):
         try:
             tool_names = [t.get('function_name', 'unknown') for t in tool_calls]
             logging.info(f"Executing {len(tool_calls)} tools in parallel: {tool_names}")
-            langfuse.create_event(trace_context=self.trace_context, name="executing_tools_in_parallel", level="DEFAULT",
-                             status_message=(f"Executing {len(tool_calls)} tools in parallel: {tool_names}"))
+            # langfuse.create_event(trace_context=self.trace_context, name="executing_tools_in_parallel", level="DEFAULT",
+            #                  status_message=(f"Executing {len(tool_calls)} tools in parallel: {tool_names}"))
 
             # Create tasks for all tool calls
             tasks = [self._execute_tool(tool_call) for tool_call in tool_calls]
@@ -389,8 +384,8 @@ class TaskResponseProcessor(ABC):
                     processed_results.append((tool_call, result))
 
             logging.info(f"Parallel execution completed for {len(tool_calls)} tools")
-            langfuse.create_event(trace_context=self.trace_context, name="parallel_execution_completed", level="DEFAULT",
-                             status_message=(f"Parallel execution completed for {len(tool_calls)} tools"))
+            # langfuse.create_event(trace_context=self.trace_context, name="parallel_execution_completed", level="DEFAULT",
+            #                  status_message=(f"Parallel execution completed for {len(tool_calls)} tools"))
             return processed_results
 
         except Exception as e:
@@ -417,16 +412,11 @@ class TaskResponseProcessor(ABC):
             if assistant_message_id:
                 metadata["assistant_message_id"] = assistant_message_id
                 logging.info(f"Linking tool result to assistant message: {assistant_message_id}")
-                langfuse.create_event(trace_context=self.trace_context, name="linking_tool_result_to_assistant_message", level="DEFAULT",
-                                 status_message=(f"Linking tool result to assistant message: {assistant_message_id}"))
 
             # --- Add parsing details to metadata if available ---
             if parsing_details:
                 metadata["parsing_details"] = parsing_details
                 logging.info("Adding parsing_details to tool result metadata")
-                langfuse.create_event(trace_context=self.trace_context, name="adding_parsing_details_to_tool_result_metadata", level="DEFAULT",
-                                 status_message=(f"Adding parsing_details to tool result metadata"),
-                                 metadata={"parsing_details": parsing_details})
 
             # For XML and other non-native tools, use the new structured format
             # Determine message role based on strategy
@@ -599,8 +589,8 @@ class TaskResponseProcessor(ABC):
         if context.function_name in ['ask', 'complete']:
             metadata["agent_should_terminate"] = "true"
             logging.info(f"Marking tool status for '{context.function_name}' with termination signal.")
-            langfuse.create_event(trace_context=self.trace_context, name="marking_tool_status_for_termination", level="DEFAULT", status_message=(
-                f"Marking tool status for '{context.function_name}' with termination signal."))
+            # langfuse.create_event(trace_context=self.trace_context, name="marking_tool_status_for_termination", level="DEFAULT", status_message=(
+            #     f"Marking tool status for '{context.function_name}' with termination signal."))
         # <<< END ADDED >>>
 
         return  self.add_response_message(

{xgae-0.1.6 → xgae-0.1.7}/src/xgae/engine/task_engine.py

@@ -1,6 +1,7 @@
 
 import logging
 import json
+import os
 
 from typing import List, Any, Dict, Optional, AsyncGenerator, Union, Literal
 from uuid import uuid4
@@ -12,16 +13,19 @@ from xgae.utils import langfuse, handle_error
 from xgae.utils.llm_client import LLMClient, LLMConfig
 
 from xgae.utils.json_helpers import format_for_yield
-from prompt_builder import XGAPromptBuilder
-from mcp_tool_box import XGAMcpToolBox
+from xgae.engine.prompt_builder import XGAPromptBuilder
+from xgae.engine.mcp_tool_box import XGAMcpToolBox
 
 class XGATaskEngine:
     def __init__(self,
                  session_id: Optional[str] = None,
                  task_id: Optional[str] = None,
                  agent_id: Optional[str] = None,
-                 trace_id: Optional[str] = None,
+                 general_tools: Optional[List[str]] = None,
+                 custom_tools: Optional[List[str]] = None,
                  system_prompt: Optional[str] = None,
+                 max_auto_run: Optional[int] = None,
+                 tool_exec_parallel: Optional[bool] = None,
                  llm_config: Optional[LLMConfig] = None,
                  prompt_builder: Optional[XGAPromptBuilder] = None,
                  tool_box: Optional[XGAToolBox] = None):
@@ -34,125 +38,109 @@ class XGATaskEngine:
         self.is_stream = self.llm_client.is_stream
 
         self.prompt_builder = prompt_builder or XGAPromptBuilder(system_prompt)
-        self.tool_box = tool_box or XGAMcpToolBox()
+        self.tool_box: XGAToolBox = tool_box or XGAMcpToolBox()
 
+        self.general_tools:List[str] = general_tools
+        self.custom_tools:List[str] = custom_tools
         self.task_response_msgs: List[XGAResponseMessage] = []
-        self.task_no = -1
-        self.task_run_id = f"{self.task_id}[{self.task_no}]"
-        self.trace_id :str = trace_id or langfuse.create_trace_id()
-
-    async def _post_init_(self, general_tools:List[str], custom_tools: List[str]) -> None:
-        await  self.tool_box.load_mcp_tools_schema()
-        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_tool")
-        custom_tool_schemas = self.tool_box.get_task_tool_schemas(self.task_id, "custom_tool")
 
-        self.task_prompt = self.prompt_builder.build_task_prompt(self.model_name, general_tool_schemas, custom_tool_schemas)
+        max_auto_run = max_auto_run if max_auto_run  else int(os.getenv("MAX_AUTO_RUN", 15))
+        self.max_auto_run: int = 1 if max_auto_run <= 1 else max_auto_run
+        self.tool_exec_parallel = True if tool_exec_parallel is None else tool_exec_parallel
 
-    @classmethod
-    async def create(cls,
-                     session_id: Optional[str] = None,
-                     task_id: Optional[str] = None,
-                     agent_id: Optional[str] = None,
-                     trace_id: Optional[str] = None,
-                     system_prompt: Optional[str] = None,
-                     general_tools: Optional[List[str]] = None,
-                     custom_tools: Optional[List[str]] = None,
-                     llm_config: Optional[LLMConfig] = None,
-                     prompt_builder: Optional[XGAPromptBuilder] = None,
-                     tool_box: Optional[XGAToolBox] = None) -> 'XGATaskEngine':
-        engine: XGATaskEngine = cls(session_id=session_id,
-                                    task_id=task_id,
-                                    agent_id=agent_id,
-                                    trace_id=trace_id,
-                                    system_prompt=system_prompt,
-                                    llm_config=llm_config,
-                                    prompt_builder=prompt_builder,
-                                    tool_box=tool_box)
+        self.task_no = -1
+        self.task_run_id :str = None
 
-        general_tools = general_tools or ["complete", "ask"]
-        if "*" not in general_tools:
-            if "complete" not in general_tools:
-                general_tools.append("complete")
-            elif "ask" not in general_tools:
-                general_tools.append("ask")
+        self.task_prompt :str = None
+        self.trace_id :str = None
+        self.root_span_id :str = None
 
-        custom_tools = custom_tools or []
-        await engine._post_init_(general_tools, custom_tools)
+    async def run_task_with_final_answer(self,
+                                         task_message: Dict[str, Any],
+                                         trace_id: Optional[str] = None) -> XGATaskResult:
+        self.trace_id = trace_id or langfuse.create_trace_id()
+        with langfuse.start_as_current_span(trace_context={"trace_id": self.trace_id},
+                                            name="run_task_with_final_answer",
+                                            input=task_message,
+                                            metadata={"task_id": self.task_id},
+                                            ) as root_span:
+            self.root_span_id = root_span.id
+
+            chunks = []
+            async for chunk in self.run_task(task_message=task_message, trace_id=trace_id):
+                chunks.append(chunk)
+
+            if len(chunks) > 0:
+                final_result = self._parse_final_result(chunks)
+            else:
+                final_result = XGATaskResult(type="error", content="LLM Answer is Empty")
 
-        logging.info("*"*30 + f"   XGATaskEngine Task'{engine.task_id}' Initialized   " + "*"*30)
-        logging.info(f"model_name={engine.model_name}, is_stream={engine.is_stream}, trace_id={engine.trace_id}")
-        logging.info(f"general_tools={general_tools}, custom_tools={custom_tools}")
+            root_span.update(output=final_result)
+            return final_result
 
-        return engine
-
-    async def run_task_with_final_answer(self,
-                       task_message: Dict[str, Any],
-                       max_auto_run: int = 25,
-                       trace_id: Optional[str] = None) -> XGATaskResult:
-        chunks = []
-        async for chunk in self.run_task(task_message=task_message, max_auto_run=max_auto_run, trace_id=trace_id):
-            chunks.append(chunk)
-        if len(chunks) > 0:
-            final_result = self._parse_final_result(chunks)
-        else:
-            final_result = XGATaskResult(type="error", content="LLM Answer is Empty")
-        return final_result
 
     async def run_task(self,
                        task_message: Dict[str, Any],
-                       max_auto_run: int = 25,
                        trace_id: Optional[str] = None) -> AsyncGenerator[Dict[str, Any], None]:
         try:
-            self.trace_id = trace_id or self.trace_id or langfuse.create_trace_id()
+            await self._init_task()
+            if self.root_span_id is None:
+                self.trace_id = trace_id or langfuse.create_trace_id()
+                with langfuse.start_as_current_span(trace_context={"trace_id": self.trace_id},
+                                                    name="run_task",
+                                                    input=task_message
+                                                    ) as root_span:
+                    self.root_span_id = root_span.id
 
-            self.task_no += 1
-            self.task_run_id = f"{self.task_id}[{self.task_no}]"
 
             self.add_response_message(type="user", content=task_message, is_llm_message=True)
 
             continuous_state: TaskRunContinuousState = {
                 "accumulated_content": "",
                 "auto_continue_count": 0,
-                "auto_continue": False if max_auto_run <= 1 else True,
-                "max_auto_run": max_auto_run
+                "auto_continue": False if self.max_auto_run <= 1 else True
             }
             async for chunk in self._run_task_auto(continuous_state):
                 yield chunk
         finally:
             await self.tool_box.destroy_task_tool_box(self.task_id)
+            self.root_span_id = None
 
-    async def _run_task_once(self, continuous_state: TaskRunContinuousState) -> AsyncGenerator[Dict[str, Any], None]:
-        llm_messages = [{"role": "system", "content": self.task_prompt}]
-        cxt_llm_contents = self.get_history_llm_messages()
-        llm_messages.extend(cxt_llm_contents)
 
-        partial_content = continuous_state.get('accumulated_content', '')
-        if partial_content:
-            temp_assistant_message = {
-                "role": "assistant",
-                "content": partial_content
-            }
-            llm_messages.append(temp_assistant_message)
+    async def _init_task(self) -> None:
+        self.task_no = self.task_no + 1
+        self.task_run_id = f"{self.task_id}[{self.task_no}]"
 
-        llm_response = await self.llm_client.create_completion(llm_messages)
-        response_processor = self._create_response_processer()
+        general_tools = self.general_tools or ["complete", "ask"]
+        if "*" not in general_tools:
+            if "complete" not in general_tools:
+                general_tools.append("complete")
+            elif "ask" not in general_tools:
+                general_tools.append("ask")
 
-        async for chunk in response_processor.process_response(llm_response, llm_messages, continuous_state):
-            self._logging_reponse_chunk(chunk)
-            yield chunk
+        custom_tools = self.custom_tools or []
+        if isinstance(self.tool_box, XGAMcpToolBox):
+            await  self.tool_box.load_mcp_tools_schema()
 
-    async def _run_task_auto(self, continuous_state: TaskRunContinuousState) -> AsyncGenerator[Dict[str, Any], None]:
-        max_auto_run = continuous_state['max_auto_run']
-        max_auto_run = max_auto_run if max_auto_run > 0 else 1
+        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_tool")
+        custom_tool_schemas = self.tool_box.get_task_tool_schemas(self.task_id, "custom_tool")
+
+        self.task_prompt = self.prompt_builder.build_task_prompt(self.model_name, general_tool_schemas, custom_tool_schemas)
 
+        logging.info("*" * 30 + f"   XGATaskEngine Task'{self.task_id}' Initialized   " + "*" * 30)
+        logging.info(f"model_name={self.model_name}, is_stream={self.is_stream}, trace_id={self.trace_id}")
+        logging.info(f"general_tools={general_tools}, custom_tools={custom_tools}")
+
+
+    async def _run_task_auto(self, continuous_state: TaskRunContinuousState) -> AsyncGenerator[Dict[str, Any], None]:
         def update_continuous_state(_auto_continue_count,  _auto_continue):
             continuous_state["auto_continue_count"] = _auto_continue_count
             continuous_state["auto_continue"] = _auto_continue
 
         auto_continue_count = 0
         auto_continue = True
-        while auto_continue and auto_continue_count < max_auto_run:
+        while auto_continue and auto_continue_count < self.max_auto_run:
             auto_continue = False
 
             try:
@@ -180,7 +168,7 @@ class XGATaskEngine:
                                     auto_continue = True
                                     auto_continue_count += 1
                                     update_continuous_state(auto_continue_count, auto_continue)
-                                    logging.info(f"run_task_auto: Detected finish_reason='{finish_reason}', auto-continuing ({auto_continue_count}/{max_auto_run})")
+                                    logging.info(f"run_task_auto: Detected finish_reason='{finish_reason}', auto-continuing ({auto_continue_count}/{self.max_auto_run})")
                     except Exception as parse_error:
                         logging.error(f"run_task_auto: Error in parse chunk: {str(parse_error)}")
                         content = {"role": "system", "status_type": "error", "message": "Parse response chunk Error"}
@@ -194,6 +182,28 @@ class XGATaskEngine:
                 error_msg = self.add_response_message(type="status", content=content, is_llm_message=False)
                 yield format_for_yield(error_msg)
 
+
+    async def _run_task_once(self, continuous_state: TaskRunContinuousState) -> AsyncGenerator[Dict[str, Any], None]:
+        llm_messages = [{"role": "system", "content": self.task_prompt}]
+        cxt_llm_contents = self.get_history_llm_messages()
+        llm_messages.extend(cxt_llm_contents)
+
+        partial_content = continuous_state.get('accumulated_content', '')
+        if partial_content:
+            temp_assistant_message = {
+                "role": "assistant",
+                "content": partial_content
+            }
+            llm_messages.append(temp_assistant_message)
+
+        llm_response = await self.llm_client.create_completion(llm_messages, self.trace_id)
+        response_processor = self._create_response_processer()
+
+        async for chunk in response_processor.process_response(llm_response, llm_messages, continuous_state):
+            self._logging_reponse_chunk(chunk)
+            yield chunk
+
+
     def _parse_final_result(self, chunks: List[Dict[str, Any]]) -> XGATaskResult:
         final_result: XGATaskResult = None
         try:
@@ -245,6 +255,7 @@ class XGATaskEngine:
 
         return final_result
 
+
     def add_response_message(self, type: XGAResponseMsgType,
                              content: Union[Dict[str, Any], List[Any], str],
                              is_llm_message: bool,
@@ -289,6 +300,7 @@ class XGATaskEngine:
 
         return response_llm_contents
 
+
     def _create_response_processer(self) -> TaskResponseProcessor:
         response_context = self._create_response_context()
         is_stream = response_context.get("is_stream", False)
@@ -305,11 +317,12 @@ class XGATaskEngine:
             "task_id": self.task_id,
             "task_run_id": self.task_run_id,
             "trace_id": self.trace_id,
+            "root_span_id": self.root_span_id,
             "model_name": self.model_name,
             "max_xml_tool_calls": 0,
             "add_response_msg_func": self.add_response_message,
             "tool_box": self.tool_box,
-            "tool_execution_strategy": "sequential" ,#"parallel",
+            "tool_execution_strategy": "parallel" if self.tool_exec_parallel else "sequential" ,#,
             "xml_adding_strategy": "user_message",
         }
         return response_context
@@ -338,23 +351,17 @@ if __name__ == "__main__":
 
     async def main():
         tool_box = XGAMcpToolBox(custom_mcp_server_file="mcpservers/custom_servers.json")
-        system_prompt = read_file("templates/scp_test_prompt.txt")
-        engine = await XGATaskEngine.create(tool_box=tool_box,
-                                            general_tools=[],
-                                            custom_tools=["bomc_fault.*"],
-                                            llm_config=LLMConfig(stream=False),
-                                            system_prompt=system_prompt)
-
-        final_result = await engine.run_task_with_final_answer(task_message={"role": "user", "content": "定位10.0.1.1故障"},max_auto_run=8)
+        system_prompt = read_file("templates/example_user_prompt.txt")
+        engine =  XGATaskEngine(tool_box=tool_box,
+                                    general_tools=[],
+                                    custom_tools=["*"],
+                                    llm_config=LLMConfig(stream=False),
+                                    system_prompt=system_prompt,
+                                    max_auto_run=8)
+
+        final_result = await engine.run_task_with_final_answer(task_message={"role": "user",
+                                                                             "content": "locate 10.0.0.1 fault and solution"})
         print("FINAL RESULT:", final_result)
 
-        # ====  test streaming response   ========
-        #chunks = []
-        # async for chunk in engine.run_task(task_message={"role": "user", "content": "定位10.0.0.1的故障"}, max_auto_run=8):
-        #     print(chunk)
 
-        # ====  test no tool call   ========
-        # engine = await XGATaskEngine.create(llm_config=LLMConfig(stream=False))
-        # final_result = await engine.run_task_with_final_answer(task_message={"role": "user", "content": "1+1"}, max_auto_run=2)
-        # print("FINAL RESULT:", final_result)
     asyncio.run(main())

xgae-0.1.7/src/xgae/tools/without_general_tools_app.py

@@ -0,0 +1,48 @@
+from typing import Annotated, Optional
+from pydantic import Field
+
+from mcp.server.fastmcp import FastMCP
+
+from xgae.engine.engine_base import  XGAToolResult
+
+mcp = FastMCP(name="XGAE Message Tools")
+
+@mcp.tool(
+    description="""A special tool to indicate you have completed all tasks and are about to enter complete state. Use ONLY when: 1) All tasks in todo.md are marked complete [x], 2) The user's original request has been fully addressed, 3) There are no pending actions or follow-ups required, 4) You've delivered all final outputs and results to the user. IMPORTANT: This is the ONLY way to properly terminate execution. Never use this tool unless ALL tasks are complete and verified. Always ensure you've provided all necessary outputs and references before using this tool. Include relevant attachments when the completion relates to specific files or resources."""
+)
+async def complete(task_id: str,
+                   text: Annotated[Optional[str], Field(default=None,
+                       description="Completion summary. Include: 1) Task summary 2) Key deliverables 3) Next steps 4) Impact achieved")],
+                   attachments: Annotated[Optional[str], Field(default=None,
+                       description="Comma-separated list of final outputs. Use when: 1) Completion relates to files 2) User needs to review outputs 3) Deliverables in files")]
+                   ):
+    print(f"<XGAETools-complete>: task_id={task_id}, text={text}, attachments={attachments}")
+    return XGAToolResult(success=True, output=str({"status": "complete"}))
+
+
+@mcp.tool(
+    description="""Ask user a question and wait for response. Use for: 1) Requesting clarification on ambiguous requirements, 2) Seeking confirmation before proceeding with high-impact changes, 3) Gathering additional information needed to complete a task, 4) Offering options and requesting user preference, 5) Validating assumptions when critical to task success, 6) When encountering unclear or ambiguous results during task execution, 7) When tool results don't match expectations, 8) For natural conversation and follow-up questions, 9) When research reveals multiple entities with the same name, 10) When user requirements are unclear or could be interpreted differently. IMPORTANT: Use this tool when user input is essential to proceed. Always provide clear context and options when applicable. Use natural, conversational language that feels like talking with a helpful friend. Include relevant attachments when the question relates to specific files or resources. CRITICAL: When you discover ambiguity (like multiple people with the same name), immediately stop and ask for clarification rather than making assumptions."""
+)
+async def ask(task_id: str,
+              text: Annotated[str, Field(
+                  description="Question text to present to user. Include: 1) Clear question/request 2) Context why input is needed 3) Available options 4) Impact of choices 5) Relevant constraints")],
+              attachments: Annotated[Optional[str], Field(default=None,
+                  description="Comma-separated list of files/URLs to attach. Use when: 1) Question relates to files/configs 2) User needs to review content 3) Options documented in files 4) Supporting evidence needed")]
+              ):
+    print(f"<XGAETools-ask>: task_id={task_id}, text={text}, attachments={attachments}")
+    return XGAToolResult(success=True, output=str({"status": "Awaiting user response..."}))
+
+@mcp.tool(
+    description="end task, destroy sandbox"
+)
+async def end_task(task_id: str) :
+    print(f"<XGAETools-end_task> task_id: {task_id}")
+
+
+
+def main():
+    #print("="*20 + "   XGAE Message Tools Sever Started in Stdio mode   " + "="*20)
+    mcp.run(transport="stdio")
+
+if __name__ == "__main__":
+    main()

{xgae-0.1.6 → xgae-0.1.7}/src/xgae/utils/llm_client.py

@@ -47,6 +47,7 @@ class LLMClient:
             reasoning_effort: Optional level of reasoning effort, default is  ‘low’
             top_p: Optional Top-p sampling parameter, default is None
         """
+
         llm_config = llm_config or LLMConfig()
         litellm.modify_params = True
         litellm.drop_params = True
@@ -205,9 +206,10 @@ class LLMClient:
             logging.debug(f"LLMClient: Waiting {delay} seconds before retry llm completion...")
             await asyncio.sleep(delay)
 
-
-    async def create_completion(self, messages: List[Dict[str, Any]]) -> Union[ModelResponse, CustomStreamWrapper]:
+    async def create_completion(self, messages: List[Dict[str, Any]], trace_id: Optional[str]=None) -> Union[ModelResponse, CustomStreamWrapper]:
         complete_params = self._prepare_complete_params(messages)
+        if trace_id:
+            complete_params["litellm_trace_id"] = trace_id
 
         last_error = None
         for attempt in range(self.max_retries):
@@ -226,10 +228,13 @@ class LLMClient:
         raise LLMError(f"LLM completion failed after {self.max_retries} attempts !")
 
 if __name__ == "__main__":
+    from xgae.utils import langfuse
+
     async def llm_completion():
         llm_client = LLMClient(LLMConfig(stream=False))
         messages = [{"role": "user", "content": "今天是2025年8月15日，北京本周每天温度"}]
-        response = await llm_client.create_completion(messages)
+        trace_id = langfuse.create_trace_id()
+        response = await llm_client.create_completion(messages, trace_id)
         if llm_client.is_stream:
             async for chunk in response:
                 choices = chunk.get("choices", [{}])

{xgae-0.1.6 → xgae-0.1.7}/src/xgae/utils/setup_env.py

@@ -64,6 +64,7 @@ def setup_langfuse() -> Langfuse:
                             public_key=env_public_key,
                             secret_key=env_secret_key,
                             host=env_host)
+
         logging.info("Langfuse initialized Successfully by Key !")
     else:
         _langfuse = Langfuse(tracing_enabled=False)
@@ -74,5 +75,6 @@ def setup_langfuse() -> Langfuse:
 
 if __name__ == "__main__":
         from xgae.utils import langfuse
+
         trace_id = langfuse.create_trace_id()
         logging.warning(f"trace_id={trace_id}")

xgae-0.1.7/templates/example_user_prompt.txt

@@ -0,0 +1,22 @@
+#1. Objective: Strictly follow the task steps in TODO.MD to process user instructions. Do not execute any steps not listed. Terminate the process immediately if any task fails without retrying.
+#2. Call MCP tools directly , do not retry if the MCP tool call fails.
+#3. After completing all task steps, output the result and terminate the task by calling the 'complete' tool.
+#4. Extract tool call parameters exclusively from user input and tool outputs. If parameters cannot be extracted, directly call the 'ask' tool to request user input. Never generate parameters outside of user input and tool output. 
+#5. TODO.MD
+     Process Title: Alarm and Fault Query Process
+     Process Summary: Achieve precise fault location through resource alarm detection and classification
+    Task[1]: Fault Object Processing
+    Step[1]: Query alarm records of target resource
+    Step[2]: Check for uncleared alarms
+    Step[3]: If no alarms exist, terminate process and return normal status
+    Step[4]: If alarms exist, proceed to alarm type analysis
+    Step[5]: Determine if alarm type is business layer (type=1)
+    Step[6]: If yes, trigger business fault location module
+    Step[7]: Else determine if alarm type is device layer (type=2)
+    Step[8]: If yes, trigger device fault location module
+    Step[9]: Else determine if alarm type is middleware (type=3)
+    Step[10]: If yes, trigger middleware fault location module
+    Task[2]: Solution Retrieval
+    Step[1]: For business alarms, call getBusiFaultCause to query business fault solutions
+    Step[2]: For device alarms, call getHostFaultCause to query device fault solutions
+    Step[3]: For middleware alarms, call web_search to query middleware fault solutions

{xgae-0.1.6 → xgae-0.1.7}/uv.lock

@@ -1366,7 +1366,7 @@ wheels = [
 
 [[package]]
 name = "xgae"
-version = "0.1.1"
+version = "0.1.5"
 source = { editable = "." }
 dependencies = [
     { name = "colorlog" },

xgae-0.1.6/templates/scp_test_prompt.txt

@@ -1,21 +0,0 @@
-#1. 目标：严格按照TODO.MD中的任务步骤处理用户指令，不要执行没有的任务步骤，任务异常直接结束，不重复执行任务步骤
-#2. 调用MCP工具，不要通过"call_mcp_tool", 直接调用，MCP工具调用不成功不重试。
-#3. 任务步骤执行完毕，输出结果，就直接调用complete工具终止任务。
-#5. TODO.MD
-     流程标题：告警与故障查询流程
-    流程概要：通过资源告警检测及分类实现故障精准定位
-    Task[1]: 用户输入故障对象处理
-    Step[1]: 查询目标资源的告警记录
-    Step[2]: 判断是否存在未清除的告警
-    Step[3]: 无告警则终止流程并反馈正常状态
-    Step[4]: 存在告警则进入告警类型分析
-    Step[5]: 判断告警类型为业务层告警（类型=1）
-    Step[6]: 是则触发业务故障定位模块
-    Step[7]: 否则判断告警类型为设备层告警（类型=2）
-    Step[8]: 是则触发设备故障定位模块
-    Step[9]: 否则判断告警类型为中间件告警（类型=3）
-    Step[10]: 是则触发中间件故障定位模块
-    Task[2]: 解决方案获取
-    Step[1]: 若业务告警调用getBusiFaultCause查询业务故障解决方案
-    Step[2]: 若设备告警调用getHostFaultCause查询设备故障解决方案
-    Step[3]: 若中间件告警调用web_search查询中间件故障解决方案