xgae 0.1.8__tar.gz → 0.1.9__tar.gz

{xgae-0.1.8 → xgae-0.1.9}/.env

@@ -10,6 +10,7 @@ LANGFUSE_HOST=https://cloud.langfuse.com
 
 # LLM
 LLM_MODEL=openai/qwen3-235b-a22b
+#LLM_MODEL=openai/qwen-plus
 LLM_API_BASE=https://dashscope.aliyuncs.com/compatible-mode/v1
 LLM_API_KEY=
 LLM_MAX_TOKENS=16384

{xgae-0.1.8 → xgae-0.1.9}/.idea/workspace.xml

@@ -33,6 +33,7 @@
     "Python.message_tools_app.executor": "Run",
     "Python.responser_base.executor": "Run",
     "Python.run_engine_with_human_in_loop.executor": "Run",
+    "Python.run_human_in_loop.executor": "Run",
     "Python.run_simple.executor": "Run",
     "Python.run_task_engine.executor": "Run",
     "Python.run_user_prompt.executor": "Run",
@@ -58,6 +59,7 @@
 }]]></component>
   <component name="RecentsManager">
     <key name="MoveFile.RECENT_KEYS">
+      <recent name="$PROJECT_DIR$/src/examples/engine" />
       <recent name="$PROJECT_DIR$/src/xgae/engine/responser" />
     </key>
   </component>
@@ -164,7 +166,7 @@
       <workItem from="1755737435202" duration="48139000" />
       <workItem from="1756044658912" duration="1248000" />
       <workItem from="1756082326044" duration="23657000" />
-      <workItem from="1756168626188" duration="26778000" />
+      <workItem from="1756168626188" duration="45746000" />
     </task>
     <servers />
   </component>
@@ -185,20 +187,21 @@
   <component name="com.intellij.coverage.CoverageDataManagerImpl">
     <SUITE FILE_PATH="coverage/xgae$test_litellm_langfuse.coverage" NAME="test_litellm_langfuse Coverage Results" MODIFIED="1756196476262" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
     <SUITE FILE_PATH="coverage/xgae$xga_engine.coverage" NAME="xga_engine Coverage Results" MODIFIED="1755580277172" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
-    <SUITE FILE_PATH="coverage/xgae$run_simple.coverage" NAME="run_simple Coverage Results" MODIFIED="1756111714718" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
+    <SUITE FILE_PATH="coverage/xgae$run_simple.coverage" NAME="run_simple Coverage Results" MODIFIED="1756280626870" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
+    <SUITE FILE_PATH="coverage/xgae$run_human_in_loop.coverage" NAME="run_human_in_loop Coverage Results" MODIFIED="1756279131815" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
     <SUITE FILE_PATH="coverage/xgae$run_xga_engine.coverage" NAME="run_task_engine Coverage Results" MODIFIED="1756111613459" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
     <SUITE FILE_PATH="coverage/xgae$message_tools_app.coverage" NAME="message_tools_app Coverage Results" MODIFIED="1756094157566" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
     <SUITE FILE_PATH="coverage/xgae$run_engine_with_human_in_loop.coverage" NAME="run_engine_with_human_in_loop Coverage Results" MODIFIED="1756089269027" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
     <SUITE FILE_PATH="coverage/xgae$xga_prompt_builder.coverage" NAME="xga_prompt_builder Coverage Results" MODIFIED="1755587456555" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
     <SUITE FILE_PATH="coverage/xgae$test_langfuse.coverage" NAME="test_langfuse Coverage Results" MODIFIED="1756196410142" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
-    <SUITE FILE_PATH="coverage/xgae$run_task_engine.coverage" NAME="run_task_engine Coverage Results" MODIFIED="1756207048901" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
+    <SUITE FILE_PATH="coverage/xgae$run_task_engine.coverage" NAME="run_task_engine Coverage Results" MODIFIED="1756280748615" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
     <SUITE FILE_PATH="coverage/xgae$responser_base.coverage" NAME="responser_base Coverage Results" MODIFIED="1756103040764" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
-    <SUITE FILE_PATH="coverage/xgae$mcp_tool_box.coverage" NAME="mcp_tool_box Coverage Results" MODIFIED="1756188784603" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
+    <SUITE FILE_PATH="coverage/xgae$mcp_tool_box.coverage" NAME="mcp_tool_box Coverage Results" MODIFIED="1756274403389" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
     <SUITE FILE_PATH="coverage/xgae$utils.coverage" NAME="utils Coverage Results" MODIFIED="1755226923439" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
-    <SUITE FILE_PATH="coverage/xgae$setup_env.coverage" NAME="setup_env Coverage Results" MODIFIED="1756200209483" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
-    <SUITE FILE_PATH="coverage/xgae$run_user_prompt.coverage" NAME="run_user_prompt Coverage Results" MODIFIED="1756089624828" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
+    <SUITE FILE_PATH="coverage/xgae$setup_env.coverage" NAME="setup_env Coverage Results" MODIFIED="1756273791782" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
+    <SUITE FILE_PATH="coverage/xgae$run_user_prompt.coverage" NAME="run_user_prompt Coverage Results" MODIFIED="1756279512361" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
     <SUITE FILE_PATH="coverage/xgae$xga_mcp_tool_box.coverage" NAME="xga_mcp_tool_box Coverage Results" MODIFIED="1755583099719" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
-    <SUITE FILE_PATH="coverage/xgae$llm_client.coverage" NAME="llm_client Coverage Results" MODIFIED="1756188100577" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
-    <SUITE FILE_PATH="coverage/xgae$task_engine.coverage" NAME="task_engine Coverage Results" MODIFIED="1756199881134" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
+    <SUITE FILE_PATH="coverage/xgae$llm_client.coverage" NAME="llm_client Coverage Results" MODIFIED="1756261767854" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
+    <SUITE FILE_PATH="coverage/xgae$task_engine.coverage" NAME="task_engine Coverage Results" MODIFIED="1756269353871" SOURCE_PROVIDER="com.intellij.coverage.DefaultCoverageFileProvider" RUNNER="coverage.py" COVERAGE_BY_TEST_ENABLED="false" COVERAGE_TRACING_ENABLED="false" WORKING_DIRECTORY="$PROJECT_DIR$" />
   </component>
 </project>

