xgae 0.1.18__py3-none-any.whl → 0.1.19__py3-none-any.whl

xgae/__init__.py

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

xgae/engine/task_engine.py

@@ -17,8 +17,9 @@ from xgae.engine.responser.responser_base import TaskResponserContext, TaskRespo
 
 class XGATaskEngine:
     def __init__(self,
-                 session_id: Optional[str] = None,
                  task_id: Optional[str] = None,
+                 session_id: Optional[str] = None,
+                 user_id: Optional[str] = None,
                  agent_id: Optional[str] = None,
                  general_tools: Optional[List[str]] = None,
                  custom_tools: Optional[List[str]] = None,
@@ -29,8 +30,9 @@ class XGATaskEngine:
                  prompt_builder: Optional[XGAPromptBuilder] = None,
                  tool_box: Optional[XGAToolBox] = None):
         self.task_id    = task_id if task_id else f"xga_task_{uuid4()}"
-        self.agent_id   = agent_id
         self.session_id = session_id
+        self.user_id    = user_id
+        self.agent_id   = agent_id
 
         self.llm_client = LLMClient(llm_config)
         self.model_name = self.llm_client.model_name
@@ -56,16 +58,16 @@ class XGATaskEngine:
         self.task_response_msgs: List[XGAResponseMessage] = []
 
     async def run_task_with_final_answer(self,
-                                         task_message: Dict[str, Any],
+                                         task_input: Dict[str, Any],
                                          trace_id: Optional[str] = None) -> XGATaskResult:
-        final_result:XGATaskResult = None
+        final_result: XGATaskResult = None
         try:
             await self._init_task()
 
-            self.task_langfuse.start_root_span("run_task_with_final_answer", task_message, trace_id)
+            self.task_langfuse.start_root_span("run_task_with_final_answer", task_input, trace_id)
 
             chunks = []
-            async for chunk in self.run_task(task_message=task_message, trace_id=trace_id):
+            async for chunk in self.run_task(task_input, trace_id):
                 chunks.append(chunk)
 
             if len(chunks) > 0:
@@ -79,14 +81,14 @@ class XGATaskEngine:
 
 
     async def run_task(self,
-                       task_message: Dict[str, Any],
+                       task_input: Dict[str, Any],
                        trace_id: Optional[str] = None) -> AsyncGenerator[Dict[str, Any], None]:
         try:
             await self._init_task()
 
-            self.task_langfuse.start_root_span("run_task", task_message, trace_id)
+            self.task_langfuse.start_root_span("run_task", task_input, trace_id)
 
-            self.add_response_message(type="user", content=task_message, is_llm_message=True)
+            self.add_response_message(type="user", content=task_input, is_llm_message=True)
 
             async for chunk in self._run_task_auto():
                 yield chunk
@@ -153,30 +155,30 @@ class XGATaskEngine:
                             status_content = chunk['content']
                             status_type = status_content['status_type']
                             if status_type == "error":
-                                logging.error(f"TaskEngine run_task_auto: task_response error: {chunk.get('message')}")
+                                logging.error(f"XGATaskEngine run_task_auto: task_response error: {chunk.get('message')}")
                                 auto_continue = False
                                 break
                             elif status_type == "finish":
                                 finish_reason = status_content['finish_reason']
                                 if finish_reason == "completed":
-                                    logging.info(f"TaskEngine run_task_auto: Detected finish_reason='completed', TASK_COMPLETE Success !")
+                                    logging.info(f"XGATaskEngine run_task_auto: Detected finish_reason='completed', TASK_COMPLETE Success !")
                                     auto_continue = False
                                     break
                                 elif finish_reason == "xml_tool_limit_reached":
