xgae 0.1.4__tar.gz → 0.1.5__tar.gz

{xgae-0.1.4 → xgae-0.1.5}/.idea/workspace.xml

@@ -151,7 +151,7 @@
       <workItem from="1755611972189" duration="13340000" />
       <workItem from="1755668525673" duration="14877000" />
       <workItem from="1755700523844" duration="24000" />
-      <workItem from="1755737435202" duration="24716000" />
+      <workItem from="1755737435202" duration="48139000" />
     </task>
     <servers />
   </component>
@@ -172,7 +172,7 @@
   <component name="com.intellij.coverage.CoverageDataManagerImpl">
     <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$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$run_xga_engine.coverage" NAME="run_xga_engine Coverage Results" MODIFIED="1755768463510" 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="1755854764155" 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$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$" />

{xgae-0.1.4 → xgae-0.1.5}/PKG-INFO

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

{xgae-0.1.4 → xgae-0.1.5}/pyproject.toml

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

{xgae-0.1.4 → xgae-0.1.5}/src/xgae/engine/responser/xga_non_stream_responser.py

@@ -40,7 +40,7 @@ class NonStreamTaskResponser(TaskResponseProcessor):
                 type="status", content=start_content,
                 is_llm_message=False, metadata={"thread_run_id": thread_run_id}
             )
-            if start_msg_obj: yield format_for_yield(start_msg_obj)
+           # if start_msg_obj: yield format_for_yield(start_msg_obj)
 
             # Extract finish_reason, content, tool calls
             if hasattr(llm_response, 'choices') and llm_response.choices:
@@ -157,6 +157,9 @@ class NonStreamTaskResponser(TaskResponseProcessor):
                         self.trace.event(name="failed_to_save_tool_result_for_index", level="ERROR",
                                          status_message=(f"Failed to save tool result for index {tool_index}"))
 
+                    if completed_msg_obj["metadata"].get("agent_should_terminate") == "true":
+                        finish_reason = "completed"
+                        break
                     tool_index += 1
 
             # --- Save and Yield Final Status ---
@@ -209,5 +212,5 @@ class NonStreamTaskResponser(TaskResponseProcessor):
                 type="status", content=end_content,
                 is_llm_message=False, metadata={"thread_run_id": thread_run_id if 'thread_run_id' in locals() else None}
             )
-            if end_msg_obj: yield format_for_yield(end_msg_obj)
+            #if end_msg_obj: yield format_for_yield(end_msg_obj)
 

{xgae-0.1.4 → xgae-0.1.5}/src/xgae/engine/responser/xga_responser_base.py

@@ -5,7 +5,7 @@ from dataclasses import dataclass
 from typing import List, Dict, Any, Optional, Tuple, Union, Literal, Callable,TypedDict,AsyncGenerator
 from abc import ABC, abstractmethod
 
