xgae 0.1.12__tar.gz → 0.1.15__tar.gz

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

@@ -3,17 +3,19 @@ LOG_LEVEL=DEBUG
 LOG_FILE=log/xgae.log
 LOG_ENABLE=True
 
+
 # LANGFUSE
 LANGFUSE_PUBLIC_KEY=
 LANGFUSE_SECRET_KEY=
 LANGFUSE_HOST=https://cloud.langfuse.com
 
+
 # LLM
 LLM_MODEL=openai/qwen3-235b-a22b
 LLM_API_BASE=https://dashscope.aliyuncs.com/compatible-mode/v1
 LLM_API_KEY=
 LLM_MAX_TOKENS=16384
-LLM_TEMPERATURE=0.7
+LLM_TEMPERATURE=0
 LLM_MAX_RETRIES=2
 LLM_STREAM=True
 LLM_ENABLE_THINKING=False

{xgae-0.1.12 → xgae-0.1.15}/PKG-INFO

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "xgae"
-version = "0.1.12"
+version = "0.1.15"
 description = "Extreme General Agent Engine"
 readme = "README.md"
 requires-python = ">=3.13"
@@ -18,9 +18,9 @@ requires = ["hatchling"]
 build-backend = "hatchling.build"
 
 [tool.hatch.build]
-exclude = ["log/*"]
+exclude = ["log/*", ".idea/*"]
 
 [project.scripts]
 xgae = "xgae.cli_app:main"
 xgae-tools = "xgae.tools.without_general_tools_app:main"
-custom_fault_tools = "examples.tools.custom_fault_tools_app:main"
+example-fault-tools = "examples.tools.custom_fault_tools_app:main"

xgae-0.1.15/release.md

@@ -0,0 +1,12 @@
+# Relese Changelog
+## [0.1.15] - 2025-9-1
+### Target
+- Saved for StreamResponser tool_exec_on_stream mode, next release will be abolished
+### Changed
+- Improve French translation (#377).
+### Fixed
+- Fix finish_reason judge logic
+
+## [0.1.15] - 2025-8-31
+### Target
+- First complete version 

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

@@ -10,7 +10,7 @@ from langgraph.graph.message import add_messages
 from xgae.engine.engine_base import XGATaskResult, XGAResponseMessage
 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 import log_trace
 from xgae.utils.misc import read_file
 from xgae.engine.task_engine import XGATaskEngine
 
@@ -183,9 +183,8 @@ class XGAReactAgent:
 
             return result
         except Exception as e:
-            logging.error("### Error ManagerAgent _agent_work for user_input '%s': %s ###", user_input, str(e))
-            handle_error(e)
-            result = XGATaskResult(type="error", content="Never get result, Unexpected Error")
+            log_trace(e, f"XReactAgent generate: user_input={user_input}")
+            result = XGATaskResult(type="error", content=f"React Agent error: {e}")
             return result
 
 

xgae-0.1.15/src/examples/engine/run_general_tools.py

@@ -0,0 +1,16 @@
+import asyncio
+
+from xgae.engine.task_engine import XGATaskEngine
+from xgae.utils.setup_env import setup_logging
+
+
+setup_logging()
+
+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})
+    print("FINAL RESULT:", final_result)
+
+asyncio.run(main())

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

@@ -11,7 +11,7 @@ setup_logging()
 langfuse = setup_langfuse()
 
 async def main() -> None:
-    # Before Run Exec: uv run custom_fault_tools
+    # Before Run Exec: uv run example-fault-tools
     tool_box = XGAMcpToolBox(custom_mcp_server_file="mcpservers/custom_servers.json")
     system_prompt = read_file("templates/example/fault_user_prompt.txt")
 

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

@@ -9,7 +9,7 @@ from xgae.utils.setup_env import setup_logging
 setup_logging(log_level="ERROR")
 
 async def main() -> None:
-    # Before Run Exec: uv run custom_fault_tools
+    # Before Run Exec: uv run example-fault-tools
     tool_box = XGAMcpToolBox(custom_mcp_server_file="mcpservers/custom_servers.json")
     system_prompt = read_file("templates/example/fault_user_prompt.txt")
 

{xgae-0.1.12 → xgae-0.1.15}/src/examples/tools/custom_fault_tools_app.py

@@ -89,7 +89,8 @@ def main(transport: str, host: str, port: int, alarmtype:int):
     if transport != "stdio":
         from xgae.utils.setup_env import setup_logging
         setup_logging()
