xgae 0.1.18__tar.gz → 0.1.20__tar.gz

xgae-0.1.18/release.md → xgae-0.1.20/CHANGELOG.md

@@ -1,3 +1,14 @@
+# Release Changelog
+## [0.1.20] - 2025-9-8
+### Added
+- Example: Langgraph react agent add final_result_agent 
+
+
+## [0.1.19] - 2025-9-8
+### Added
+- Example: Langgraph react agent release V1, full logic but no final result agent and tool select agent
+
+
 # Release Changelog
 ## [0.1.18] - 2025-9-3
 ### Added

{xgae-0.1.18 → xgae-0.1.20}/PKG-INFO

@@ -1,10 +1,11 @@
 Metadata-Version: 2.4
 Name: xgae
-Version: 0.1.18
+Version: 0.1.20
 Summary: Extreme General Agent Engine
 Requires-Python: >=3.13
 Requires-Dist: colorlog==6.9.0
 Requires-Dist: langchain-mcp-adapters==0.1.9
+Requires-Dist: langchain==0.3.27
 Requires-Dist: langfuse==2.60.9
 Requires-Dist: langgraph==0.6.5
 Requires-Dist: litellm==1.74.15

{xgae-0.1.18 → xgae-0.1.20}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "xgae"
-version = "0.1.18"
+version = "0.1.20"
 description = "Extreme General Agent Engine"
 readme = "README.md"
 requires-python = ">=3.13"
@@ -11,6 +11,7 @@ dependencies = [
     "litellm==1.74.15",
     "mcp==1.13.0",
     "langfuse==2.60.9",
+    "langchain==0.3.27",
 ]
 
 [build-system]
@@ -21,7 +22,7 @@ build-backend = "hatchling.build"
 exclude = ["log/*", ".idea/*"]
 
 [project.scripts]
-xgae = "xgae.cli_app:main"
+xgae = "xgae.engine_cli_app:main"
 xgae-tools = "xgae.tools.without_general_tools_app:main"
 example-fault-tools = "examples.tools.custom_fault_tools_app:main"
 example-a2a-tools = "examples.tools.simu_a2a_tools_app:main"

xgae-0.1.20/src/examples/agent/langgraph/react/agent_base.py

@@ -0,0 +1,31 @@
+from typing import Any, Dict, List, TypedDict, Optional
+from xgae.engine.engine_base import XGATaskResult
+
+class EvaluateResult(TypedDict, total=False):
+    task_result: Dict[str, Any]
+    task_process: Dict[str, Any]
+    function_call: Dict[str, Any]
+
+class AgentContext(TypedDict, total=False):
+    task_id: str
+    session_id: str
+    user_id: str
+    agent_id: str
+    thread_id: str
+
+
+class TaskState(TypedDict, total=False):
+    """State definition for the agent orchestration graph"""
+    llm_messages: List[Dict[str, Any]]
+    user_input: str
+    next_node: str
+    system_prompt: str
+    custom_tools: List[str]
+    general_tools: List[str]
+    task_result: XGATaskResult
+    final_result: XGATaskResult
+    eval_result: EvaluateResult
+    iteration_count: int
+    agent_context: AgentContext
+
+

xgae-0.1.20/src/examples/agent/langgraph/react/final_result_agent.py