-from xgae.engine.xga_base import XGAToolResult, XGAContextMsg, XGAToolBox
+from xgae.engine.xga_base import XGAToolResult, XGAResponseMsg, XGAToolBox
 # from xgae.utils.setup_env import langfuse
 from xgae.utils.json_helpers import (
     safe_json_parse,
@@ -26,7 +26,7 @@ class TaskResponseContext(TypedDict, total=False):
     trace_id: str
     model_name: str
     max_xml_tool_calls: int
-    add_context_msg: Callable
+    add_response_msg_func: Callable
     tool_box: XGAToolBox
     tool_execution_strategy: Literal["sequential", "parallel"]
     xml_adding_strategy: Literal["user_message", "assistant_message", "inline_edit"]
@@ -49,7 +49,6 @@ class Trace:
         return Span()
 
 
-
 @dataclass
 class ToolExecutionContext:
     """Context for a tool execution including call details, result, and display info."""
@@ -63,46 +62,6 @@ class ToolExecutionContext:
     parsing_details: Optional[Dict[str, Any]] = None
 
 
-@dataclass
-class ProcessorConfig:
-    """
-    Configuration for response processing and tool execution.
-
-    This class controls how the LLM's responses are processed, including how tool calls
-    are detected, executed, and their results handled.
-
-    Attributes:
-        xml_tool_calling: Enable XML-based tool call detection (<tool>...</tool>)
-        native_tool_calling: Enable OpenAI-style function calling format
-        execute_tools: Whether to automatically execute detected tool calls
-        execute_on_stream: For streaming, execute tools as they appear vs. at the end
-        tool_execution_strategy: How to execute multiple tools ("sequential" or "parallel")
-        xml_adding_strategy: How to add XML tool results to the conversation
-        max_xml_tool_calls: Maximum number of XML tool calls to process (0 = no limit)
-    """
-
-    xml_tool_calling: bool = True
-    native_tool_calling: bool = False
-
-    execute_tools: bool = True
-    execute_on_stream: bool = False
-    tool_execution_strategy: ToolExecutionStrategy = "sequential"
-    xml_adding_strategy: XmlAddingStrategy = "assistant_message"
-    max_xml_tool_calls: int = 0  # 0 means no limit
-
-    def __post_init__(self):
-        """Validate configuration after initialization."""
-        if self.xml_tool_calling is False and self.native_tool_calling is False and self.execute_tools:
-            raise ValueError(
-                "At least one tool calling format (XML or native) must be enabled if execute_tools is True")
-
-        if self.xml_adding_strategy not in ["user_message", "assistant_message", "inline_edit"]:
-            raise ValueError("xml_adding_strategy must be 'user_message', 'assistant_message', or 'inline_edit'")
-
-        if self.max_xml_tool_calls < 0:
-            raise ValueError("max_xml_tool_calls must be a non-negative integer (0 = no limit)")
-
-
 class TaskResponseProcessor(ABC):
     def __init__(self, response_context: TaskResponseContext):
         self.response_context = response_context

{xgae-0.1.4 → xgae-0.1.5}/src/xgae/engine/responser/xga_stream_responser.py

@@ -2,15 +2,58 @@ import asyncio
 import json
 import logging
 import uuid
+
+from dataclasses import dataclass
 from datetime import datetime, timezone
 from typing import List, Dict, Any, Optional, AsyncGenerator, override
 
-from xgae.engine.responser.xga_responser_base import TaskResponseProcessor, ProcessorConfig, TaskResponseContext,TaskRunContinuousState
+from xgae.engine.responser.xga_responser_base import TaskResponseProcessor, ToolExecutionStrategy, XmlAddingStrategy, TaskResponseContext,TaskRunContinuousState
 from xgae.utils.json_helpers import (
     ensure_dict, safe_json_parse,
     to_json_string, format_for_yield
 )
 
+@dataclass
+class ProcessorConfig:
+    """
+    Configuration for response processing and tool execution.
+
+    This class controls how the LLM's responses are processed, including how tool calls
+    are detected, executed, and their results handled.
+
+    Attributes:
+        xml_tool_calling: Enable XML-based tool call detection (<tool>...</tool>)
+        native_tool_calling: Enable OpenAI-style function calling format
+        execute_tools: Whether to automatically execute detected tool calls
+        execute_on_stream: For streaming, execute tools as they appear vs. at the end
+        tool_execution_strategy: How to execute multiple tools ("sequential" or "parallel")
+        xml_adding_strategy: How to add XML tool results to the conversation
+        max_xml_tool_calls: Maximum number of XML tool calls to process (0 = no limit)
+    """
+
+    xml_tool_calling: bool = True
+    native_tool_calling: bool = False
+
+    execute_tools: bool = True
+    execute_on_stream: bool = False
+    tool_execution_strategy: ToolExecutionStrategy = "sequential"
+    xml_adding_strategy: XmlAddingStrategy = "assistant_message"
+    max_xml_tool_calls: int = 0  # 0 means no limit
+
+    def __post_init__(self):
+        """Validate configuration after initialization."""
+        if self.xml_tool_calling is False and self.native_tool_calling is False and self.execute_tools:
+            raise ValueError(
+                "At least one tool calling format (XML or native) must be enabled if execute_tools is True")
+
+        if self.xml_adding_strategy not in ["user_message", "assistant_message", "inline_edit"]:
+            raise ValueError("xml_adding_strategy must be 'user_message', 'assistant_message', or 'inline_edit'")
+
+        if self.max_xml_tool_calls < 0:
+            raise ValueError("max_xml_tool_calls must be a non-negative integer (0 = no limit)")
+
+
+
 class StreamTaskResponser(TaskResponseProcessor):
     def __init__(self, response_context: TaskResponseContext):
         super().__init__(response_context)

{xgae-0.1.4 → xgae-0.1.5}/src/xgae/engine/xga_base.py

@@ -7,23 +7,22 @@ class XGAError(Exception):
     pass
 
 
-class XGAContextMsg(TypedDict, total=False):
+class XGAResponseMsg(TypedDict, total=False):
     type: Literal["user", "status",  "tool", "assistant", "assistant_response_end"]
     content: Union[Dict[str, Any], List[Any], str]
     is_llm_message: bool
     metadata: Dict[str, Any]
     message_id: str
-    session_id: str
-    agent_id: str
     task_id: str
     task_run_id: str
     trace_id: str
+    session_id: Optional[str]
+    agent_id: Optional[str]
 
-class XGAResponseMsg(TypedDict, total=False):
-    type: Literal["content", "status"]
-    content: Union[Dict[str, Any], List[Any], str]
-    status: Literal["error", "status"]
-    message: str
+class XGATaskResult(TypedDict, total=False):
+    type: Literal["ask", "answer", "error"]
+    content: str
+    attachments: Optional[List[str]]
 
 @dataclass
 class XGAToolSchema:
@@ -39,6 +38,7 @@ class XGAToolResult:
     success: bool
     output: str
 
+
 class XGAToolBox(ABC):
     @abstractmethod
     async def creat_task_tool_box(self, task_id: str, general_tools: List[str], custom_tools: List[str]):

{xgae-0.1.4 → xgae-0.1.5}/src/xgae/engine/xga_engine.py

@@ -6,7 +6,7 @@ from typing import List, Any, Dict, Optional, AsyncGenerator, cast, Union, Liter
 from uuid import uuid4
 
 from xgae.engine.responser.xga_responser_base import TaskResponseContext, TaskResponseProcessor, TaskRunContinuousState
-from xgae.engine.xga_base import XGAContextMsg, XGAToolBox, XGAResponseMsg
+from xgae.engine.xga_base import XGAResponseMsg, XGAToolBox, XGATaskResult
 from xgae.utils.llm_client import LLMClient, LLMConfig
 from xgae.utils.setup_env import langfuse
 from xgae.utils.utils import handle_error
@@ -23,9 +23,9 @@ class XGATaskEngine:
                  llm_config: Optional[LLMConfig] = None,
                  prompt_builder: Optional[XGAPromptBuilder] = None,
                  tool_box: Optional[XGAToolBox] = None):