-                                    logging.warning(f"TaskEngine run_task_auto: Detected finish_reason='xml_tool_limit_reached', stop auto-continue")
+                                    logging.warning(f"XGATaskEngine 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"TaskEngine run_task_auto: Detected finish_reason='non_tool_call', stop auto-continue")
+                                    logging.warning(f"XGATaskEngine run_task_auto: Detected finish_reason='non_tool_call', stop auto-continue")
                                     auto_continue = False
                                     break
                                 elif finish_reason in ["stop", "length"]: # 'length'  occur on some LLM
                                     auto_continue_count += 1
                                     auto_continue = True if auto_continue_count < self.max_auto_run else False
                                     update_continuous_state(auto_continue_count, auto_continue)
-                                    logging.info(f"TaskEngine run_task_auto: Detected finish_reason='{finish_reason}', auto-continuing ({auto_continue_count}/{self.max_auto_run})")
+                                    logging.info(f"XGATaskEngine run_task_auto: Detected finish_reason='{finish_reason}', auto-continuing ({auto_continue_count}/{self.max_auto_run})")
                     except Exception as parse_error:
-                        trace = log_trace(parse_error,f"TaskEngine run_task_auto: Parse chunk error, chunk: {chunk}")
+                        trace = log_trace(parse_error,f"XGATaskEngine run_task_auto: Parse chunk error, chunk: {chunk}")
                         self.task_langfuse.root_span.event(name="engine_parse_chunk_error", level="ERROR",
                                              status_message=f"Task Engine parse chunk error: {parse_error}",
                                              metadata={"content": chunk, "trace": trace})
@@ -185,7 +187,7 @@ class XGATaskEngine:
                         error_msg = self.add_response_message(type="status", content=status_content, is_llm_message=False)
                         yield error_msg
             except Exception as run_error:
-                trace = log_trace(run_error, "TaskEngine run_task_auto: Call task_run_once")
+                trace = log_trace(run_error, "XGATaskEngine run_task_auto: Call task_run_once")
                 self.task_langfuse.root_span.event(name="engine_task_run_once_error", level="ERROR",
                                                    status_message=f"Call task_run_once error: {run_error}",
                                                    metadata={"trace": trace})
@@ -271,7 +273,7 @@ class XGATaskEngine:
                 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:
-            trace = log_trace(e, f"TaskEngine parse_final_result: Parse message chunk error, chunk: {chunk}")
+            trace = log_trace(e, f"XGATaskEngine parse_final_result: Parse message chunk error, chunk: {chunk}")
             self.task_langfuse.root_span.event(name="engine_parse_final_result_error", level="ERROR",
                                                status_message=f"Task Engine parse final result error: {e}",
                                                metadata={"content": chunk, "trace": trace})
@@ -285,11 +287,12 @@ class XGATaskEngine:
                              is_llm_message: bool,
                              metadata: Optional[Dict[str, Any]]=None)-> XGAResponseMessage:
         metadata = metadata or {}
-        metadata["task_id"]     = self.task_id
-        metadata["task_run_id"] = self.task_run_id
-        metadata["trace_id"]    = self.task_langfuse.trace_id
-        metadata["session_id"]  = self.session_id
-        metadata["agent_id"]    = self.agent_id
+        metadata['task_id']     = self.task_id
+        metadata['task_run_id'] = self.task_run_id
+        metadata['trace_id']    = self.task_langfuse.trace_id
+        metadata['session_id']  = self.session_id
+        metadata['user_id']     = self.user_id
+        metadata['agent_id']    = self.agent_id
 
         message = XGAResponseMessage(
             message_id      = f"xga_msg_{uuid4()}",
@@ -359,7 +362,14 @@ class XGATaskEngine:
 
 
     def _create_task_langfuse(self)-> XGATaskLangFuse:
-        return XGATaskLangFuse(self.session_id, self.task_id, self.task_run_id, self.task_no, self.agent_id)
+        return XGATaskLangFuse(
+            task_id      = self.task_id,
+            task_run_id  = self.task_run_id,
+            task_no      = self.task_no,
+            session_id   = self.session_id,
+            agent_id     = self.agent_id,
+            user_id      = self.user_id
+        )
 
 
     def _logging_reponse_chunk(self, chunk, auto_count: int)-> None:
@@ -384,11 +394,11 @@ class XGATaskEngine:
                 pretty_content = json.dumps(status_content, ensure_ascii=False, indent=2)
 
             if chunk_type == "assistant_chunk":
-                logging.debug(f"TASK_RESP_CHUNK[{auto_count}]<{chunk_type}{prefix}> content: {pretty_content}")
+                logging.debug(f"TASK_RESP_CHUNK[{self.task_no}]({auto_count})<{chunk_type}{prefix}> content: {pretty_content}")
             else:
-                logging.info(f"TASK_RESP_CHUNK[{auto_count}]<{chunk_type}{prefix}> content: {pretty_content}")
+                logging.info(f"TASK_RESP_CHUNK[{self.task_no}]({auto_count})<{chunk_type}{prefix}> content: {pretty_content}")
         except Exception as e:
-            logging.error(f"TaskEngine logging_reponse_chunk: Decorate chunk={chunk}, error: {e}")
+            logging.error(f"XGATaskEngine logging_reponse_chunk: Decorate chunk={chunk}, error: {e}")
 
 
 
@@ -410,7 +420,7 @@ if __name__ == "__main__":
                                 agent_id="agent_1"
                                 )
         user_input = "locate 10.0.0.1 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_input={'role': "user", 'content': user_input})
         print(f"FINAL RESULT:{final_result}")
 
 

