xgae 0.1.10__tar.gz → 0.1.12__tar.gz

{xgae-0.1.10 → xgae-0.1.12}/.env

@@ -1,5 +1,5 @@
 # LOG
-LOG_LEVEL=INFO
+LOG_LEVEL=DEBUG
 LOG_FILE=log/xgae.log
 LOG_ENABLE=True
 
@@ -15,10 +15,15 @@ LLM_API_KEY=
 LLM_MAX_TOKENS=16384
 LLM_TEMPERATURE=0.7
 LLM_MAX_RETRIES=2
+LLM_STREAM=True
+LLM_ENABLE_THINKING=False
+
 LLM_LANGFUSE_ENABLE=False
 
-# TASK
-MAX_AUTO_RUN = 15
+
+# TASK_ENGINE
+MAX_AUTO_RUN=15
+USE_ASSISTANT_CHUNK_MSG=False
 
 
 

{xgae-0.1.10 → xgae-0.1.12}/.idea/workspace.xml

@@ -29,9 +29,11 @@
   "keyToString": {
     "ModuleVcsDetector.initialDetectionPerformed": "true",
     "Python.__init__.executor": "Run",
-    "Python.llm_client.executor": "Run",
+    "Python.cli_app.executor": "Run",
+    "Python.llm_client.executor": "Debug",
     "Python.mcp_tool_box.executor": "Run",
     "Python.message_tools_app.executor": "Run",
+    "Python.react_agent.executor": "Run",
     "Python.responser_base.executor": "Run",
     "Python.run_engine_with_human_in_loop.executor": "Run",
     "Python.run_human_in_loop.executor": "Run",
@@ -62,6 +64,7 @@
 }]]></component>
   <component name="RecentsManager">
     <key name="MoveFile.RECENT_KEYS">
+      <recent name="$PROJECT_DIR$/src/examples/agent/langgraph/react" />
       <recent name="$PROJECT_DIR$/src/examples" />
       <recent name="$PROJECT_DIR$/src/examples/engine" />
       <recent name="$PROJECT_DIR$/src/xgae/engine/responser" />
@@ -172,7 +175,11 @@
       <workItem from="1756082326044" duration="23657000" />
       <workItem from="1756168626188" duration="52435000" />
       <workItem from="1756305726553" duration="2819000" />
-      <workItem from="1756340066915" duration="14276000" />
+      <workItem from="1756340066915" duration="19032000" />
+      <workItem from="1756371469253" duration="1657000" />
+      <workItem from="1756383619553" duration="2663000" />
+      <workItem from="1756386338550" duration="12000" />
+      <workItem from="1756429146558" duration="24412000" />
     </task>
     <servers />
   </component>
@@ -191,26 +198,28 @@
     </breakpoint-manager>
   </component>
   <component name="com.intellij.coverage.CoverageDataManagerImpl">
-    <SUITE FILE_PATH="coverage/xgae$test_litellm_langfuse.coverage" NAME="test_litellm_langfuse Coverage Results" MODIFIED="1756196476262" 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_langfuse.coverage" NAME="task_langfuse Coverage Results" MODIFIED="1756306181167" 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$test_litellm_langfuse.coverage" NAME="test_litellm_langfuse Coverage Results" MODIFIED="1756196476262" 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="1756359842556" 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="1756452256460" 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_human_in_loop.coverage" NAME="run_human_in_loop Coverage Results" MODIFIED="1756279131815" 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$cli_app.coverage" NAME="cli_app Coverage Results" MODIFIED="1756372555094" 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$__init__.coverage" NAME="__init__ Coverage Results" MODIFIED="1756345820610" 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$react_agent.coverage" NAME="react_agent Coverage Results" MODIFIED="1756372008835" 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$test_langfuse.coverage" NAME="test_langfuse Coverage Results" MODIFIED="1756196410142" 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_task_engine.coverage" NAME="run_task_engine Coverage Results" MODIFIED="1756341371676" 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_task_engine.coverage" NAME="run_task_engine Coverage Results" MODIFIED="1756459820516" 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$mcp_tool_box.coverage" NAME="mcp_tool_box Coverage Results" MODIFIED="1756274403389" 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="1756273791782" 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="1756279512361" 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="1756453021298" 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$xgae_cli.coverage" NAME="xgae_cli Coverage Results" MODIFIED="1756347000850" 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="1756308226461" 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="1756308364265" 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="1756429245697" 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="1756454873435" 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.10 → xgae-0.1.12}/PKG-INFO

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

