xgae 0.1.19__tar.gz → 0.1.20__tar.gz

{xgae-0.1.19 → xgae-0.1.20}/CHANGELOG.md

@@ -1,4 +1,9 @@
 # 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

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

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

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

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

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.19 → xgae-0.1.20}/src/examples/agent/langgraph/react/react_agent.py

@@ -1,61 +1,42 @@
 import logging
 import os
 
-from typing import Any, Dict, List, Annotated, Sequence, TypedDict, Optional, AsyncGenerator
+from typing import Any, Dict, List, Optional, AsyncGenerator
 from uuid import uuid4
 
 from langfuse.callback import CallbackHandler
 from langfuse import Langfuse
 
-from langchain_core.messages import BaseMessage, HumanMessage, AIMessage
 
 from langgraph.graph import END, START, StateGraph
 from langgraph.types import interrupt, Command
 from langgraph.checkpoint.memory import MemorySaver
-from langgraph.graph.message import add_messages
 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, XGAResponseMessage
+from xgae.engine.engine_base import XGATaskResult
 from xgae.engine.mcp_tool_box import XGAMcpToolBox
 from xgae.engine.task_engine import XGATaskEngine
 
-
-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"""
-    messages: Annotated[Sequence[BaseMessage], add_messages]  # for message persistent
-    user_input: str
-    next_node: str
-    system_prompt: str
-    custom_tools: List[str]
-    general_tools: List[str]
-    task_result: XGATaskResult
-    final_result: XGATaskResult
-    iteration_count: int
-    agent_context: AgentContext
-
+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.tool_box = XGAMcpToolBox(custom_mcp_server_file="mcpservers/custom_servers.json")
         self.graph = None
-        self.graph_config = None
-        self.graph_langfuse = Langfuse(enabled=False)
 
+        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)
@@ -105,13 +86,22 @@ class XGAReactAgent:
         return system_prompt
 
     async def _supervisor_node(self, state: TaskState) -> Dict[str, Any]:
-        user_input = state.get("user_input", "")
+        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 []
 
-        next_node = "select_tool" if system_prompt else "exec_task"
+        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,
@@ -141,13 +131,14 @@ class XGAReactAgent:
         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),
+                    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,
@@ -164,6 +155,7 @@ class XGAReactAgent:
                 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")
@@ -172,32 +164,42 @@ class XGAReactAgent:
         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"
-        if task_result['type'] == "error" and iteration_count < self.MAX_TASK_RETRY:
-            next_node = "supervisor"
-            final_result = None
-        elif task_result['type'] == "ask":
-            final_result = task_result
+        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' : final_result
+                'final_result' : task_result
             })
             logging.info(f"XReactAgent final_result_node: ASK_USER_ANSWER: {user_input}")
             next_node = "exec_task"
-        else:
-            final_result = task_result
+            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,
+            'user_input'    : user_input,
+            'next_node'     : next_node,
+            'final_result'  : final_result,
+            'eval_result'   : eval_result
         }
 
 
@@ -266,13 +268,15 @@ class XGAReactAgent:
 
         except Exception as e:
             log_trace(e, f"XReactAgent generate: user_input={user_input}")
-            yield XGATaskResult(type="error", content=f"React Agent error: {e}")
+            yield {'type': "error", 'content': f"React Agent generate error: {e}"}
 
 
-    async def _prepare_graph_start(self, user_input, agent_context: AgentContext):
+    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
@@ -281,20 +285,14 @@ class XGAReactAgent:
         session_id = agent_context.get('session_id', task_id)
         agent_context['session_id'] = session_id
 
-        graph_input = {
-            'messages'          : [HumanMessage(content=f"information for: {user_input}")],
-            'user_input'        : user_input,
-            'next_node'         : None,
-            'agent_context'     : agent_context,
-            'iteration_count'   : 0
-        }
 
         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,
@@ -304,6 +302,13 @@ class XGAReactAgent:
             'callbacks': callbacks
         }
 
+        graph_input = {
+            'user_input'        : user_input,
+            'next_node'         : None,
+            'agent_context'     : agent_context,
+            'iteration_count'   : 0
+        }
+
         return graph_input
 
 
@@ -324,4 +329,7 @@ class XGAReactAgent:
             )
         return langfuse_handler
 
-
+    def _clear_graph(self):
+        self.graph_config = None
+        self.graph_langfuse = None
+        self.task_engine: XGATaskEngine = None

{xgae-0.1.19 → xgae-0.1.20}/src/examples/agent/langgraph/react/run_react_agent.py

@@ -1,5 +1,7 @@
 import asyncio
 
+from uuid import uuid4
+
 from xgae.utils.setup_env import setup_logging
 
 from examples.agent.langgraph.react.react_agent import XGAReactAgent, AgentContext
@@ -9,18 +11,18 @@ 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
+        #"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_{task_no}",
-            'user_id': f"agent_user_{task_no}",
-            'agent_id': f"agent_{task_no}",
+            '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

{xgae-0.1.19 → xgae-0.1.20}/src/xgae/engine/task_engine.py

@@ -28,7 +28,8 @@ class XGATaskEngine:
                  tool_exec_parallel: Optional[bool] = None,
                  llm_config: Optional[LLMConfig] = None,
                  prompt_builder: Optional[XGAPromptBuilder] = None,
-                 tool_box: Optional[XGAToolBox] = None):
+                 tool_box: Optional[XGAToolBox] = None
+                 ):
         self.task_id    = task_id if task_id else f"xga_task_{uuid4()}"
         self.session_id = session_id
         self.user_id    = user_id
@@ -213,7 +214,7 @@ class XGATaskEngine:
         auto_count = continuous_state.get("auto_continue_count")
         langfuse_metadata = self.task_langfuse.create_llm_langfuse_meta(auto_count)
 
-        llm_response = await self.llm_client.create_completion(llm_messages, langfuse_metadata)
+        llm_response = await self.llm_client.acompletion(llm_messages, langfuse_metadata)
         response_processor = self._create_response_processer()
 
         async for chunk in response_processor.process_response(llm_response, llm_messages, continuous_state):
@@ -315,7 +316,7 @@ class XGATaskEngine:
     def get_history_llm_messages (self) -> List[Dict[str, Any]]:
         llm_messages = []
         for message in self.task_response_msgs:
-            if message['is_llm_message']:
+            if message['is_llm_message'] and message['type'] != "assistant_chunk":
                 llm_messages.append(message)
 
         response_llm_contents = []

{xgae-0.1.19 → xgae-0.1.20}/src/xgae/engine/task_langfuse.py

@@ -51,10 +51,12 @@ class XGATaskLangFuse:
                 'agent_id'      : self.agent_id
             }
 
-            self.root_span = trace.span(id=self.task_run_id,
-                                        name=f"{root_span_name}[{self.task_no}]",
-                                        input=task_input,
-                                        metadata=metadata)
+            self.root_span = trace.span(
+                id          = self.task_run_id,
+                name        = f"{root_span_name}[{self.task_no}]",
+                input       = task_input,
+                metadata    = metadata
+            )
             self.root_span_name = root_span_name
 
             logging.info(f"{root_span_name} TASK_INPUT: {task_input}")

{xgae-0.1.19 → xgae-0.1.20}/src/xgae/utils/llm_client.py

@@ -226,7 +226,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]], langfuse_metadata: Optional[LangfuseMetadata]=None) -> Union[ModelResponse, CustomStreamWrapper]:
+    async def acompletion(self,
+                          messages: List[Dict[str, Any]],
+                          langfuse_metadata: Optional[LangfuseMetadata]=None
+                          ) -> Union[ModelResponse, CustomStreamWrapper]:
         complete_params = self._prepare_complete_params(messages)
         if LLMClient.langfuse_enabled and langfuse_metadata:
             complete_params["metadata"] = langfuse_metadata
@@ -234,19 +237,38 @@ class LLMClient:
         last_error = None
         for attempt in range(self.max_retries):
             try:
-                logging.info(f"*** LLMClient create_completion: LLM '{self.model_name}' completion attempt {attempt + 1}/{self.max_retries}")
+                logging.info(f"*** LLMClient acompletion: LLM '{self.model_name}' completion attempt {attempt + 1}/{self.max_retries}")
                 response = await litellm.acompletion(**complete_params)
                 return response
             except (litellm.exceptions.RateLimitError, OpenAIError, json.JSONDecodeError) as e:
                 last_error = e
                 await self._handle_llm_error(e, attempt)
             except Exception as e:
-                logging.error(f"LLMClient create_completion: Unexpected error during LLM completion: {str(e)}", exc_info=True)
+                logging.error(f"LLMClient acompletion: Unexpected error during LLM completion: {str(e)}", exc_info=True)
                 raise LLMError(f"LLMClient create completion failed: {e}")
 
-        logging.error(f"LLMClient create_completion: LLM completion failed after {self.max_retries} attempts: {last_error}", exc_info=True)
+        logging.error(f"LLMClient acompletion: LLM completion failed after {self.max_retries} attempts: {last_error}", exc_info=True)
         raise LLMError(f"LLMClient create completion failed after {self.max_retries} attempts !")
 
+
+    async def get_response_result(self, response: Union[ModelResponse, CustomStreamWrapper]) -> str:
+        response_text: str = ""
+
+        if self.is_stream:
+            async for chunk in response:
+                choices = chunk.get("choices", [{}])
+                if not choices:
+                    continue
+                delta = choices[0].get("delta", {})
+                content = delta.get("content", "")
+                if content:
+                    response_text += content
+        else:
+            response_text = response.choices[0].message.content
+
+        return response_text
+
+
 if __name__ == "__main__":
     from xgae.utils.setup_env import setup_logging
 
@@ -267,7 +289,7 @@ if __name__ == "__main__":
                 session_id="session_0",
         )
 
-        response = await llm_client.create_completion(messages, meta)
+        response = await llm_client.acompletion(messages, meta)
         if llm_client.is_stream:
             async for chunk in response:
                 choices = chunk.get("choices", [{}])

xgae-0.1.20/templates/example/final_result_template.txt

@@ -0,0 +1,61 @@
+# Scoring Criteria
+Grading is based on task requirements and task answers. Key scoring elements include:
+1. The most important scoring element: whether the task answer satisfies the user’s question.
+2.Final answer requirements:
+- Provide accurate and complete information
+- Contain no factual errors
+- Address all parts of the question
+- Maintain logical consistency
+3. When scoring, points should be deducted for:
+- Factual errors or inaccurate information
+- Incomplete or partial answers
+- Misleading or unclear statements
+- Logical inconsistencies
+- Missing key information
+
+
+# Evaluation Dimensions
+1. Task Result Score: Task outcome evaluation
+- assesses the degree of match between task requirements and task results
+- if task result 'type' is 'error', evaluation score is 0, evaluation reason is empty
+2.Task Process Score : Task process evaluation
+- assesses whether task planning is reasonable
+- Whether task steps can yield answers to the user’s question
+- Whether task steps can be executed
+- Whether task steps can properly match and call tools
+3. Function Call Score: Function Call evaluation
+- assesses whether function calls are successful and whether parameter transmission is reasonable
+- if no function call, evaluation score is 1.00, evaluation reason is empty
+
+
+# Output Format: JSON
+{
+  "task_result": {  			# Task Result Score
+    "score": 0.62,   			# value: 0 ~ 1.00 , using two decimal places
+    "reasons": "Evaluation and reasons for deduction regarding task results"
+  },
+  "task_process": {  		# Task Process Score
+    "score": 0.53,  			# value: 0 ~ 1.00 , using two decimal places
+    "reasons": "Evaluation and reasons for deduction regarding the task process"
+  },
+  "function_call": {   		# Function Call Score
+    "score": 0.41, 			# value: 0 ~ 1.00 , using two decimal places
+    "reasons": "Evaluation and reasons for deduction regarding tool execution"
+  }
+}
+
+
+# Task Requirements
+{task_input}
+
+
+# Task Result
+{task_result}
+
+
+# LLM Procedure
+{llm_process}
+
+# Function Call Procedure
+{function_process}
+

{xgae-0.1.19 → xgae-0.1.20}/uv.lock

@@ -1332,7 +1332,7 @@ wheels = [
 
 [[package]]
 name = "xgae"
-version = "0.1.19"
+version = "0.1.20"
 source = { editable = "." }
 dependencies = [
     { name = "colorlog" },

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

@@ -1,59 +0,0 @@
-import json
-import logging
-import re
-from typing import Any, Dict, List
-
-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 final_result(self, user_request: str, task_results: str, langfuse_metadata:LangfuseMetadata=None)-> Dict[str, Any]:
-        prompt = self.prompt_template.replace("{user_request}", user_request)
-        prompt = prompt.replace("{task_results}", task_results)
-
-        messages = [{"role": "user", "content": prompt}]
-
-        response_text: str = ""
-        response = await self.model_client.create_completion(
-            messages,
-            langfuse_metadata
-        )
-        if self.model_client.is_stream:
-            async for chunk in response:
-                choices = chunk.get("choices", [{}])
-                if not choices:
-                    continue
-                delta = choices[0].get("delta", {})
-                content = delta.get("content", "")
-                if content:
-                    response_text += content
-        else:
-            response_text = response.choices[0].message.content
-
-        cleaned_text = re.sub(r'^\s*```json|```\s*$', '', response_text, flags=re.MULTILINE).strip()
-        final_result = json.loads(cleaned_text)
-        return final_result
-
-
-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.")
-        return await final_result_agent.final_result(user_input, answer)
-
-
-    final_result = asyncio.run(main())
-    print(f"FINAL_RESULT：   {final_result} ")

xgae-0.1.19/templates/example/final_result_template.txt

@@ -1,19 +0,0 @@
-#Objective: 
-Compare the user's requirements with the task execution results and extract the final result for user request format.
-
-#User Input Requirements: 
-{user_request}
-
-#Task Execution Results:
- {task_results}
-
-#Final Result Principles:
-1. Extract the final result solely based on the task execution results; no additional information from other sources should be used.
-2. If task agent is 'mcp_creation_agent', task result is 'output' field when no 'error'
-3. If only part of the requirements are met, include the partially met content in the final result.
-
-#Final Result Output Format: JSON
-{
-    "final_result_type": 0,  // Value explanation: -1: Not met, no final result; 0: All requirements met; 1: Partially met
-    "formatted_result": "Final result"  // If not met at all, provide an empty string
-}