{xgae-0.1.8 → xgae-0.1.9}/PKG-INFO

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

{xgae-0.1.8 → xgae-0.1.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "xgae"
-version = "0.1.8"
+version = "0.1.9"
 description = "Extreme General Agent Engine"
 readme = "README.md"
 requires-python = ">=3.13"
@@ -22,3 +22,4 @@ exclude = ["log/*"]
 
 [project.scripts]
 xgae-tools = "xgae.tools.without_general_tools_app:main"
+custom_fault_tools = "examples.tools.custom_fault_tools_app:main"

{xgae-0.1.8/src/examples → xgae-0.1.9/src/examples/engine}/run_human_in_loop.py

@@ -5,10 +5,13 @@ from xgae.engine.task_engine import XGATaskEngine
 from xgae.utils.llm_client import LLMConfig
 from xgae.utils.misc import read_file
 
+from xgae.utils.setup_env import setup_langfuse
 
 async def main() -> None:
+    # Before Run Exec: uv run custom_fault_tools
     tool_box = XGAMcpToolBox(custom_mcp_server_file="mcpservers/custom_servers.json")
     system_prompt = read_file("templates/example_user_prompt.txt")
+
     engine = XGATaskEngine(tool_box=tool_box,
                            general_tools=[],
                            custom_tools=["*"],
@@ -16,14 +19,24 @@ async def main() -> None:
                            system_prompt=system_prompt,
                            max_auto_run=8)
 
+    langfuse = setup_langfuse()
+    # Two task run in same langfuse trace
+    trace_id = langfuse.trace(name="xgae_example_run_human_in_loop").trace_id
+
     user_input =  "locate fault and solution"
-    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_message={"role": "user", "content": user_input},
+        trace_id=trace_id
+    )
     print("FINAL RESULT:", final_result)
 
     if final_result["type"] == "ask":
         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})
+        final_result = await engine.run_task_with_final_answer(
+            task_message={"role": "user", "content": user_input},
+            trace_id=trace_id
+        )
         print("FINAL RESULT:", final_result)
 
 asyncio.run(main())

{xgae-0.1.8/src/examples → xgae-0.1.9/src/examples/engine}/run_simple.py

@@ -6,7 +6,11 @@ from xgae.utils.llm_client import LLMConfig
 
 async def main() -> None:
     engine =  XGATaskEngine(llm_config=LLMConfig(stream=False), max_auto_run=1)
-    final_result = await engine.run_task_with_final_answer(task_message={"role": "user", "content": "1+1"})
+
+    final_result = await engine.run_task_with_final_answer(
+        task_message={"role": "user", "content": "1+1"}
+    )
+
     print("FINAL RESULT:", final_result)
 
 asyncio.run(main())

{xgae-0.1.8/src/examples → xgae-0.1.9/src/examples/engine}/run_user_prompt.py

@@ -7,8 +7,10 @@ from xgae.utils.misc import read_file
 
 
 async def main() -> None:
+    # Before Run Exec: uv run custom_fault_tools
     tool_box = XGAMcpToolBox(custom_mcp_server_file="mcpservers/custom_servers.json")
     system_prompt = read_file("templates/example_user_prompt.txt")
+
     engine = XGATaskEngine(tool_box=tool_box,
                            general_tools=[],
                            custom_tools=["*"],

xgae-0.1.9/src/examples/tools/custom_fault_tools_app.py

@@ -0,0 +1,104 @@
+import click
+import logging
+
+from typing import Annotated
+from typing import Dict, Any
+from pydantic import Field
+
+from mcp.server.fastmcp import FastMCP
+
+mcp = FastMCP(name="Fault Location Tools")
+alarm_type = 0
+
+@mcp.tool(
+    description="Get Alarm Object",
+)
+def get_alarm(ip: Annotated[str, Field(description="Alarm Object IP Address")]) -> Dict[str, str]:
+    logging.info(f"get_alarm: ip={ip}")
+    return {"alarmId":"alm0123", "objId": "obj567"}
+
+
+@mcp.tool(
+    description="Get alarm type, return result enum: 1: Business Type Alarm; 2: Equipment Type Alarm; 3: Middleware Type Alarm",
+)
+def get_alarm_type(alarm_id: Annotated[str, Field(description="Alarm Object Id")]) -> str:
+    logging.info(f"get_alarm_type: alarm_id={alarm_id}, alarm_type={alarm_type}")
+    return f"{alarm_type}"
+
+
+@mcp.tool(
+    description="Locate Business Type Fault",
+)
+def get_busi_fault(obj_id: Annotated[str, Field(description="Alarm Object Id")]) -> Dict[str, Any]:
+    logging.info(f"get_busi_fault: obj_id={obj_id}")
+    return {"fault_code": "F01", "fault_desc": "Business Recharge Fault"}
+
+
+@mcp.tool(
+    description="Locate Equipment Type Fault",
+)
+def get_equip_fault(obj_id: Annotated[str, Field(description="Alarm Object Id")]) -> Dict[str, Any]:
+    logging.info(f"get_equip_fault: obj_id={obj_id}")
+    return {"fault_code": "F02", "fault_desc": "Host Disk Fault"}
+
+
+@mcp.tool(
+    description="Locate Middleware Type Fault",
+)
+def get_middle_fault(obj_id: Annotated[str, Field(description="Alarm Object Id")]) -> Dict[str, Any]:
+    logging.info(f"get_middle_fault: obj_id={obj_id}")
+    return {"fault_code": "F03", "fault_desc": "Redis Fault"}
+
+
+@mcp.tool(
+    description="Get Business Type Fault Solution and Cause",
+)
+async def get_busi_fault_cause(fault_code: Annotated[str, Field(description="Fault Code")]) -> str:
+    logging.info(f"get_busi_fault_cause: faultCode={fault_code}")
+
+    fault_cause = ""
+    if (fault_code == 'F01'):
+        fault_cause = "Business Recharge Fault, Fault Cause is 'Phone Recharge Application Crash' ，Solution is 'Restart Phone Recharge Application'"
+    else:
+        fault_cause = f"FaultCode '{fault_code}' is not Business Type"
+
+    return  fault_cause
+
+
+@mcp.tool(
+    description="Get Equipment Type Fault Solution and Cause",
+)
+async def get_equip_fault_cause(fault_code: Annotated[str, Field(description="Fault Code")]) -> str:
+    logging.info(f"get_equip_fault_cause: faultCode={fault_code}")
+
+    fault_cause = ""
+    if (fault_code == 'F01'):
+        fault_cause = "Host Fault, Fault Cause is 'Host Disk is Damaged' ，Solution is 'Change Host Disk'"
+    else:
+        fault_cause = f"FaultCode '{fault_code}' is not Equipment Type"
+
+    return  fault_cause
+
+
+@click.command()
+@click.option("--transport", type=click.Choice(["stdio", "sse"]), default="sse", help="Transport type")
+@click.option("--host", default="0.0.0.0", help="Host to listen on for SSE")
+@click.option("--port", default=17070, help="Port to listen on for SSE")
+@click.option("--alarmtype", default=1, help="AlarmType Set")
+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)
+
+    global alarm_type
+    alarm_type = alarmtype
+
+    mcp.settings.host = host
+    mcp.settings.port = port
+
+    mcp.run(transport=transport)
+
+
+if __name__ == '__main__':
+    main()