@@ -0,0 +1,119 @@
+import json
+import logging
+import re
+
+from typing import Any, Dict, List, Optional
+
+from xgae.engine.engine_base import XGATaskResult
+from xgae.utils.misc import read_file
+from xgae.utils.llm_client import LLMClient, LangfuseMetadata
+
+
+class FinalResultAgent:
+    def __init__(self):
+        self.model_client = LLMClient()
+        self.prompt_template: str = read_file("templates/example/final_result_template.txt")
+
+
+    async def eval_result(self,
+                          task_input: str,
+                          task_result: XGATaskResult,
+                          llm_messages: List[Dict[str, Any]],
+                          trace_id: Optional[str] = None,
+                          session_id: Optional[str] = None)-> Dict[str, Any]:
+        prompt = self._build_prompt(task_input, task_result, llm_messages)
+        messages = [{"role": "user", "content": prompt}]
+
+        langfuse_metadata = self._create_llm_langfuse_meta(trace_id, session_id)
+
+        response = await self.model_client.acompletion(messages, langfuse_metadata)
+        response_text = await self.model_client.get_response_result(response)
+
+        cleaned_text = re.sub(r'^\s*```json|```\s*$', '', response_text, flags=re.MULTILINE).strip()
+        eval_result = json.loads(cleaned_text)
+
+        result_score = eval_result.get('task_result', {}).get('score', -1)
+        process_score = eval_result.get('task_process', {}).get('score', -1)
+        function_score = eval_result.get('function_call', {}).get('score', -1)
+
+        logging.info(f"FINAL_RESULT_SCORE: task_result_score={result_score}, "
+                     f"task_process_score={process_score}, function_call_score={function_score}")
+        return eval_result
+
+
+    def _build_prompt(self, task_input: str, task_result: XGATaskResult, llm_messages: List[Dict[str, Any]])-> str:
+        prompt = self.prompt_template.replace("{task_input}", task_input)
+        prompt = prompt.replace("{task_result}", str(task_result))
+        llm_process = ""
+        function_process = ""
+        llm_step = 1
+        function_step = 1
+        for llm_message in llm_messages:
+            content = llm_message.get('content', '')
+            if "tool_execution" in content:
+                function_process += f"{function_step}. \n"
+                tool_exec = json.loads(content)
+                func_call = tool_exec['tool_execution']
+                func_call.pop('xml_tag_name')
+                clear_content = json.dumps(func_call, indent=2)
+                function_process += clear_content
+                function_process += "\n"
+                function_step += 1
+            else:
+                llm_process += f"{llm_step}. \n"
+                llm_process += content
+                llm_process += "\n"
+                llm_step += 1
+
+        prompt = prompt.replace("{llm_process}", llm_process)
+        prompt = prompt.replace("{function_process}", function_process)
+
+        return prompt
+
+
+    def _create_llm_langfuse_meta(self, trace_id:str, session_id: str)-> LangfuseMetadata:
+        generation_name = "xga_agent_final_result_completion"
+
+        return LangfuseMetadata(
+            generation_name     = generation_name,
+            existing_trace_id   = trace_id,
+            session_id          = session_id
+        )
+
+
+
+if __name__ == "__main__":
+    import asyncio
+    from xgae.utils.setup_env import setup_logging
+    setup_logging()
+
+    async def main():
+        final_result_agent = FinalResultAgent()
+
+        user_input = "locate 10.2.3.4 fault and solution"
+        answer = ("Task Summary: The fault for IP 10.2.3.4 was identified as a Business Recharge Fault (Code: F01), "
+                  "caused by a Phone Recharge Application Crash. The solution applied was to restart the application. "
+                  "Key Deliverables: Fault diagnosis and resolution steps. Impact Achieved: Service restored.")
+        task_result:XGATaskResult = {'type': "answer",  'content': answer}
+        llm_messages: List[Dict[str, Any]] = [{
+            'content':
+                    """<function_calls> 
+                        <invoke name="get_alarm_type">
+                                       <parameter name="alarm_id">alm0123</parameter>
+                         </invoke>
+                    </function_calls>'""",
+             'role': "assistant"
+             },{
+            'content': """{"tool_execution": {
+                                "function_name": "get_alarm_type", 
+                                "xml_tag_name": "get-alarm-type", 
+                                "arguments": {"alarm_id": "alm0123"}, 
+                                "result": {"success": true, "output": "1", "error": null}}}""",
+            'role': 'assistant'
+            }]
+        return await final_result_agent.eval_result(user_input, task_result, llm_messages)
+
+
+    final_result = asyncio.run(main())
+    final_result_json = json.dumps(final_result, ensure_ascii=False, indent=2)
+    print(f"FINAL_RESULT：   {final_result_json} ")

xgae-0.1.20/src/examples/agent/langgraph/react/react_agent.py