-        self.session_id = session_id if session_id else f"xga_sid_{uuid4()}"
         self.task_id = task_id if task_id else f"xga_task_{uuid4()}"
         self.agent_id = agent_id
+        self.session_id = session_id
 
         self.llm_client = LLMClient(llm_config)
         self.model_name = self.llm_client.model_name
@@ -34,12 +34,12 @@ class XGATaskEngine:
         self.prompt_builder = prompt_builder or XGAPromptBuilder(system_prompt)
         self.tool_box = tool_box or XGAMcpToolBox()
 
-        self.task_context_msgs: List[XGAContextMsg] = []
+        self.task_response_msgs: List[XGAResponseMsg] = []
         self.task_no = -1
         self.task_run_id = f"{self.task_id}[{self.task_no}]"
         self.trace_id = None
 
-    async def __async_init__(self, general_tools:List[str], custom_tools: List[str]) -> None:
+    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")
@@ -66,9 +66,9 @@ class XGATaskEngine:
                                     prompt_builder=prompt_builder,
                                     tool_box=tool_box)
 
-        general_tools = general_tools or ["complete"]
+        general_tools = general_tools or ["complete", "ask"]
         custom_tools = custom_tools or []
-        await engine.__async_init__(general_tools, custom_tools)
+        await engine._post_init_(general_tools, custom_tools)
 
         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}")