{xgae-0.1.8 → xgae-0.1.9}/src/xgae/engine/engine_base.py

@@ -7,7 +7,7 @@ class XGAError(Exception):
     pass
 
 XGAMsgStatusType = Literal["error", "finish", "tool_error", "tool_started", "tool_completed", "tool_failed", "thread_run_start", "thread_run_end", "assistant_response_start", "assistant_response_end"]
-XGAResponseMsgType = Literal["user", "status",  "tool", "assistant"]
+XGAResponseMsgType = Literal["user", "status",  "tool", "assistant", "assistant_complete"]
 
 class XGAResponseMessage(TypedDict, total=False):
     message_id: str

{xgae-0.1.8 → xgae-0.1.9}/src/xgae/engine/mcp_tool_box.py

@@ -190,11 +190,16 @@ class XGAMcpToolBox(XGAToolBox):
 if __name__ == "__main__":
     import asyncio
     from dataclasses import asdict
+    from xgae.utils.setup_env import setup_logging
+
+    setup_logging()
 
     async def main():
-        task_id = "task1"
+        ## Before Run Exec: uv run custom_fault_tools
         mcp_tool_box = XGAMcpToolBox(custom_mcp_server_file="mcpservers/custom_servers.json")
         #mcp_tool_box = XGAMcpToolBox()
+
+        task_id = "task1"
         await mcp_tool_box.load_mcp_tools_schema()
         await mcp_tool_box.creat_task_tool_box(task_id=task_id, general_tools=["*"], custom_tools=["bomc_fault.*"])
         tool_schemas = mcp_tool_box.get_task_tool_schemas(task_id, "general_tool")

{xgae-0.1.8 → xgae-0.1.9}/src/xgae/engine/prompt_builder.py

@@ -3,7 +3,7 @@ import datetime
 
 from typing import Optional, List
 
-from xgae.engine.engine_base import XGAToolSchema, XGAError
+from xgae.engine.engine_base import XGAToolSchema
 from xgae.utils.misc import read_file, format_file_with_args
 
 

{xgae-0.1.8 → xgae-0.1.9}/src/xgae/engine/responser/non_stream_responser.py

@@ -1,9 +1,10 @@
 import logging
 
 from typing import List, Dict, Any, AsyncGenerator, override,Optional
+from xgae.utils.json_helpers import format_for_yield
 
 from xgae.engine.responser.responser_base import TaskResponseProcessor, TaskResponserContext, TaskRunContinuousState
-from xgae.utils.json_helpers import format_for_yield
+
 
 class NonStreamTaskResponser(TaskResponseProcessor):
     def __init__(self, response_context: TaskResponserContext):
@@ -47,8 +48,8 @@ class NonStreamTaskResponser(TaskResponseProcessor):
                 else:
                     logging.warning(f"NonStreamTask：LLM response_message is empty")
 
-            message_data = {"role": "assistant", "content": llm_content, "index": -1} # index=-1, full llm_content
-            assistant_msg = self.add_response_message(type="assistant", content=message_data, is_llm_message=True)
+            message_data = {"role": "assistant", "content": llm_content} # index=-1, full llm_content
+            assistant_msg = self.add_response_message(type="assistant_complete", content=message_data, is_llm_message=True)
             yield assistant_msg
 
             tool_calls_to_execute = [item['tool_call'] for item in parsed_xml_data]

{xgae-0.1.8 → xgae-0.1.9}/src/xgae/engine/responser/responser_base.py

@@ -6,11 +6,12 @@ from abc import ABC, abstractmethod
 from dataclasses import dataclass
 from typing import List, Dict, Any, Optional, Tuple, Union, Literal, Callable, TypedDict, AsyncGenerator
 
+from xgae.utils.json_helpers import safe_json_parse
+from xgae.utils.xml_tool_parser import XMLToolParser
+
 from xgae.engine.engine_base import XGAToolResult, XGAToolBox
