xgae 0.1.8__py3-none-any.whl → 0.1.10__py3-none-any.whl

xgae/__init__.py

@@ -0,0 +1,4 @@
+if __name__ == "__main__":
+    from xgae.cli_app import main
+
+    main()

xgae/cli_app.py

@@ -0,0 +1,87 @@
+import asyncio
+import sys
+
+from xgae.engine.mcp_tool_box import XGAMcpToolBox
+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, setup_env_logging
+
+setup_env_logging()
+langfuse = setup_langfuse()
+
+def get_user_message(question)-> str:
+    while True:
+        user_message = input(f"\n💬 {question}: ")
+        if user_message.lower() == 'exit':
+            print("\n====== Extreme General Agent Engine CLI EXIT ======")
+            sys.exit()
+
+        if not user_message.strip():
+            print("\nuser message is empty， input agin ！！！\n")
+            continue
+
+        return user_message
+
+async def cli() -> None:
+    await asyncio.sleep(1)
+    print("\n====== Extreme General Agent Engine CLI START ======")
+    user_message = input("\n💬 Start Custom MCP Server and Load User Prompt (Yes/No): ")
+    tool_box = None
+    system_prompt = None
+    general_tools = []
+    custom_tools = []
+    if user_message.lower() == 'yes':
+        print(f"--- Start Custom MCP Server in custom_servers.json")
+        print(f"--- Load User Prompt in example/fault_user_prompt.txt")
+        tool_box = XGAMcpToolBox(custom_mcp_server_file="mcpservers/custom_servers.json")
+        system_prompt = read_file("templates/example/fault_user_prompt.txt")
+        custom_tools = ["*"]
+    else:
+        print(f"--- Start General Agent Server")
+        print(f"--- Load System Prompt")
+        general_tools = ["*"]
+
+    while True:
+        user_message = get_user_message("Enter your message (or 'exit' to quit)")
+
+        print("\n🔄 Running XGA Engine ...\n")
+        engine = XGATaskEngine(tool_box=tool_box,
+                               general_tools=general_tools,
+                               custom_tools=custom_tools,
+                               llm_config=LLMConfig(stream=False),
+                               system_prompt=system_prompt,
+                               max_auto_run=8)
+
+        # Two task run in same langfuse trace
+        trace_id = langfuse.trace(name="xgae_cli").trace_id
+
+        final_result = await engine.run_task_with_final_answer(
+            task_message={"role": "user", "content": user_message},
+            trace_id=trace_id
+        )
+
+        if final_result["type"] == "ask":
+            await asyncio.sleep(1)
+            print(f"\n📌 ASK INFO: {final_result['content']}")
+            user_message = get_user_message("Enter ASK information (or 'exit' to quit)")
+            final_result = await engine.run_task_with_final_answer(
+                task_message={"role": "user", "content": user_message},
+                trace_id=trace_id
+            )
+
+        await asyncio.sleep(1)
+        result_prefix = "✅" if final_result["type"] == "answer" else "❌"
+        if final_result["type"] == "ask":
+            print("\n *** IMPORTANT: XGA CLI only support showing ONE TURN ASK !")
+            result_prefix = "⚠️"
+        print(f"\n {result_prefix} FINAL RESULT: {final_result['content']}")
+
+
+def main():
+    asyncio.run(cli())
+
+
+if __name__ == "__main__":
+    main()

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/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/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/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]
@@ -81,6 +82,9 @@ class NonStreamTaskResponser(TaskResponseProcessor):
                         finish_reason = "completed"
                         break
                     tool_index += 1
+            else:
+                finish_reason = "non_tool_call"
+                logging.warning(f"NonStreamTask: tool_calls is empty, No Tool need to call !")
 
             if finish_reason:
                 finish_content = {"status_type": "finish", "finish_reason": finish_reason}

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/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}]"
 
-        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")
+            self.task_langfuse =self._create_task_langfuse()
 
