xgae 0.1.5__py3-none-any.whl → 0.1.6__py3-none-any.whl

xgae/engine/{xga_engine.py → task_engine.py}

@@ -2,23 +2,25 @@
 import logging
 import json
 
-from typing import List, Any, Dict, Optional, AsyncGenerator, cast, Union, Literal
+from typing import List, Any, Dict, Optional, AsyncGenerator, Union, Literal
 from uuid import uuid4
 
-from xgae.engine.responser.xga_responser_base import TaskResponseContext, TaskResponseProcessor, TaskRunContinuousState
-from xgae.engine.xga_base import XGAResponseMsg, XGAToolBox, XGATaskResult
+from xgae.engine.responser.responser_base import TaskResponserContext, TaskResponseProcessor, TaskRunContinuousState
+from xgae.engine.engine_base import XGAResponseMsgType, XGAResponseMessage, XGAToolBox, XGATaskResult
+
+from xgae.utils import langfuse, handle_error
 from xgae.utils.llm_client import LLMClient, LLMConfig
-from xgae.utils.setup_env import langfuse
-from xgae.utils.utils import handle_error
 
-from xga_prompt_builder import XGAPromptBuilder
-from xga_mcp_tool_box import XGAMcpToolBox
+from xgae.utils.json_helpers import format_for_yield
+from prompt_builder import XGAPromptBuilder
+from mcp_tool_box import XGAMcpToolBox
 
 class XGATaskEngine:
     def __init__(self,
                  session_id: Optional[str] = None,
                  task_id: Optional[str] = None,
                  agent_id: Optional[str] = None,
+                 trace_id: Optional[str] = None,
                  system_prompt: Optional[str] = None,
                  llm_config: Optional[LLMConfig] = None,
                  prompt_builder: Optional[XGAPromptBuilder] = None,
@@ -34,10 +36,10 @@ class XGATaskEngine:
         self.prompt_builder = prompt_builder or XGAPromptBuilder(system_prompt)
         self.tool_box = tool_box or XGAMcpToolBox()
 
-        self.task_response_msgs: List[XGAResponseMsg] = []
+        self.task_response_msgs: List[XGAResponseMessage] = []
         self.task_no = -1
         self.task_run_id = f"{self.task_id}[{self.task_no}]"
-        self.trace_id = None
+        self.trace_id :str = trace_id or langfuse.create_trace_id()
 
     async def _post_init_(self, general_tools:List[str], custom_tools: List[str]) -> None:
         await  self.tool_box.load_mcp_tools_schema()
@@ -52,6 +54,7 @@ class XGATaskEngine:
                      session_id: Optional[str] = None,
                      task_id: Optional[str] = None,
                      agent_id: Optional[str] = None,
+                     trace_id: Optional[str] = None,
                      system_prompt: Optional[str] = None,
                      general_tools: Optional[List[str]] = None,
                      custom_tools: Optional[List[str]] = None,
@@ -61,12 +64,19 @@ class XGATaskEngine:
         engine: XGATaskEngine = cls(session_id=session_id,
                                     task_id=task_id,
                                     agent_id=agent_id,
+                                    trace_id=trace_id,
                                     system_prompt=system_prompt,
                                     llm_config=llm_config,
                                     prompt_builder=prompt_builder,
                                     tool_box=tool_box)
 
         general_tools = 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 = custom_tools or []
         await engine._post_init_(general_tools, custom_tools)
 
@@ -83,8 +93,10 @@ class XGATaskEngine:
         chunks = []
         async for chunk in self.run_task(task_message=task_message, max_auto_run=max_auto_run, trace_id=trace_id):
             chunks.append(chunk)
-
-        final_result = self._parse_final_result(chunks)
+        if len(chunks) > 0:
+            final_result = self._parse_final_result(chunks)
+        else:
+            final_result = XGATaskResult(type="error", content="LLM Answer is Empty")
         return final_result
 
     async def run_task(self,
@@ -97,25 +109,22 @@ class XGATaskEngine:
             self.task_no += 1
             self.task_run_id = f"{self.task_id}[{self.task_no}]"
 
-            self.add_response_msg(type="user", content=task_message, is_llm_message=True)
+            self.add_response_message(type="user", content=task_message, is_llm_message=True)
 
-            if max_auto_run <= 1:
-                continuous_state:TaskRunContinuousState  = {
-                    "accumulated_content": "",
-                    "auto_continue_count": 0,
-                    "auto_continue": False
-                }
-                async for chunk in self._run_task_once(continuous_state):
-                    yield chunk
-            else:
-                async for chunk in self._run_task_auto(max_auto_run):
-                    yield chunk
+            continuous_state: TaskRunContinuousState = {
+                "accumulated_content": "",
+                "auto_continue_count": 0,
+                "auto_continue": False if max_auto_run <= 1 else True,
+                "max_auto_run": max_auto_run
+            }
+            async for chunk in self._run_task_auto(continuous_state):
+                yield chunk
         finally:
             await self.tool_box.destroy_task_tool_box(self.task_id)
 
     async def _run_task_once(self, continuous_state: TaskRunContinuousState) -> AsyncGenerator[Dict[str, Any], None]:
         llm_messages = [{"role": "system", "content": self.task_prompt}]
-        cxt_llm_contents = self._get_response_llm_contents()
+        cxt_llm_contents = self.get_history_llm_messages()
         llm_messages.extend(cxt_llm_contents)
 
         partial_content = continuous_state.get('accumulated_content', '')
@@ -130,15 +139,12 @@ class XGATaskEngine:
         response_processor = self._create_response_processer()
 
         async for chunk in response_processor.process_response(llm_response, llm_messages, continuous_state):
-            self._reponse_chunk_log(chunk)
+            self._logging_reponse_chunk(chunk)
             yield chunk
 
-    async def _run_task_auto(self, max_auto_run: int) -> AsyncGenerator[Dict[str, Any], None]:
-        continuous_state: TaskRunContinuousState = {
-            "accumulated_content": "",
-            "auto_continue_count": 0,
-            "auto_continue": True
-        }
+    async def _run_task_auto(self, continuous_state: TaskRunContinuousState) -> AsyncGenerator[Dict[str, Any], None]:
+        max_auto_run = continuous_state['max_auto_run']
+        max_auto_run = max_auto_run if max_auto_run > 0 else 1
 
         def update_continuous_state(_auto_continue_count,  _auto_continue):
             continuous_state["auto_continue_count"] = _auto_continue_count
@@ -163,11 +169,11 @@ class XGATaskEngine:
                             elif status_type == 'finish':
                                 finish_reason = content.get('finish_reason', None)
                                 if finish_reason == 'completed':
-                                    logging.warning(f"run_task_auto: Detected finish_reason='completed', Task Completed Success !")
+                                    logging.info(f"run_task_auto: Detected finish_reason='completed', TASK_COMPLETE Success !")
                                     auto_continue = False
                                     break
                                 elif finish_reason == 'xml_tool_limit_reached':
-                                    logging.warning(f"run_task_auto: Detected finish_reason='xml_tool_limit_reached', stopping auto-continue")
+                                    logging.warning(f"run_task_auto: Detected finish_reason='xml_tool_limit_reached', stop auto-continue")
                                     auto_continue = False
                                     break
                                 elif finish_reason == 'stop' or finish_reason == 'length': # 'length' never occur
@@ -175,18 +181,18 @@ class XGATaskEngine:
                                     auto_continue_count += 1
                                     update_continuous_state(auto_continue_count, auto_continue)
                                     logging.info(f"run_task_auto: Detected finish_reason='{finish_reason}', auto-continuing ({auto_continue_count}/{max_auto_run})")
-                    except StopAsyncIteration:
-                        pass
                     except Exception as parse_error:
                         logging.error(f"run_task_auto: Error in parse chunk: {str(parse_error)}")
                         content = {"role": "system", "status_type": "error", "message": "Parse response chunk Error"}
-                        error_msg = self.add_response_msg(type="status", content=content, is_llm_message=False)
-                        yield error_msg
+                        handle_error(parse_error)
+                        error_msg = self.add_response_message(type="status", content=content, is_llm_message=False)
+                        yield format_for_yield(error_msg)
             except Exception as run_error:
                 logging.error(f"run_task_auto: Call task_run_once error: {str(run_error)}")
                 content = {"role": "system", "status_type": "error", "message": "Call task_run_once error"}
-                error_msg = self.add_response_msg(type="status", content=content, is_llm_message=False)
-                yield error_msg
+                handle_error(run_error)
+                error_msg = self.add_response_message(type="status", content=content, is_llm_message=False)
+                yield format_for_yield(error_msg)
 
     def _parse_final_result(self, chunks: List[Dict[str, Any]]) -> XGATaskResult:
         final_result: XGATaskResult = None
@@ -200,14 +206,11 @@ class XGATaskEngine:
                     if status_type == "error":
                         error = status_content.get('message', 'Unknown error')
                         final_result = XGATaskResult(type="error", content=error)
-                        break
                     elif status_type == "finish":
                         finish_reason = status_content.get('finish_reason', None)
                         if finish_reason == 'xml_tool_limit_reached':
                             error = "Completed due to over task max_auto_run limit !"
                             final_result = XGATaskResult(type="error", content=error)
-                            break
-                        continue
                 elif chunk_type == "tool" and finish_reason in ['completed', 'stop']:
                     tool_content = json.loads(chunk.get('content', '{}'))
                     tool_execution = tool_content.get('tool_execution')
@@ -229,9 +232,10 @@ class XGATaskEngine:
                             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':
-                    assis_content = chunk.get('content', '{}')
+                    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
         except Exception as e:
@@ -241,74 +245,77 @@ class XGATaskEngine:
 
         return final_result
 
-    def add_response_msg(self, type: Literal["user", "status", "tool", "assistant", "assistant_response_end"],
-                         content: Union[Dict[str, Any], List[Any], str],
-                         is_llm_message: bool,
-                         metadata: Optional[Dict[str, Any]]=None)-> XGAResponseMsg:
-        message = XGAResponseMsg(
+    def add_response_message(self, type: XGAResponseMsgType,
+                             content: Union[Dict[str, Any], List[Any], str],
+                             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.trace_id
+        metadata["session_id"] = self.session_id
+        metadata["agent_id"] = self.agent_id
+
+        message = XGAResponseMessage(
             message_id = f"xga_msg_{uuid4()}",
             type = type,
-            content = content,
             is_llm_message=is_llm_message,
-            metadata = metadata,
-            session_id = self.session_id,
-            agent_id = self.agent_id,
-            task_id = self.task_id,
-            task_run_id = self.task_run_id,
-            trace_id = self.trace_id
+            content = content,
+            metadata = metadata
         )
         self.task_response_msgs.append(message)
 
         return message
 
-    def _get_response_llm_contents (self) -> List[Dict[str, Any]]:
+    def get_history_llm_messages (self) -> List[Dict[str, Any]]:
         llm_messages = []
         for message in self.task_response_msgs:
             if message["is_llm_message"]:
                 llm_messages.append(message)
 
-        cxt_llm_contents = []
+        response_llm_contents = []
         for llm_message in llm_messages:
             content = llm_message["content"]
             # @todo content List type
             if isinstance(content, str):
                 try:
                     _content = json.loads(content)
-                    cxt_llm_contents.append(_content)
+                    response_llm_contents.append(_content)
                 except json.JSONDecodeError as e:
                     logging.error(f"get_context_llm_contents: Failed to decode json, content=:{content}")
                     handle_error(e)
             else:
-                cxt_llm_contents.append(content)
+                response_llm_contents.append(content)
 
-        return cxt_llm_contents
+        return response_llm_contents
 
     def _create_response_processer(self) -> TaskResponseProcessor:
         response_context = self._create_response_context()
         is_stream = response_context.get("is_stream", False)
         if is_stream:
-            from xgae.engine.responser.xga_stream_responser import StreamTaskResponser
+            from xgae.engine.responser.stream_responser import StreamTaskResponser
             return StreamTaskResponser(response_context)
         else:
-            from xgae.engine.responser.xga_non_stream_responser import NonStreamTaskResponser
+            from xgae.engine.responser.non_stream_responser import NonStreamTaskResponser
             return NonStreamTaskResponser(response_context)
 
-    def _create_response_context(self) -> TaskResponseContext:
-        response_context: TaskResponseContext = {
+    def _create_response_context(self) -> TaskResponserContext:
+        response_context: TaskResponserContext = {
             "is_stream": self.is_stream,
             "task_id": self.task_id,
             "task_run_id": self.task_run_id,
             "trace_id": self.trace_id,
             "model_name": self.model_name,
             "max_xml_tool_calls": 0,
-            "add_context_msg": self.add_response_msg,
+            "add_response_msg_func": self.add_response_message,
             "tool_box": self.tool_box,
-            "tool_execution_strategy": "parallel",
+            "tool_execution_strategy": "sequential" ,#"parallel",
             "xml_adding_strategy": "user_message",
         }
         return response_context
 
-    def _reponse_chunk_log(self, chunk):
+
+    def _logging_reponse_chunk(self, chunk):
         chunk_type = chunk.get('type')
         prefix = ""
 
@@ -327,7 +334,8 @@ class XGATaskEngine:
 
 if __name__ == "__main__":
     import asyncio
-    from xgae.utils.utils import read_file
+    from xgae.utils.misc import read_file
+
     async def main():
         tool_box = XGAMcpToolBox(custom_mcp_server_file="mcpservers/custom_servers.json")
         system_prompt = read_file("templates/scp_test_prompt.txt")
@@ -336,12 +344,17 @@ if __name__ == "__main__":
                                             custom_tools=["bomc_fault.*"],
                                             llm_config=LLMConfig(stream=False),
                                             system_prompt=system_prompt)
-        # engine = await XGATaskEngine.create(llm_config=LLMConfig(stream=False))
-        #chunks = []
-        # async for chunk in engine.run_task(task_message={"role": "user", "content": "定位10.0.0.1的故障"},max_auto_run=8):
-        #     print(chunk)
-        #final_result = await engine.run_task_with_final_answer(task_message={"role": "user", "content": "1+1"}, max_auto_run=2)
 
         final_result = await engine.run_task_with_final_answer(task_message={"role": "user", "content": "定位10.0.1.1故障"},max_auto_run=8)
         print("FINAL RESULT:", final_result)
+
+        # ====  test streaming response   ========
+        #chunks = []
+        # async for chunk in engine.run_task(task_message={"role": "user", "content": "定位10.0.0.1的故障"}, max_auto_run=8):
+        #     print(chunk)
+
+        # ====  test no tool call   ========
+        # engine = await XGATaskEngine.create(llm_config=LLMConfig(stream=False))
+        # final_result = await engine.run_task_with_final_answer(task_message={"role": "user", "content": "1+1"}, max_auto_run=2)
+        # print("FINAL RESULT:", final_result)
     asyncio.run(main())

xgae/utils/__init__.py

@@ -0,0 +1,13 @@
+import logging
+
+from .setup_env import setup_langfuse, setup_logging
+
+setup_logging()
+langfuse = setup_langfuse()
+
+def handle_error(e: Exception) -> None:
+    import traceback
+
+    logging.error("An error occurred: %s", str(e))
+    logging.error("Traceback details:\n%s", traceback.format_exc())
+    raise (e) from e

xgae/utils/{utils.py → misc.py}

@@ -1,17 +1,9 @@
 import logging
 import os
 import sys
-import datetime
 
 from typing import Any, Dict
 
-def handle_error(e: Exception) -> None:
-    import traceback
-
-    logging.error("An error occurred: %s", str(e))
-    logging.error("Traceback details:\n%s", traceback.format_exc())
-    raise (e) from e
-
 def read_file(file_path: str) -> str:
     if not os.path.exists(file_path):
         logging.error(f"File '{file_path}' not found")

xgae/utils/setup_env.py

@@ -3,91 +3,76 @@ import os
 
 from langfuse import Langfuse
 
-_log_initialized = False
-
 def setup_logging() -> None:
-    global _log_initialized
-    if not _log_initialized:
-        import colorlog
-        from dotenv import load_dotenv
-        load_dotenv()
-
-        env_log_level = os.getenv("LOG_LEVEL", "INFO")
-        env_log_file = os.getenv("LOG_FILE", "log/xga.log")
-        log_level = getattr(logging, env_log_level.upper(), logging.INFO)
-
-        log_dir = os.path.dirname(env_log_file)
-        if log_dir and not os.path.exists(log_dir):
-            os.makedirs(log_dir, exist_ok=True)
-        else:
-            os.remove(env_log_file)
-
-        logger = logging.getLogger()
-        for handler in logger.handlers[:]:
-            logger.removeHandler(handler)
+    import colorlog
+    from dotenv import load_dotenv
+    load_dotenv()
 
+    env_log_level = os.getenv("LOG_LEVEL", "INFO")
+    env_log_file = os.getenv("LOG_FILE", "log/xga.log")
+    log_level = getattr(logging, env_log_level.upper(), logging.INFO)
 
+    log_dir = os.path.dirname(env_log_file)
+    if log_dir and not os.path.exists(log_dir):
+        os.makedirs(log_dir, exist_ok=True)
+    else:
+        os.remove(env_log_file)
 
-        log_colors = {
-            'DEBUG': 'cyan',
-            'INFO': 'green',
-            'WARNING': 'yellow',
-            'ERROR': 'red',
-            'CRITICAL': 'red,bg_white'
-        }
+    logger = logging.getLogger()
+    for handler in logger.handlers[:]:
+        logger.removeHandler(handler)
 
-        console_formatter = colorlog.ColoredFormatter('%(log_color)s%(asctime)s - %(levelname)-8s%(reset)s %(white)s%(message)s',
-            log_colors=log_colors,
-            datefmt='%Y-%m-%d %H:%M:%S'
-        )
+    log_colors = {
+        'DEBUG': 'cyan',
+        'INFO': 'green',
+        'WARNING': 'yellow',
+        'ERROR': 'red',
+        'CRITICAL': 'red,bg_white'
+    }
 
-        file_formatter = logging.Formatter(
-            '%(asctime)s -%(levelname)-8s  %(message)s',
-            datefmt='%Y-%m-%d %H:%M:%S'
-        )
+    console_formatter = colorlog.ColoredFormatter('%(log_color)s%(asctime)s - %(levelname)-8s%(reset)s %(white)s%(message)s',
+        log_colors=log_colors,
+        datefmt='%Y-%m-%d %H:%M:%S'
+    )
 
-        console_handler = logging.StreamHandler()
-        console_handler.setFormatter(console_formatter)
+    file_formatter = logging.Formatter(
+        '%(asctime)s -%(levelname)-8s  %(message)s',
+        datefmt='%Y-%m-%d %H:%M:%S'
+    )
 
-        file_handler = logging.FileHandler(env_log_file, encoding='utf-8')
-        file_handler.setFormatter(file_formatter)
+    console_handler = logging.StreamHandler()
+    console_handler.setFormatter(console_formatter)
 
-        logger.addHandler(console_handler)
-        logger.addHandler(file_handler)
+    file_handler = logging.FileHandler(env_log_file, encoding='utf-8')
+    file_handler.setFormatter(file_formatter)
 
-        logger.setLevel(log_level)
+    logger.addHandler(console_handler)
+    logger.addHandler(file_handler)
 
-        logging.info(f"Logger is initialized, log_level={env_log_level}, log_file={env_log_file}")
+    logger.setLevel(log_level)
 
-    _log_initialized = True
+    logging.info(f"Logger is initialized, log_level={env_log_level}, log_file={env_log_file}")
 
-setup_logging()
-
-_langfuse_initialized = False
 
 def setup_langfuse() -> Langfuse:
-    global _langfuse_initialized
     _langfuse = None
-    if not _langfuse_initialized:
-        env_public_key = os.getenv("LANGFUSE_PUBLIC_KEY")
-        env_secret_key = os.getenv("LANGFUSE_SECRET_KEY")
-        env_host = os.getenv("LANGFUSE_HOST", "https://cloud.langfuse.com")
-        if env_public_key and env_secret_key:
-            _langfuse = Langfuse(tracing_enabled=True,
-                                public_key=env_public_key,
-                                secret_key=env_secret_key,
-                                host=env_host)
-            logging.info("Langfuse initialized Successfully by Key !")
-        else:
-            _langfuse = Langfuse(tracing_enabled=False)
-            logging.warning("Not set key, Langfuse is disabled!")
-
-    _langfuse_initialized = True
-    return _langfuse
+    env_public_key = os.getenv("LANGFUSE_PUBLIC_KEY")
+    env_secret_key = os.getenv("LANGFUSE_SECRET_KEY")
+    env_host = os.getenv("LANGFUSE_HOST", "https://cloud.langfuse.com")
+    if env_public_key and env_secret_key:
+        _langfuse = Langfuse(tracing_enabled=True,
+                            public_key=env_public_key,
+                            secret_key=env_secret_key,
+                            host=env_host)
+        logging.info("Langfuse initialized Successfully by Key !")
+    else:
+        _langfuse = Langfuse(tracing_enabled=False)
+        logging.warning("Not set key, Langfuse is disabled!")
 
-langfuse: Langfuse = Langfuse if _langfuse_initialized else setup_langfuse()
+    return _langfuse
 
 
 if __name__ == "__main__":
+        from xgae.utils import langfuse
         trace_id = langfuse.create_trace_id()
         logging.warning(f"trace_id={trace_id}")

xgae/utils/xml_tool_parser.py

@@ -5,14 +5,11 @@ This module provides a reliable XML tool call parsing system that supports
 the XML format with structured function_calls blocks.
 """
 
-import re
-import xml.etree.ElementTree as ET
-from typing import List, Dict, Any, Optional, Tuple
-from dataclasses import dataclass
 import json
 import logging
-
-logger = logging.getLogger(__name__)
+import re
+from dataclasses import dataclass
+from typing import List, Dict, Any, Optional, Tuple
 
 
 @dataclass
@@ -85,7 +82,7 @@ class XMLToolParser:
                     if tool_call:
                         tool_calls.append(tool_call)
                 except Exception as e:
-                    logger.error(f"Error parsing invoke block for {function_name}: {e}")
+                    logging.error(f"Error parsing invoke block for {function_name}: {e}")
         
         return tool_calls
     

{xgae-0.1.5.dist-info → xgae-0.1.6.dist-info}/METADATA

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

xgae-0.1.6.dist-info/RECORD

@@ -0,0 +1,17 @@
+xgae/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+xgae/engine/engine_base.py,sha256=ySERuLy1YWsf-3s0NFKcyTnXQ4g69wR-cQhtnG0OFmU,1747
+xgae/engine/mcp_tool_box.py,sha256=6mdvu9-aquyLJEwebTtpa_bfGmgT1jPszKE90NIpR5c,9852
+xgae/engine/prompt_builder.py,sha256=ygFAIc4p3opIMyl6g1JeBuSiMjNVxwRloKeF2eX8R5I,4354
+xgae/engine/task_engine.py,sha256=xxAWtPfKgSpf6L7wOc243U-7YP8AC2WYoCI-FUdDpOc,18132
+xgae/engine/responser/non_stream_responser.py,sha256=QEFE4JGYVaIbFeMUMJa1Mt1uBblU_hAOywAhyp9V1k4,6634
+xgae/engine/responser/responser_base.py,sha256=aHKJ880B1ezfBWzyHoOSNVDb-CJY4ujH2MGm61aJLy8,31468
+xgae/engine/responser/stream_responser.py,sha256=5KzCHApiPplZ-zN_sbbEbSvj2rtvKWBshJKe_-x7RDI,52927
+xgae/utils/__init__.py,sha256=jChvD-p_p5gsrCZUVYPUGJs4CS9gIdNFcSOpkRpcM4Y,317
+xgae/utils/json_helpers.py,sha256=K1ja6GJCatrAheW9bEWAYSQbDI42__boBCZgtsv1gtk,4865
+xgae/utils/llm_client.py,sha256=mgzn8heUyRm92HTLEYGdfsGEpFtD-xLFr39P98_JP0s,12402
+xgae/utils/misc.py,sha256=EK94YesZp8AmRUqWfN-CjTxyEHPWdIIWpFNO17dzm9g,915
+xgae/utils/setup_env.py,sha256=Nc0HCQOnK-EGNLTWCQ9-iYysNRdIvwGhcHdqpNeV910,2407
+xgae/utils/xml_tool_parser.py,sha256=EJ6BjpD4CSdmS_LqViUJ6P8H9GY2R1e4Dh8rLCR6nSE,7474
+xgae-0.1.6.dist-info/METADATA,sha256=Q5OiPe5W3H7ym2TDPaM1x3k6jSTIol3QDyWI0dsQetw,309
+xgae-0.1.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+xgae-0.1.6.dist-info/RECORD,,