-from xgae.utils.setup_env import langfuse
+from xgae.engine.task_langfuse import XGATaskLangFuse
 
-from xgae.utils.json_helpers import safe_json_parse, format_for_yield
-from xgae.utils.xml_tool_parser import XMLToolParser
 
 # Type alias for XML result adding strategy
 XmlAddingStrategy = Literal["user_message", "assistant_message", "inline_edit"]
@@ -23,14 +24,13 @@ class TaskResponserContext(TypedDict, total=False):
     task_id: str
     task_run_id: str
     task_no: int
-    trace_id: str
-    root_span_id: str
     model_name: str
     max_xml_tool_calls: int             # LLM generate max_xml_tool limit, 0 is no limit
-    add_response_msg_func: Callable
-    tool_box: XGAToolBox
     tool_execution_strategy: ToolExecutionStrategy
     xml_adding_strategy: XmlAddingStrategy
+    add_response_msg_func: Callable
+    tool_box: XGAToolBox
+    task_langfuse: XGATaskLangFuse
 
 
 class TaskRunContinuousState(TypedDict, total=False):
@@ -63,14 +63,14 @@ class TaskResponseProcessor(ABC):
         self.xml_adding_strategy = self.response_context.get("xml_adding_strategy", "user_message")
         self.max_xml_tool_calls = self.response_context.get("max_xml_tool_calls", 0)
 
-        self.root_span = langfuse.span(trace_id=response_context.get("trace_id"), id=response_context.get("root_span_id"))
+        task_langfuse = response_context.get("task_langfuse")
+        self.root_span = task_langfuse.root_span
         self.add_response_message = response_context.get("add_response_msg_func")
 
         self.tool_box = response_context.get("tool_box")
         self.xml_parser = XMLToolParser()
 
 