-        logging.info("=" * 20 + f"   Custom Fault Tools Sever Started in {transport} mode   " + "=" * 20)
+        logging.info("=" * 10 + f"   Example Fault Tools Sever Started   " + "=" * 10)
+        logging.info(f"=== transport={transport}, host={host}, port={port}, alarmtype={alarmtype}")
 
     global alarm_type
     alarm_type = alarmtype

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

@@ -17,16 +17,17 @@ class XGAMcpToolBox(XGAToolBox):
                  custom_mcp_server_config: Optional[Dict[str, Any]] = None
         ):
         general_mcp_server_config = self._load_mcp_servers_config("mcpservers/xga_server.json")
-        tool_box_mcp_server_config = general_mcp_server_config.get("mcpServers", {})
+        tool_box_mcp_server_config = general_mcp_server_config.get('mcpServers', {})
 
         if custom_mcp_server_config:
             tool_box_mcp_server_config.update(custom_mcp_server_config)
         elif custom_mcp_server_file:
             custom_mcp_server_config = self._load_mcp_servers_config(custom_mcp_server_file)
-            custom_mcp_server_config = custom_mcp_server_config.get("mcpServers", {})
+            custom_mcp_server_config = custom_mcp_server_config.get('mcpServers', {})
             tool_box_mcp_server_config.update(custom_mcp_server_config)
 
         self._mcp_client = MultiServerMCPClient(tool_box_mcp_server_config)
+
         self.mcp_server_names: List[str] = [server_name for server_name in tool_box_mcp_server_config]
         self.mcp_tool_schemas: Dict[str, List[XGAToolSchema]] = {}
         self.task_tool_schemas: Dict[str, Dict[str,XGAToolSchema]] = {}
@@ -113,15 +114,20 @@ class XGAMcpToolBox(XGAToolBox):
         async with self._mcp_client.session(server_name) as session:
             tools = await load_mcp_tools(session)
             mcp_tool = next((t for t in tools if t.name == tool_name), None)
-
+            is_general_tool = False
             if mcp_tool:
                 tool_args = args or {}
                 if server_name == self.GENERAL_MCP_SERVER_NAME:
                     tool_args = dict({"task_id": task_id}, **tool_args)
+                    is_general_tool = True
 
                 try:
                     tool_result = await mcp_tool.arun(tool_args)
-                    result = XGAToolResult(success=True, output=str(tool_result))
+                    if is_general_tool:
+                        tool_result = json.loads(tool_result)
+                        result = XGAToolResult(success=tool_result['success'], output=str(tool_result['output']))
+                    else:
+                        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"McpToolBox call_tool: {error}")
@@ -173,18 +179,18 @@ class XGAMcpToolBox(XGAToolBox):
                     for server_name, server_info in server_config["mcpServers"].items():
                         if "transport" not in server_info:
                             if "url" in server_info:
-                                server_info["transport"] = "streamable_http" if "mcp" in server_info["url"] else "sse"
+                                server_info['transport'] = "streamable_http" if "mcp" in server_info['url'] else "sse"
                             else:
-                                server_info["transport"] = "stdio"
+                                server_info['transport'] = "stdio"
 
                     return server_config
             else:
                 logging.warning(f"McpToolBox load_mcp_servers_config: MCP servers config file not found at: {mcp_config_path}")
-                return {"mcpServers": {}}
+                return {'mcpServers': {}}
 
         except Exception as e:
             logging.error(f"McpToolBox load_mcp_servers_config: Failed to load MCP servers config: {e}")
-            return {"mcpServers": {}}
+            return {'mcpServers': {}}
 
 
 if __name__ == "__main__":
@@ -195,7 +201,7 @@ if __name__ == "__main__":
     setup_logging()
 
     async def main():
-        ## Before Run Exec: uv run custom_fault_tools
+        ## Before Run Exec: uv run example-fault-tools
         mcp_tool_box = XGAMcpToolBox(custom_mcp_server_file="mcpservers/custom_servers.json")
         #mcp_tool_box = XGAMcpToolBox()
 

{xgae-0.1.12 → xgae-0.1.15}/src/xgae/engine/prompt_builder.py

@@ -34,19 +34,20 @@ class XGAPromptBuilder():
             openai_schemas = []
             for tool_schema in tool_schemas:
                 openai_schema = {}
-                openai_schema["type"] = "function"
                 openai_function = {}
-                openai_schema["function"] = openai_function
+                openai_schema['type'] = "function"
+                openai_schema['function'] = openai_function
 
-                openai_function["name"] = tool_schema.tool_name
-                openai_function["description"] = tool_schema.description if tool_schema.description else 'No description available'
+                openai_function['name'] = tool_schema.tool_name
+                openai_function['description'] = tool_schema.description if tool_schema.description else 'No description available'
 
                 openai_parameters = {}