{xgae-0.1.10 → xgae-0.1.12}/pyproject.toml

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

{xgae-0.1.10 → xgae-0.1.12}/src/examples/agent/langgraph/react/react_agent.py

@@ -12,26 +12,28 @@ from xgae.engine.mcp_tool_box import XGAMcpToolBox
 from xgae.utils.setup_env import setup_langfuse, setup_logging
 from xgae.utils import handle_error
 from xgae.utils.misc import read_file
+from xgae.engine.task_engine import XGATaskEngine
 
 class TaskState(TypedDict, total=False):
     """State definition for the agent orchestration graph"""
     messages: Annotated[Sequence[BaseMessage], add_messages]
     user_input: str
     next_node: str
-    context: Dict[str, Any]
+    agent_context: Dict[str, Any]
     system_prompt: str
     custom_tools: List[str]
     general_tools: List[str]
     task_result: XGATaskResult
-    formatted_result: XGATaskResult
     iteration_count: int
 
 langfuse = setup_langfuse()
 
 class XGAReactAgent:
     MAX_TASK_RETRY = 2
+
     def __init__(self):
-        self.tool_box = XGAMcpToolBox()
+        self.tool_box = XGAMcpToolBox(custom_mcp_server_file="mcpservers/custom_servers.json")
+        self.graph = None
 
     async def _create_graph(self) -> StateGraph:
         try:
@@ -41,8 +43,7 @@ class XGAReactAgent:
             graph_builder.add_node("supervisor", self._supervisor_node)
             graph_builder.add_node("select_tool", self._select_tool_node)
             graph_builder.add_node("exec_task", self._exec_task_node)
-            graph_builder.add_node("eval_result", self._eval_result_node)
-            graph_builder.add_node("format_result", self._format_result_node)
+            graph_builder.add_node("final_result", self._final_result_node)
 
             # Add edges
             graph_builder.add_edge(START, "supervisor")
@@ -52,69 +53,98 @@ class XGAReactAgent:
                 {
                     "select_tool": "select_tool",
                     "exec_task": "exec_task",
-                    "format_result": "format_result"
+                    "end": END
                 }
             )
 
             graph_builder.add_edge("select_tool", "exec_task")
-            graph_builder.add_edge("exec_task", "eval_result")
+            graph_builder.add_edge("exec_task", "final_result")
 
             graph_builder.add_conditional_edges(
-                "eval_result",
+                "final_result",
                 self._next_condition,
                 {
-                    "retry": "supervisor",
-                    "format_result": "format_result",
+                    "supervisor": "supervisor",
+                    "end": END
                 }
             )
             
-            graph_builder.add_edge("format_result", END)
-            
             graph = graph_builder.compile(checkpointer=MemorySaver())
-            graph.name = "XGARectAgent"
+            graph.name = "XGARectAgentGraph"
 
             return graph
         except Exception as e:
-            logging.error("Failed to create XGARectAgent graph: %s", str(e))
+            logging.error("Failed to create XGARectAgent Graph: %s", str(e))
             raise
 
+    def _search_system_prompt(self, user_input: str) -> str:
+        # You should search RAG use user_input, fetch COT or Prompt for your business
+        system_prompt = None if "fault" not in user_input else read_file("templates/example/fault_user_prompt.txt")
+        return system_prompt
 
     async def _supervisor_node(self, state: TaskState) -> Dict[str, Any]:
         user_input = state.get("user_input", "")
-        system_prompt = None if "fault" in user_input else read_file("templates/example/fault_user_prompt.txt")
+        system_prompt = self._search_system_prompt(user_input)
+
+        general_tools = [] if system_prompt else ["*"]
+        custom_tools = ["*"] if system_prompt  else []
+
+        next_node = "select_tool" if system_prompt else "exec_task"
         return {
             "system_prompt" : system_prompt,
-            "next_node" : "select_tool",
+            "next_node" : next_node,
+            "general_tools": general_tools,
+            "custom_tools": custom_tools,
         }
 