-
     @abstractmethod
     async def process_response(self,
                                llm_response: AsyncGenerator,

{xgae-0.1.8 → xgae-0.1.9}/src/xgae/engine/task_engine.py

@@ -1,4 +1,3 @@
-
 import logging
 import json
 import os
@@ -6,18 +5,15 @@ import os
 from typing import List, Any, Dict, Optional, AsyncGenerator, Union, Literal
 from uuid import uuid4
 
-from xgae.engine.responser.responser_base import TaskResponserContext, TaskResponseProcessor, TaskRunContinuousState
-from xgae.engine.engine_base import XGAResponseMsgType, XGAResponseMessage, XGAToolBox, XGATaskResult
-
 from xgae.utils import handle_error
-from xgae.utils.setup_env import langfuse
-
-from xgae.utils.llm_client import LLMClient, LLMConfig, LangfuseMetadata
-
+from xgae.utils.llm_client import LLMClient, LLMConfig
 from xgae.utils.json_helpers import format_for_yield
+
+from xgae.engine.engine_base import XGAResponseMsgType, XGAResponseMessage, XGAToolBox, XGATaskResult
+from xgae.engine.task_langfuse import XGATaskLangFuse
 from xgae.engine.prompt_builder import XGAPromptBuilder
 from xgae.engine.mcp_tool_box import XGAMcpToolBox
-
+from xgae.engine.responser.responser_base import TaskResponserContext, TaskResponseProcessor, TaskRunContinuousState
 
 class XGATaskEngine:
     def __init__(self,
@@ -42,6 +38,7 @@ class XGATaskEngine:
 
         self.prompt_builder = prompt_builder or XGAPromptBuilder(system_prompt)
         self.tool_box: XGAToolBox = tool_box or XGAMcpToolBox()
+        self.task_langfuse: XGATaskLangFuse = None
 
         self.general_tools:List[str] = general_tools
         self.custom_tools:List[str] = custom_tools
@@ -53,18 +50,18 @@ class XGATaskEngine:
 
         self.task_no = -1
         self.task_run_id :str = None
-
         self.task_prompt :str = None
-        self.trace_id :str = None
-        self.root_span_id :str = None
-        self.root_span_name :str = None
+
 
     async def run_task_with_final_answer(self,
                                          task_message: Dict[str, Any],
                                          trace_id: Optional[str] = None) -> XGATaskResult:
         final_result:XGATaskResult = None
         try:
-            self._init_langfuse("run_task_with_final_answer", task_message, trace_id)
+            await self._init_task()
+
+            self.task_langfuse.start_root_span("run_task_with_final_answer", task_message, trace_id)
+
             chunks = []
             async for chunk in self.run_task(task_message=task_message, trace_id=trace_id):
                 chunks.append(chunk)
@@ -76,7 +73,7 @@ class XGATaskEngine:
 
             return final_result
         finally:
-            self._end_langfuse("run_task_with_final_answer", final_result)
+            self.task_langfuse.end_root_span("run_task_with_final_answer", final_result)
 
 
     async def run_task(self,
@@ -84,7 +81,8 @@ class XGATaskEngine:
                        trace_id: Optional[str] = None) -> AsyncGenerator[Dict[str, Any], None]:
         try:
             await self._init_task()
-            self._init_langfuse("run_task", task_message, trace_id)
+
+            self.task_langfuse.start_root_span("run_task", task_message, trace_id)
 
             self.add_response_message(type="user", content=task_message, is_llm_message=True)
 
@@ -92,33 +90,36 @@ class XGATaskEngine:
                 yield chunk
         finally:
             await self.tool_box.destroy_task_tool_box(self.task_id)
-            self._end_langfuse("run_task")
-
+            self.task_langfuse.end_root_span("run_task")
+            self.task_run_id = None
 
     async def _init_task(self) -> None:
-        self.task_no = self.task_no + 1
-        self.task_run_id = f"{self.task_id}[{self.task_no}]"
+        if self.task_run_id is None:
+            self.task_no = self.task_no + 1
+            self.task_run_id = f"{self.task_id}[{self.task_no}]"
+
+            self.task_langfuse =self._create_task_langfuse()
 
-        general_tools = self.general_tools or ["complete", "ask"]
-        if "*" not in general_tools:
-            if "complete" not in general_tools:
-                general_tools.append("complete")
-            elif "ask" not in general_tools:
-                general_tools.append("ask")
+            general_tools = self.general_tools or ["complete", "ask"]
+            if "*" not in general_tools:
+                if "complete" not in general_tools:
+                    general_tools.append("complete")
+                elif "ask" not in general_tools:
+                    general_tools.append("ask")
 
-        custom_tools = self.custom_tools or []
-        if isinstance(self.tool_box, XGAMcpToolBox):
-            await  self.tool_box.load_mcp_tools_schema()
+            custom_tools = self.custom_tools or []
+            if isinstance(self.tool_box, XGAMcpToolBox):
+                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")
-        custom_tool_schemas = self.tool_box.get_task_tool_schemas(self.task_id, "custom_tool")
+            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")
+            custom_tool_schemas = self.tool_box.get_task_tool_schemas(self.task_id, "custom_tool")
 
-        self.task_prompt = self.prompt_builder.build_task_prompt(self.model_name, general_tool_schemas, custom_tool_schemas)
+            self.task_prompt = self.prompt_builder.build_task_prompt(self.model_name, general_tool_schemas, custom_tool_schemas)
 
-        logging.info("*" * 30 + f"   XGATaskEngine Task'{self.task_id}' Initialized   " + "*" * 30)
-        logging.info(f"model_name={self.model_name}, is_stream={self.is_stream}, trace_id={self.trace_id}")
-        logging.info(f"general_tools={general_tools}, custom_tools={custom_tools}")
+            logging.info("*" * 30 + f"   XGATaskEngine Task'{self.task_id}' Initialized   " + "*" * 30)
+            logging.info(f"model_name={self.model_name}, is_stream={self.is_stream}")
+            logging.info(f"general_tools={general_tools}, custom_tools={custom_tools}")
 
 
     async def _run_task_auto(self) -> AsyncGenerator[Dict[str, Any], None]:
@@ -191,7 +192,8 @@ class XGATaskEngine:
             llm_messages.append(temp_assistant_message)
 
         llm_count = continuous_state.get("auto_continue_count")
-        langfuse_metadata = self._create_llm_langfuse_meta(llm_count)
+        langfuse_metadata = self.task_langfuse.create_llm_langfuse_meta(llm_count)
+
         llm_response = await self.llm_client.create_completion(llm_messages, langfuse_metadata)
         response_processor = self._create_response_processer()
 
@@ -236,7 +238,7 @@ class XGATaskEngine:
                             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':
+                elif chunk_type == "assistant_complete" 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)
@@ -258,7 +260,7 @@ class XGATaskEngine:
         metadata = metadata or {}
         metadata["task_id"] = self.task_id
         metadata["task_run_id"] = self.task_run_id
-        metadata["trace_id"] = self.trace_id
+        metadata["trace_id"] = self.task_langfuse.trace_id
         metadata["session_id"] = self.session_id
         metadata["agent_id"] = self.agent_id
 
@@ -295,41 +297,6 @@ class XGATaskEngine:
 
         return response_llm_contents
 
-
-    def _create_llm_langfuse_meta(self, llm_count:int)-> LangfuseMetadata:
-        generation_name = f"xga_task_engine_llm_completion[{self.task_no}]({llm_count})"
-        generation_id = f"{self.task_run_id}({llm_count})"
-        return LangfuseMetadata(
-            generation_name=generation_name,
-            generation_id=generation_id,
-            existing_trace_id=self.trace_id,
-            session_id=self.session_id,
-        )
-
-    def _init_langfuse(self,
-                       root_span_name: str,
-                       task_message: Dict[str, Any],
-                       trace_id: Optional[str] = None):
-
-        if self.root_span_id is None:
-            trace = None
-            if trace_id:
-                self.trace_id = trace_id
-                trace = langfuse.trace(id=trace_id)
-            else:
-                trace = langfuse.trace(name="xga_task_engine")
-                self.trace_id = trace.id
-
-            span = trace.span(name=root_span_name, input=task_message,metadata={"task_id": self.task_id})
-            self.root_span_id = span.id
-            self.root_span_name = root_span_name
-
-    def _end_langfuse(self, root_span_name:str, output: Optional[XGATaskResult]=None):
-        if self.root_span_id and self.root_span_name == root_span_name:
-            langfuse.span(trace_id=self.trace_id, id=self.root_span_id).end(output=output)
-            self.root_span_id = None
-            self.root_span_name = None
-
     def _create_response_processer(self) -> TaskResponseProcessor:
         response_context = self._create_response_context()
         is_stream = response_context.get("is_stream", False)
@@ -346,18 +313,21 @@ class XGATaskEngine:
             "task_id": self.task_id,
             "task_run_id": self.task_run_id,
             "task_no": self.task_no,
-            "trace_id": self.trace_id,
-            "root_span_id": self.root_span_id,
             "model_name": self.model_name,
             "max_xml_tool_calls": 0,
+            "tool_execution_strategy": "parallel" if self.tool_exec_parallel else "sequential",  # ,
+            "xml_adding_strategy": "user_message",
             "add_response_msg_func": self.add_response_message,
             "tool_box": self.tool_box,
-            "tool_execution_strategy": "parallel" if self.tool_exec_parallel else "sequential" ,#,
-            "xml_adding_strategy": "user_message",
+            "task_langfuse": self.task_langfuse,
         }
         return response_context
 
 
+    def _create_task_langfuse(self)-> XGATaskLangFuse:
+        return XGATaskLangFuse(self.session_id, self.task_id, self.task_run_id, self.task_no, self.agent_id)
+
+
     def _logging_reponse_chunk(self, chunk):
         chunk_type = chunk.get('type')
         prefix = ""