xgae/engine/task_langfuse.py

@@ -1,4 +1,4 @@
-
+import logging
 from typing import Any, Dict, Optional
 from langfuse import Langfuse
 
@@ -10,10 +10,11 @@ class XGATaskLangFuse:
     langfuse: Langfuse = None
 
     def __init__(self,
-                 session_id: str,
                  task_id:str,
                  task_run_id: str,
                  task_no: int,
+                 session_id: str,
+                 user_id: str,
                  agent_id: str) -> None:
         if XGATaskLangFuse.langfuse is None:
             XGATaskLangFuse.langfuse =  setup_langfuse()
@@ -22,6 +23,7 @@ class XGATaskLangFuse:
         self.task_id        = task_id
         self.task_run_id    = task_run_id
         self.task_no        = task_no
+        self.user_id        = user_id
         self.agent_id       = agent_id
 
         self.trace_id       = None
@@ -31,7 +33,7 @@ class XGATaskLangFuse:
 
     def start_root_span(self,
                         root_span_name: str,
-                        task_message: Dict[str, Any],
+                        task_input: Dict[str, Any],
                         trace_id: Optional[str] = None):
         if self.root_span is None:
             trace = None
@@ -39,13 +41,23 @@ class XGATaskLangFuse:
                 self.trace_id = trace_id
                 trace = XGATaskLangFuse.langfuse.trace(id=trace_id)
             else:
-                trace = XGATaskLangFuse.langfuse.trace(name="xga_task_engine")
+                trace = XGATaskLangFuse.langfuse.trace(name="xga_task_engine", session_id=self.session_id)
                 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)
+            metadata = {
+                'task_id'       : self.task_id,
+                'session_id'    : self.session_id,
+                'user_id'       : self.user_id,
+                'agent_id'      : self.agent_id
+            }
+
+            self.root_span = trace.span(id=self.task_run_id,
+                                        name=f"{root_span_name}[{self.task_no}]",
+                                        input=task_input,
+                                        metadata=metadata)
             self.root_span_name = root_span_name
 
+            logging.info(f"{root_span_name} TASK_INPUT: {task_input}")
 
     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:
@@ -55,7 +67,7 @@ class XGATaskLangFuse:
 
 
     def create_llm_langfuse_meta(self, llm_count:int)-> LangfuseMetadata:
-        generation_name = f"xga_task_engine_llm_completion[{self.task_no}]({llm_count})"
+        generation_name = f"xga_engine_llm_completion[{self.task_no}]({llm_count})"
         generation_id = f"{self.task_run_id}({llm_count})"
         return LangfuseMetadata(
             generation_name     = generation_name,

xgae/{cli_app.py → engine_cli_app.py}

@@ -14,7 +14,7 @@ langfuse = setup_langfuse()
 def get_user_message(question)-> str:
     while True:
         user_message = input(f"\n💬 {question}: ")
-        if user_message.lower() == 'exit':
+        if user_message.lower() == 'exit' or user_message.lower() == 'quit':
             print("\n====== Extreme General Agent Engine CLI EXIT ======")
             sys.exit()
 
@@ -44,7 +44,7 @@ async def cli() -> None:
         general_tools = ["*"]
 
     while True:
-        user_message = get_user_message("Enter your message (or 'exit' to quit)")
+        user_message = get_user_message("Enter your task input message (or 'exit' to quit)")
 
         print("\n🔄 Running XGA Engine ...\n")
         engine = XGATaskEngine(tool_box=tool_box,
@@ -54,27 +54,24 @@ async def cli() -> None:
 
         # 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)")
+        auto_continue = True
+        while auto_continue:
+            auto_continue = False
             final_result = await engine.run_task_with_final_answer(
-                task_message={'role': "user", 'content': user_message},
+                task_input={'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']}")
+            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)")
+                auto_continue = True
+                continue
+
+            await asyncio.sleep(1)
+            result_prefix = "✅" if final_result["type"] == "answer" else "❌"
+            print(f"\n {result_prefix} FINAL RESULT: {final_result['content']}")
 
 
 def main():

{xgae-0.1.18.dist-info → xgae-0.1.19.dist-info}/METADATA

@@ -1,10 +1,11 @@
 Metadata-Version: 2.4
 Name: xgae
-Version: 0.1.18
+Version: 0.1.19
 Summary: Extreme General Agent Engine
 Requires-Python: >=3.13
 Requires-Dist: colorlog==6.9.0
 Requires-Dist: langchain-mcp-adapters==0.1.9
+Requires-Dist: langchain==0.3.27
 Requires-Dist: langfuse==2.60.9
 Requires-Dist: langgraph==0.6.5
 Requires-Dist: litellm==1.74.15

{xgae-0.1.18.dist-info → xgae-0.1.19.dist-info}/RECORD

@@ -1,10 +1,10 @@
-xgae/__init__.py,sha256=OEUd9y9AoGBd3xYerdTTpz9xl4NWkmXeq1a2eil7Qro,72
-xgae/cli_app.py,sha256=ieTaS0b532P_8g9Mz2xda8TOZwYD2hKGnNZiarADAM0,3000
+xgae/__init__.py,sha256=oBX_YzTliM-343BAlR-sD7BUZmsCJ7PY2oYrGBhsdLM,79
+xgae/engine_cli_app.py,sha256=FdmIpq8KDsgyZNfwCDgNX7FEZFeRFyGOt_H1oZF8aKs,2890
 xgae/engine/engine_base.py,sha256=RR1em2wHiM2jP-peHt77SKdHWjnYOjdIIzN93zT61cA,1715
 xgae/engine/mcp_tool_box.py,sha256=G4hKIMguwg1cO4Us2NMfdloYim8kuikVyVTIPucJr7o,10903
 xgae/engine/prompt_builder.py,sha256=6I5rjgvNJ27QJ8DDuBTplutoPZdGs9LYFv3TSgT7zmc,5045
-xgae/engine/task_engine.py,sha256=_GfIpWGBd83jf2xnS0vDvgyQR0mqQSb6ZrGoBFFrMt4,21249
-xgae/engine/task_langfuse.py,sha256=n2bajsHq2Zt3jetel8cSlN2lo42mZgTmbR4Zbx9JvsM,2416
+xgae/engine/task_engine.py,sha256=7B7nbERTh9HDgDH4lXS_s4KTsVU41AgR7rnN4jKLozQ,21588
+xgae/engine/task_langfuse.py,sha256=J9suOhlIGSJor-mZsggPZf3XQld9dTkfpHAS2fVirvM,2859
 xgae/engine/responser/non_stream_responser.py,sha256=zEJjqCgZVe2B8gkHYRFU7tmBV834f7w2a4Ws25P1N-c,5289
 xgae/engine/responser/responser_base.py,sha256=jhl1Bdz1Fs3KofGEymThNXlQuCORFTTkTAR_U47krds,24403
 xgae/engine/responser/stream_responser.py,sha256=cv4UGcxj8OksEogW7DUGTCvSJabu-DF6GceFyUwaXI4,7627
@@ -15,7 +15,7 @@ xgae/utils/llm_client.py,sha256=mWRtvtSMk_8NuzFReT9x52ayHlCNVZMZAltD6TQ-xZ8,1440
 xgae/utils/misc.py,sha256=aMWOvJ9VW52q-L9Lkjl1hvXqLwpJAmyxA-Z8jzqFG0U,907
 xgae/utils/setup_env.py,sha256=MqNG0c2QQBDFU1kI8frxr9kB5d08Mmi3QZ1OoorgIa0,2662
 xgae/utils/xml_tool_parser.py,sha256=Mb0d8kBrfyAEvUwW1Nqir-3BgxZRr0ZX3WymQouuFSo,4859
-xgae-0.1.18.dist-info/METADATA,sha256=zMbJrDIxmWY79uRRluq-HuNOtxdE7jOQELEcRvVB57w,310
-xgae-0.1.18.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-xgae-0.1.18.dist-info/entry_points.txt,sha256=KdL6b_heFPyb1XIq5_L8Rgydpn64VDExFZafU_Qd9ow,222
-xgae-0.1.18.dist-info/RECORD,,
+xgae-0.1.19.dist-info/METADATA,sha256=MHUqZkPIWB9Tn_sLyFkFBw4XZKPAQqC_z0QudI1s5hk,343
+xgae-0.1.19.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+xgae-0.1.19.dist-info/entry_points.txt,sha256=wmvgtMQbtzTbDPETS-tbQJD7jVlcs4hp0w6wOB0ooCc,229
+xgae-0.1.19.dist-info/RECORD,,

{xgae-0.1.18.dist-info → xgae-0.1.19.dist-info}/entry_points.txt

@@ -1,5 +1,5 @@
 [console_scripts]
 example-a2a-tools = examples.tools.simu_a2a_tools_app:main
 example-fault-tools = examples.tools.custom_fault_tools_app:main
-xgae = xgae.cli_app:main
+xgae = xgae.engine_cli_app:main
 xgae-tools = xgae.tools.without_general_tools_app:main