+    def _select_custom_tools(self, system_prompt: str) -> list[str]:
+        custom_tools = ["*"] if system_prompt  else []
+        return custom_tools
+
     async def _select_tool_node(self, state: TaskState) -> Dict[str, Any]:
         system_prompt = state.get("system_prompt",None)
-        general_tools = ["*"] if system_prompt else []
-        custom_tools = ["*"] if not system_prompt  else []
+        general_tools = []
+        custom_tools = self._select_custom_tools(system_prompt)
         return {
             "general_tools" : general_tools,
             "custom_tools" : custom_tools,
         }
 
     async def _exec_task_node(self, state: TaskState) -> Dict[str, Any]:
-        task_result = XGATaskResult(type="answer", content="test task result")
+        user_input = state.get("user_input", "")
+        system_prompt = state.get("system_prompt",None)
+        general_tools = state.get("general_tools",[])
+        custom_tools = state.get("custom_tools",[])
+        is_system_prompt = True if system_prompt is not None else False
+        try:
+            logging.info(f"🔥 XGATaskEngine: run_task_with_final_answer: user_input={user_input}, general_tools={general_tools}, custom_tools={custom_tools}, is_system_prompt={is_system_prompt}")
+            engine = XGATaskEngine(tool_box=self.tool_box,
+                                   general_tools=general_tools,
+                                   custom_tools=custom_tools,
+                                   system_prompt=system_prompt)
+            task_result = await engine.run_task_with_final_answer(
+                task_message={"role": "user", "content": user_input}
+            )
+        except Exception as e:
+            logging.error("Failed to execute task: %s", str(e))
+            task_result = XGATaskResult(type="error", content="Failed to execute task")
+
+        iteration_count = state.get("iteration_count", 0) + 1
         return {
-            "task_result" : task_result
+            "task_result" : task_result,
+            "iteration_count": iteration_count,
         }
 
-    async def _eval_result_node(self, state: TaskState) -> Dict[str, Any]:
+    async def _final_result_node(self, state: TaskState) -> Dict[str, Any]:
+        iteration_count = state.get("iteration_count")
+        task_result = state.get("task_result")
         next_node = "end"
+        if iteration_count < self.MAX_TASK_RETRY and task_result["type"] == "error":
+            next_node = "supervisor"
         return {
             "next_node" : next_node
         }
 
-    async def _format_result_node(self, state: TaskState) -> Dict[str, Any]:
-        formatted_result = state.get("task_result")
-        return {
-            "formatted_result" : formatted_result,
-            "messages": state["messages"] + [AIMessage(content=f"")]
-        }
-    
     def _next_condition(self, state: TaskState) -> str:
         next_node = state.get("next_node")
         return next_node
@@ -134,13 +164,8 @@ class XGAReactAgent:
                 "messages": [HumanMessage(content=f"information for: {user_input}")],
                 "user_input": user_input,
                 "next_node": None,
-                "tasks": [],
-                "context": "",
-                "current_task": None,
-                "next_task": None,
-                "formatted_result": "",
-                "final_error_info": "",
-                "iteration_count": 1
+                "agent_context": {},
+                "iteration_count": 0
             }
 
             # Run the retrieval graph with proper configuration
@@ -149,7 +174,7 @@ class XGAReactAgent:
             final_state = await self.graph.ainvoke(initial_state, config=config)
 
             # Parse and return formatted results
-            result = final_state["formatted_result"]
+            result = final_state["task_result"]
 
             logging.info("=" * 100)
             logging.info("User question: %s", user_input)
@@ -167,11 +192,15 @@ class XGAReactAgent:
 if __name__ == "__main__":
     setup_logging()
 