@@ -380,6 +350,7 @@ if __name__ == "__main__":
     from xgae.utils.misc import read_file
 
     async def main():
+        # Before Run Exec: uv run custom_fault_tools
         tool_box = XGAMcpToolBox(custom_mcp_server_file="mcpservers/custom_servers.json")
         system_prompt = read_file("templates/example_user_prompt.txt")
         engine =  XGATaskEngine(tool_box=tool_box,
@@ -387,7 +358,9 @@ if __name__ == "__main__":
                                     custom_tools=["*"],
                                     llm_config=LLMConfig(stream=False),
                                     system_prompt=system_prompt,
-                                    max_auto_run=8)
+                                    max_auto_run=8,
+                                    session_id="session_1",
+                                    agent_id="agent_1",)
 
         final_result = await engine.run_task_with_final_answer(task_message={"role": "user",
                                                                              "content": "locate 10.0.0.1 fault and solution"})

xgae-0.1.9/src/xgae/engine/task_langfuse.py

@@ -0,0 +1,63 @@
+
+from typing import Any, Dict, Optional
+from langfuse import Langfuse
+
+from xgae.utils.setup_env import setup_langfuse, setup_env_logging
+from xgae.utils.llm_client import LangfuseMetadata
+from xgae.engine.engine_base import XGATaskResult
+
+setup_env_logging()
+langfuse:Langfuse = setup_langfuse()
+
+class XGATaskLangFuse:
+    def __init__(self,
+                 session_id: str,
+                 task_id:str,
+                 task_run_id: str,
+                 task_no: int,
+                 agent_id: str) -> None:
+        self.session_id = session_id
+        self.task_id = task_id
+        self.task_run_id = task_run_id
+        self.task_no = task_no
+        self.agent_id = agent_id
+
+        self.trace_id = None
+        self.root_span = None
+        self.root_span_name = None
+
+
+    def start_root_span(self,
+                        root_span_name: str,
+                        task_message: Dict[str, Any],
+                        trace_id: Optional[str] = None):
+        if self.root_span is None:
+            trace = None
+            if trace_id:
+                self.trace_id = trace_id
+                trace = langfuse.trace(id=trace_id)
+            else:
+                trace = langfuse.trace(name="xga_task_engine")
+                self.trace_id = trace.id
+
+            metadata = {"task_id": self.task_id, "session_id": self.session_id, "agent_id": self.agent_id}
+            self.root_span = trace.span(id=self.task_run_id, name=root_span_name, input=task_message,metadata=metadata)
+            self.root_span_name = root_span_name
+
+
+    def end_root_span(self, root_span_name:str, output: Optional[XGATaskResult]=None):
+        if self.root_span and self.root_span_name == root_span_name:
+            self.root_span.end(output=output)
+            self.root_span = None
+            self.root_span_name = None
+
+
+    def create_llm_langfuse_meta(self, llm_count:int)-> LangfuseMetadata:
+        generation_name = f"xga_task_engine_llm_completion[{self.task_no}]({llm_count})"
+        generation_id = f"{self.task_run_id}({llm_count})"
+        return LangfuseMetadata(
+            generation_name=generation_name,
+            generation_id=generation_id,
+            existing_trace_id=self.trace_id,
+            session_id=self.session_id,
+        )

{xgae-0.1.8 → xgae-0.1.9}/src/xgae/tools/without_general_tools_app.py

@@ -41,7 +41,7 @@ async def end_task(task_id: str) :
 
 
 def main():
-    #print("="*20 + "   XGAE Message Tools Sever Started in Stdio mode   " + "="*20)
+    print("="*20 + "   XGAE Message Tools Sever Started in Stdio mode   " + "="*20)
     mcp.run(transport="stdio")
 
 if __name__ == "__main__":

{xgae-0.1.8 → xgae-0.1.9}/src/xgae/utils/__init__.py

@@ -7,3 +7,9 @@ def handle_error(e: Exception) -> None:
     logging.error("Traceback details:\n%s", traceback.format_exc())
     raise (e) from e
 
+
+def to_bool(value: str) -> bool:
+    if value is None:
+        return False
+
+    return True if value.lower() == "true" else False

{xgae-0.1.8 → xgae-0.1.9}/src/xgae/utils/json_helpers.py