@@ -76,6 +76,16 @@ class XGATaskEngine:
 
         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)
+
+        final_result = self._parse_final_result(chunks)
+        return final_result
 
     async def run_task(self,
                        task_message: Dict[str, Any],
@@ -87,7 +97,7 @@ class XGATaskEngine:
             self.task_no += 1
             self.task_run_id = f"{self.task_id}[{self.task_no}]"
 
-            self.add_context_msg(type="user", content=task_message, is_llm_message=True)
+            self.add_response_msg(type="user", content=task_message, is_llm_message=True)
 
             if max_auto_run <= 1:
                 continuous_state:TaskRunContinuousState  = {
@@ -105,7 +115,7 @@ class XGATaskEngine:
 
     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_context_llm_contents()
+        cxt_llm_contents = self._get_response_llm_contents()
         llm_messages.extend(cxt_llm_contents)
 
         partial_content = continuous_state.get('accumulated_content', '')
@@ -120,10 +130,10 @@ class XGATaskEngine:
         response_processor = self._create_response_processer()
 
         async for chunk in response_processor.process_response(llm_response, llm_messages, continuous_state):
+            self._reponse_chunk_log(chunk)
             yield chunk
 
-
-    async def _run_task_auto(self, max_auto_run: int) -> AsyncGenerator:
+    async def _run_task_auto(self, max_auto_run: int) -> AsyncGenerator[Dict[str, Any], None]:
         continuous_state: TaskRunContinuousState = {
             "accumulated_content": "",
             "auto_continue_count": 0,
@@ -141,61 +151,101 @@ class XGATaskEngine:
 
             try:
                 async for chunk in self._run_task_once(continuous_state):
+                    yield chunk
                     try:
                         if chunk.get("type") == "status":
                             content = json.loads(chunk.get('content', '{}'))
                             status_type = content.get('status_type', None)
                             if status_type == "error":
                                 logging.error(f"run_task_auto: task_response error: {chunk.get('message', 'Unknown error')}")
-                                yield chunk
-                                return
+                                auto_continue = False
+                                break
                             elif status_type == 'finish':
                                 finish_reason = content.get('finish_reason', None)
-                                if finish_reason == 'stop' :
-                                    auto_continue = True
-                                    auto_continue_count += 1
-                                    update_continuous_state(auto_continue_count, auto_continue)
-                                    logging.info(f"run_task_auto: Detected finish_reason='stop', auto-continuing ({auto_continue_count}/{max_auto_run})")
-                                    continue
+                                if finish_reason == 'completed':
+                                    logging.warning(f"run_task_auto: Detected finish_reason='completed', Task Completed Success !")
+                                    auto_continue = False
+                                    break
                                 elif finish_reason == 'xml_tool_limit_reached':
-                                    logging.info(f"run_task_auto: Detected finish_reason='xml_tool_limit_reached', stopping auto-continue")
+                                    logging.warning(f"run_task_auto: Detected finish_reason='xml_tool_limit_reached', stopping auto-continue")
                                     auto_continue = False
-                                    update_continuous_state(auto_continue_count, auto_continue)
-                                elif finish_reason == 'length':
+                                    break
+                                elif finish_reason == 'stop' or finish_reason == 'length': # 'length' never occur
                                     auto_continue = True
                                     auto_continue_count += 1
                                     update_continuous_state(auto_continue_count, auto_continue)
-                                    logging.info(f"run_task_auto: Detected finish_reason='length', auto-continuing ({auto_continue_count}/{max_auto_run})")
-                                    continue
+                                    logging.info(f"run_task_auto: Detected finish_reason='{finish_reason}', auto-continuing ({auto_continue_count}/{max_auto_run})")
+                    except StopAsyncIteration:
+                        pass
                     except Exception as parse_error:
                         logging.error(f"run_task_auto: Error in parse chunk: {str(parse_error)}")
-                        yield {
-                            "type": "status",
-                            "status": "error",
-                            "message": f"Error in parse chunk: {str(parse_error)}"
-                        }
-                        return
-
-                    # Otherwise just yield the chunk normally
-                    yield chunk
-
-                # If not auto-continuing, we're done
-                if not auto_continue:
-                    break
+                        content = {"role": "system", "status_type": "error", "message": "Parse response chunk Error"}
+                        error_msg = self.add_response_msg(type="status", content=content, is_llm_message=False)
+                        yield error_msg
             except Exception as run_error:
                 logging.error(f"run_task_auto: Call task_run_once error: {str(run_error)}")
-                yield {
-                    "type": "status",
-                    "status": "error",
-                    "message": f"Call task_run_once error: {str(run_error)}"
-                }
-                return
+                content = {"role": "system", "status_type": "error", "message": "Call task_run_once error"}
+                error_msg = self.add_response_msg(type="status", content=content, is_llm_message=False)
+                yield error_msg
 
-    def add_context_msg(self, type: Literal["user", "status",  "tool", "assistant", "assistant_response_end"],
-                        content: Union[Dict[str, Any], List[Any], str],
-                        is_llm_message: bool,
-                        metadata: Optional[Dict[str, Any]]=None)-> XGAContextMsg:
-        message = XGAContextMsg(
+    def _parse_final_result(self, chunks: List[Dict[str, Any]]) -> XGATaskResult:
+        final_result: XGATaskResult = None
+        try:
+            finish_reason = ''
+            for chunk in reversed(chunks):
+                chunk_type = chunk.get("type")
+                if chunk_type == "status":
+                    status_content = json.loads(chunk.get('content', '{}'))
+                    status_type = status_content.get('status_type', None)
+                    if status_type == "error":
+                        error = status_content.get('message', 'Unknown error')
+                        final_result = XGATaskResult(type="error", content=error)
+                        break
+                    elif status_type == "finish":
+                        finish_reason = status_content.get('finish_reason', None)
+                        if finish_reason == 'xml_tool_limit_reached':
+                            error = "Completed due to over task max_auto_run limit !"
+                            final_result = XGATaskResult(type="error", content=error)
+                            break
+                        continue
+                elif chunk_type == "tool" and finish_reason in ['completed', 'stop']:
+                    tool_content = json.loads(chunk.get('content', '{}'))
+                    tool_execution = tool_content.get('tool_execution')
+                    tool_name = tool_execution.get('function_name')
+                    if tool_name == "complete":
+                        result_content = tool_execution["arguments"].get("text", "Task completed with no answer")
+                        attachments = tool_execution["arguments"].get("attachments", None)
+                        final_result = XGATaskResult(type="answer", content=result_content, attachments=attachments)
+                    elif tool_name == "ask":
+                        result_content = tool_execution["arguments"].get("text", "Task ask for more info")
+                        attachments = tool_execution["arguments"].get("attachments", None)
+                        final_result = XGATaskResult(type="ask", content=result_content, attachments=attachments)
+                    else:
+                        tool_result = tool_execution.get("result", None)
+                        if tool_result is not None:
+                            success = tool_result.get("success")
+                            output = tool_result.get("output")
+                            result_type = "answer" if success else "error"
+                            result_content = f"Task execute '{tool_name}' {result_type}: {output}"
+                            final_result = XGATaskResult(type=result_type, content=result_content)
+                elif chunk_type == "assistant" and finish_reason == 'stop':
+                    assis_content = chunk.get('content', '{}')
+                    result_content = assis_content.get("content", "LLM output is empty")
+                    final_result = XGATaskResult(type="answer", content=result_content)
+                if final_result is not None:
+                    break
+        except Exception as e:
+            logging.error(f"parse_final_result: Final result pass error: {str(e)}")
+            final_result = XGATaskResult(type="error", content="Parse final result failed!")
+            handle_error(e)
+
+        return final_result
+
+    def add_response_msg(self, type: Literal["user", "status", "tool", "assistant", "assistant_response_end"],
+                         content: Union[Dict[str, Any], List[Any], str],
+                         is_llm_message: bool,
+                         metadata: Optional[Dict[str, Any]]=None)-> XGAResponseMsg:
+        message = XGAResponseMsg(
             message_id = f"xga_msg_{uuid4()}",
             type = type,
             content = content,
@@ -207,13 +257,13 @@ class XGATaskEngine:
             task_run_id = self.task_run_id,
             trace_id = self.trace_id
         )
-        self.task_context_msgs.append(message)
+        self.task_response_msgs.append(message)
 
         return message
 
-    def _get_context_llm_contents (self) -> List[Dict[str, Any]]:
+    def _get_response_llm_contents (self) -> List[Dict[str, Any]]:
         llm_messages = []
-        for message in self.task_context_msgs:
+        for message in self.task_response_msgs:
             if message["is_llm_message"]:
                 llm_messages.append(message)
 
@@ -251,13 +301,30 @@ class XGATaskEngine:
             "trace_id": self.trace_id,
             "model_name": self.model_name,
             "max_xml_tool_calls": 0,
-            "add_context_msg": self.add_context_msg,
+            "add_context_msg": self.add_response_msg,
             "tool_box": self.tool_box,
             "tool_execution_strategy": "parallel",
             "xml_adding_strategy": "user_message",
         }
         return response_context
 
+    def _reponse_chunk_log(self, chunk):
+        chunk_type = chunk.get('type')
+        prefix = ""
+
+        if chunk_type == 'status':
+            content = json.loads(chunk.get('content', '{}'))
+            status_type = content.get('status_type', "empty")
+            prefix = "-" + status_type
+        elif chunk_type == 'tool':
+            tool_content = json.loads(chunk.get('content', '{}'))
+            tool_execution = tool_content.get('tool_execution')
+            tool_name = tool_execution.get('function_name')
+            prefix = "-" + tool_name
+
+        logging.info(f"TASK_RESP_CHUNK[{chunk_type}{prefix}]: {chunk}")
+
+
 if __name__ == "__main__":
     import asyncio
     from xgae.utils.utils import read_file
@@ -269,10 +336,12 @@ if __name__ == "__main__":
                                             custom_tools=["bomc_fault.*"],
                                             llm_config=LLMConfig(stream=False),
                                             system_prompt=system_prompt)
-        #engine = await XGATaskEngine.create()
-
-        async for chunk in engine.run_task(task_message={"role": "user", "content": "定位10.0.0.1的故障"},
-                                           max_auto_run=8):
-             print(chunk)
-
+        # engine = await XGATaskEngine.create(llm_config=LLMConfig(stream=False))
+        #chunks = []
+        # async for chunk in engine.run_task(task_message={"role": "user", "content": "定位10.0.0.1的故障"},max_auto_run=8):
+        #     print(chunk)
+        #final_result = await engine.run_task_with_final_answer(task_message={"role": "user", "content": "1+1"}, max_auto_run=2)
+
+        final_result = await engine.run_task_with_final_answer(task_message={"role": "user", "content": "定位10.0.1.1故障"},max_auto_run=8)
+        print("FINAL RESULT:", final_result)
     asyncio.run(main())

{xgae-0.1.4 → xgae-0.1.5}/src/xgae/engine/xga_mcp_tool_box.py

@@ -112,10 +112,7 @@ class XGAMcpToolBox(XGAToolBox):
             if mcp_tool:
                 tool_args = args or {}
                 if server_name == self.GENERAL_MCP_SERVER_NAME:
-                    pass
-                    #tool_args["task_id"] = task_id #xga general tool, first param must be task_id
-                else:
-                    tool_args = args
+                    tool_args = dict({"task_id": task_id}, **tool_args)
 
                 try:
                     tool_result = await mcp_tool.arun(tool_args)