-        custom_tools = self.custom_tools or []
-        if isinstance(self.tool_box, XGAMcpToolBox):
-            await  self.tool_box.load_mcp_tools_schema()
+            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")
 
-        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")
+            custom_tools = self.custom_tools or []
+            if isinstance(self.tool_box, XGAMcpToolBox):
+                await  self.tool_box.load_mcp_tools_schema()
 
-        self.task_prompt = self.prompt_builder.build_task_prompt(self.model_name, general_tool_schemas, custom_tool_schemas)
+            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")
 
-        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}")
+            self.task_prompt = self.prompt_builder.build_task_prompt(self.model_name, general_tool_schemas, custom_tool_schemas)
+
+            logging.info("*" * 10 + f"   XGATaskEngine Task'{self.task_id}' Initialized   " + "*" * 10)
+            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]:
@@ -158,6 +159,10 @@ class XGATaskEngine:
                                     logging.warning(f"run_task_auto: Detected finish_reason='xml_tool_limit_reached', stop auto-continue")
                                     auto_continue = False
                                     break
+                                elif finish_reason == 'non_tool_call':
+                                    logging.warning(f"run_task_auto: Detected finish_reason='non_tool_call', stop auto-continue")
+                                    auto_continue = False
+                                    break
                                 elif finish_reason == 'stop' or finish_reason == 'length': # 'length' never occur
                                     auto_continue = True
                                     auto_continue_count += 1
@@ -190,13 +195,14 @@ 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)
+        auto_count = continuous_state.get("auto_continue_count")
+        langfuse_metadata = self.task_langfuse.create_llm_langfuse_meta(auto_count)
+
         llm_response = await self.llm_client.create_completion(llm_messages, langfuse_metadata)
         response_processor = self._create_response_processer()
 
         async for chunk in response_processor.process_response(llm_response, llm_messages, continuous_state):
-            self._logging_reponse_chunk(chunk)
+            self._logging_reponse_chunk(chunk, auto_count)
             yield chunk
 
     def _parse_final_result(self, chunks: List[Dict[str, Any]]) -> XGATaskResult:
@@ -236,13 +242,21 @@ 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 == 'non_tool_call':
                     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
+
+            if final_result and finish_reason == "completed":
+                logging.info(f"✅ FINAL_RESULT: finish_reason={finish_reason}, final_result={final_result}")
+            elif final_result is not None:
+                logging.warning(f"⚠️ FINAL_RESULT: finish_reason={finish_reason}, final_result={final_result}")
+            else:
+                logging.warning(f"❌ FINAL_RESULT: LLM Result is EMPTY, finish_reason={finish_reason}")
+                final_result = XGATaskResult(type="error", content="LLM has no answer")
         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!")
@@ -258,7 +272,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 +309,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,19 +325,22 @@ 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 _logging_reponse_chunk(self, chunk):
+    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, auto_count: int) -> None:
         chunk_type = chunk.get('type')
         prefix = ""
 
@@ -372,22 +354,28 @@ class XGATaskEngine:
             tool_name = tool_execution.get('function_name')
             prefix = "-" + tool_name
 
-        logging.info(f"TASK_RESP_CHUNK[{chunk_type}{prefix}]: {chunk}")
+        logging.info(f"TASK_RESP_CHUNK[{auto_count}]<{chunk_type}{prefix}>: {chunk}")
 
 
 if __name__ == "__main__":
     import asyncio
     from xgae.utils.misc import read_file
+    from xgae.utils.setup_env import setup_logging
+
+    setup_logging()
 
     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")