+                openai_function['parameters'] = openai_parameters
+
                 input_schema = tool_schema.input_schema
-                openai_function["parameters"] = openai_parameters
-                openai_parameters["type"] = input_schema["type"]
-                openai_parameters["properties"] = input_schema.get("properties", {})
-                openai_parameters["required"] = input_schema["required"]
+                openai_parameters['type']       = input_schema['type']
+                openai_parameters['properties'] = input_schema.get('properties', {})
+                openai_parameters['required']   = input_schema['required']
 
                 openai_schemas.append(openai_schema)
 

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

@@ -2,8 +2,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.utils import log_trace
+
 
 from xgae.engine.responser.responser_base import TaskResponseProcessor, TaskResponserContext, TaskRunContinuousState
 
@@ -25,7 +25,7 @@ class NonStreamTaskResponser(TaskResponseProcessor):
         try:
             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
+                    finish_reason = llm_response.choices[0].finish_reason # LLM finish reason: ‘stop' , 'length'
                     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
@@ -35,12 +35,13 @@ 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"NonStreamResp: Truncate content, parsed_xml_data length={len(parsed_xml_data)} limit over max_xml_tool_calls={self.max_xml_tool_calls}")
+                            logging.warning(f"NonStreamResp: Over XML Tool Limit, finish_reason='xml_tool_limit_reached', "
+                                            f"parsed_xml_data_len={len(parsed_xml_data)}")
                             parsed_xml_data = parsed_xml_data[:self.max_xml_tool_calls]
                             finish_reason = "xml_tool_limit_reached"
 
             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}, "
+                             status_message=f"finish_reason={finish_reason}, tool_exec_strategy={self.tool_exec_strategy}, "
                                             f"parsed_xml_data_len={len(parsed_xml_data)}, llm_content_len={len(llm_content)}")
 
             if  len(llm_content) == 0:
@@ -52,7 +53,7 @@ class NonStreamTaskResponser(TaskResponseProcessor):
 
             tool_calls_to_execute = [item['tool_call'] for item in parsed_xml_data]
             if  len(tool_calls_to_execute) > 0:
-                tool_results = await self._execute_tools(tool_calls_to_execute, self.tool_execution_strategy)
+                tool_results = await self._execute_tools(tool_calls_to_execute, self.tool_exec_strategy)
 
                 tool_index = 0
                 for i, (returned_tool_call, tool_result) in enumerate(tool_results):
@@ -61,20 +62,19 @@ class NonStreamTaskResponser(TaskResponseProcessor):
                     parsing_details = parsed_xml_item['parsing_details']
                     assistant_msg_id = assistant_msg['message_id'] if assistant_msg else None
 
-                    tool_context = self._create_tool_context(tool_call, tool_index, assistant_msg_id, parsing_details)
-                    tool_context.result = tool_result
+                    tool_context = self._create_tool_context(tool_call, tool_index, assistant_msg_id, parsing_details, tool_result)
 
                     tool_start_msg = self._add_tool_start_message(tool_context)
-                    yield format_for_yield(tool_start_msg)
+                    yield tool_start_msg
 
                     tool_message = self._add_tool_messsage(tool_call, tool_result, self.xml_adding_strategy, assistant_msg_id, parsing_details)
 
                     tool_completed_msg = self._add_tool_completed_message(tool_context, tool_message['message_id'])
-                    yield format_for_yield(tool_completed_msg)
+                    yield tool_completed_msg
 
-                    yield format_for_yield(tool_message)
+                    yield tool_message
 
-                    if tool_completed_msg["metadata"].get("agent_should_terminate") == "true":
+                    if tool_context.function_name in ['ask', 'complete']:
                         finish_reason = "completed"
                         break
 
@@ -86,17 +86,16 @@ class NonStreamTaskResponser(TaskResponseProcessor):
             if finish_reason:
                 finish_content = {"status_type": "finish", "finish_reason": finish_reason}
                 finish_msg = self.add_response_message(type="status", content=finish_content, is_llm_message=False)
-                yield format_for_yield(finish_msg)
+                yield finish_msg
         except Exception as e:
-            logging.error(f"NonStreamResp: Process response llm_content: {llm_content}")
-            handle_error(e)
+            trace = log_trace(e, f"NonStreamResp: Process response llm_content:\n {llm_content}")
             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})
+                                 metadata={"content": llm_content, "trace": trace})
 
             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)
+            yield error_msg
 
             raise  # Use bare 'raise' to preserve the original exception with its traceback