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

xgae/engine/task_engine.py

@@ -0,0 +1,360 @@
+
+import logging
+import json
+
+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 langfuse, handle_error
+from xgae.utils.llm_client import LLMClient, LLMConfig
+
+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,
+                 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.llm_client = LLMClient(llm_config)
+        self.model_name = self.llm_client.model_name
+        self.is_stream = self.llm_client.is_stream
+
+        self.prompt_builder = prompt_builder or XGAPromptBuilder(system_prompt)
+        self.tool_box = tool_box or XGAMcpToolBox()
+
+        self.task_response_msgs: List[XGAResponseMessage] = []
+        self.task_no = -1
+        self.task_run_id = f"{self.task_id}[{self.task_no}]"
+        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()
+        await self.tool_box.creat_task_tool_box(self.task_id, general_tools, custom_tools)
+        general_tool_schemas = self.tool_box.get_task_tool_schemas(self.task_id, "general_tool")
+        custom_tool_schemas = self.tool_box.get_task_tool_schemas(self.task_id, "custom_tool")
+
+        self.task_prompt = self.prompt_builder.build_task_prompt(self.model_name, general_tool_schemas, custom_tool_schemas)
+
+    @classmethod
+    async def create(cls,
+                     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,
+                     llm_config: Optional[LLMConfig] = None,
+                     prompt_builder: Optional[XGAPromptBuilder] = None,
+                     tool_box: Optional[XGAToolBox] = None) -> '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)
+
+        logging.info("*"*30 + f"   XGATaskEngine Task'{engine.task_id}' Initialized   " + "*"*30)
+        logging.info(f"model_name={engine.model_name}, is_stream={engine.is_stream}, trace_id={engine.trace_id}")
+        logging.info(f"general_tools={general_tools}, custom_tools={custom_tools}")
+
+        return engine
+
+    async def run_task_with_final_answer(self,
+                       task_message: Dict[str, Any],
+                       max_auto_run: int = 25,
+                       trace_id: Optional[str] = None) -> XGATaskResult:
+        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)
+        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,
+                       task_message: Dict[str, Any],
+                       max_auto_run: int = 25,
+                       trace_id: Optional[str] = None) -> AsyncGenerator[Dict[str, Any], None]:
+        try:
+            self.trace_id = trace_id or self.trace_id or langfuse.create_trace_id()
+
+            self.task_no += 1
+            self.task_run_id = f"{self.task_id}[{self.task_no}]"
+
+            self.add_response_message(type="user", content=task_message, is_llm_message=True)
+
+            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_history_llm_messages()
+        llm_messages.extend(cxt_llm_contents)
+
+        partial_content = continuous_state.get('accumulated_content', '')
+        if partial_content:
+            temp_assistant_message = {
+                "role": "assistant",
+                "content": partial_content
+            }
+            llm_messages.append(temp_assistant_message)
+
+        llm_response = await self.llm_client.create_completion(llm_messages)
+        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)
+            yield chunk
+
+    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
+            continuous_state["auto_continue"] = _auto_continue
+
+        auto_continue_count = 0
+        auto_continue = True
+        while auto_continue and auto_continue_count < max_auto_run:
+            auto_continue = False
+
+            try:
+                async for chunk in self._run_task_once(continuous_state):
+                    yield chunk
+                    try:
+                        if chunk.get("type") == "status":
+                            content = json.loads(chunk.get('content', '{}'))
+                            status_type = content.get('status_type', None)
+                            if status_type == "error":
+                                logging.error(f"run_task_auto: task_response error: {chunk.get('message', 'Unknown error')}")
+                                auto_continue = False
+                                break
+                            elif status_type == 'finish':
+                                finish_reason = content.get('finish_reason', None)
+                                if finish_reason == 'completed':
+                                    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', 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
+                                    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 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"}
+                        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"}
+                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
+        try:
+            finish_reason = ''
+            for chunk in reversed(chunks):
+                chunk_type = chunk.get("type")
+                if chunk_type == "status":
+                    status_content = json.loads(chunk.get('content', '{}'))
+                    status_type = status_content.get('status_type', None)
+                    if status_type == "error":
+                        error = status_content.get('message', 'Unknown error')
+                        final_result = XGATaskResult(type="error", content=error)
+                    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)
+                elif chunk_type == "tool" and finish_reason in ['completed', 'stop']:
+                    tool_content = json.loads(chunk.get('content', '{}'))
+                    tool_execution = tool_content.get('tool_execution')
+                    tool_name = tool_execution.get('function_name')
+                    if tool_name == "complete":
+                        result_content = tool_execution["arguments"].get("text", "Task completed with no answer")
+                        attachments = tool_execution["arguments"].get("attachments", None)
+                        final_result = XGATaskResult(type="answer", content=result_content, attachments=attachments)
+                    elif tool_name == "ask":
+                        result_content = tool_execution["arguments"].get("text", "Task ask for more info")
+                        attachments = tool_execution["arguments"].get("attachments", None)
+                        final_result = XGATaskResult(type="ask", content=result_content, attachments=attachments)
+                    else:
+                        tool_result = tool_execution.get("result", None)
+                        if tool_result is not None:
+                            success = tool_result.get("success")
+                            output = tool_result.get("output")
+                            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':
+                    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:
+            logging.error(f"parse_final_result: Final result pass error: {str(e)}")
+            final_result = XGATaskResult(type="error", content="Parse final result failed!")
+            handle_error(e)
+
+        return final_result
+
+    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,
+            is_llm_message=is_llm_message,
+            content = content,
+            metadata = metadata
+        )
+        self.task_response_msgs.append(message)
+
+        return message
+
+    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)
+
+        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)
+                    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:
+                response_llm_contents.append(content)
+
+        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.stream_responser import StreamTaskResponser
+            return StreamTaskResponser(response_context)
+        else:
+            from xgae.engine.responser.non_stream_responser import NonStreamTaskResponser
+            return NonStreamTaskResponser(response_context)
+
+    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_response_msg_func": self.add_response_message,
+            "tool_box": self.tool_box,
+            "tool_execution_strategy": "sequential" ,#"parallel",
+            "xml_adding_strategy": "user_message",
+        }
+        return response_context
+
+
+    def _logging_reponse_chunk(self, chunk):
+        chunk_type = chunk.get('type')
+        prefix = ""
+
+        if chunk_type == 'status':
+            content = json.loads(chunk.get('content', '{}'))
+            status_type = content.get('status_type', "empty")
+            prefix = "-" + status_type
+        elif chunk_type == 'tool':
+            tool_content = json.loads(chunk.get('content', '{}'))
+            tool_execution = tool_content.get('tool_execution')
+            tool_name = tool_execution.get('function_name')
+            prefix = "-" + tool_name
+
+        logging.info(f"TASK_RESP_CHUNK[{chunk_type}{prefix}]: {chunk}")
+
+
+if __name__ == "__main__":
+    import asyncio
+    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")
+        engine = await XGATaskEngine.create(tool_box=tool_box,
+                                            general_tools=[],
+                                            custom_tools=["bomc_fault.*"],
+                                            llm_config=LLMConfig(stream=False),
+                                            system_prompt=system_prompt)
+
+        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.4.dist-info → xgae-0.1.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xgae
-Version: 0.1.4
+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,,