+        system_prompt = read_file("templates/example/fault_user_prompt.txt")
         engine =  XGATaskEngine(tool_box=tool_box,
                                     general_tools=[],
                                     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/engine/task_langfuse.py

@@ -0,0 +1,65 @@
+
+from typing import Any, Dict, Optional
+from langfuse import Langfuse
+
+from xgae.utils.setup_env import setup_langfuse
+from xgae.utils.llm_client import LangfuseMetadata
+from xgae.engine.engine_base import XGATaskResult
+
+class XGATaskLangFuse:
+    langfuse: Langfuse = None
+
+    def __init__(self,
+                 session_id: str,
+                 task_id:str,
+                 task_run_id: str,
+                 task_no: int,
+                 agent_id: str) -> None:
+        if XGATaskLangFuse.langfuse is None:
+            XGATaskLangFuse.langfuse =  setup_langfuse()
+
+        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 = XGATaskLangFuse.langfuse.trace(id=trace_id)
+            else:
+                trace = XGATaskLangFuse.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/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/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 value.lower() == "true"

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/utils/llm_client.py

@@ -1,15 +1,15 @@
 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 import to_bool
+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
@@ -47,6 +47,7 @@ class LLMClient:
     def __init__(self, llm_config: LLMConfig=None):
         litellm.modify_params = True
         litellm.drop_params = True
+
         self._init_langfuse()
 
         llm_config = llm_config or LLMConfig()
@@ -79,22 +80,27 @@ class LLMClient:
         self.is_stream = llm_config_params['stream']
 
         self.lite_llm_params = self._prepare_llm_params(llm_config_params)
-        logging.info(f"📡 LLMClient initialed : model={self.model_name}, is_stream={self.is_stream}, enable thinking={self.lite_llm_params['enable_thinking']}")
+        logging.info(f"=== LLMClient initialed : model={self.model_name}, is_stream={self.is_stream}, enable thinking={self.lite_llm_params['enable_thinking']}")
 
     @staticmethod
     def _init_langfuse():
         if not LLMClient.langfuse_inited:
             LLMClient.langfuse_inited =True
-            if langfuse and langfuse.enabled:
-                litellm.success_callback = ["langfuse"]
-                litellm.failure_callback = ["langfuse"]
-                LLMClient.langfuse_enabled = True
-                logging.info("=== LiteLLM Langfuse is enable !")
+
+            env_llm_langfuse_enable = to_bool(os.getenv("LLM_LANGFUSE_ENABLE", False))
+            if env_llm_langfuse_enable:
+                env_langfuse = setup_langfuse()
+                if env_langfuse and env_langfuse.enabled:
+                    litellm.success_callback = ["langfuse"]
+                    litellm.failure_callback = ["langfuse"]
+                    LLMClient.langfuse_enabled = True
+                    logging.info("🛠️ LiteLLM Langfuse is enable !")
+                else:
+                    LLMClient.langfuse_enabled = False
+                    logging.warning("🛠️ LiteLLM Langfuse is disable, langfuse.enabled=false !")
             else:
                 LLMClient.langfuse_enabled = False
-                logging.warning("*** LiteLLM Langfuse is disable !")
-
-
+                logging.warning("🛠️ LiteLLM Langfuse is disable, LLM_LANGFUSE_ENABLE=False !")
 
     def _prepare_llm_params(self, llm_config_params: Dict[str, Any]) -> Dict[str, Any]:
         prepared_llm_params = llm_config_params.copy()
@@ -240,12 +246,26 @@ class LLMClient:
         raise LLMError(f"LLM completion failed after {self.max_retries} attempts !")
 
 if __name__ == "__main__":
-    async def llm_completion():
+    from xgae.utils.setup_env import setup_logging
+
+    setup_logging()
+    langfuse = setup_langfuse()
+
+    async def main():
         llm_client = LLMClient(LLMConfig(stream=False))
+
         messages = [{"role": "user", "content": "1+1="}]
         trace_id = langfuse.trace(name = "xgae_litellm_test").trace_id
+        await asyncio.sleep(1)
+
+        meta = LangfuseMetadata(
+                generation_name="llm_completion_test",
+                generation_id="generation_id_0",
+                existing_trace_id=trace_id,
+                session_id="session_0",
+        )
 
-        response = await llm_client.create_completion(messages, trace_id)
+        response = await llm_client.create_completion(messages, meta)
         if llm_client.is_stream:
             async for chunk in response:
                 choices = chunk.get("choices", [{}])
@@ -258,7 +278,6 @@ if __name__ == "__main__":
         else:
             print(response.choices[0].message.content)
 
-
-    asyncio.run(llm_completion())
+    asyncio.run(main())
 
 

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/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"🛠️ XGA_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")
@@ -70,11 +71,13 @@ def setup_langfuse() -> Langfuse:
                             secret_key=env_secret_key,
                             host=env_host)
 