@@ -26,8 +26,7 @@ def ensure_dict(value: Union[str, Dict[str, Any], None], default: Dict[str, Any]
     Returns:
         A dictionary
     """
-    if default is None:
-        default = {}
+    default = default or {}
         
     if value is None:
         return default
@@ -64,8 +63,7 @@ def ensure_list(value: Union[str, List[Any], None], default: List[Any] = None) -
     Returns:
         A list
     """
-    if default is None:
-        default = []
+    default = default or []
         
     if value is None:
         return default
@@ -84,7 +82,7 @@ def ensure_list(value: Union[str, List[Any], None], default: List[Any] = None) -
             
     return default
 
-
+# @todo if all call value is str, delete useless code
 def safe_json_parse(value: Union[str, Dict, List, Any], default: Any = None) -> Any:
     """
     Safely parse a value that might be JSON string or already parsed.
@@ -105,16 +103,13 @@ def safe_json_parse(value: Union[str, Dict, List, Any], default: Any = None) ->
     # If it's already a dict or list, return as-is
     if isinstance(value, (dict, list)):
         return value
-        
-    # If it's a string, try to parse it
+
     if isinstance(value, str):
         try:
             return json.loads(value)
         except (json.JSONDecodeError, TypeError):
-            # If it's not valid JSON, return the string itself
             return value
-            
-    # For any other type, return as-is
+
     return value
 
 
@@ -137,9 +132,8 @@ def to_json_string(value: Any) -> str:
             json.loads(value)
             return value  # It's already a JSON string
         except (json.JSONDecodeError, TypeError):
-            # It's a plain string, encode it as JSON
-            return json.dumps(value)
-    
+            pass
+
     # For all other types, convert to JSON
     return json.dumps(value)
 

{xgae-0.1.8 → xgae-0.1.9}/src/xgae/utils/llm_client.py

@@ -1,15 +1,14 @@
 import asyncio
 import json
-import logging
 import os
+import logging
 import litellm
 
 from typing import Union, Dict, Any, Optional, List, TypedDict
-
-from litellm.utils import ModelResponse, CustomStreamWrapper
 from openai import OpenAIError
+from litellm.utils import ModelResponse, CustomStreamWrapper
 
-from xgae.utils.setup_env import langfuse
+from xgae.utils.setup_env import setup_langfuse
 
 class LLMConfig(TypedDict, total=False):
     model: str              # Optional Name of the model to use , Override .env LLM_MODEL
@@ -85,7 +84,8 @@ class LLMClient:
     def _init_langfuse():
         if not LLMClient.langfuse_inited:
             LLMClient.langfuse_inited =True
-            if langfuse and langfuse.enabled:
+            env_langfuse = setup_langfuse()
+            if env_langfuse and env_langfuse.enabled:
                 litellm.success_callback = ["langfuse"]
                 litellm.failure_callback = ["langfuse"]
                 LLMClient.langfuse_enabled = True
@@ -95,7 +95,6 @@ class LLMClient:
                 logging.warning("*** LiteLLM Langfuse is disable !")
 
 
-
     def _prepare_llm_params(self, llm_config_params: Dict[str, Any]) -> Dict[str, Any]:
         prepared_llm_params = llm_config_params.copy()
 
@@ -240,12 +239,24 @@ class LLMClient:
         raise LLMError(f"LLM completion failed after {self.max_retries} attempts !")
 
 if __name__ == "__main__":
+    from xgae.utils.setup_env import setup_logging
+
+    setup_logging()
+    langfuse = setup_langfuse()
+
     async def llm_completion():
         llm_client = LLMClient(LLMConfig(stream=False))
+
         messages = [{"role": "user", "content": "1+1="}]
         trace_id = langfuse.trace(name = "xgae_litellm_test").trace_id
-
-        response = await llm_client.create_completion(messages, trace_id)
+        meta = LangfuseMetadata(
+                generation_name="llm_completion_test",
+                generation_id="generation_id",
+                existing_trace_id=trace_id,
+                session_id="session_0",
+        )
+
+        response = await llm_client.create_completion(messages, meta)
         if llm_client.is_stream:
             async for chunk in response:
                 choices = chunk.get("choices", [{}])

{xgae-0.1.8 → xgae-0.1.9}/src/xgae/utils/misc.py

@@ -4,6 +4,8 @@ import sys
 
 from typing import Any, Dict
 
+from xgae.utils import handle_error
+
 def read_file(file_path: str) -> str:
     if not os.path.exists(file_path):
         logging.error(f"File '{file_path}' not found")
@@ -31,4 +33,4 @@ def format_file_with_args(file_content:str, args: Dict[str, Any])-> str:
     finally:
         sys.stdout = original_stdout
 
-    return formated
+    return formated

{xgae-0.1.8 → xgae-0.1.9}/src/xgae/utils/setup_env.py

@@ -4,24 +4,14 @@ import os
 from dotenv import load_dotenv
 from langfuse import Langfuse
 
-load_dotenv()
+from xgae.utils import to_bool
 
-def setup_logging() :
-    log_enable = bool(os.getenv("LOG_ENABLE", True))
-    if not log_enable :
-        return
+load_dotenv()
 
+def setup_logging(log_file: str=None, log_level: str="INFO") :
     import colorlog
 
-    env_log_level = os.getenv("LOG_LEVEL", "INFO")
-    log_file = os.getenv("LOG_FILE", "log/xga.log")
-    log_level = getattr(logging, env_log_level.upper(), logging.INFO)
-
-    log_dir = os.path.dirname(log_file)
-    if log_dir and not os.path.exists(log_dir):
-        os.makedirs(log_dir, exist_ok=True)
-    else:
-        os.remove(log_file)
+    logging_level = getattr(logging, log_level.upper(), logging.INFO)
 
     logger = logging.getLogger()
     for handler in logger.handlers[:]:
@@ -40,25 +30,36 @@ def setup_logging() :
         datefmt='%Y-%m-%d %H:%M:%S'
     )
 
-    file_formatter = logging.Formatter(
-        '%(asctime)s -%(levelname)-8s  %(message)s',
-        datefmt='%Y-%m-%d %H:%M:%S'
-    )
-
     console_handler = logging.StreamHandler()
     console_handler.setFormatter(console_formatter)
+    logger.addHandler(console_handler)
 
-    file_handler = logging.FileHandler(log_file, encoding='utf-8')
-    file_handler.setFormatter(file_formatter)
+    if log_file:
+        log_dir = os.path.dirname(log_file)
+        if log_dir and not os.path.exists(log_dir):
+            os.makedirs(log_dir, exist_ok=True)
+        else:
+            os.remove(log_file)
 
-    logger.addHandler(console_handler)
-    logger.addHandler(file_handler)
+        file_formatter = logging.Formatter(
+            '%(asctime)s -%(levelname)-8s  %(message)s',
+            datefmt='%Y-%m-%d %H:%M:%S'
+        )
+
+        file_handler = logging.FileHandler(log_file, encoding='utf-8')
+        file_handler.setFormatter(file_formatter)
+        logger.addHandler(file_handler)
 
-    logger.setLevel(log_level)
+    logger.setLevel(logging_level)
 
-    logging.info(f"📡 XGAE_LOGGING is initialized, log_level={env_log_level}, log_file={log_file}")
+    logging.info(f"📡 XGAE_LOGGING is initialized, log_level={log_level}, log_file={log_file}")
 
-setup_logging()
+def setup_env_logging():
+    log_enable = to_bool(os.getenv("LOG_ENABLE", True))
+    log_level = os.getenv("LOG_LEVEL", "INFO")
+    log_file = os.getenv("LOG_FILE", "log/xga.log")
+    if log_enable :
+        setup_logging(log_file, log_level)
 
 def setup_langfuse() -> Langfuse:
     env_public_key = os.getenv("LANGFUSE_PUBLIC_KEY")
@@ -77,4 +78,6 @@ def setup_langfuse() -> Langfuse:
 
     return _langfuse
 
-langfuse = setup_langfuse()
+if __name__ == "__main__":
+    langfuse = setup_langfuse()
+    logging.warning(f"langfuse is enable={langfuse.enabled}")

{xgae-0.1.8 → xgae-0.1.9}/src/xgae/utils/xml_tool_parser.py

@@ -68,16 +68,16 @@ class XMLToolParser:
         # Find function_calls blocks
         function_calls_matches = self.FUNCTION_CALLS_PATTERN.findall(content)
         
-        for fc_content in function_calls_matches:
+        for func_content in function_calls_matches:
             # Find all invoke blocks within this function_calls block
-            invoke_matches = self.INVOKE_PATTERN.findall(fc_content)
+            invoke_matches = self.INVOKE_PATTERN.findall(func_content)
             
             for function_name, invoke_content in invoke_matches:
                 try:
                     tool_call = self._parse_invoke_block(
                         function_name, 
                         invoke_content,
-                        fc_content
+                        func_content
                     )
                     if tool_call:
                         tool_calls.append(tool_call)
@@ -98,17 +98,11 @@ class XMLToolParser:
             "function_name": function_name,
             "raw_parameters": {}
         }
-        
-        # Extract all parameters
+
         param_matches = self.PARAMETER_PATTERN.findall(invoke_content)
-        
         for param_name, param_value in param_matches:
-            # Clean up the parameter value
             param_value = param_value.strip()
-            
-            # Try to parse as JSON if it looks like JSON
             parsed_value = self._parse_parameter_value(param_value)
-            
             parameters[param_name] = parsed_value
             parsing_details["raw_parameters"][param_name] = param_value
         
@@ -161,73 +155,3 @@ class XMLToolParser:
         
         # Return as string
         return value
-    
-    
-    def format_tool_call(self, function_name: str, parameters: Dict[str, Any]) -> str:
-        """
-        Format a tool call in the XML format.
-        
-        Args:
-            function_name: Name of the function to call
-            parameters: Dictionary of parameters
-            
-        Returns:
-            Formatted XML string
-        """
-        lines = ['<function_calls>', '<invoke name="{}">'.format(function_name)]
-        
-        for param_name, param_value in parameters.items():
-            # Convert value to string representation
-            if isinstance(param_value, (dict, list)):
-                value_str = json.dumps(param_value)
-            elif isinstance(param_value, bool):
-                value_str = str(param_value).lower()
-            else:
-                value_str = str(param_value)
-            
-            lines.append('<parameter name="{}">{}</parameter>'.format(
-                param_name, value_str
-            ))
-        
-        lines.extend(['</invoke>', '</function_calls>'])
-        return '\n'.join(lines)
-    
-    def validate_tool_call(self, tool_call: XMLToolCall, expected_params: Optional[Dict[str, type]] = None) -> Tuple[bool, Optional[str]]:
-        """
-        Validate a tool call against expected parameters.
-        
-        Args:
-            tool_call: The XMLToolCall to validate
-            expected_params: Optional dict of parameter names to expected types
-            
-        Returns:
-            Tuple of (is_valid, error_message)
-        """
-        if not tool_call.function_name:
-            return False, "Function name is required"
-        
-        if expected_params:
-            for param_name, expected_type in expected_params.items():
-                if param_name not in tool_call.parameters:
-                    return False, f"Missing required parameter: {param_name}"
-                
-                param_value = tool_call.parameters[param_name]
-                if not isinstance(param_value, expected_type):
-                    return False, f"Parameter {param_name} should be of type {expected_type.__name__}"
-        
-        return True, None
-
-
-# Convenience function for quick parsing
-def parse_xml_tool_calls(content: str) -> List[XMLToolCall]:
-    """
-    Parse XML tool calls from content.
-    
-    Args:
-        content: The text content potentially containing XML tool calls
-        
-    Returns:
-        List of parsed XMLToolCall objects
-    """
-    parser = XMLToolParser()
-    return parser.parse_content(content) 

{xgae-0.1.8 → xgae-0.1.9}/templates/example_user_prompt.txt

@@ -17,6 +17,6 @@
     Step[9]: Else determine if alarm type is middleware (type=3)
     Step[10]: If yes, trigger middleware fault location module
     Task[2]: Solution Retrieval
-    Step[1]: For business alarms, call getBusiFaultCause to query business fault solutions
-    Step[2]: For device alarms, call getHostFaultCause to query device fault solutions
+    Step[1]: For business alarms, call get_busi_fault_cause to query business fault solutions
+    Step[2]: For device alarms, call get_equip_fault_cause to query device fault solutions
     Step[3]: For middleware alarms, call web_search to query middleware fault solutions

{xgae-0.1.8 → xgae-0.1.9}/test/test_langfuse.py

@@ -1,6 +1,8 @@
 import logging
 
-from xgae.utils.setup_env import langfuse
+from xgae.utils.setup_env import setup_langfuse
+
+langfuse = setup_langfuse()
 
 langfuse.span()
 trace_id = langfuse.trace(name="xgae_test_trace").trace_id

{xgae-0.1.8 → xgae-0.1.9}/uv.lock

@@ -1257,7 +1257,7 @@ wheels = [
 
 [[package]]
 name = "xgae"
-version = "0.1.8"
+version = "0.1.9"
 source = { editable = "." }
 dependencies = [
     { name = "colorlog" },