-    agent = XGAReactAgent()
-    user_inputs = [
-                    "Create a function to sort a list of numbers, sort [6,8,7,5]"
-                    , "sort [3,2,7,5]"
-                ]
-    for user_input in user_inputs:
-        result = agent.generate(user_input)
-        print(result)
+    async def main():
+        agent = XGAReactAgent()
+        user_inputs = [
+                        #"locate 10.2.3.4 fault and solution",
+                        "5+5",
+                    ]
+        for user_input in user_inputs:
+            result = await agent.generate(user_input)
+            await asyncio.sleep(1)
+            print(result)
+
+    asyncio.run(main())

{xgae-0.1.10 → xgae-0.1.12}/src/examples/engine/run_human_in_loop.py

@@ -2,7 +2,7 @@ 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
 
 from xgae.utils.setup_env import setup_langfuse, setup_logging
@@ -18,9 +18,7 @@ async def main() -> None:
     engine = XGATaskEngine(tool_box=tool_box,
                            general_tools=[],
                            custom_tools=["*"],
-                           llm_config=LLMConfig(stream=False),
-                           system_prompt=system_prompt,
-                           max_auto_run=8)
+                           system_prompt=system_prompt)
 
     # Two task run in same langfuse trace
     trace_id = langfuse.trace(name="xgae_example_run_human_in_loop").trace_id

{xgae-0.1.10 → xgae-0.1.12}/src/examples/engine/run_simple.py

@@ -1,14 +1,13 @@
 import asyncio
 
 from xgae.engine.task_engine import XGATaskEngine
-from xgae.utils.llm_client import LLMConfig
 
 from xgae.utils.setup_env import setup_logging
 
 setup_logging()
 
 async def main() -> None:
-    engine =  XGATaskEngine(llm_config=LLMConfig(stream=False), max_auto_run=3)
+    engine =  XGATaskEngine()
 
     final_result = await engine.run_task_with_final_answer(
         task_message={"role": "user", "content": "1+7"}

{xgae-0.1.10 → xgae-0.1.12}/src/examples/engine/run_user_prompt.py

@@ -2,12 +2,11 @@ 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
 
 from xgae.utils.setup_env import setup_logging
 
-setup_logging()
+setup_logging(log_level="ERROR")
 
 async def main() -> None:
     # Before Run Exec: uv run custom_fault_tools
@@ -17,19 +16,15 @@ async def main() -> None:
     engine = XGATaskEngine(tool_box=tool_box,
                            general_tools=[],
                            custom_tools=["*"],
-                           llm_config=LLMConfig(stream=False),
-                           system_prompt=system_prompt,
-                           max_auto_run=8)
+                           system_prompt=system_prompt)
 
     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)
+    chunks = []
+    async for chunk in engine.run_task(task_message={"role": "user", "content": user_input}):
+        chunks.append(chunk)
+        print(chunk)
+
+    final_result = engine.parse_final_result(chunks)
+    print(f"\n\nFINAL_RESULT: {final_result}")
 
 asyncio.run(main())

{xgae-0.1.10 → xgae-0.1.12}/src/xgae/cli_app.py

@@ -3,7 +3,7 @@ import sys
 
 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
 
 from xgae.utils.setup_env import setup_langfuse, setup_env_logging
@@ -50,9 +50,7 @@ async def cli() -> None:
         engine = XGATaskEngine(tool_box=tool_box,
                                general_tools=general_tools,
                                custom_tools=custom_tools,
-                               llm_config=LLMConfig(stream=False),
-                               system_prompt=system_prompt,
-                               max_auto_run=8)
+                               system_prompt=system_prompt)
 
         # Two task run in same langfuse trace
         trace_id = langfuse.trace(name="xgae_cli").trace_id

{xgae-0.1.10 → xgae-0.1.12}/src/xgae/engine/engine_base.py

@@ -6,14 +6,14 @@ class XGAError(Exception):
     """Custom exception for errors in the XGA system."""
     pass
 
-XGAMsgStatusType = Literal["error", "finish", "tool_error", "tool_started", "tool_completed", "tool_failed", "thread_run_start", "thread_run_end", "assistant_response_start", "assistant_response_end"]
-XGAResponseMsgType = Literal["user", "status",  "tool", "assistant", "assistant_complete"]
+XGAMsgStatusType = Literal["error", "finish", "tool_started", "tool_completed", "tool_error", "tool_failed"]
+XGAResponseMsgType = Literal["user", "status",  "tool", "assistant", "assistant_chunk"]
 
 class XGAResponseMessage(TypedDict, total=False):
     message_id: str
     type: XGAResponseMsgType
     is_llm_message: bool