-        logging.info("📡 XGAE_LANGFUSE initialized Successfully by Key !")
+        logging.info("🛠️ XGA_LANGFUSE initialized Successfully by Key !")
     else:
         _langfuse = Langfuse(enabled=False)
-        logging.warning("📡 XGAE_LANGFUSE Not set key, Langfuse is disabled!")
+        logging.warning("🛠️ XGA_LANGFUSE Not set key, Langfuse is disabled!")
 
     return _langfuse
 
-langfuse = setup_langfuse()
+if __name__ == "__main__":
+    langfuse = setup_langfuse()
+    logging.warning(f"langfuse is enable={langfuse.enabled}")

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.dist-info → xgae-0.1.10.dist-info}/METADATA

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

xgae-0.1.10.dist-info/RECORD

@@ -0,0 +1,21 @@
+xgae/__init__.py,sha256=OEUd9y9AoGBd3xYerdTTpz9xl4NWkmXeq1a2eil7Qro,72
+xgae/cli_app.py,sha256=ePis7gYYZrevEArnCQOhaN7z4C8Y5yJSOIov8z-lGBs,3157
+xgae/engine/engine_base.py,sha256=ioywuTpDMHEmyVcd6BInoU-vR70PhQStE2MVRWoEiJg,1768
+xgae/engine/mcp_tool_box.py,sha256=ZSCBSXRWhISwyZ1uEIbt3esjesM46g-ktv6CxvyPVDU,10030
+xgae/engine/prompt_builder.py,sha256=X9bS7YIms6LYplCpNHeUmi74xFP5MwFXmXNqOt1Xz-Q,4356
+xgae/engine/task_engine.py,sha256=LAo55FKmmO8Jbo5geEUYr8kFCaVigTb-Jm06XuYKYyY,19010
+xgae/engine/task_langfuse.py,sha256=b0aJ_Di-WDcYzi0TFCvcKWxkBz7PYP2jx3N52OptQMs,2349
+xgae/engine/responser/non_stream_responser.py,sha256=9YCCUedbotH-TPPbTh2Mv1qNVYvznHYFPgAnQB7NJSE,6510
+xgae/engine/responser/responser_base.py,sha256=8PcsvQHP68FEhu6v3dT9hDCc_rLKs38i4txWLcJD4ck,29851
+xgae/engine/responser/stream_responser.py,sha256=oPGtrT1nedGMjiBAwPzUlu6Z_rPWeVSODC1xQ6D8cTY,52055
+xgae/tools/without_general_tools_app.py,sha256=FGMV6njcOKwwfitc0j_nUov0RC-eWlhO1IP8_KHz1tQ,3788
+xgae/utils/__init__.py,sha256=_-TTNq5FanrA-jl_w3-4xp-BnRM7SLwfYQcFyvepcW0,332
+xgae/utils/json_helpers.py,sha256=6BkqiyEF3jV3Irb4Z6-wGY2_FNaLlxE1WKlMJHHT6E0,4645
+xgae/utils/llm_client.py,sha256=hvEDb4DBaWVQTXMjXOd6KrFwJFBcI-YXEQD4f_AhG7Q,14008
+xgae/utils/misc.py,sha256=M8lMXYp1pHiY6Ee8ZTUG88GpOAsE5fbYoRO_hcBFUCE,953
+xgae/utils/setup_env.py,sha256=HweQ-WAyxfV3KYjGYi-rRQAbI_SXoimduOLpQPbHfl8,2619
+xgae/utils/xml_tool_parser.py,sha256=I9xAZC_ElwBY19PNUq-WLXe9FSIJMeAv2Xs-VlajI7Y,4782
+xgae-0.1.10.dist-info/METADATA,sha256=SGnhZrr3DDZ600FDMep9ihERmhwFspEtUKRv1THqQsk,310
+xgae-0.1.10.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+xgae-0.1.10.dist-info/entry_points.txt,sha256=vClvL_WBJyF2x3wJCz5CNJ_BJG-dWUh7h2YbAoskHsc,162
+xgae-0.1.10.dist-info/RECORD,,

