xgae 0.1.18__py3-none-any.whl → 0.1.20__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,
@@ -27,10 +28,12 @@ class XGATaskEngine:
                  tool_exec_parallel: Optional[bool] = None,
                  llm_config: Optional[LLMConfig] = None,
                  prompt_builder: Optional[XGAPromptBuilder] = None,
-                 tool_box: Optional[XGAToolBox] = 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 +59,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 +82,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 +156,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 +188,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})
@@ -211,7 +214,7 @@ class XGATaskEngine:
         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)
+        llm_response = await self.llm_client.acompletion(llm_messages, langfuse_metadata)
         response_processor = self._create_response_processer()
 
         async for chunk in response_processor.process_response(llm_response, llm_messages, continuous_state):
@@ -271,7 +274,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 +288,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()}",
@@ -312,7 +316,7 @@ class XGATaskEngine:
     def get_history_llm_messages (self) -> List[Dict[str, Any]]:
         llm_messages = []
         for message in self.task_response_msgs:
-            if message['is_llm_message']:
+            if message['is_llm_message'] and message['type'] != "assistant_chunk":
                 llm_messages.append(message)
 
         response_llm_contents = []
@@ -359,7 +363,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 +395,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 +421,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,25 @@ 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 +69,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/utils/llm_client.py

@@ -226,7 +226,10 @@ class LLMClient:
             logging.debug(f"LLMClient: Waiting {delay} seconds before retry llm completion...")
             await asyncio.sleep(delay)
 
-    async def create_completion(self, messages: List[Dict[str, Any]], langfuse_metadata: Optional[LangfuseMetadata]=None) -> Union[ModelResponse, CustomStreamWrapper]:
+    async def acompletion(self,
+                          messages: List[Dict[str, Any]],
+                          langfuse_metadata: Optional[LangfuseMetadata]=None
+                          ) -> Union[ModelResponse, CustomStreamWrapper]:
         complete_params = self._prepare_complete_params(messages)
         if LLMClient.langfuse_enabled and langfuse_metadata:
             complete_params["metadata"] = langfuse_metadata
@@ -234,19 +237,38 @@ class LLMClient:
         last_error = None
         for attempt in range(self.max_retries):
             try:
-                logging.info(f"*** LLMClient create_completion: LLM '{self.model_name}' completion attempt {attempt + 1}/{self.max_retries}")
+                logging.info(f"*** LLMClient acompletion: LLM '{self.model_name}' completion attempt {attempt + 1}/{self.max_retries}")
                 response = await litellm.acompletion(**complete_params)
                 return response
             except (litellm.exceptions.RateLimitError, OpenAIError, json.JSONDecodeError) as e:
                 last_error = e
                 await self._handle_llm_error(e, attempt)
             except Exception as e:
-                logging.error(f"LLMClient create_completion: Unexpected error during LLM completion: {str(e)}", exc_info=True)
+                logging.error(f"LLMClient acompletion: Unexpected error during LLM completion: {str(e)}", exc_info=True)
                 raise LLMError(f"LLMClient create completion failed: {e}")
 
-        logging.error(f"LLMClient create_completion: LLM completion failed after {self.max_retries} attempts: {last_error}", exc_info=True)
+        logging.error(f"LLMClient acompletion: LLM completion failed after {self.max_retries} attempts: {last_error}", exc_info=True)
         raise LLMError(f"LLMClient create completion failed after {self.max_retries} attempts !")
 
+
+    async def get_response_result(self, response: Union[ModelResponse, CustomStreamWrapper]) -> str:
+        response_text: str = ""
+
+        if self.is_stream:
+            async for chunk in response:
+                choices = chunk.get("choices", [{}])
+                if not choices:
+                    continue
+                delta = choices[0].get("delta", {})
+                content = delta.get("content", "")
+                if content:
+                    response_text += content
+        else:
+            response_text = response.choices[0].message.content
+
+        return response_text
+
+
 if __name__ == "__main__":
     from xgae.utils.setup_env import setup_logging
 
@@ -267,7 +289,7 @@ if __name__ == "__main__":
                 session_id="session_0",
         )
 
-        response = await llm_client.create_completion(messages, meta)
+        response = await llm_client.acompletion(messages, meta)
         if llm_client.is_stream:
             async for chunk in response:
                 choices = chunk.get("choices", [{}])

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

@@ -1,10 +1,11 @@
 Metadata-Version: 2.4
 Name: xgae
-Version: 0.1.18
+Version: 0.1.20
 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.20.dist-info}/RECORD

@@ -1,21 +1,21 @@
-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=l0wOIIkyVUtyf95wSi4oXTHZjv15m9XB68pTk24baig,21641
+xgae/engine/task_langfuse.py,sha256=ifkGrPBv2daLTKE-fCfEtOoI0n4Pd-lCwhyRRL0h308,2850
 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
 xgae/tools/without_general_tools_app.py,sha256=KqsdhxD3hvTpiygaGUVHysRFjvv_1A8zOwMKN1J0J0U,3821
 xgae/utils/__init__.py,sha256=ElaGS-zdeZeu6is41u3Ny7lkvhg7BDSK-jMNg9j6K5A,499
 xgae/utils/json_helpers.py,sha256=WD4G5U9Dh8N6J9O0L5wGyqj-NHi09kcXHGdLD_26nlc,3607
-xgae/utils/llm_client.py,sha256=mWRtvtSMk_8NuzFReT9x52ayHlCNVZMZAltD6TQ-xZ8,14404
+xgae/utils/llm_client.py,sha256=AphZ57n9VvaQBq6xu2_cRQE6DtIGN2PfQ2h7D50cATw,15056
 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.20.dist-info/METADATA,sha256=H8uCaLYabJqLy0BCBC_tP8B0Ti-dKiefMWqkZ_d3ySs,343
+xgae-0.1.20.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+xgae-0.1.20.dist-info/entry_points.txt,sha256=wmvgtMQbtzTbDPETS-tbQJD7jVlcs4hp0w6wOB0ooCc,229
+xgae-0.1.20.dist-info/RECORD,,

{xgae-0.1.18.dist-info → xgae-0.1.20.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