-    content: Union[Dict[str, Any], List[Any], str]
+    content: Union[Dict[str, Any], str]
     metadata: Dict[str, Any]
 
 class XGATaskResult(TypedDict, total=False):

{xgae-0.1.10 → xgae-0.1.12}/src/xgae/engine/mcp_tool_box.py

@@ -124,11 +124,11 @@ class XGAMcpToolBox(XGAToolBox):
                     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}")
+                    logging.error(f"McpToolBox 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}")
+                logging.info(f"McpToolBox call_tool: error={error}")
                 result =  XGAToolResult(success=False, output=error)
 
             return result
@@ -179,11 +179,11 @@ class XGAMcpToolBox(XGAToolBox):
 
                     return server_config
             else:
-                logging.warning("MCP servers config file not found at: %s", mcp_config_path)
+                logging.warning(f"McpToolBox load_mcp_servers_config: MCP servers config file not found at: {mcp_config_path}")
                 return {"mcpServers": {}}
 
         except Exception as e:
-            logging.error("Failed to load MCP servers config: %s", str(e))
+            logging.error(f"McpToolBox load_mcp_servers_config: Failed to load MCP servers config: {e}")
             return {"mcpServers": {}}
 
 

{xgae-0.1.10 → xgae-0.1.12}/src/xgae/engine/responser/non_stream_responser.py

@@ -1,6 +1,8 @@
 import logging
 
 from typing import List, Dict, Any, AsyncGenerator, override,Optional
+
+from xgae.utils import handle_error
 from xgae.utils.json_helpers import format_for_yield
 
 from xgae.engine.responser.responser_base import TaskResponseProcessor, TaskResponserContext, TaskRunContinuousState
@@ -11,22 +13,20 @@ class NonStreamTaskResponser(TaskResponseProcessor):
         super().__init__(response_context)
 
     @override
-    async def process_response(self,llm_response: Any,prompt_messages: List[Dict[str, Any]],
-                               continuous_state: Optional[TaskRunContinuousState] = None) -> AsyncGenerator[Dict[str, Any], None]:
+    async def process_response(self,
+                               llm_response: Any,prompt_messages: List[Dict[str, Any]],
+                               continuous_state: TaskRunContinuousState
+                               ) -> AsyncGenerator[Dict[str, Any], None]:
         llm_content = ""
         parsed_xml_data = []
         finish_reason = None
         llm_count = continuous_state.get("auto_continue_count")
 
         try:
-            # Extract finish_reason, content, tool calls
             if hasattr(llm_response, 'choices') and llm_response.choices:
                 if hasattr(llm_response.choices[0], 'finish_reason'):
                     finish_reason = llm_response.choices[0].finish_reason
-                    logging.info(f"NonStreamTask：LLM response finish_reason={finish_reason}")
-
-                    self.root_span.event(name=f"non_stream_processor_start[{self.task_no}]({llm_count})", level="DEFAULT",
-                                     status_message=(f"finish_reason={finish_reason}, tool_exec_strategy={self.tool_execution_strategy}"))
+                    logging.info(f"NonStreamResp: LLM response finish_reason={finish_reason}")
 
                 response_message = llm_response.choices[0].message if hasattr(llm_response.choices[0], 'message') else None
                 if response_message:
@@ -35,27 +35,23 @@ class NonStreamTaskResponser(TaskResponseProcessor):
                         
                         parsed_xml_data = self._parse_xml_tool_calls(llm_content)
                         if self.max_xml_tool_calls > 0 and len(parsed_xml_data) > self.max_xml_tool_calls:
-                            logging.warning(f"NonStreamTask：Truncate content, parsed_xml_data length {len(parsed_xml_data)} limit over max_xml_tool_calls={self.max_xml_tool_calls}")
-                            xml_chunks = self._extract_xml_chunks(llm_content)[:self.max_xml_tool_calls]
-                            if xml_chunks:
-                                last_chunk = xml_chunks[-1]
-                                last_chunk_pos = llm_content.find(last_chunk)
-                                if last_chunk_pos >= 0:
-                                    llm_content = llm_content[:last_chunk_pos + len(last_chunk)]
+                            logging.warning(f"NonStreamResp: Truncate content, parsed_xml_data length={len(parsed_xml_data)} limit over max_xml_tool_calls={self.max_xml_tool_calls}")
                             parsed_xml_data = parsed_xml_data[:self.max_xml_tool_calls]
                             finish_reason = "xml_tool_limit_reached"
-                            logging.info(f"NonStreamTask：LLM response finish_reason={finish_reason}")
-                else:
-                    logging.warning(f"NonStreamTask：LLM response_message is empty")
 
-            message_data = {"role": "assistant", "content": llm_content} # index=-1, full llm_content
-            assistant_msg = self.add_response_message(type="assistant_complete", content=message_data, is_llm_message=True)
+            self.root_span.event(name=f"non_stream_processor_start[{self.task_no}]({llm_count})", level="DEFAULT",
+                             status_message=f"finish_reason={finish_reason}, tool_exec_strategy={self.tool_execution_strategy}, "
+                                            f"parsed_xml_data_len={len(parsed_xml_data)}, llm_content_len={len(llm_content)}")
+
+            if  len(llm_content) == 0:
+                logging.warning(f"NonStreamResp: LLM response_message llm_content is empty")
+
+            message_data = {"role": "assistant", "content": llm_content}
+            assistant_msg = self.add_response_message(type="assistant", content=message_data, is_llm_message=True)
             yield assistant_msg
 
             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}")
-
                 tool_results = await self._execute_tools(tool_calls_to_execute, self.tool_execution_strategy)
 
                 tool_index = 0
@@ -81,31 +77,27 @@ class NonStreamTaskResponser(TaskResponseProcessor):
                     if tool_completed_msg["metadata"].get("agent_should_terminate") == "true":
                         finish_reason = "completed"
                         break
+
                     tool_index += 1
             else:
                 finish_reason = "non_tool_call"
-                logging.warning(f"NonStreamTask: tool_calls is empty, No Tool need to call !")
+                logging.warning(f"NonStreamResp:  tool_calls is empty, No Tool need to call !")
 
             if finish_reason:
                 finish_content = {"status_type": "finish", "finish_reason": finish_reason}
-                finish_msg_obj = self.add_response_message(type="status", content=finish_content, is_llm_message=False)
-                if finish_msg_obj:
-                    yield format_for_yield(finish_msg_obj)
-
+                finish_msg = self.add_response_message(type="status", content=finish_content, is_llm_message=False)
+                yield format_for_yield(finish_msg)
         except Exception as e:
-            logging.error(f"NonStreamTask: Error processing non-streaming response: {llm_content}")
-            self.root_span.event(name="error_processing_non_streaming_response", level="ERROR",
-                             status_message=(f"Error processing non-streaming response: {str(e)}"))
-
-            content = {"role": "system", "status_type": "error", "message": str(e)}
-            err_msg = self.add_response_message(ype="status", content=content,is_llm_message=False)
-            if err_msg:
-                yield format_for_yield(err_msg)
-
-            # Re-raise the same exception (not a new one) to ensure proper error propagation
-            logging.critical(f"NonStreamTask: Re-raising error to stop further processing: {str(e)}")
-            self.root_span.event(name="re_raising_error_to_stop_further_processing", level="CRITICAL",
-                             status_message=(f"Re-raising error to stop further processing: {str(e)}"))
+            logging.error(f"NonStreamResp: Process response llm_content: {llm_content}")
+            handle_error(e)
+            self.root_span.event(name="non_stream_process_response_error", level="ERROR",
+                                 status_message=f"Process non-streaming response error: {e}",
+                                 metadata={"content": llm_content})
+
+            content = {"role": "system", "status_type": "error", "message": f"Process non-streaming response error: {e}"}
+            error_msg = self.add_response_message(type="status", content=content, is_llm_message=False)
+            yield format_for_yield(error_msg)
+
             raise  # Use bare 'raise' to preserve the original exception with its traceback