xgae-0.1.10.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+custom_fault_tools = examples.tools.custom_fault_tools_app:main
+xgae = xgae.cli_app:main
+xgae-tools = xgae.tools.without_general_tools_app:main

xgae-0.1.8.dist-info/RECORD

@@ -1,19 +0,0 @@
-xgae/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-xgae/engine/engine_base.py,sha256=MExJxXHkufv_a-n9tm3FZAbJyxVAwEkRC3C_WAGdu4Q,1746
-xgae/engine/mcp_tool_box.py,sha256=6bsORGK2HE-NS8vWNnbbgUQ9uGr_MI7JGO9j_FYKUKA,9903
-xgae/engine/prompt_builder.py,sha256=8_rNRJksn2QLV_K98S0x0qNeHcmxhU0kB_53IZJTGOU,4366
-xgae/engine/task_engine.py,sha256=kOntdzVtTjjakIhcBNK5vBMiBuAXPqB4R5ustY-BNfU,18931
-xgae/engine/responser/non_stream_responser.py,sha256=tXvkGHFGm2oO0IE8Bz9DFDwqemBkO92Nb6MbX1ukHeE,6352
-xgae/engine/responser/responser_base.py,sha256=FdR0yX7VfU5kW-4JmTXBfnn9AwyX1EbOAnslkC7Vcyg,29874
-xgae/engine/responser/stream_responser.py,sha256=oPGtrT1nedGMjiBAwPzUlu6Z_rPWeVSODC1xQ6D8cTY,52055
-xgae/tools/without_general_tools_app.py,sha256=QknIF4OW9xvOad8gx-F_sCBwQYXqMalnNFvYvZXkQ_I,3789
-xgae/utils/__init__.py,sha256=GPubcIs2XFPiWKnuCpevAtYEmVWKJuXlmGkmsH9qoXA,219
-xgae/utils/json_helpers.py,sha256=K1ja6GJCatrAheW9bEWAYSQbDI42__boBCZgtsv1gtk,4865
-xgae/utils/llm_client.py,sha256=Y-o26VW1MOhJYsWJ0zR4u_YXsHSEbvVPY6r90zLQJXU,13213
-xgae/utils/misc.py,sha256=EK94YesZp8AmRUqWfN-CjTxyEHPWdIIWpFNO17dzm9g,915
-xgae/utils/setup_env.py,sha256=P_p74q3nroBdTkAElfGr4QLm4fu7ZRP0R9BMGNUL010,2352
-xgae/utils/xml_tool_parser.py,sha256=EJ6BjpD4CSdmS_LqViUJ6P8H9GY2R1e4Dh8rLCR6nSE,7474
-xgae-0.1.8.dist-info/METADATA,sha256=mk0D1208wUJnbIZxyteCAjE2tlKtQixumHo0mcqD3RI,309
-xgae-0.1.8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-xgae-0.1.8.dist-info/entry_points.txt,sha256=rhQ9Vksnu8nA78lPTjiJxOCZ5k6sH6s5YNMR68y7C-A,73
-xgae-0.1.8.dist-info/RECORD,,

xgae-0.1.8.dist-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-xgae-tools = xgae.tools.without_general_tools_app:main