@@ -0,0 +1,335 @@
+import logging
+import os
+
+from typing import Any, Dict, List, Optional, AsyncGenerator
+from uuid import uuid4
+
+from langfuse.callback import CallbackHandler
+from langfuse import Langfuse
+
+
+from langgraph.graph import END, START, StateGraph
+from langgraph.types import interrupt, Command
+from langgraph.checkpoint.memory import MemorySaver
+from langgraph.config import get_stream_writer
+
+from xgae.utils.misc import read_file
+from xgae.utils import log_trace
+
+from xgae.engine.engine_base import XGATaskResult
+from xgae.engine.mcp_tool_box import XGAMcpToolBox
+from xgae.engine.task_engine import XGATaskEngine
+
+from examples.agent.langgraph.react.agent_base import AgentContext, TaskState, EvaluateResult
+from examples.agent.langgraph.react.final_result_agent import FinalResultAgent
+
+class XGAReactAgent:
+    MAX_TASK_RETRY = 2
+    QUALIFIED_RESULT_SCORE = 0.7
+
+    def __init__(self):
+        self.graph = None
+
+        self.graph_config = None
+        self.graph_langfuse = None
+        self.task_engine: XGATaskEngine = None
+
+        self.tool_box = XGAMcpToolBox(custom_mcp_server_file="mcpservers/custom_servers.json")
+        self.final_result_agent = FinalResultAgent()
+
+    async def _create_graph(self) -> StateGraph:
+        try:
+            graph_builder = StateGraph(TaskState)
+
+            # Add nodes
+            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('final_result', self._final_result_node)
+
+            # Add edges
+            graph_builder.add_edge(START, 'supervisor')
+            graph_builder.add_conditional_edges(
+                'supervisor',
+                self._next_condition,
+                {
+                    'select_tool': 'select_tool',
+                    'exec_task': 'exec_task',
+                    'end': END
+                }
+            )
+
+            graph_builder.add_edge('select_tool', 'exec_task')
+            graph_builder.add_edge('exec_task', 'final_result')
+
+            graph_builder.add_conditional_edges(
+                'final_result',
+                self._next_condition,
+                {
+                    'supervisor': 'supervisor',
+                    'exec_task': 'exec_task',
+                    'end': END
+                }
+            )
+            
+            graph = graph_builder.compile(checkpointer=MemorySaver())
+            graph.name = "XGARectAgentGraph"
+
+            return graph
+        except Exception as 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['user_input']
+        eval_result = state.get('eval_result', None)
+
+        system_prompt = self._search_system_prompt(user_input)
+
+        general_tools = [] if system_prompt else ["*"]
+        custom_tools = ["*"] if system_prompt  else []
+
+        if eval_result and 'function_call' in eval_result and 'score' in eval_result['function_call']:
+            score = eval_result['function_call'].get('score', 1.0)
+            if score < self.QUALIFIED_RESULT_SCORE:
+                next_node = "select_tool"
+            else:
+                next_node = "end"
+        else:
+            next_node = "select_tool" if system_prompt else "exec_task"
+
+        return {
+            'system_prompt' : system_prompt,
+            '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 = []
+        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]:
+        user_input = state['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
+
+        trace_id = self.graph_langfuse.get_trace_id()
+        llm_messages = []
+        try:
+            logging.info(f"🔥 XGATaskEngine run_task: user_input={user_input}, general_tools={general_tools}, "
+                         f"custom_tools={custom_tools}, is_system_prompt={is_system_prompt}")
+            if self.task_engine is None:
+                self.task_engine = XGATaskEngine(
+                    task_id         = state['agent_context']['task_id'],
+                    session_id      = state['agent_context'].get('session_id', None),
+                    user_id         = state['agent_context'].get('user_id', None),
+                    agent_id        = state['agent_context'].get('agent_id', None),
+                    tool_box        = self.tool_box,
+                    general_tools   = general_tools,
+                    custom_tools    = custom_tools,
+                    system_prompt   = system_prompt
+                )
+
+            chunks = []
+            stream_writer = get_stream_writer()
+            async for chunk in self.task_engine.run_task(task_input={"role": "user", "content": user_input},
+                                                         trace_id=trace_id):
+                chunks.append(chunk)
+                stream_writer({"engine_message": chunk})
+
+            task_result = self.task_engine.parse_final_result(chunks)
+            llm_messages = self.task_engine.get_history_llm_messages()
+        except Exception as e:
+            logging.error(f"XReactAgent exec_task_node: Failed to execute task: {e}")
+            task_result = XGATaskResult(type="error", content="Failed to execute task")
+
+        iteration_count = state.get('iteration_count', 0) + 1
+        return {
+            'task_result' : task_result,
+            'iteration_count': iteration_count,
+            'llm_messages' : llm_messages.copy()
+        }
+
+
+    async def _final_result_node(self, state: TaskState) -> Dict[str, Any]:
+        user_input = state['user_input']
+        iteration_count = state['iteration_count']
+        task_result = state['task_result']
+        llm_messages = state['llm_messages']
+        agent_context = state['agent_context']
+
+        next_node = "end"
+        final_result = task_result
+        eval_result = None
+        if task_result['type'] == "ask":
+            logging.info(f"XReactAgent final_result_node: ASK_USER_QUESTION: {task_result['content']}")
+            user_input = interrupt({
+                'final_result' : task_result
+            })
+            logging.info(f"XReactAgent final_result_node: ASK_USER_ANSWER: {user_input}")
+            next_node = "exec_task"
+            final_result = None
+        elif iteration_count < self.MAX_TASK_RETRY:
+            trace_id = self.graph_langfuse.get_trace_id()
+            session_id = agent_context.get('session_id', None)
+            eval_result = await self.final_result_agent.eval_result(user_input, task_result, llm_messages, trace_id, session_id)
+            if "task_result" in eval_result and "score" in eval_result['task_result']:
+                score =  eval_result['task_result'].get('score', 1.0)
+                if score < self.QUALIFIED_RESULT_SCORE:
+                    next_node = "supervisor"
+
+        return {
+            'user_input'    : user_input,
+            'next_node'     : next_node,
+            'final_result'  : final_result,
+            'eval_result'   : eval_result
+        }
+
+
+    def _next_condition(self, state: TaskState) -> str:
+        next_node = state['next_node']
+        return next_node
+
+
+    async def generate_with_result(self, user_input: str,
+                                   agent_context: Optional[AgentContext] = None,
+                                   is_resume: Optional[bool]=False) -> XGATaskResult:
+        agent_context = agent_context or {}
+        try:
+
+            if is_resume:
+                logging.info(f"=== Start React Agent for USER_ASK_ANSWER: {user_input}")
+                graph_input = Command(resume=user_input)
+            else:
+                logging.info(f"=== Start React Agent for USER_INPUT: {user_input}")
+                graph_input = await self._prepare_graph_start(user_input, agent_context)
+
+            final_state = await self.graph.ainvoke(graph_input, config=self.graph_config)
+
+            if "__interrupt__" in final_state:
+                interrupt_event = final_state["__interrupt__"][0]
+                interrupt_value = interrupt_event.value
+                result = interrupt_value['final_result']
+            else:
+                result = final_state['final_result']
+
+            return result
+        except Exception as e:
+            log_trace(e, f"XReactAgent generate: user_input={user_input}")
+            result = XGATaskResult(type="error", content=f"React Agent error: {e}")
+            return result
+
+
+    async def generate(self, user_input: str,
+                       agent_context: Optional[AgentContext]=None,
+                       is_resume: Optional[bool]=False) -> AsyncGenerator[Dict[str, Any], None]:
+        agent_context = agent_context or {}
+        try:
+            if is_resume:
+                logging.info(f"=== Start React Stream Agent for USER_ASK_ANSWER: {user_input}")
+                graph_input = Command(resume=user_input)
+            else:
+                logging.info(f"=== Start React Stream Agent USER_ASK_ANSWER: {user_input}")
+                graph_input = await self._prepare_graph_start(user_input, agent_context)
+
+            async for msg_type, message in self.graph.astream(input=graph_input,
+                                                              config=self.graph_config,
+                                                              stream_mode=["custom", "updates"]):
+                if msg_type == "updates" and '__interrupt__' in message:
+                    interrupt_event = message["__interrupt__"][0]
+                    interrupt_value = interrupt_event.value
+                    final_result = interrupt_value['final_result']
+                    yield final_result
+                elif msg_type == "updates" and 'final_result' in message:
+                    message = message['final_result']
+                    final_result = message.get('final_result', None)
+                    if final_result:
+                        yield final_result
+                elif msg_type == "custom" and 'engine_message' in message:
+                    message = {'type': "message", 'content': message['engine_message']}
+                    yield message
+
+        except Exception as e:
+            log_trace(e, f"XReactAgent generate: user_input={user_input}")
+            yield {'type': "error", 'content': f"React Agent generate error: {e}"}
+
+
+    async def _prepare_graph_start(self, user_input, agent_context: AgentContext)->TaskState:
+        if self.graph is None:
+            self.graph = await self._create_graph()
+
+        self._clear_graph()
+
+        agent_context = agent_context or {}
+        task_id = agent_context.get("task_id", f"xga_task_{uuid4()}")
+        agent_context["task_id"] = task_id
+        thread_id = agent_context.get('thread_id', task_id)
+        agent_context['thread_id'] = thread_id
+        session_id = agent_context.get('session_id', task_id)
+        agent_context['session_id'] = session_id
+
+
+        langfuse_handler = self._get_langfuse_handler(agent_context)
+        callbacks = None
+        if langfuse_handler:
+            callbacks = [langfuse_handler]
+            self.graph_langfuse = langfuse_handler.langfuse
+        else:
+            self.graph_langfuse = Langfuse(enabled=False)
+
+        self.graph_config = {
+            'recursion_limit': 100,
+            'configurable': {
+                'thread_id': thread_id
+            },
+            'callbacks': callbacks
+        }
+
+        graph_input = {
+            'user_input'        : user_input,
+            'next_node'         : None,
+            'agent_context'     : agent_context,
+            'iteration_count'   : 0
+        }
+
+        return graph_input
+
+
+    def _get_langfuse_handler(self, agent_context: AgentContext)->CallbackHandler:
+        langfuse_handler = None
+        public_key = os.getenv("LANGFUSE_PUBLIC_KEY")
+        secret_key = os.getenv("LANGFUSE_SECRET_KEY")
+        host = os.getenv("LANGFUSE_HOST", "https://cloud.langfuse.com")
+
+        if public_key and secret_key:
+            langfuse_handler =  CallbackHandler(
+                public_key  = public_key,
+                secret_key  = secret_key,
+                host        = host,
+                trace_name  = "xga_react_agent",
+                session_id  = agent_context.get('session_id', None),
+                user_id     = agent_context.get('user_id', None),
+            )
+        return langfuse_handler
+
+    def _clear_graph(self):
+        self.graph_config = None
+        self.graph_langfuse = None
+        self.task_engine: XGATaskEngine = None

xgae-0.1.20/src/examples/agent/langgraph/react/run_react_agent.py

@@ -0,0 +1,64 @@
+import asyncio
+
+from uuid import uuid4
+
+from xgae.utils.setup_env import setup_logging
+
+from examples.agent.langgraph.react.react_agent import XGAReactAgent, AgentContext
+
+
+async def main():
+    is_stream = True  # two mode agent experience
+    task_no = 0
+    user_inputs = [
+        #"5+5", # For no tool call
+        "locate 10.2.3.4 fault and solution",  # For custom tool
+        #"locate fault and solution",   # For human append input
+    ]
+
+    for user_input in user_inputs:
+        agent = XGAReactAgent()
+        task_no += 1
+        context: AgentContext = {
+            'task_id': f"agent_task_{uuid4()}",   # can be set with request_id, must be unique
+            'user_id': "agent_user_1",
+            'agent_id': "agent_1",
+        }
+
+        is_resume = False
+        auto_continue = True
+        while auto_continue:
+            if is_stream:
+                print(f"*** START AGENT : RUN generate USER_INPUT={user_input}")
+                async for chunk in agent.generate(user_input, context, is_resume):
+                    type = chunk['type']
+                    if type == "error" or type == "answer":
+                        await asyncio.sleep(1)
+                        print(f"FINAL_RESULT: {chunk}")
+                        auto_continue = False
+                    elif type == "ask":
+                        print(f"ASK_USER: {chunk}")
+                        user_input = "17.0.0.1"
+                        is_resume = True
+                        auto_continue = True
+                    else:
+                        print(f"RESULT_CHUNK: {chunk}")
+                        auto_continue = False
+            else:
+                print(f"*** START AGENT : RUN generate_with_result  USER_INPUT={user_input}")
+                result = await agent.generate_with_result(user_input, context, is_resume)
+                await asyncio.sleep(1)
+                type = result['type']
+                if type == "error" or type == "answer":
+                    print(f"FINAL_RESULT: {result}")
+                    auto_continue = False
+                elif type == "ask":
+                    print(f"ASK_USER: {result}")
+                    user_input = "18.0.0.1"
+                    is_resume = True
+                    auto_continue = True
+
+
+if __name__ == "__main__":
+    setup_logging()
+    asyncio.run(main())

{xgae-0.1.18 → xgae-0.1.20}/src/examples/engine/run_custom_and_agent_tools.py

@@ -13,6 +13,9 @@ if is_stream:
 else:
     setup_logging()
 
+# Before Run Exec: uv run example-fault-tools --alarmtype=2  , uv run example-a2a-tools
+# If want to use real A2A agent tool, use xga-agent-tool project
+
 async def main() -> None:
     tool_box = XGAMcpToolBox(custom_mcp_server_file="mcpservers/custom_servers.json")
     system_prompt = read_file("templates/example/fault_user_prompt.txt")
@@ -27,16 +30,16 @@ async def main() -> None:
     global is_stream
     if is_stream:
         chunks = []
-        async for chunk in engine.run_task(task_message={"role": "user", "content": user_input}):
+        async for chunk in engine.run_task(task_input={"role": "user", "content": user_input}):
             chunks.append(chunk)
             print(chunk)
 
         final_result = engine.parse_final_result(chunks)
         print(f"\n\nFINAL_RESULT: {final_result}")
     else:
-        final_result = await engine.run_task_with_final_answer(task_message={"role": "user", "content": user_input})
+        final_result = await engine.run_task_with_final_answer(task_input={"role": "user", "content": user_input})
         print(f"\n\nFINAL_RESULT: {final_result}")
 
 
- # Before Run Exec: uv run example-fault-tools --alarmtype=2  , uv run example-a2a-tools
+
 asyncio.run(main())

{xgae-0.1.18 → xgae-0.1.20}/src/examples/engine/run_general_tools.py

@@ -10,7 +10,7 @@ async def main() -> None:
     engine = XGATaskEngine(general_tools=["*"])
 
     user_input =  "This week's gold price"
-    final_result = await engine.run_task_with_final_answer(task_message={"role": "user", "content": user_input})
+    final_result = await engine.run_task_with_final_answer(task_input={"role": "user", "content": user_input})
     print("FINAL RESULT:", final_result)
 
 asyncio.run(main())

{xgae-0.1.18 → xgae-0.1.20}/src/examples/engine/run_human_in_loop.py

@@ -25,7 +25,7 @@ async def main() -> None:
 
     user_input =  "locate fault and solution"
     final_result = await engine.run_task_with_final_answer(
-        task_message={"role": "user", "content": user_input},
+        task_input={"role": "user", "content": user_input},
         trace_id=trace_id
     )
     print("FINAL RESULT:", final_result)
@@ -34,7 +34,7 @@ async def main() -> None:
         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},
+            task_input={"role": "user", "content": user_input},
             trace_id=trace_id
         )
         print("FINAL RESULT:", final_result)

{xgae-0.1.18 → xgae-0.1.20}/src/examples/engine/run_simple.py

@@ -10,7 +10,7 @@ async def main() -> None:
     engine =  XGATaskEngine()
 
     final_result = await engine.run_task_with_final_answer(
-        task_message={"role": "user", "content": "1+7"}
+        task_input={"role": "user", "content": "1+7"}
     )
 
     print("FINAL RESULT:", final_result)